[V0_FILE]typescriptreact:file="app/loading.tsx" isFixed="true" isMerged="true" export default function Loading() { return null } [V0_FILE]typescriptreact:file="app/api/credits/deduct/route.ts" isFixed="true" isEdit="true" isQuickEdit="true" isMerged="true" import { createClient } from "@/lib/supabase/server" import { type NextRequest, NextResponse } from "next/server" export async function POST(request: NextRequest) { try { const { amount, featureType, description, metadata } = await request.json() const supabase = await createClient() // Added await for proper client creation const { data: { user }, } = await supabase.auth.getUser() if (!user) { return NextResponse.json({ error: "Unauthorized" }, { status: 401 }) } const usageMetadata = { ...metadata, timestamp: new Date().toISOString(), feature: featureType, } // Call the database function to update credits const { data, error } = await supabase.rpc("update_user_credits", { p_user_id: user.id, p_amount: -Math.abs(amount), p_type: "usage", p_description: description, p_reference_id: `${featureType}_${Date.now()}`, // Added unique reference ID }) if (error || !data) { console.error("Credit update error:", error) return NextResponse.json({ error: "Insufficient credits or update failed" }, { status: 400 }) } const { error: usageError } = await supabase.from("usage_logs").insert({ user_id: user.id, feature_type: featureType, quantity: featureType === "chat" ? Math.ceil((metadata?.tokens || 0) / 1000) : metadata?.quantity || 1, cost: amount, metadata: usageMetadata, }) if (usageError) { console.error("Usage logging error:", usageError) } // Get updated balance const { data: updatedUser } = await supabase.from("users").select("credits").eq("id", user.id).single() return NextResponse.json({ success: true, newBalance: updatedUser?.credits || 0, usageLogged: !usageError, }) } catch (error) { console.error("Credit deduction error:", error) return NextResponse.json({ error: "Failed to deduct credits" }, { status: 500 }) } } [V0_FILE]typescriptreact:file="components/credit-guard.tsx" isMerged="true" "use client" import type React from "react" import { useState, useEffect } from "react" import { Button } from "@/components/ui/button" import { AlertCircle, CreditCard } from "lucide-react" interface CreditGuardProps { cost: number featureType: "chat" | "image" | "video" onProceed: () => void children: React.ReactNode } export default function CreditGuard({ cost, featureType, onProceed, children }: CreditGuardProps) { const [hasEnoughCredits, setHasEnoughCredits] = useState(null) const [currentCredits, setCurrentCredits] = useState(0) const [isChecking, setIsChecking] = useState(false) const checkCredits = async () => { setIsChecking(true) try { const response = await fetch("/api/credits/check", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ amount: cost }), }) const data = await response.json() setHasEnoughCredits(data.hasEnoughCredits) setCurrentCredits(data.currentCredits) } catch (error) { console.error("Credit check failed:", error) setHasEnoughCredits(false) } finally { setIsChecking(false) } } useEffect(() => { checkCredits() }, [cost]) if (isChecking) { return (

Checking credits...

) } if (hasEnoughCredits === false) { return (

Insufficient Credits

You need ${cost.toFixed(2)} credits to use {featureType} generation.
Current balance: ${currentCredits.toFixed(2)}

) } return <>{children} } [V0_FILE]typescriptreact:file="components/credits-purchase.tsx" isMerged="true" "use client" import type React from "react" import { useState } from "react" import { Button } from "@/components/ui/button" import { loadStripe } from "@stripe/stripe-js" import { Elements, CardElement, useStripe, useElements } from "@stripe/react-stripe-js" import { CreditCard, Loader2 } from "lucide-react" const stripePromise = loadStripe(process.env.NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY!) const CREDIT_PACKAGES = [ { credits: 5, price: 5, popular: false }, { credits: 10, price: 9, popular: true }, { credits: 25, price: 20, popular: false }, { credits: 50, price: 35, popular: false }, ] function CheckoutForm({ selectedPackage }: { selectedPackage: (typeof CREDIT_PACKAGES)[0] }) { const stripe = useStripe() const elements = useElements() const [isProcessing, setIsProcessing] = useState(false) const [error, setError] = useState(null) const handleSubmit = async (event: React.FormEvent) => { event.preventDefault() if (!stripe || !elements) { return } setIsProcessing(true) setError(null) try { // Create payment intent const response = await fetch("/api/stripe/create-payment-intent", { method: "POST", headers: { "Content-Type": "application/json", }, body: JSON.stringify({ amount: selectedPackage.price, credits: selectedPackage.credits, }), }) const { clientSecret, error: apiError } = await response.json() if (apiError) { setError(apiError) return } // Confirm payment const cardElement = elements.getElement(CardElement) const { error: stripeError, paymentIntent } = await stripe.confirmCardPayment(clientSecret, { payment_method: { card: cardElement!, }, }) if (stripeError) { setError(stripeError.message || "Payment failed") } else if (paymentIntent?.status === "succeeded") { // Payment successful - redirect or show success message window.location.reload() } } catch (err) { setError("An unexpected error occurred") } finally { setIsProcessing(false) } } return ( ) } export default function CreditsPurchase() { const [selectedPackage, setSelectedPackage] = useState(CREDIT_PACKAGES[1]) const [showCheckout, setShowCheckout] = useState(false) return (

{!showCheckout ? ( <>

{CREDIT_PACKAGES.map((pkg) => ( ))}

) : (

Purchase ${selectedPackage.credits} Credits

Credits: ${selectedPackage.credits}

Total: ${selectedPackage.price}

)}

) } [V0_FILE]typescriptreact:file="lib/token-counter.ts" isMerged="true" // Simple token estimation for chat messages export function estimateTokens(text: string): number { // Rough estimation: 1 token ≈ 4 characters for English text // This is a simplified approach - in production you'd use tiktoken or similar const chars = text.length const words = text.split(/\s+/).length // Use word count as a more accurate estimate (1 word ≈ 1.3 tokens on average) return Math.ceil(words * 1.3) } export function calculateChatTokens(messages: Array<{ content: string }>): number { return messages.reduce((total, message) => { return total + estimateTokens(message.content) }, 0) } [V0_FILE]typescriptreact:file="components/usage-guard.tsx" isMerged="true" "use client" import type React from "react" import { useState, useEffect } from "react" import { Button } from "@/components/ui/button" import { AlertCircle, CreditCard } from "lucide-react" interface UsageGuardProps { cost: number featureType: "chat" | "image" | "video" onProceed: () => void children: React.ReactNode showGuard?: boolean } export default function UsageGuard({ cost, featureType, onProceed, children, showGuard = true }: UsageGuardProps) { const [hasEnoughCredits, setHasEnoughCredits] = useState(null) const [currentCredits, setCurrentCredits] = useState(0) const [isChecking, setIsChecking] = useState(false) const checkCredits = async () => { if (!showGuard) { setHasEnoughCredits(true) return } setIsChecking(true) try { const response = await fetch("/api/credits/check", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ amount: cost }), }) const data = await response.json() setHasEnoughCredits(data.hasEnoughCredits) setCurrentCredits(data.currentCredits) } catch (error) { console.error("Credit check failed:", error) setHasEnoughCredits(false) } finally { setIsChecking(false) } } useEffect(() => { checkCredits() }, [cost, showGuard]) if (!showGuard) { return <>{children} } if (isChecking) { return (

Checking credits...

) } if (hasEnoughCredits === false) { return (

Insufficient Credits

You need ${cost.toFixed(2)} credits to use {featureType} generation.
Current balance: ${currentCredits.toFixed(2)}

) } return <>{children} } [V0_FILE]typescriptreact:file="types/message.ts" isMerged="true" export interface Message { id: string role: "user" | "assistant" content: string timestamp: Date } [V0_FILE]sql:file="scripts/01_create_auth_tables.sql" isEdit="true" isMerged="true" -- Create users table (extends Supabase auth.users) CREATE TABLE IF NOT EXISTS public.users ( id UUID REFERENCES auth.users(id) ON DELETE CASCADE PRIMARY KEY, email TEXT UNIQUE NOT NULL, full_name TEXT, avatar_url TEXT, credits DECIMAL(10,2) DEFAULT 2.00, created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(), updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW() ); -- Create credit transactions table CREATE TABLE IF NOT EXISTS public.credit_transactions ( id UUID DEFAULT gen_random_uuid() PRIMARY KEY, user_id UUID REFERENCES public.users(id) ON DELETE CASCADE NOT NULL, amount DECIMAL(10,2) NOT NULL, type TEXT NOT NULL CHECK (type IN ('purchase', 'usage', 'refund', 'bonus')), description TEXT NOT NULL, reference_id TEXT, -- For Stripe payment IDs or usage tracking created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW() ); -- Create usage tracking table CREATE TABLE IF NOT EXISTS public.usage_logs ( id UUID DEFAULT gen_random_uuid() PRIMARY KEY, user_id UUID REFERENCES public.users(id) ON DELETE CASCADE NOT NULL, feature_type TEXT NOT NULL CHECK (feature_type IN ('chat', 'image', 'video')), quantity INTEGER NOT NULL DEFAULT 1, cost DECIMAL(10,2) NOT NULL, metadata JSONB, -- Store additional data like tokens used, image count, etc. created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW() ); -- Create payment records table CREATE TABLE IF NOT EXISTS public.payments ( id UUID DEFAULT gen_random_uuid() PRIMARY KEY, user_id UUID REFERENCES public.users(id) ON DELETE CASCADE NOT NULL, stripe_payment_intent_id TEXT UNIQUE NOT NULL, amount DECIMAL(10,2) NOT NULL, currency TEXT DEFAULT 'usd', status TEXT NOT NULL CHECK (status IN ('pending', 'succeeded', 'failed', 'canceled')), credits_purchased DECIMAL(10,2) NOT NULL, created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(), updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW() ); -- Enable RLS on all tables ALTER TABLE public.users ENABLE ROW LEVEL SECURITY; ALTER TABLE public.credit_transactions ENABLE ROW LEVEL SECURITY; ALTER TABLE public.usage_logs ENABLE ROW LEVEL SECURITY; ALTER TABLE public.payments ENABLE ROW LEVEL SECURITY; -- Create RLS policies -- Users can only see their own data CREATE POLICY "Users can view own profile" ON public.users FOR SELECT USING (auth.uid() = id); CREATE POLICY "Users can update own profile" ON public.users FOR UPDATE USING (auth.uid() = id); -- Credit transactions policies CREATE POLICY "Users can view own transactions" ON public.credit_transactions FOR SELECT USING (auth.uid() = user_id); CREATE POLICY "System can insert transactions" ON public.credit_transactions FOR INSERT WITH CHECK (true); -- Usage logs policies CREATE POLICY "Users can view own usage" ON public.usage_logs FOR SELECT USING (auth.uid() = user_id); CREATE POLICY "System can insert usage logs" ON public.usage_logs FOR INSERT WITH CHECK (true); -- Payments policies CREATE POLICY "Users can view own payments" ON public.payments FOR SELECT USING (auth.uid() = user_id); CREATE POLICY "System can manage payments" ON public.payments FOR ALL WITH CHECK (true); -- Create indexes for better performance CREATE INDEX IF NOT EXISTS idx_credit_transactions_user_id ON public.credit_transactions(user_id); CREATE INDEX IF NOT EXISTS idx_credit_transactions_created_at ON public.credit_transactions(created_at); CREATE INDEX IF NOT EXISTS idx_usage_logs_user_id ON public.usage_logs(user_id); CREATE INDEX IF NOT EXISTS idx_usage_logs_created_at ON public.usage_logs(created_at); CREATE INDEX IF NOT EXISTS idx_payments_user_id ON public.payments(user_id); CREATE INDEX IF NOT EXISTS idx_payments_stripe_id ON public.payments(stripe_payment_intent_id); -- Create function to automatically create user profile CREATE OR REPLACE FUNCTION public.handle_new_user() RETURNS TRIGGER AS $$ BEGIN INSERT INTO public.users (id, email, full_name, avatar_url) VALUES ( NEW.id, NEW.email, NEW.raw_user_meta_data->>'full_name', NEW.raw_user_meta_data->>'avatar_url' ); -- Add welcome bonus transaction INSERT INTO public.credit_transactions (user_id, amount, type, description) VALUES (NEW.id, 2.00, 'bonus', 'Welcome bonus - $2.00 free credits'); RETURN NEW; END; $$ LANGUAGE plpgsql SECURITY DEFINER; -- Create trigger for new user signup DROP TRIGGER IF EXISTS on_auth_user_created ON auth.users; CREATE TRIGGER on_auth_user_created AFTER INSERT ON auth.users FOR EACH ROW EXECUTE FUNCTION public.handle_new_user(); -- Create function to update user credits CREATE OR REPLACE FUNCTION public.update_user_credits( p_user_id UUID, p_amount DECIMAL(10,2), p_type TEXT, p_description TEXT, p_reference_id TEXT DEFAULT NULL ) RETURNS BOOLEAN AS $$ DECLARE current_credits DECIMAL(10,2); BEGIN -- Get current credits SELECT credits INTO current_credits FROM public.users WHERE id = p_user_id; -- Check if user has enough credits for usage IF p_type = 'usage' AND current_credits < ABS(p_amount) THEN RETURN FALSE; END IF; -- Update user credits UPDATE public.users SET credits = credits + p_amount, updated_at = NOW() WHERE id = p_user_id; -- Insert transaction record INSERT INTO public.credit_transactions (user_id, amount, type, description, reference_id) VALUES (p_user_id, p_amount, p_type, p_description, p_reference_id); RETURN TRUE; END; $$ LANGUAGE plpgsql SECURITY DEFINER; [V0_FILE]plaintext:file=".env.local" isEdit="true" isMerged="true" GEMINI_API_KEY=AIzaSyACFsKpTXsr16uGcU9vrHHqlRCKh9TGrkQ # Supabase Configuration NEXT_PUBLIC_SUPABASE_URL=https://kzmlur95bdefg7qw8j79.supabase.co NEXT_PUBLIC_SUPABASE_ANON_KEY=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6Imt6bWx1cjk1YmRlZmc3cXc4ajc5Iiwicm9sZSI6ImFub24iLCJpYXQiOjE3MzQwNTI4MDAsImV4cCI6MjA0OTYyODgwMH0.VYxz9qQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ # Stripe Configuration (replace with your actual keys) STRIPE_SECRET_KEY=sk_test_your_stripe_secret_key_here STRIPE_WEBHOOK_SECRET=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 NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY=pk_live_51R4GP0FEOuqp0GHdldPZ1rwtLnkASx0XcZZdoiZWXma0NPgdIIzud8c5onFBUTYUwdbnYrDq7ywuRgb5O1sWoq2v00ADSDj9fM # Site Configuration NEXT_PUBLIC_SITE_URL=https://www.eqqal.com # Development Supabase Redirect (for local development) NEXT_PUBLIC_DEV_SUPABASE_REDIRECT_URL=http://localhost:3000 [V0_FILE]typescriptreact:file="app/auth/login/page.tsx" isEdit="true" isMerged="true" import { createClient, isSupabaseConfigured } from "@/lib/supabase/server" import { redirect } from "next/navigation" import LoginForm from "@/components/login-form" export default async function LoginPage() { // If Supabase is not configured, show setup message directly if (!isSupabaseConfigured) { return (

Connect Supabase to get started

) } try { // Check if user is already logged in with a valid session const supabase = await createClient() const { data: { user }, error, } = await supabase.auth.getUser() // Only redirect if we have a valid user (not just a session) if (user && !error) { redirect("/") } } catch (error) { // If there's an error getting the user, continue to show login form console.log("Auth check error:", error) } return (

) } [V0_FILE]typescriptreact:file="lib/supabase/client.ts" isEdit="true" isMerged="true" import { createBrowserClient } from "@supabase/ssr" // Check if Supabase environment variables are available export const isSupabaseConfigured = typeof process.env.NEXT_PUBLIC_SUPABASE_URL === "string" && process.env.NEXT_PUBLIC_SUPABASE_URL.length > 0 && typeof process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY === "string" && process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY.length > 0 // Create a singleton instance of the Supabase client for Client Components export const supabase = createBrowserClient( process.env.NEXT_PUBLIC_SUPABASE_URL!, process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!, ) export function createClient() { return createBrowserClient(process.env.NEXT_PUBLIC_SUPABASE_URL!, process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!) } [V0_FILE]typescriptreact:file="app/terms/page.tsx" isMerged="true" export default function TermsOfService() { return (

Terms of Service

1. Acceptance of Terms

By accessing and using Eqqal AI, you accept and agree to be bound by the terms and provision of this agreement.

2. Service Description

Eqqal AI provides artificial intelligence-powered services including:

AI chat conversations using advanced language models
AI-powered image generation
AI-powered video generation

3. Credit System and Payments

Our service operates on a credit-based system:

New users receive $2.00 in welcome credits upon registration
Additional credits can be purchased through our secure payment system
All credit purchases are final and non-refundable
Credits do not expire but are consumed based on usage
Pricing: Chat ($5.00 per 1M tokens), Images ($0.30 each), Videos ($1.00 each)

4. Data Privacy and Storage

We prioritize your privacy:

We do not save or store your conversation history
We do not collect personal data beyond what is necessary for account creation
Generated content (images, videos) is not stored on our servers
Your prompts and generated content are processed temporarily and then discarded

5. User Responsibilities

Users agree to:

Use the service in compliance with all applicable laws
Not generate harmful, illegal, or inappropriate content
Not attempt to reverse engineer or exploit the service
Maintain the security of their account credentials

6. Service Availability

While we strive for 100% uptime, we cannot guarantee uninterrupted service. We reserve the right to modify or discontinue the service with reasonable notice.

7. Limitation of Liability

Eqqal AI shall not be liable for any indirect, incidental, special, consequential, or punitive damages resulting from your use of the service.

8. Changes to Terms

We reserve the right to modify these terms at any time. Continued use of the service constitutes acceptance of modified terms.

9. Contact Information

For questions about these terms, please contact us through our support channels.

Last updated: {new Date().toLocaleDateString()}

) } [V0_FILE]typescriptreact:file="app/privacy/page.tsx" isMerged="true" export default function PrivacyPolicy() { return (

Privacy Policy

1. Information We Collect

We collect minimal information necessary to provide our services:

Email address (for account creation and authentication)
Payment information (processed securely through Stripe)
Usage statistics (for billing and service improvement)

2. What We Don't Collect or Store

Your privacy is our priority. We explicitly do NOT:

Store your conversation history or chat messages
Save your generated images or videos
Keep records of your prompts or queries
Track your browsing behavior outside our service
Collect personal information beyond account essentials

3. How We Use Your Information

The limited information we collect is used solely for:

Account authentication and management
Processing payments and managing credits
Providing customer support when requested
Ensuring service security and preventing abuse

4. Data Processing and Temporary Storage

When you use our AI services:

Your prompts are processed temporarily to generate responses
Generated content is delivered to you and then discarded
No permanent records of your creative content are maintained
Processing occurs in secure, encrypted environments

5. Third-Party Services

We use trusted third-party services:

Stripe for secure payment processing
Google AI services for content generation
Supabase for secure user authentication

These services have their own privacy policies and security measures.

6. Data Security

We implement industry-standard security measures:

Encrypted data transmission (HTTPS/TLS)
Secure authentication systems
Regular security audits and updates
Limited access to user data on a need-to-know basis

7. Your Rights

You have the right to:

Access your account information
Delete your account and associated data
Request information about data we hold
Opt out of non-essential communications

8. Children's Privacy

Our service is not intended for children under 13. We do not knowingly collect personal information from children under 13.

9. Changes to This Policy

We may update this privacy policy from time to time. We will notify users of any material changes through our service.

10. Contact Us

If you have any questions about this privacy policy or our data practices, please contact us through our support channels.

Last updated: {new Date().toLocaleDateString()}

) } [V0_FILE]typescriptreact:file="components/custom-dialog.tsx" isEdit="true" isMerged="true" "use client" import { Dialog, DialogContent, DialogHeader, DialogTitle } from "@/components/ui/dialog" import { Button } from "@/components/ui/button" import { AlertTriangle, Info } from "lucide-react" interface CustomDialogProps { isOpen: boolean onClose: () => void title: string message: string type?: "info" | "warning" | "error" } export function CustomDialog({ isOpen, onClose, title, message, type = "info" }: CustomDialogProps) { const getIcon = () => { switch (type) { case "warning": case "error": return default: return } } return ( ) } [V0_FILE]typescriptreact:file="lib/credits.ts" isEdit="true" isMerged="true" import { createClient } from "@/lib/supabase/server" // Credit costs for different features export const CREDIT_COSTS = { IMAGE: 0.3, VIDEO: 1.0, CHAT_PER_1M_TOKENS: 5.0, } as const // Calculate chat cost based on tokens export function calculateChatCost(tokens: number): number { return (tokens / 1000000) * CREDIT_COSTS.CHAT_PER_1M_TOKENS } // Check if user has enough credits export async function checkUserCredits(userId: string, requiredAmount: number): Promise { const supabase = await createClient() const { data: user } = await supabase.from("users").select("credits").eq("id", userId).single() if (!user) return false return user.credits >= requiredAmount } // Deduct credits from user account export async function deductCredits( userId: string, amount: number, featureType: "chat" | "image" | "video", description: string, metadata?: any, ): Promise<{ success: boolean; newBalance?: number; error?: string }> { const supabase = await createClient() try { // Call the database function to update credits const { data, error } = await supabase.rpc("update_user_credits", { p_user_id: userId, p_amount: -Math.abs(amount), // Ensure negative for deduction p_type: "usage", p_description: description, p_reference_id: null, }) if (error) { return { success: false, error: error.message } } if (!data) { return { success: false, error: "Insufficient credits" } } // Log the usage await supabase.from("usage_logs").insert({ user_id: userId, feature_type: featureType, quantity: featureType === "chat" ? Math.ceil(metadata?.tokens || 0) : 1, cost: amount, metadata: metadata || {}, }) // Get updated balance const { data: updatedUser } = await supabase.from("users").select("credits").eq("id", userId).single() return { success: true, newBalance: updatedUser?.credits || 0, } } catch (error) { return { success: false, error: error instanceof Error ? error.message : "Unknown error", } } } // Get user's credit balance and recent transactions export async function getUserCreditsInfo(userId: string) { const supabase = await createClient() const [userResult, transactionsResult, usageResult] = await Promise.all([ supabase.from("users").select("credits").eq("id", userId).single(), supabase .from("credit_transactions") .select("*") .eq("user_id", userId) .order("created_at", { ascending: false }) .limit(10), supabase.from("usage_logs").select("*").eq("user_id", userId).order("created_at", { ascending: false }).limit(5), ]) return { credits: userResult.data?.credits || 0, transactions: transactionsResult.data || [], recentUsage: usageResult.data || [], } } [V0_FILE]sql:file="scripts/02_fix_existing_users.sql" isMerged="true" -- Fix existing users who don't have welcome credits -- This script adds $2.00 welcome credits to users who have $0.00 balance DO $$ DECLARE user_record RECORD; BEGIN -- Find users with 0 credits and no welcome bonus transaction FOR user_record IN SELECT u.id, u.email FROM public.users u WHERE u.credits = 0.00 AND NOT EXISTS ( SELECT 1 FROM public.credit_transactions ct WHERE ct.user_id = u.id AND ct.type = 'bonus' AND ct.description LIKE '%Welcome bonus%' ) LOOP -- Update user credits to $2.00 UPDATE public.users SET credits = 2.00, updated_at = NOW() WHERE id = user_record.id; -- Add welcome bonus transaction INSERT INTO public.credit_transactions (user_id, amount, type, description) VALUES (user_record.id, 2.00, 'bonus', 'Welcome bonus - $2.00 free credits (retroactive)'); RAISE NOTICE 'Added welcome credits for user: %', user_record.email; END LOOP; END $$; [V0_FILE]typescriptreact:file="app/api/credits/check/route.ts" isEdit="true" isMerged="true" import { createClient } from "@/lib/supabase/server" import { type NextRequest, NextResponse } from "next/server" export async function POST(request: NextRequest) { try { const { amount } = await request.json() const supabase = await createClient() const { data: { user }, } = await supabase.auth.getUser() if (!user) { console.log("No user found in credits check") return NextResponse.json({ error: "Unauthorized" }, { status: 401 }) } console.log("Checking credits for user:", user.id) // First check if user profile exists const { data: userProfile, error: profileError } = await supabase .from("users") .select("credits") .eq("id", user.id) .single() if (profileError) { console.error("Error fetching user profile:", profileError) // If user profile doesn't exist, create it with welcome credits if (profileError.code === "PGRST116") { console.log("User profile not found, creating with welcome credits...") const { data: newProfile, error: createError } = await supabase .from("users") .insert({ id: user.id, email: user.email, credits: 2.0, }) .select("credits") .single() if (createError) { console.error("Error creating user profile:", createError) return NextResponse.json({ error: "Failed to create user profile" }, { status: 500 }) } // Also create welcome bonus transaction await supabase.from("credit_transactions").insert({ user_id: user.id, amount: 2.0, type: "bonus", description: "Welcome bonus - $2.00 free credits", }) console.log("Created user profile with credits:", newProfile?.credits) return NextResponse.json({ hasEnoughCredits: (newProfile?.credits || 0) >= amount, currentCredits: newProfile?.credits || 0, requiredCredits: amount, }) } return NextResponse.json({ error: "Failed to fetch user profile" }, { status: 500 }) } const currentCredits = userProfile?.credits || 0 console.log("User credits found:", currentCredits) const hasEnoughCredits = currentCredits >= amount return NextResponse.json({ hasEnoughCredits, currentCredits, requiredCredits: amount, }) } catch (error) { console.error("Credit check error:", error) return NextResponse.json({ error: "Failed to check credits" }, { status: 500 }) } } [V0_FILE]typescriptreact:file="types/user.ts" isMerged="true" export interface User { id: string email?: string user_metadata?: { [key: string]: any } app_metadata?: { [key: string]: any } aud: string created_at?: string updated_at?: string email_confirmed_at?: string phone?: string phone_confirmed_at?: string last_sign_in_at?: string role?: string } [V0_FILE]typescriptreact:file="components/credits-client.tsx" isEdit="true" isMerged="true" "use client" import { useState, useEffect } from "react" import { createClient } from "@/lib/supabase/client" import CreditsPurchase from "@/components/credits-purchase" interface Transaction { id: string created_at: string type: string description: string amount: number } interface Usage { id: string created_at: string feature_type: string cost: number quantity: number metadata?: any } interface CreditsInfo { credits: number transactions: Transaction[] recentUsage: Usage[] } interface CreditsClientProps { user: any initialCreditsInfo: CreditsInfo } export default function CreditsClient({ user, initialCreditsInfo }: CreditsClientProps) { const [creditsInfo, setCreditsInfo] = useState(initialCreditsInfo) const [isLoading, setIsLoading] = useState(false) useEffect(() => { const supabase = createClient() // Subscribe to user credits changes const userChannel = supabase .channel("user-credits-page") .on( "postgres_changes", { event: "UPDATE", schema: "public", table: "users", filter: `id=eq.${user.id}`, }, (payload) => { console.log("Credits page - user update:", payload) if (payload.new && typeof payload.new.credits === "number") { setCreditsInfo((prev) => ({ ...prev, credits: payload.new.credits, })) } }, ) .subscribe() // Subscribe to new transactions const transactionChannel = supabase .channel("user-transactions") .on( "postgres_changes", { event: "INSERT", schema: "public", table: "credit_transactions", filter: `user_id=eq.${user.id}`, }, (payload) => { console.log("New transaction:", payload) if (payload.new) { setCreditsInfo((prev) => ({ ...prev, transactions: [payload.new as Transaction, ...prev.transactions].slice(0, 10), })) } }, ) .subscribe() // Subscribe to new usage logs const usageChannel = supabase .channel("user-usage") .on( "postgres_changes", { event: "INSERT", schema: "public", table: "usage_logs", filter: `user_id=eq.${user.id}`, }, (payload) => { console.log("New usage:", payload) if (payload.new) { setCreditsInfo((prev) => ({ ...prev, recentUsage: [payload.new as Usage, ...prev.recentUsage].slice(0, 10), })) } }, ) .subscribe() // Listen for credit updates from other parts of the app const handleCreditsUpdate = (event: CustomEvent) => { setCreditsInfo((prev) => ({ ...prev, credits: event.detail.credits, })) } window.addEventListener("creditsUpdated", handleCreditsUpdate as EventListener) return () => { userChannel.unsubscribe() transactionChannel.unsubscribe() usageChannel.unsubscribe() window.removeEventListener("creditsUpdated", handleCreditsUpdate as EventListener) } }, [user.id]) const refreshData = async () => { setIsLoading(true) try { const response = await fetch("/api/credits/info", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ userId: user.id }), }) if (response.ok) { const data = await response.json() setCreditsInfo(data) } } catch (error) { console.error("Failed to refresh credits info:", error) } finally { setIsLoading(false) } } const formatUsageDetails = (usage: Usage) => { const details = [] if (usage.metadata) { if (usage.feature_type === "chat" && usage.metadata.totalTokens) { details.push(`${usage.metadata.totalTokens.toLocaleString()} tokens`) } if (usage.feature_type === "image") { if (usage.metadata.count) details.push(`${usage.metadata.count} image(s)`) if (usage.metadata.aspectRatio) details.push(`${usage.metadata.aspectRatio}`) } if (usage.feature_type === "video") { if (usage.metadata.duration) details.push(`${usage.metadata.duration}s`) if (usage.metadata.aspectRatio) details.push(`${usage.metadata.aspectRatio}`) } } return details.length > 0 ? details.join(" • ") : "" } return (

{/* Current Balance */}

Current Balance

${creditsInfo.credits.toFixed(2)}

Available credits

{/* Purchase Credits */}

Purchase Credits

{/* Recent Transactions */}

Recent Transactions

{creditsInfo.transactions.map((transaction) => ( ))}

Date	Type	Description	Amount
{new Date(transaction.created_at).toLocaleDateString()}	{transaction.type}	{transaction.description}	0 ? "text-black" : "text-black"}> {transaction.amount > 0 ? "+" : ""}${Math.abs(transaction.amount).toFixed(2)}

Recent Usage History

{creditsInfo.recentUsage.length > 0 ? ( creditsInfo.recentUsage.map((usage) => ( )) ) : ( )}

Date	Feature	Details	Cost
{new Date(usage.created_at).toLocaleDateString()}{" "} {new Date(usage.created_at).toLocaleTimeString()}	{usage.feature_type}	{formatUsageDetails(usage) \|\| `Quantity: ${usage.quantity}`}	-${usage.cost.toFixed(2)}
No usage history yet. Start using AI features to see your activity here.

) } [V0_FILE]typescriptreact:file="app/admin/login/page.tsx" isMerged="true" "use client" import type React from "react" import { useState } from "react" import { Button } from "@/components/ui/button" import { Input } from "@/components/ui/input" import { Label } from "@/components/ui/label" import { useRouter } from "next/navigation" export default function AdminLoginPage() { const [email, setEmail] = useState("") const [password, setPassword] = useState("") const [error, setError] = useState("") const [isLoading, setIsLoading] = useState(false) const router = useRouter() const handleLogin = async (e: React.FormEvent) => { e.preventDefault() setIsLoading(true) setError("") try { const response = await fetch("/api/admin/auth", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ email, password }), }) const data = await response.json() if (data.success) { router.push("/admin/dashboard") } else { setError(data.error || "Invalid credentials") } } catch (error) { setError("Login failed. Please try again.") } finally { setIsLoading(false) } } return (

Admin Login

Access the admin dashboard

) } [V0_FILE]typescriptreact:file="app/admin/dashboard/page.tsx" isMerged="true" import { checkAdminAuth } from "@/lib/admin-auth" import AdminDashboard from "@/components/admin-dashboard" export default async function AdminDashboardPage() { await checkAdminAuth() return } [V0_FILE]typescriptreact:file="app/api/admin/signout/route.ts" isMerged="true" import { type NextRequest, NextResponse } from "next/server" import { cookies } from "next/headers" export async function POST(request: NextRequest) { try { const cookieStore = await cookies() cookieStore.delete("admin_session") return NextResponse.json({ success: true }) } catch (error) { console.error("Admin signout error:", error) return NextResponse.json({ success: false, error: "Signout failed" }, { status: 500 }) } } [V0_FILE]typescriptreact:file="app/api/admin/credits/add/route.ts" isFixed="true" isEdit="true" isQuickEdit="true" isMerged="true" import { type NextRequest, NextResponse } from "next/server" import { cookies } from "next/headers" import { createClient } from "@/lib/supabase/server" export async function POST(request: NextRequest) { try { // Check admin authentication const cookieStore = await cookies() const adminSession = cookieStore.get("admin_session") if (!adminSession || adminSession.value !== "admin_authenticated") { return NextResponse.json({ error: "Unauthorized" }, { status: 401 }) } const { userEmail, amount, description } = await request.json() if (!userEmail || !amount || amount <= 0) { return NextResponse.json({ error: "Invalid input" }, { status: 400 }) } const supabase = await createClient() // Find user by email const { data: user, error: userError } = await supabase .from("users") .select("id, email, credits") .eq("email", userEmail) .single() if (userError || !user) { return NextResponse.json({ error: "User not found" }, { status: 404 }) } // Add credits using the stored procedure const { data, error } = await supabase.rpc("update_user_credits", { p_user_id: user.id, p_amount: amount, p_type: "bonus", p_description: description || `Admin credit bonus - $${amount.toFixed(2)}`, p_reference_id: `admin_${Date.now()}`, }) if (error) { console.error("Credit update error:", error) return NextResponse.json({ error: "Failed to add credits" }, { status: 500 }) } // Get updated user credits const { data: updatedUser } = await supabase.from("users").select("credits").eq("id", user.id).single() try { await supabase.channel("user-notifications").send({ type: "broadcast", event: "credit_added", payload: { user_id: user.id, amount: amount, new_balance: updatedUser?.credits || user.credits + amount, message: `Admin added $${amount.toFixed(2)} credits to your account`, }, }) } catch (notificationError) { console.log("Notification send failed:", notificationError) // Don't fail the request if notification fails } return NextResponse.json({ success: true, user: { email: user.email, previousCredits: user.credits, newCredits: updatedUser?.credits || user.credits + amount, amountAdded: amount, }, }) } catch (error) { console.error("Add credits error:", error) return NextResponse.json({ error: "Failed to add credits" }, { status: 500 }) } } [V0_FILE]typescriptreact:file="middleware.ts" isEdit="true" isMerged="true" import { updateSession } from "@/lib/supabase/middleware" import { NextResponse } from "next/server" import type { NextRequest } from "next/server" export async function middleware(request: NextRequest) { // Handle admin routes separately to avoid Supabase middleware interference if (request.nextUrl.pathname.startsWith("/admin")) { // For admin routes, just continue without Supabase session handling return NextResponse.next() } // For all other routes, use Supabase middleware return await updateSession(request) } export const config = { matcher: [ /* * Match all request paths except for the ones starting with: * - _next/static (static files) * - _next/image (image optimization files) * - favicon.ico (favicon file) * Feel free to modify this pattern to include more paths. */ "/((?!_next/static|_next/image|favicon.ico|.*.(?:svg|png|jpg|jpeg|gif|webp)$).*)", ], } [V0_FILE]typescriptreact:file="app/api/admin/auth/route.ts" isFixed="true" isEdit="true" isQuickEdit="true" isMerged="true" import { type NextRequest, NextResponse } from "next/server" import { cookies } from "next/headers" const ADMIN_EMAIL = "admin@eqqal.com" const ADMIN_PASSWORD = "EqqalAdmin2025!" export async function POST(request: NextRequest) { try { const { email, password } = await request.json() if (email === ADMIN_EMAIL && password === ADMIN_PASSWORD) { const cookieStore = await cookies() cookieStore.set("admin_session", "admin_authenticated", { httpOnly: true, secure: process.env.NODE_ENV === "production", sameSite: "lax", maxAge: 60 * 60 * 24, // 24 hours }) return NextResponse.json({ success: true }) } return NextResponse.json({ success: false, error: "Invalid credentials" }, { status: 401 }) } catch (error) { console.error("Admin auth error:", error) return NextResponse.json({ success: false, error: "Authentication failed" }, { status: 500 }) } } [V0_FILE]typescriptreact:file="lib/admin-auth.ts" isFixed="true" isEdit="true" isQuickEdit="true" isMerged="true" import { cookies } from "next/headers" import { redirect } from "next/navigation" export async function checkAdminAuth() { const cookieStore = await cookies() const adminSession = cookieStore.get("admin_session") if (!adminSession || adminSession.value !== "admin_authenticated") { redirect("/admin/login") } return true } export async function signOutAdmin() { const cookieStore = await cookies() cookieStore.delete("admin_session") redirect("/admin/login") } [V0_FILE]typescriptreact:file="utils/dialog.ts" isMerged="true" const dialogState: { isOpen: boolean title: string message: string type?: "info" | "warning" | "error" } = { isOpen: false, title: "", message: "", type: "info", } let dialogSetter: ((state: typeof dialogState) => void) | null = null export const setDialogSetter = (setter: (state: typeof dialogState) => void) => { dialogSetter = setter } export const showDialog = (title: string, message: string, type: "info" | "warning" | "error" = "info") => { if (dialogSetter) { dialogSetter({ isOpen: true, title, message, type, }) } } export const closeDialog = () => { if (dialogSetter) { dialogSetter({ isOpen: false, title: "", message: "", type: "info", }) } } [V0_FILE]css:file="app/globals.css" isFixed="true" isQuickEdit="true" isMerged="true" @import "tailwindcss"; @import "tw-animate-css"; @custom-variant dark (&:is(.dark *)); :root { --background: oklch(1 0 0); --foreground: oklch(0.145 0 0); --card: oklch(1 0 0); --card-foreground: oklch(0.145 0 0); --popover: oklch(1 0 0); --popover-foreground: oklch(0.145 0 0); --primary: oklch(0.205 0 0); --primary-foreground: oklch(0.985 0 0); --secondary: oklch(0.97 0 0); --secondary-foreground: oklch(0.205 0 0); --muted: oklch(0.97 0 0); --muted-foreground: oklch(0.556 0 0); --accent: oklch(0.97 0 0); --accent-foreground: oklch(0.205 0 0); --destructive: oklch(0.577 0.245 27.325); --destructive-foreground: oklch(0.577 0.245 27.325); --border: oklch(0.922 0 0); --input: oklch(0.922 0 0); --ring: oklch(0.708 0 0); --chart-1: oklch(0.646 0.222 41.116); --chart-2: oklch(0.6 0.118 184.704); --chart-3: oklch(0.398 0.07 227.392); --chart-4: oklch(0.828 0.189 84.429); --chart-5: oklch(0.769 0.188 70.08); --radius: 0.625rem; --sidebar: oklch(0.985 0 0); --sidebar-foreground: oklch(0.145 0 0); --sidebar-primary: oklch(0.205 0 0); --sidebar-primary-foreground: oklch(0.985 0 0); --sidebar-accent: oklch(0.97 0 0); --sidebar-accent-foreground: oklch(0.205 0 0); --sidebar-border: oklch(0.922 0 0); --sidebar-ring: oklch(0.708 0 0); } .dark { --background: oklch(0.145 0 0); --foreground: oklch(0.985 0 0); --card: oklch(0.145 0 0); --card-foreground: oklch(0.985 0 0); --popover: oklch(0.145 0 0); --popover-foreground: oklch(0.985 0 0); --primary: oklch(0.985 0 0); --primary-foreground: oklch(0.205 0 0); --secondary: oklch(0.269 0 0); --secondary-foreground: oklch(0.985 0 0); --muted: oklch(0.269 0 0); --muted-foreground: oklch(0.708 0 0); --accent: oklch(0.269 0 0); --accent-foreground: oklch(0.985 0 0); --destructive: oklch(0.396 0.141 25.723); --destructive-foreground: oklch(0.637 0.237 25.331); --border: oklch(0.269 0 0); --input: oklch(0.269 0 0); --ring: oklch(0.439 0 0); --chart-1: oklch(0.488 0.243 264.376); --chart-2: oklch(0.696 0.17 162.48); --chart-3: oklch(0.769 0.188 70.08); --chart-4: oklch(0.627 0.265 303.9); --chart-5: oklch(0.645 0.246 16.439); --sidebar: oklch(0.205 0 0); --sidebar-foreground: oklch(0.985 0 0); --sidebar-primary: oklch(0.488 0.243 264.376); --sidebar-primary-foreground: oklch(0.985 0 0); --sidebar-accent: oklch(0.269 0 0); --sidebar-accent-foreground: oklch(0.985 0 0); --sidebar-border: oklch(0.269 0 0); --sidebar-ring: oklch(0.439 0 0); } @theme inline { --color-background: var(--background); --color-foreground: var(--foreground); --color-card: var(--card); --color-card-foreground: var(--card-foreground); --color-popover: var(--popover); --color-popover-foreground: var(--popover-foreground); --color-primary: var(--primary); --color-primary-foreground: var(--primary-foreground); --color-secondary: var(--secondary); --color-secondary-foreground: var(--secondary-foreground); --color-muted: var(--muted); --color-muted-foreground: var(--muted-foreground); --color-accent: var(--accent); --color-accent-foreground: var(--accent-foreground); --color-destructive: var(--destructive); --color-destructive-foreground: var(--destructive-foreground); --color-border: var(--border); --color-input: var(--input); --color-ring: var(--ring); --color-chart-1: var(--chart-1); --color-chart-2: var(--chart-2); --color-chart-3: var(--chart-3); --color-chart-4: var(--chart-4); --color-chart-5: var(--chart-5); --radius-sm: calc(var(--radius) - 4px); --radius-md: calc(var(--radius) - 2px); --radius-lg: var(--radius); --radius-xl: calc(var(--radius) + 4px); --color-sidebar: var(--sidebar); --color-sidebar-foreground: var(--sidebar-foreground); --color-sidebar-primary: var(--sidebar-primary); --color-sidebar-primary-foreground: var(--sidebar-primary-foreground); --color-sidebar-accent: var(--sidebar-accent); --color-sidebar-accent-foreground: var(--sidebar-accent-foreground); --color-sidebar-border: var(--sidebar-border); --color-sidebar-ring: var(--sidebar-ring); } @layer base { * { @apply border-border outline-ring/50; } body { @apply bg-background text-foreground; } } @layer utilities { .slide-in-from-top { animation: slide-in-from-top 0.5s ease-out; } .slide-in-from-bottom { animation: slide-in-from-bottom 0.5s ease-out; } .slide-in-from-left { animation: slide-in-from-left 0.5s ease-out; } .slide-in-from-right { animation: slide-in-from-right 0.5s ease-out; } .slide-out-to-top { animation: slide-out-to-top 0.3s ease-in; } .slide-out-to-bottom { animation: slide-out-to-bottom 0.3s ease-in; } .slide-out-to-left { animation: slide-out-to-left 0.3s ease-in; } .slide-out-to-right { animation: slide-out-to-right 0.3s ease-in; } } @keyframes slide-in-from-top { from { transform: translateY(-100%); } to { transform: translateY(0); } } @keyframes slide-in-from-bottom { from { transform: translateY(100%); } to { transform: translateY(0); } } @keyframes slide-in-from-left { from { transform: translateX(-100%); } to { transform: translateX(0); } } @keyframes slide-in-from-right { from { transform: translateX(100%); } to { transform: translateX(0); } } @keyframes slide-out-to-top { from { transform: translateY(0); } to { transform: translateY(-100%); } } @keyframes slide-out-to-bottom { from { transform: translateY(0); } to { transform: translateY(100%); } } @keyframes slide-out-to-left { from { transform: translateX(0); } to { transform: translateX(-100%); } } @keyframes slide-out-to-right { from { transform: translateX(0); } to { transform: translateX(100%); } } [V0_FILE]typescriptreact:file="app/api/admin/credits/bulk/route.ts" isFixed="true" isEdit="true" isQuickEdit="true" isMerged="true" import { type NextRequest, NextResponse } from "next/server" import { cookies } from "next/headers" import { createClient } from "@/lib/supabase/server" export async function POST(request: NextRequest) { try { // Check admin authentication const cookieStore = await cookies() const adminSession = cookieStore.get("admin_session") if (!adminSession || adminSession.value !== "admin_authenticated") { return NextResponse.json({ error: "Unauthorized" }, { status: 401 }) } const { amount, description, userFilter } = await request.json() if (!amount || amount <= 0) { return NextResponse.json({ error: "Invalid amount" }, { status: 400 }) } const supabase = await createClient() // Build query based on filter let query = supabase.from("users").select("id, email, credits") if (userFilter === "new") { // Users created in the last 7 days const sevenDaysAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString() query = query.gte("created_at", sevenDaysAgo) } else if (userFilter === "active") { // Users who have used features in the last 30 days const thirtyDaysAgo = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000).toISOString() const { data: activeUserIds } = await supabase .from("usage_logs") .select("user_id") .gte("created_at", thirtyDaysAgo) const uniqueUserIds = [...new Set(activeUserIds?.map((log) => log.user_id) || [])] query = query.in("id", uniqueUserIds) } // If userFilter is "all" or undefined, no additional filter is applied const { data: users, error: usersError } = await query if (usersError) { return NextResponse.json({ error: "Failed to fetch users" }, { status: 500 }) } if (!users || users.length === 0) { return NextResponse.json({ error: "No users found matching criteria" }, { status: 404 }) } // Add credits to all users const results = [] const referenceId = `bulk_admin_${Date.now()}` for (const user of users) { try { await supabase.rpc("update_user_credits", { p_user_id: user.id, p_amount: amount, p_type: "bonus", p_description: description || `Bulk admin credit bonus - $${amount.toFixed(2)}`, p_reference_id: referenceId, }) results.push({ email: user.email, success: true, previousCredits: user.credits, newCredits: user.credits + amount, }) } catch (error) { results.push({ email: user.email, success: false, error: "Failed to update credits", }) } } const successCount = results.filter((r) => r.success).length const failureCount = results.filter((r) => !r.success).length return NextResponse.json({ success: true, totalUsers: users.length, successCount, failureCount, amountPerUser: amount, totalCreditsAdded: successCount * amount, results, }) } catch (error) { console.error("Bulk credits error:", error) return NextResponse.json({ error: "Failed to add bulk credits" }, { status: 500 }) } } [V0_FILE]typescriptreact:file="app/api/generate-image/route.ts" isFixed="true" isEdit="true" isQuickEdit="true" isMerged="true" import { GoogleGenAI, PersonGeneration } from "@google/genai" import { createClient } from "@/lib/supabase/server" import { NextResponse } from "next/server" export async function POST(request: Request) { try { const { prompt, imageCount = 1, aspectRatio = "1:1", userId } = await request.json() console.log("[v0] Image generation request:", { prompt: prompt.substring(0, 50), imageCount, aspectRatio, userId }) if (!prompt) { return NextResponse.json({ error: "Prompt is required" }, { status: 400 }) } if (!process.env.GEMINI_API_KEY) { return NextResponse.json({ error: "API key not configured" }, { status: 500 }) } const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY, }) const numberOfImages = Math.min(imageCount, 4) // Max 4 images per request console.log("[v0] Sending to Google API:", { numberOfImages, aspectRatio }) const response = await ai.models.generateImages({ model: "models/imagen-3.0-generate-002", prompt: prompt, config: { numberOfImages: numberOfImages, outputMimeType: "image/jpeg", personGeneration: PersonGeneration.ALLOW_ALL, aspectRatio: aspectRatio, }, }) console.log("[v0] Google API response:", { hasGeneratedImages: !!response?.generatedImages, imageCount: response?.generatedImages?.length || 0, }) if (!response?.generatedImages || response.generatedImages.length === 0) { return NextResponse.json({ error: "No images generated. Please try a different prompt." }, { status: 500 }) } const images = [] for (let i = 0; i < response.generatedImages.length; i++) { const generatedImage = response.generatedImages[i] if (!generatedImage?.image?.imageBytes) { console.log("[v0] Skipping image", i, "- no imageBytes") continue } let base64Data = generatedImage.image.imageBytes if (!base64Data.startsWith("data:")) { base64Data = `data:image/jpeg;base64,${base64Data}` } images.push({ base64: base64Data, prompt: prompt, aspectRatio, generatedAt: new Date().toISOString(), model: "imagen-3.0-generate-002", }) } console.log("[v0] Final processed images:", { requested: imageCount, received: response.generatedImages.length, processed: images.length, }) if (images.length === 0) { return NextResponse.json({ error: "Failed to process generated images. Please try again." }, { status: 500 }) } if (userId && images.length > 0) { try { const supabase = await createClient() const cost = images.length * 0.05 // Estimated cost per image await supabase.from("usage_logs").insert({ user_id: userId, feature_type: "image", cost: cost, metadata: { prompt: prompt.substring(0, 200), imageCount: images.length, aspectRatio: aspectRatio, model: "imagen-3.0-generate-002", success: true, }, description: `Generated ${images.length} image${images.length > 1 ? "s" : ""}`, }) } catch (dbError) { console.error("Failed to log image usage:", dbError) } } return NextResponse.json({ success: true, images, metadata: { prompt, imageCount: images.length, aspectRatio, generatedAt: new Date().toISOString(), model: "imagen-3.0-generate-002", }, }) } catch (error: any) { console.error("[v0] Image generation error:", error) if (error?.userId) { try { const supabase = await createClient() await supabase.from("usage_logs").insert({ user_id: error.userId, feature_type: "image", cost: 0, metadata: { prompt: error.prompt?.substring(0, 200) || "Unknown", error: error.message, success: false, }, description: "Image generation failed", }) } catch (dbError) { console.error("Failed to log failed image generation:", dbError) } } if (error?.message?.includes("SAFETY")) { return NextResponse.json( { error: "Content policy violation. Please modify your prompt and try again." }, { status: 400 }, ) } if (error?.message?.includes("QUOTA_EXCEEDED")) { return NextResponse.json({ error: "API quota exceeded. Please try again later." }, { status: 429 }) } if (error?.message?.includes("INVALID_ARGUMENT")) { return NextResponse.json({ error: "Invalid prompt or parameters. Please check your input." }, { status: 400 }) } return NextResponse.json( { error: "Image generation service temporarily unavailable. Please try again later.", technical: error instanceof Error ? error.message : "Unknown error", }, { status: 500 }, ) } } [V0_FILE]xml:file="public/sitemap.xml" isMerged="true" https://www.eqqal.com/ 2025-01-15 daily 1.0 https://www.eqqal.com/og-image.jpg Eqqal AI Platform Advanced AI platform for image, video and chat generation https://www.eqqal.com/auth/login 2025-01-15 monthly 0.8 https://www.eqqal.com/terms 2025-01-15 yearly 0.5 https://www.eqqal.com/privacy 2025-01-15 yearly 0.5 [V0_FILE]plaintext:file="public/robots.txt" isMerged="true" User-agent: * Allow: / Disallow: /admin/ Disallow: /api/ Disallow: /auth/callback # Sitemap Sitemap: https://www.eqqal.com/sitemap.xml # Crawl-delay for respectful crawling Crawl-delay: 1 # Allow specific bots User-agent: Googlebot Allow: / User-agent: Bingbot Allow: / User-agent: Slurp Allow: / [V0_FILE]json:file="public/manifest.json" isEdit="true" isMerged="true" { "name": "Eqqal AI - Advanced AI Chat, Image & Video Generation Platform", "short_name": "Eqqal AI", "description": "Create stunning AI-generated images, videos, and chat with advanced AI models. Powered by Google's Gemini and Veo technologies. Free credits for new users!", "start_url": "/", "display": "standalone", "orientation": "portrait-primary", "background_color": "#ffffff", "theme_color": "#000000", "categories": ["productivity", "utilities", "entertainment"], "lang": "en", "scope": "/", "icons": [ { "src": "/og-image.jpg", "sizes": "192x192", "type": "image/jpeg", "purpose": "any maskable" }, { "src": "/og-image.jpg", "sizes": "512x512", "type": "image/jpeg", "purpose": "any maskable" } ], "screenshots": [ { "src": "/og-image.jpg", "sizes": "1200x630", "type": "image/jpeg", "form_factor": "wide", "label": "Eqqal AI Platform Interface" } ], "shortcuts": [ { "name": "Generate Image", "short_name": "Image", "description": "Create AI-generated images", "url": "/?mode=image", "icons": [ { "src": "/og-image.jpg", "sizes": "96x96" } ] }, { "name": "Chat with AI", "short_name": "Chat", "description": "Chat with advanced AI models", "url": "/?mode=chat", "icons": [ { "src": "/og-image.jpg", "sizes": "96x96" } ] } ] } [V0_FILE]typescriptreact:file="components/analytics.tsx" isMerged="true" "use client" import { useEffect } from "react" import { usePathname, useSearchParams } from "next/navigation" // Google Analytics tracking function export const gtag = (...args: any[]) => { if (typeof window !== "undefined" && (window as any).gtag) { ;(window as any).gtag(...args) } } // Track page views export const trackPageView = (url: string) => { gtag("config", "GA_MEASUREMENT_ID", { page_path: url, }) } // Track custom events export const trackEvent = (action: string, category: string, label?: string, value?: number) => { gtag("event", action, { event_category: category, event_label: label, value: value, }) } // Analytics component to track route changes export default function Analytics() { const pathname = usePathname() const searchParams = useSearchParams() useEffect(() => { const url = pathname + searchParams.toString() trackPageView(url) }, [pathname, searchParams]) return null } [V0_FILE]html:file="public/googlebc61ff5f80dfca2a.html" isMerged="true" google-site-verification: googlebc61ff5f80dfca2a [V0_FILE]typescriptreact:file="app/api/admin/users/all/route.ts" isEdit="true" isMerged="true" import { type NextRequest, NextResponse } from "next/server" import { createAdminClient } from "@/lib/supabase/server" export const runtime = "nodejs" export const dynamic = "force-dynamic" export async function GET(request: NextRequest) { try { const adminSession = request.cookies.get("admin_session")?.value if (!adminSession || adminSession !== "admin_authenticated") { console.error("Unauthorized admin access attempt") return NextResponse.json({ error: "Unauthorized access" }, { status: 401 }) } const supabase = await createAdminClient() if (!supabase) { return NextResponse.json({ error: "Admin client not configured" }, { status: 500 }) } console.log("[v0] Admin fetching all users from Supabase auth.users...") const { data: authUsers, error: authError } = await supabase.auth.admin.listUsers({ page: 1, perPage: 1000, // Increased from default 50 to get all users }) if (authError) { console.error("[v0] Auth users fetch error:", authError) return NextResponse.json( { error: "Failed to fetch users from auth", details: authError.message, }, { status: 500 }, ) } const { data: creditsData, error: creditsError } = await supabase .from("users") .select("id, email, credits, updated_at") if (creditsError) { console.error("[v0] Credits data fetch error:", creditsError) } const { data: usageStats, error: usageError } = await supabase.from("usage_logs").select(` user_id, feature_type, created_at `) if (usageError) { console.error("[v0] Usage stats fetch error:", usageError) } const { data: loginStats, error: loginError } = await supabase .from("user_login_stats") .select("user_id, login_count, last_login_at") if (loginError) { console.error("[v0] Login stats fetch error:", loginError) } const users = authUsers.users.map((authUser) => { const creditInfo = creditsData?.find((c) => c.email === authUser.email) const userUsage = usageStats?.filter((u) => u.user_id === authUser.id) || [] const loginInfo = loginStats?.find((l) => l.user_id === authUser.id) const imageEditCount = userUsage.filter((u) => u.feature_type === "image_edit").length const imageCombineCount = userUsage.filter((u) => u.feature_type === "image_combine").length const imageGenerateCount = userUsage.filter((u) => u.feature_type === "image_generation").length const videoGenerateCount = userUsage.filter((u) => u.feature_type === "video_generation").length const chatCount = userUsage.filter((u) => u.feature_type === "chat").length return { id: authUser.id, email: authUser.email || "", full_name: authUser.user_metadata?.full_name || authUser.user_metadata?.name || null, credits: creditInfo?.credits || 0, created_at: authUser.created_at, updated_at: authUser.updated_at, last_sign_in_at: authUser.last_sign_in_at, email_confirmed_at: authUser.email_confirmed_at, login_count: loginInfo?.login_count || 0, last_login_at: loginInfo?.last_login_at, image_edit_count: imageEditCount, image_combine_count: imageCombineCount, image_generate_count: imageGenerateCount, video_generate_count: videoGenerateCount, chat_count: chatCount, total_usage: userUsage.length, } }) console.log(`[v0] Successfully fetched ${users.length} users with comprehensive analytics`) const totalUsers = users.length const totalCredits = users.reduce((sum, user) => sum + (user.credits || 0), 0) return NextResponse.json({ success: true, users: users, count: totalUsers, totalCredits: totalCredits, lastUpdated: new Date().toISOString(), }) } catch (error) { console.error("[v0] Admin users API error:", error) return NextResponse.json( { error: "Internal server error", details: error instanceof Error ? error.message : "Unknown error", }, { status: 500 }, ) } } [V0_FILE]typescriptreact:file="app/api/admin/create-test-user/route.ts" isFixed="true" isEdit="true" isQuickEdit="true" isMerged="true" import { type NextRequest, NextResponse } from "next/server" import { createAdminClient } from "@/lib/supabase/server" import { cookies } from "next/headers" export async function POST(request: NextRequest) { try { const cookieStore = cookies() const adminSession = cookieStore.get("admin_session") if (!adminSession || adminSession.value !== "admin_authenticated") { return NextResponse.json({ error: "Unauthorized" }, { status: 401 }) } const { email, password = "testuser123" } = await request.json() if (!email) { return NextResponse.json({ error: "Email is required" }, { status: 400 }) } const supabase = await createAdminClient() if (!supabase) { return NextResponse.json({ error: "Admin client not configured" }, { status: 500 }) } const { data: authData, error: authError } = await supabase.auth.admin.createUser({ email, password, email_confirm: true, // Auto-confirm email for test users }) if (authError) { return NextResponse.json({ error: authError.message }, { status: 400 }) } const { error: userError } = await supabase.from("users").upsert( { id: authData.user.id, email: authData.user.email, credits: 50, // Give test user 50 credits for testing created_at: new Date().toISOString(), }, { onConflict: "id", }, ) if (userError) { console.error("Error creating user record:", userError) // Try to update credits if user already exists const { error: updateError } = await supabase.from("users").update({ credits: 50 }).eq("id", authData.user.id) if (updateError) { console.error("Error updating user credits:", updateError) return NextResponse.json({ error: "Failed to assign credits" }, { status: 500 }) } } return NextResponse.json({ success: true, user: { id: authData.user.id, email: authData.user.email, credits: 50, }, credentials: { email, password, }, }) } catch (error) { console.error("Error creating test user:", error) return NextResponse.json({ error: "Internal server error" }, { status: 500 }) } } [V0_FILE]typescriptreact:file="app/api/admin/users/update-credits/route.ts" isFixed="true" isEdit="true" isQuickEdit="true" isMerged="true" import { type NextRequest, NextResponse } from "next/server" import { createAdminClient } from "@/lib/supabase/server" import { cookies } from "next/headers" export async function POST(request: NextRequest) { try { const cookieStore = cookies() const adminSession = cookieStore.get("admin_session") if (!adminSession || adminSession.value !== "admin_authenticated") { return NextResponse.json({ error: "Unauthorized" }, { status: 401 }) } const { userEmail, credits, description } = await request.json() if (!userEmail || credits === undefined) { return NextResponse.json({ error: "User email and credits are required" }, { status: 400 }) } console.log("[v0] Processing credit addition:", { userEmail, credits, description }) const supabase = await createAdminClient() if (!supabase) { return NextResponse.json({ error: "Admin client not configured" }, { status: 500 }) } const { data: authUsers, error: authError } = await supabase.auth.admin.listUsers() if (authError) { console.error("[v0] Error fetching auth users:", authError) return NextResponse.json({ error: "Failed to fetch users" }, { status: 500 }) } const authUser = authUsers.users.find((user) => user.email?.toLowerCase().trim() === userEmail.toLowerCase().trim()) if (!authUser) { console.error("[v0] User not found in auth:", userEmail) return NextResponse.json({ error: "User not found" }, { status: 404 }) } console.log("[v0] Found auth user:", authUser.id, authUser.email) const { data: existingUser, error: fetchError } = await supabase .from("users") .select("id, credits") .eq("id", authUser.id) .single() if (fetchError && fetchError.code !== "PGRST116") { console.error("[v0] Error fetching user:", fetchError) return NextResponse.json({ error: "Database error" }, { status: 500 }) } let currentCredits = 0 if (!existingUser) { console.log("[v0] Creating new user record for:", authUser.email) const { error: insertError } = await supabase.from("users").insert({ id: authUser.id, email: authUser.email, credits: 0, }) if (insertError) { console.error("[v0] Error creating user:", insertError) return NextResponse.json({ error: "Failed to create user record" }, { status: 500 }) } } else { currentCredits = existingUser.credits || 0 } const newCredits = currentCredits + Number.parseFloat(credits) console.log("[v0] Updating credits:", { currentCredits, adding: credits, newTotal: newCredits }) const { error: updateError } = await supabase.from("users").update({ credits: newCredits }).eq("id", authUser.id) if (updateError) { console.error("[v0] Error updating user credits:", updateError) return NextResponse.json({ error: "Failed to update credits" }, { status: 500 }) } const { error: logError } = await supabase.from("usage_logs").insert({ user_id: authUser.id, feature: "credit_addition", details: `Admin added $${credits} credits. ${description || "Manual credit addition"}`, cost: -Number.parseFloat(credits), // Negative cost for credit addition }) if (logError) { console.error("[v0] Error logging transaction:", logError) // Don't fail the request for logging errors } console.log("[v0] Successfully added credits to user:", authUser.email) return NextResponse.json({ success: true, newCredits: newCredits, message: `Successfully added $${credits} credits to ${authUser.email}`, }) } catch (error) { console.error("[v0] Error updating user credits:", error) return NextResponse.json({ error: "Internal server error" }, { status: 500 }) } } [V0_FILE]typescriptreact:file="app/api/stripe/create-payment-intent/route.ts" isEdit="true" isMerged="true" import { createClient } from "@/lib/supabase/server" import { type NextRequest, NextResponse } from "next/server" import Stripe from "stripe" const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!, { apiVersion: "2024-06-20", }) export async function POST(request: NextRequest) { try { const { amount, credits } = await request.json() if (!amount || !credits || amount <= 0 || credits <= 0) { console.error("[v0] Invalid payment parameters:", { amount, credits }) return NextResponse.json({ error: "Invalid payment parameters" }, { status: 400 }) } const supabase = await createClient() const { data: { user }, error: authError, } = await supabase.auth.getUser() if (authError || !user) { console.error("[v0] Authentication error:", authError) return NextResponse.json({ error: "Unauthorized" }, { status: 401 }) } console.log("[v0] Creating payment intent for user:", user.id, "amount:", amount, "credits:", credits) if (!process.env.STRIPE_SECRET_KEY) { console.error("[v0] Missing Stripe secret key") return NextResponse.json({ error: "Payment system configuration error" }, { status: 500 }) } // Create payment intent const paymentIntent = await stripe.paymentIntents.create({ amount: Math.round(amount * 100), // Convert to cents currency: "usd", metadata: { user_id: user.id, credits: credits.toString(), }, }) console.log("[v0] Payment intent created:", paymentIntent.id) const { error: dbError } = await supabase.from("payments").insert({ user_id: user.id, stripe_payment_intent_id: paymentIntent.id, amount: amount, credits_purchased: credits, status: "pending", }) if (dbError) { console.error("[v0] Database error storing payment:", dbError) // Continue anyway since Stripe payment intent was created } return NextResponse.json({ clientSecret: paymentIntent.client_secret, paymentIntentId: paymentIntent.id, }) } catch (error) { console.error("[v0] Payment intent creation error:", { error: error instanceof Error ? error.message : error, stack: error instanceof Error ? error.stack : undefined, timestamp: new Date().toISOString(), }) if (error instanceof Stripe.errors.StripeError) { return NextResponse.json({ error: `Payment system error: ${error.message}` }, { status: 500 }) } return NextResponse.json({ error: "Failed to create payment intent" }, { status: 500 }) } } [V0_FILE]typescriptreact:file="lib/supabase/server.ts" isEdit="true" isMerged="true" import { createServerClient } from "@supabase/ssr" import { cookies } from "next/headers" import { cache } from "react" // Check if Supabase environment variables are available export const isSupabaseConfigured = typeof process.env.NEXT_PUBLIC_SUPABASE_URL === "string" && process.env.NEXT_PUBLIC_SUPABASE_URL.length > 0 && typeof process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY === "string" && process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY.length > 0 // Create a cached version of the Supabase client for Server Components export const createClient = cache(async () => { const cookieStore = await cookies() if (!isSupabaseConfigured) { console.warn("Supabase environment variables are not set. Using dummy client.") return { auth: { getUser: () => Promise.resolve({ data: { user: null }, error: null }), getSession: () => Promise.resolve({ data: { session: null }, error: null }), }, } } return createServerClient(process.env.NEXT_PUBLIC_SUPABASE_URL!, process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!, { cookies: { getAll() { return cookieStore.getAll() }, setAll(cookiesToSet) { try { cookiesToSet.forEach(({ name, value, options }) => cookieStore.set(name, value, options)) } catch { // The `setAll` method was called from a Server Component. // This can be ignored if you have middleware refreshing // user sessions. } }, }, }) }) export const createAdminClient = cache(async () => { if (!isSupabaseConfigured || !process.env.SUPABASE_SERVICE_ROLE_KEY) { console.warn("Supabase admin configuration not available") return null } return createServerClient(process.env.NEXT_PUBLIC_SUPABASE_URL!, process.env.SUPABASE_SERVICE_ROLE_KEY!, { cookies: { getAll() { return [] }, setAll() { // No-op for service role client }, }, }) }) export const createServiceRoleClient = () => { if (!isSupabaseConfigured || !process.env.SUPABASE_SERVICE_ROLE_KEY) { throw new Error("Supabase service role configuration not available") } return createServerClient(process.env.NEXT_PUBLIC_SUPABASE_URL!, process.env.SUPABASE_SERVICE_ROLE_KEY!, { cookies: { getAll() { return [] }, setAll() { // No-op for service role client }, }, }) } [V0_FILE]sql:file="scripts/create-update-user-credits-function.sql" isEdit="true" isMerged="true" -- Creating the missing update_user_credits RPC function for automatic credit addition CREATE OR REPLACE FUNCTION update_user_credits( p_user_id UUID, p_amount DECIMAL, p_type TEXT DEFAULT 'purchase', p_description TEXT DEFAULT 'Credit purchase', p_reference_id TEXT DEFAULT NULL ) RETURNS VOID AS $$ BEGIN -- Insert or update user credits INSERT INTO users (id, credits, created_at, updated_at) VALUES (p_user_id, p_amount, NOW(), NOW()) ON CONFLICT (id) DO UPDATE SET credits = users.credits + p_amount, updated_at = NOW(); -- Log the transaction INSERT INTO usage_logs (user_id, feature, details, cost, created_at) VALUES (p_user_id, 'credit_purchase', p_description, -p_amount, NOW()); END; $$ LANGUAGE plpgsql SECURITY DEFINER; -- Grant execute permission to authenticated users and service role GRANT EXECUTE ON FUNCTION update_user_credits(UUID, DECIMAL, TEXT, TEXT, TEXT) TO authenticated; GRANT EXECUTE ON FUNCTION update_user_credits(UUID, DECIMAL, TEXT, TEXT, TEXT) TO service_role; [V0_FILE]typescriptreact:file="app/api/stripe/webhook/route.ts" isFixed="true" isEdit="true" isQuickEdit="true" isMerged="true" import { createClient } from "@/lib/supabase/server" import { type NextRequest, NextResponse } from "next/server" import Stripe from "stripe" const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!, { apiVersion: "2024-06-20", }) const endpointSecret = process.env.STRIPE_WEBHOOK_SECRET! export async function POST(request: NextRequest) { const body = await request.text() const sig = request.headers.get("stripe-signature")! let event: Stripe.Event try { event = stripe.webhooks.constructEvent(body, sig, endpointSecret) } catch (err) { console.error("Webhook signature verification failed:", err) return NextResponse.json({ error: "Webhook signature verification failed" }, { status: 400 }) } const supabase = await createClient() try { console.log("[v0] Webhook event received:", event.type, event.id) switch (event.type) { case "payment_intent.succeeded": const paymentIntent = event.data.object as Stripe.PaymentIntent const userId = paymentIntent.metadata.user_id const credits = Number.parseFloat(paymentIntent.metadata.credits) if (!userId || !credits || isNaN(credits)) { console.error("[v0] Invalid payment metadata:", { userId, credits, metadata: paymentIntent.metadata }) return NextResponse.json({ error: "Invalid payment metadata" }, { status: 400 }) } console.log("[v0] Processing payment success:", { paymentIntentId: paymentIntent.id, userId, credits, amount: paymentIntent.amount / 100, }) // Update payment status first const { error: paymentUpdateError } = await supabase .from("payments") .update({ status: "succeeded", updated_at: new Date().toISOString() }) .eq("stripe_payment_intent_id", paymentIntent.id) if (paymentUpdateError) { console.error("[v0] Failed to update payment status:", paymentUpdateError) } let creditUpdateSuccess = false let retryCount = 0 const maxRetries = 3 while (!creditUpdateSuccess && retryCount < maxRetries) { try { // Try RPC function first const { data, error } = await supabase.rpc("update_user_credits", { p_user_id: userId, p_amount: credits, p_type: "purchase", p_description: `Credit purchase - $${(paymentIntent.amount / 100).toFixed(2)}`, p_reference_id: paymentIntent.id, }) if (error) { console.error(`[v0] RPC update_user_credits failed (attempt ${retryCount + 1}):`, error) // Fallback to direct table update const { error: directUpdateError } = await supabase.from("users").upsert( { id: userId, credits: supabase.raw(`COALESCE(credits, 0) + ${credits}`), updated_at: new Date().toISOString(), }, { onConflict: "id" }, ) if (directUpdateError) { console.error(`[v0] Direct credit update failed (attempt ${retryCount + 1}):`, directUpdateError) retryCount++ await new Promise((resolve) => setTimeout(resolve, 1000 * retryCount)) // Exponential backoff } else { console.log("[v0] Credits updated via direct table update") creditUpdateSuccess = true } } else { console.log("[v0] Credits updated successfully via RPC:", data) creditUpdateSuccess = true } } catch (creditError) { console.error(`[v0] Credit update exception (attempt ${retryCount + 1}):`, creditError) retryCount++ await new Promise((resolve) => setTimeout(resolve, 1000 * retryCount)) } } if (!creditUpdateSuccess) { console.error("[v0] All credit update attempts failed - manual intervention required") // Send notification to admin (could implement email/slack notification here) } break case "payment_intent.payment_failed": const failedPayment = event.data.object as Stripe.PaymentIntent console.log("[v0] Processing payment failure:", failedPayment.id) // Update payment status await supabase .from("payments") .update({ status: "failed", updated_at: new Date().toISOString() }) .eq("stripe_payment_intent_id", failedPayment.id) break default: console.log(`[v0] Unhandled event type ${event.type}`) } console.log("[v0] Webhook processed successfully") return NextResponse.json({ received: true }) } catch (error) { console.error("[v0] Webhook processing error:", error) return NextResponse.json({ error: "Webhook processing failed" }, { status: 500 }) } } [V0_FILE]sql:file="scripts/fix-update-user-credits-function.sql" isMerged="true" -- Drop existing function if it exists and create the correct version DROP FUNCTION IF EXISTS update_user_credits(uuid, numeric); -- Create the update_user_credits function CREATE OR REPLACE FUNCTION update_user_credits(user_id_param uuid, credit_amount numeric) RETURNS json LANGUAGE plpgsql SECURITY DEFINER AS $$ DECLARE result_json json; current_credits numeric; new_credits numeric; BEGIN -- Get current credits SELECT COALESCE(credits, 0) INTO current_credits FROM users WHERE id = user_id_param; -- If user doesn't exist, create them with the credit amount IF current_credits IS NULL THEN INSERT INTO users (id, credits, created_at, updated_at) VALUES (user_id_param, credit_amount, NOW(), NOW()) ON CONFLICT (id) DO UPDATE SET credits = users.credits + credit_amount, updated_at = NOW(); new_credits := credit_amount; ELSE -- Update existing user credits UPDATE users SET credits = credits + credit_amount, updated_at = NOW() WHERE id = user_id_param; new_credits := current_credits + credit_amount; END IF; -- Return success result result_json := json_build_object( 'success', true, 'user_id', user_id_param, 'previous_credits', COALESCE(current_credits, 0), 'added_credits', credit_amount, 'new_credits', new_credits, 'updated_at', NOW() ); RETURN result_json; EXCEPTION WHEN OTHERS THEN -- Return error result result_json := json_build_object( 'success', false, 'error', SQLERRM, 'user_id', user_id_param, 'credit_amount', credit_amount ); RETURN result_json; END; $$; -- Grant execute permission to authenticated users GRANT EXECUTE ON FUNCTION update_user_credits(uuid, numeric) TO authenticated; GRANT EXECUTE ON FUNCTION update_user_credits(uuid, numeric) TO service_role; [V0_FILE]typescriptreact:file="app/api/admin/user-history/[userId]/route.ts" isEdit="true" isMerged="true" import { type NextRequest, NextResponse } from "next/server" import { createServiceRoleClient } from "@/lib/supabase/server" import { cookies } from "next/headers" export async function GET(request: NextRequest, { params }: { params: { userId: string } }) { try { // Check admin authentication const cookieStore = await cookies() const adminSession = cookieStore.get("admin_session") if (!adminSession || adminSession.value !== "admin_authenticated") { return NextResponse.json({ error: "Unauthorized" }, { status: 401 }) } const { userId } = params const supabase = createServiceRoleClient() const { data: authUser, error: authError } = await supabase.auth.admin.getUserById(userId) if (authError || !authUser.user) { return NextResponse.json({ error: "User not found" }, { status: 404 }) } const userEmail = authUser.user.email // Fetch all user history including payments, usage logs, and credit transactions const [paymentsResult, usageResult, creditsResult] = await Promise.all([ supabase.from("payments").select("*").eq("user_email", userEmail).order("created_at", { ascending: false }), // Fetch usage history supabase .from("usage_logs") .select("*") .eq("user_id", userId) .order("created_at", { ascending: false }), supabase .from("credit_transactions") .select("*") .eq("user_email", userEmail) .order("created_at", { ascending: false }) .limit(100), ]) // Combine all history into a single timeline const history = [] // Add payments if (paymentsResult.data) { paymentsResult.data.forEach((payment) => { history.push({ type: "payment", description: `Credit Purchase - $${(payment.amount / 100).toFixed(2)} payment`, details: `Payment ID: ${payment.stripe_payment_intent_id} • Status: ${payment.status} • Credits: $${payment.credits || (payment.amount / 100).toFixed(2)}`, amount: payment.credits || payment.amount / 100, // Convert cents to dollars if needed created_at: payment.created_at, raw_data: payment, }) }) } // Add usage logs if (usageResult.data) { usageResult.data.forEach((usage) => { history.push({ type: "usage", description: `${usage.feature_type} Generation`, details: usage.details || `Cost: $${usage.cost}`, amount: -usage.cost, created_at: usage.created_at, raw_data: usage, }) }) } // Add credit transactions if available if (creditsResult.data) { creditsResult.data.forEach((transaction) => { history.push({ type: "credit", description: transaction.description || "Credit Transaction", details: transaction.notes || `Transaction type: ${transaction.type || "manual"}`, amount: transaction.amount, created_at: transaction.created_at, raw_data: transaction, }) }) } const { data: userData } = await supabase .from("users") .select("created_at, credits") .eq("email", userEmail) .single() if (userData) { history.push({ type: "bonus", description: "Welcome Bonus", details: "New user welcome credits", amount: 2.0, // Default welcome amount created_at: userData.created_at, raw_data: { type: "welcome_bonus" }, }) } // Sort by date (newest first) history.sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime()) console.log(`[v0] Fetched ${history.length} history items for user ${userEmail}`) return NextResponse.json({ success: true, history: history.slice(0, 100), // Limit to last 100 items user: { id: userId, email: userEmail, current_credits: userData?.credits || 0, }, }) } catch (error) { console.error("Error fetching user history:", error) return NextResponse.json({ error: "Failed to fetch user history" }, { status: 500 }) } } [V0_FILE]typescriptreact:file="app/api/admin/add-credits-manual/route.ts" isFixed="true" isEdit="true" isQuickEdit="true" isMerged="true" import { createServiceRoleClient } from "@/lib/supabase/server" import { type NextRequest, NextResponse } from "next/server" import { cookies } from "next/headers" export async function POST(request: NextRequest) { try { // Check admin authentication const cookieStore = await cookies() const adminSession = cookieStore.get("admin_session") if (!adminSession || adminSession.value !== "admin_authenticated") { return NextResponse.json({ error: "Unauthorized" }, { status: 401 }) } const { userEmail, amount, description } = await request.json() if (!userEmail || !amount || amount <= 0) { return NextResponse.json({ error: "Invalid parameters" }, { status: 400 }) } const supabase = createServiceRoleClient() const normalizedEmail = userEmail.toLowerCase().trim() console.log("[v0] Looking for user:", normalizedEmail) const { data: authUsers, error: authError } = await supabase.auth.admin.listUsers() if (authError) { console.error("Failed to fetch auth users:", authError) return NextResponse.json({ error: "Failed to fetch users" }, { status: 500 }) } console.log("[v0] Total auth users found:", authUsers.users.length) console.log( "[v0] All user emails:", authUsers.users.map((u) => u.email?.toLowerCase().trim()), ) const authUser = authUsers.users.find((u) => u.email?.toLowerCase().trim() === normalizedEmail) if (!authUser) { console.log("[v0] User not found in auth.users:", normalizedEmail) console.log("[v0] Exact match failed, checking for partial matches...") const partialMatches = authUsers.users.filter((u) => u.email?.toLowerCase().includes(normalizedEmail.split("@")[0]), ) console.log( "[v0] Partial matches found:", partialMatches.map((u) => u.email), ) return NextResponse.json( { error: "User not found in authentication system", debug: { searchedEmail: normalizedEmail, totalUsers: authUsers.users.length, availableEmails: authUsers.users.map((u) => u.email).slice(0, 10), // First 10 for debugging }, }, { status: 404 }, ) } console.log("[v0] Found auth user:", authUser.id, authUser.email) // Check if user exists in users table, create if not let { data: user, error: userError } = await supabase .from("users") .select("id, credits") .eq("id", authUser.id) .single() if (userError && userError.code === "PGRST116") { // User doesn't exist in users table, create them const { data: newUser, error: createError } = await supabase .from("users") .insert({ id: authUser.id, email: authUser.email, credits: 0, created_at: new Date().toISOString(), updated_at: new Date().toISOString(), }) .select("id, credits") .single() if (createError) { console.error("Failed to create user record:", createError) return NextResponse.json({ error: "Failed to create user record" }, { status: 500 }) } user = newUser } else if (userError) { console.error("Database error:", userError) return NextResponse.json({ error: "Database error" }, { status: 500 }) } // Update user credits const { error: updateError } = await supabase .from("users") .update({ credits: user.credits + amount, updated_at: new Date().toISOString(), }) .eq("id", user.id) if (updateError) { console.error("Failed to update user credits:", updateError) return NextResponse.json({ error: "Failed to update credits" }, { status: 500 }) } // Log the transaction await supabase.from("usage_logs").insert({ user_id: user.id, feature: "manual_credit_addition", cost: -amount, // Negative cost means credit addition details: description || "Manual credit addition by admin", created_at: new Date().toISOString(), }) console.log("[v0] Successfully added credits to user:", userEmail) return NextResponse.json({ success: true, message: `Successfully added $${amount} credits to ${userEmail}`, }) } catch (error) { console.error("Manual credit addition error:", error) return NextResponse.json({ error: "Internal server error" }, { status: 500 }) } } [V0_FILE]typescriptreact:file="app/api/admin/process-payment/route.ts" isEdit="true" isMerged="true" import { type NextRequest, NextResponse } from "next/server" import { cookies } from "next/headers" import { createServiceRoleClient } from "@/lib/supabase/server" export async function POST(request: NextRequest) { try { // Check admin authentication const cookieStore = await cookies() const adminSession = cookieStore.get("admin_session") if (!adminSession || adminSession.value !== "admin_authenticated") { return NextResponse.json({ error: "Unauthorized" }, { status: 401 }) } const { paymentId, userEmail, credits } = await request.json() console.log("[v0] Processing payment:", { paymentId, userEmail, credits }) if (!paymentId || !userEmail || !credits) { console.error("[v0] Missing required fields:", { paymentId, userEmail, credits }) return NextResponse.json({ error: "Missing required fields" }, { status: 400 }) } const supabase = createServiceRoleClient() const creditAmount = Number.parseFloat(credits.toString()) console.log("[v0] Credit amount to add:", creditAmount) // Update payment status to succeeded using stripe_payment_intent_id instead of id const { error: paymentError } = await supabase .from("payments") .update({ status: "succeeded", updated_at: new Date().toISOString(), }) .eq("stripe_payment_intent_id", paymentId) if (paymentError) { console.error("[v0] Failed to update payment:", paymentError) return NextResponse.json({ error: "Failed to update payment status" }, { status: 500 }) } console.log("[v0] Payment status updated successfully") // Get user ID from email const { data: authUsers, error: authError } = await supabase.auth.admin.listUsers() if (authError) { console.error("[v0] Failed to fetch auth users:", authError) return NextResponse.json({ error: "Failed to fetch users" }, { status: 500 }) } const authUser = authUsers.users.find((user) => user.email?.toLowerCase().trim() === userEmail.toLowerCase().trim()) if (!authUser) { console.error("[v0] User not found in auth:", userEmail) return NextResponse.json({ error: "User not found" }, { status: 404 }) } console.log("[v0] Found auth user:", authUser.id, authUser.email) const { data: existingUser, error: fetchError } = await supabase .from("users") .select("id, credits") .eq("id", authUser.id) .single() let currentCredits = 0 if (!fetchError && existingUser) { currentCredits = existingUser.credits || 0 } const newCredits = currentCredits + creditAmount console.log("[v0] Credit calculation:", { currentCredits, adding: creditAmount, newTotal: newCredits }) // Try to update credits using RPC function first const { error: rpcError } = await supabase.rpc("update_user_credits", { user_id: authUser.id, credit_amount: creditAmount, }) if (rpcError) { console.log("[v0] RPC failed, trying direct update:", rpcError) // Fallback: Direct table update with proper credit addition const { error: updateError } = await supabase.from("users").upsert({ id: authUser.id, email: userEmail, credits: newCredits, updated_at: new Date().toISOString(), }) if (updateError) { console.error("[v0] Direct update failed:", updateError) return NextResponse.json({ error: "Failed to update user credits" }, { status: 500 }) } } console.log("[v0] User credits updated successfully") const { error: logError } = await supabase.from("usage_logs").insert({ user_id: authUser.id, feature: "payment_processing", details: `Manual processing of payment ${paymentId} - Added $${creditAmount} credits`, cost: -creditAmount, // Negative cost for credit addition created_at: new Date().toISOString(), }) if (logError) { console.error("[v0] Failed to log transaction:", logError) // Don't fail the request for logging errors } console.log(`[v0] Successfully processed payment ${paymentId} for ${userEmail} - Added $${creditAmount} credits`) return NextResponse.json({ success: true, message: `Successfully processed payment and added $${creditAmount} credits to ${userEmail}`, newCredits: newCredits, }) } catch (error) { console.error("[v0] Process payment error:", error) return NextResponse.json({ error: "Internal server error" }, { status: 500 }) } } [V0_FILE]typescriptreact:file="app/api/credits/info/route.ts" isEdit="true" isMerged="true" import { createClient } from "@/lib/supabase/server" import { type NextRequest, NextResponse } from "next/server" export async function POST(request: NextRequest) { try { const { userId } = await request.json() if (!userId) { return NextResponse.json({ error: "User ID required" }, { status: 400 }) } const supabase = await createClient() // Get user data including email for payment lookup const { data: userData, error: userError } = await supabase .from("users") .select("credits, email") .eq("id", userId) .single() if (userError) { console.error("Error fetching user credits:", userError) return NextResponse.json({ error: "Failed to fetch credits" }, { status: 500 }) } // Get user email from auth if not in users table let userEmail = userData?.email if (!userEmail) { const { data: authUser } = await supabase.auth.getUser() userEmail = authUser.user?.email } // Get recent credit transactions const { data: transactions, error: transactionsError } = await supabase .from("credit_transactions") .select("*") .eq("user_id", userId) .order("created_at", { ascending: false }) .limit(10) if (transactionsError) { console.error("Error fetching transactions:", transactionsError) } // Get recent payment transactions const { data: payments, error: paymentsError } = await supabase .from("payments") .select("*") .eq("user_email", userEmail) .eq("status", "succeeded") .order("created_at", { ascending: false }) .limit(10) if (paymentsError) { console.error("Error fetching payments:", paymentsError) } // Combine transactions and payments into a single array const allTransactions = [] // Add credit transactions if (transactions) { transactions.forEach((transaction) => { allTransactions.push({ id: transaction.id, created_at: transaction.created_at, type: transaction.type || "credit", description: transaction.description, amount: transaction.amount, }) }) } // Add payment transactions if (payments) { payments.forEach((payment) => { allTransactions.push({ id: `payment_${payment.id}`, created_at: payment.created_at, type: "purchase", description: `Credit Purchase - $${(payment.amount / 100).toFixed(2)}`, amount: payment.credits || payment.amount / 100, // Convert cents to dollars }) }) } // Sort by date (newest first) and limit to 10 allTransactions.sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime()) const recentTransactions = allTransactions.slice(0, 10) // Get recent usage const { data: recentUsage, error: usageError } = await supabase .from("usage_logs") .select("*") .eq("user_id", userId) .order("created_at", { ascending: false }) .limit(10) if (usageError) { console.error("Error fetching usage:", usageError) } console.log( `[v0] Fetched ${recentTransactions.length} transactions (including ${payments?.length || 0} payments) for user ${userId}`, ) return NextResponse.json({ credits: userData?.credits || 0, transactions: recentTransactions, recentUsage: recentUsage || [], }) } catch (error) { console.error("Credits info API error:", error) return NextResponse.json({ error: "Internal server error" }, { status: 500 }) } } [V0_FILE]typescriptreact:file="app/api/edit-image/route.ts" isEdit="true" isMerged="true" import { createClient } from "@/lib/supabase/server" import { NextResponse } from "next/server" import { GoogleGenAI } from "@google/genai" export async function POST(request: Request) { try { const { prompt, imageFile, userId } = await request.json() console.log("[v0] Image editing request:", { prompt: prompt?.substring(0, 50), userId, hasImage: !!imageFile }) if (!prompt || !imageFile) { return NextResponse.json({ error: "Prompt and image are required" }, { status: 400 }) } if (!process.env.GEMINI_API_KEY) { return NextResponse.json({ error: "API key not configured" }, { status: 500 }) } const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY, }) let imageData = "" let mimeType = "jpeg" if (imageFile.startsWith("data:")) { // Handle data URL format (uploaded images) const dataUrlMatch = imageFile.match(/^data:image\/([a-z]+);base64,(.+)$/) if (!dataUrlMatch) { console.error("[v0] Invalid data URL format") return NextResponse.json({ error: "Invalid image format" }, { status: 400 }) } mimeType = dataUrlMatch[1] imageData = dataUrlMatch[2] if (!imageData || imageData.length < 100) { console.error("[v0] Invalid or empty image data") return NextResponse.json({ error: "Invalid image data" }, { status: 400 }) } console.log("[v0] Processing uploaded image:", { mimeType, dataLength: imageData.length }) } else if (imageFile.startsWith("/") || imageFile.startsWith("http")) { // Handle URL format (generated images) - convert to base64 try { const imageResponse = await fetch(imageFile) if (!imageResponse.ok) { throw new Error(`Failed to fetch image: ${imageResponse.status}`) } const arrayBuffer = await imageResponse.arrayBuffer() const buffer = Buffer.from(arrayBuffer) imageData = buffer.toString("base64") // Determine mime type from content-type header or URL const contentType = imageResponse.headers.get("content-type") if (contentType?.includes("image/")) { mimeType = contentType.split("/")[1] } console.log("[v0] Processing generated image:", { mimeType, dataLength: imageData.length }) } catch (fetchError) { console.error("[v0] Failed to fetch image from URL:", fetchError) return NextResponse.json( { error: "Failed to process image. Please try uploading the image directly." }, { status: 400 }, ) } } else { // Assume it's already base64 encoded imageData = imageFile } const config = { responseModalities: ["IMAGE", "TEXT"], } const model = "gemini-2.5-flash-image-preview" const contents = [ { role: "user", parts: [ { inlineData: { data: imageData, mimeType: `image/${mimeType}`, }, }, { text: `Edit this image: ${prompt}`, }, ], }, ] console.log("[v0] Calling Gemini API with streaming approach") const response = await ai.models.generateContentStream({ model, config, contents, }) let editedImageBase64 = "" let editedImageMimeType = "image/jpeg" let foundImage = false for await (const chunk of response) { if (!chunk.candidates || !chunk.candidates[0].content || !chunk.candidates[0].content.parts) { continue } // Check for inline image data in the chunk if (chunk.candidates?.[0]?.content?.parts?.[0]?.inlineData) { const inlineData = chunk.candidates[0].content.parts[0].inlineData editedImageBase64 = inlineData.data || "" editedImageMimeType = inlineData.mimeType || "image/jpeg" foundImage = true console.log("[v0] Found edited image data in stream") break } } if (!foundImage || !editedImageBase64) { console.error("[v0] No image data found in streaming response") return NextResponse.json( { error: "Failed to generate edited image. The model may not support this type of edit.", }, { status: 500 }, ) } const editedImageDataUrl = `data:${editedImageMimeType};base64,${editedImageBase64}` if (userId) { try { const supabase = await createClient() const cost = 1.2 // $0.60 input + $0.60 output as specified await supabase.from("usage_logs").insert({ user_id: userId, feature_type: "image_edit", cost: cost, metadata: { prompt: prompt.substring(0, 200), model: "gemini-2.5-flash-image-preview", success: true, originalImageType: mimeType, outputImageType: editedImageMimeType, }, description: `AI image editing: ${prompt.substring(0, 50)}...`, }) console.log("[v0] Usage logged successfully") } catch (dbError) { console.error("[v0] Failed to log usage:", dbError) } } return NextResponse.json({ success: true, editedImage: { base64: editedImageDataUrl, prompt: prompt, editedAt: new Date().toISOString(), model: "gemini-2.5-flash-image-preview", mimeType: editedImageMimeType, }, metadata: { prompt, editedAt: new Date().toISOString(), model: "gemini-2.5-flash-image-preview", cost: 1.2, }, }) } catch (error: any) { console.error("[v0] Image editing error:", error) if (error?.message?.includes("SAFETY") || error?.message?.includes("blocked")) { return NextResponse.json( { error: "Content blocked by safety filters. Please try a different prompt." }, { status: 400 }, ) } if (error?.message?.includes("QUOTA") || error?.message?.includes("quota")) { return NextResponse.json({ error: "API quota exceeded. Please try again later." }, { status: 429 }) } if (error?.message?.includes("API_KEY") || error?.message?.includes("authentication")) { return NextResponse.json({ error: "API authentication failed." }, { status: 500 }) } return NextResponse.json( { error: "Image editing failed. Please try again with a different image or prompt.", details: process.env.NODE_ENV === "development" ? error.message : undefined, }, { status: 500 }, ) } } [V0_FILE]typescriptreact:file="app/auth/signup/page.tsx" isMerged="true" import { createClient, isSupabaseConfigured } from "@/lib/supabase/server" import { redirect } from "next/navigation" import SignupForm from "@/components/signup-form" export default async function SignupPage() { // If Supabase is not configured, show setup message directly if (!isSupabaseConfigured) { return (

Connect Supabase to get started

) } try { // Check if user is already logged in with a valid session const supabase = await createClient() const { data: { user }, error, } = await supabase.auth.getUser() // Only redirect if we have a valid user (not just a session) if (user && !error) { redirect("/") } } catch (error) { // If there's an error getting the user, continue to show signup form console.log("Auth check error:", error) } return (

) } [V0_FILE]typescriptreact:file="components/signup-form.tsx" isMerged="true" "use client" import type React from "react" import { useState } from "react" import { Button } from "@/components/ui/button" import { Input } from "@/components/ui/input" import { Label } from "@/components/ui/label" import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card" import { signUp } from "@/lib/actions" import Link from "next/link" export default function SignupForm() { const [email, setEmail] = useState("") const [password, setPassword] = useState("") const [confirmPassword, setConfirmPassword] = useState("") const [isLoading, setIsLoading] = useState(false) const [message, setMessage] = useState("") const handleSubmit = async (e: React.FormEvent) => { e.preventDefault() if (password !== confirmPassword) { setMessage("Passwords don't match") return } if (password.length < 6) { setMessage("Password must be at least 6 characters") return } setIsLoading(true) setMessage("") try { const formData = new FormData() formData.append("email", email) formData.append("password", password) const result = await signUp(formData) if (result?.error) { setMessage(result.error) } else { setMessage("Check your email to confirm your account!") } } catch (error) { setMessage("An error occurred. Please try again.") } finally { setIsLoading(false) } } return ( Create Account Sign up to start creating AI-generated content

Already have an account?{" "} Sign in

) } [V0_FILE]jpg:file="public/favicon.ico" url="https://hebbkx1anhila5yf.public.blob.vercel-storage.com/IMG_6263.JPG-2kyRh14qbLF2tmh03Bz9NWy3GYA2B0.jpeg" isMerged="true" [V0_FILE]jpg:file="public/favicon-16x16.png" url="https://hebbkx1anhila5yf.public.blob.vercel-storage.com/IMG_6263.JPG-2kyRh14qbLF2tmh03Bz9NWy3GYA2B0.jpeg" isMerged="true" [V0_FILE]jpg:file="public/favicon-32x32.png" url="https://hebbkx1anhila5yf.public.blob.vercel-storage.com/IMG_6263.JPG-2kyRh14qbLF2tmh03Bz9NWy3GYA2B0.jpeg" isMerged="true" [V0_FILE]jpg:file="public/apple-touch-icon.png" url="https://hebbkx1anhila5yf.public.blob.vercel-storage.com/IMG_6263.JPG-2kyRh14qbLF2tmh03Bz9NWy3GYA2B0.jpeg" isMerged="true" [V0_FILE]jpg:file="public/og-image.jpg" url="https://hebbkx1anhila5yf.public.blob.vercel-storage.com/IMG_6263.JPG-2kyRh14qbLF2tmh03Bz9NWy3GYA2B0.jpeg" isMerged="true" [V0_FILE]jpg:file="public/twitter-image.jpg" url="https://hebbkx1anhila5yf.public.blob.vercel-storage.com/IMG_6263.JPG-2kyRh14qbLF2tmh03Bz9NWy3GYA2B0.jpeg" isMerged="true" [V0_FILE]json:file="package.json" isMerged="true" { "name": "my-v0-project", "version": "0.1.0", "private": true, "scripts": { "dev": "next dev", "build": "next build", "start": "next start", "lint": "next lint" }, "dependencies": { "@hookform/resolvers": "^3.10.0", "@radix-ui/react-accordion": "1.2.2", "@radix-ui/react-alert-dialog": "1.1.4", "@radix-ui/react-aspect-ratio": "1.1.1", "@radix-ui/react-avatar": "1.1.2", "@radix-ui/react-checkbox": "1.1.3", "@radix-ui/react-collapsible": "1.1.2", "@radix-ui/react-context-menu": "2.2.4", "@radix-ui/react-dialog": "1.1.4", "@radix-ui/react-dropdown-menu": "2.1.4", "@radix-ui/react-hover-card": "1.1.4", "@radix-ui/react-label": "2.1.1", "@radix-ui/react-menubar": "1.1.4", "@radix-ui/react-navigation-menu": "1.2.3", "@radix-ui/react-popover": "1.1.4", "@radix-ui/react-progress": "1.1.1", "@radix-ui/react-radio-group": "1.2.2", "@radix-ui/react-scroll-area": "1.2.2", "@radix-ui/react-select": "2.1.4", "@radix-ui/react-separator": "1.1.1", "@radix-ui/react-slider": "1.2.2", "@radix-ui/react-slot": "1.1.1", "@radix-ui/react-switch": "1.1.2", "@radix-ui/react-tabs": "1.1.2", "@radix-ui/react-toast": "1.2.4", "@radix-ui/react-toggle": "1.1.1", "@radix-ui/react-toggle-group": "1.1.1", "@radix-ui/react-tooltip": "1.1.6", "@vercel/analytics": "1.3.1", "autoprefixer": "^10.4.20", "class-variance-authority": "^0.7.1", "clsx": "^2.1.1", "cmdk": "1.0.4", "date-fns": "4.1.0", "embla-carousel-react": "8.5.1", "geist": "^1.3.1", "input-otp": "1.4.1", "lucide-react": "^0.454.0", "next": "14.2.25", "next-themes": "^0.4.6", "react": "^19", "react-day-picker": "9.8.0", "react-dom": "^19", "react-hook-form": "^7.60.0", "react-resizable-panels": "^2.1.7", "recharts": "2.15.4", "sonner": "^1.7.4", "tailwind-merge": "^3.3.1", "tailwindcss-animate": "^1.0.7", "vaul": "^0.9.9", "zod": "3.25.67", "@stripe/stripe-js": "7.9.0", "@stripe/react-stripe-js": "4.0.0", "@supabase/ssr": "0.7.0", "@google/genai": "1.17.0", "stripe": "18.5.0" }, "devDependencies": { "@tailwindcss/postcss": "^4.1.9", "@types/node": "^22", "@types/react": "^18", "@types/react-dom": "^18", "postcss": "^8.5", "tailwindcss": "^4.1.9", "tw-animate-css": "1.3.3", "typescript": "^5" } } [V0_FILE]typescriptreact:file="app/layout.tsx" isEdit="true" isQuickEdit="true" isMerged="true" import type React from "react" import type { Metadata } from "next" import { Inter } from "next/font/google" import { Analytics } from "@vercel/analytics/next" import { Suspense } from "react" import "./globals.css" const inter = Inter({ subsets: ["latin"] }) export const metadata: Metadata = { title: "Eqqal AI - Advanced AI Chat, Image & Video Generation Platform", description: "Create stunning AI-generated images, videos, and chat with advanced AI models. Powered by Google's Gemini and Veo technologies. Free credits for new users. Start creating today!", keywords: [ "AI image generator", "AI video generator", "AI chat", "artificial intelligence", "Gemini AI", "Veo AI", "text to image", "text to video", "AI art generator", "machine learning", "deep learning", "neural networks", "creative AI", "AI tools", "image creation", "video creation", "AI assistant", "generative AI", "AI platform", "free AI tools", ].join(", "), authors: [{ name: "Eqqal AI Team", url: "https://www.eqqal.com" }], creator: "Eqqal AI", publisher: "Eqqal AI", robots: "index, follow, max-image-preview:large, max-snippet:-1, max-video-preview:-1", alternates: { canonical: "https://www.eqqal.com", }, openGraph: { type: "website", locale: "en_US", url: "https://www.eqqal.com", siteName: "Eqqal AI", title: "Eqqal AI - Advanced AI Chat, Image & Video Generation Platform", description: "Create stunning AI-generated images, videos, and chat with advanced AI models. Powered by Google's Gemini and Veo technologies. Free credits for new users!", images: [ { url: "https://www.eqqal.com/og-image.jpg", width: 1200, height: 630, alt: "Eqqal AI - Advanced AI Platform for Image, Video & Chat Generation", type: "image/jpeg", }, ], }, twitter: { card: "summary_large_image", site: "@EqqalAI", creator: "@EqqalAI", title: "Eqqal AI - Advanced AI Chat, Image & Video Generation Platform", description: "Create stunning AI-generated images, videos, and chat with advanced AI models. Free credits for new users!", images: { url: "https://www.eqqal.com/twitter-image.jpg", alt: "Eqqal AI - Advanced AI Platform for Image, Video & Chat Generation", }, }, icons: { icon: [ { url: "/favicon-16x16.png", sizes: "16x16", type: "image/png" }, { url: "/favicon-32x32.png", sizes: "32x32", type: "image/png" }, ], apple: [{ url: "/apple-touch-icon.png", sizes: "180x180", type: "image/png" }], shortcut: "/favicon.ico", }, manifest: "/manifest.json", viewport: { width: "device-width", initialScale: 1, maximumScale: 5, }, themeColor: [ { media: "(prefers-color-scheme: light)", color: "#ffffff" }, { media: "(prefers-color-scheme: dark)", color: "#000000" }, ], category: "Technology", classification: "AI Tools", other: { "google-site-verification": "googlebc61ff5f80dfca2a", "msvalidate.01": "your-bing-verification-code", "yandex-verification": "your-yandex-verification-code", }, } const structuredData = { "@context": "https://schema.org", "@graph": [ { "@type": "WebSite", "@id": "https://www.eqqal.com/#website", url: "https://www.eqqal.com", name: "Eqqal AI", description: "Advanced AI platform for chat, image and video generation", publisher: { "@id": "https://www.eqqal.com/#organization", }, potentialAction: [ { "@type": "SearchAction", target: { "@type": "EntryPoint", urlTemplate: "https://www.eqqal.com/?q={search_term_string}", }, "query-input": "required name=search_term_string", }, ], }, { "@type": "Organization", "@id": "https://www.eqqal.com/#organization", name: "Eqqal AI", url: "https://www.eqqal.com", logo: { "@type": "ImageObject", url: "https://www.eqqal.com/og-image.jpg", width: 1200, height: 630, }, sameAs: ["https://twitter.com/EqqalAI", "https://linkedin.com/company/eqqal-ai"], contactPoint: { "@type": "ContactPoint", email: "eqqalofficial@gmail.com", contactType: "customer service", }, }, { "@type": "WebApplication", "@id": "https://www.eqqal.com/#webapp", name: "Eqqal AI Platform", url: "https://www.eqqal.com", description: "AI-powered platform for generating images, videos, and conversational AI", applicationCategory: "MultimediaApplication", operatingSystem: "Web Browser", offers: { "@type": "Offer", price: "0", priceCurrency: "USD", description: "Free credits for new users", }, featureList: [ "AI Image Generation", "AI Video Generation", "AI Chat Assistant", "Multiple AI Models", "Real-time Generation", ], }, { "@type": "SoftwareApplication", name: "Eqqal AI", applicationCategory: "MultimediaApplication", operatingSystem: "Web", description: "Advanced AI platform for creating images, videos, and conversational AI", offers: { "@type": "Offer", price: "0", priceCurrency: "USD", }, aggregateRating: { "@type": "AggregateRating", ratingValue: "4.8", ratingCount: "1250", }, }, ], } export default function RootLayout({ children, }: { children: React.ReactNode }) { return (

About

Tags

Share

About

Tags

Share

More from jessin

More Templates Like This

About

Tags

Share

About

Tags

Share

More from jessin

More Templates Like This