fix some Buggs

app/actions/business.ts

@@ -1,6 +1,7 @@
 "use server";
 
 import { auth } from "@/auth";
+import { getEffectiveUserId } from "@/lib/auth-utils";
 import { db } from "@/db";
 import { businesses } from "@/db/schema";
 import { eq, inArray, and } from "drizzle-orm";
@@ -10,10 +11,12 @@ export async function deleteBusiness(id: string) {
     const session = await auth();
     if (!session?.user?.id) throw new Error("Unauthorized");
 
+    const userId = await getEffectiveUserId(session.user.id);
+
     await db.delete(businesses).where(
         and(
             eq(businesses.id, id),
-            eq(businesses.userId, session.user.id)
+            eq(businesses.userId, userId)
         )
     );
     revalidatePath("/dashboard");
@@ -24,10 +27,12 @@ export async function bulkDeleteBusinesses(ids: string[]) {
     const session = await auth();
     if (!session?.user?.id) throw new Error("Unauthorized");
 
+    const userId = await getEffectiveUserId(session.user.id);
+
     await db.delete(businesses).where(
         and(
             inArray(businesses.id, ids),
-            eq(businesses.userId, session.user.id)
+            eq(businesses.userId, userId)
         )
     );
     revalidatePath("/dashboard");

app/actions/workflow-actions.ts

@@ -0,0 +1,48 @@
+"use server";
+
+import { generateWorkflowFromPrompt } from "@/lib/gemini";
+import { Node, Edge } from "reactflow";
+
+// Define return type
+interface GenerateWorkflowResponse {
+    success: boolean;
+    data?: {
+        nodes: Node[];
+        edges: Edge[];
+    };
+    error?: string;
+}
+
+export async function generateWorkflowAction(prompt: string): Promise<GenerateWorkflowResponse> {
+    if (!prompt) {
+        return { success: false, error: "Prompt is required" };
+    }
+
+    try {
+        const workflowData = await generateWorkflowFromPrompt(prompt);
+
+        // Ensure nodes and edges are present and valid (basic check)
+        if (!Array.isArray(workflowData.nodes) || !Array.isArray(workflowData.edges)) {
+            return { success: false, error: "AI generated invalid workflow structure" };
+        }
+
+        return { success: true, data: workflowData };
+    } catch (error: unknown) {
+        let errorMessage = "Failed to generate workflow";
+
+        if (error instanceof Error) {
+            // Log clean error for rate limits
+            if (error.message.includes("429") || error.message.includes("Quota exceeded")) {
+                console.warn("AI Workflow Action Rate Limit:", error.message);
+                errorMessage = "AI usage limit exceeded. Please try again later.";
+            } else {
+                console.error("AI Workflow Action Error:", error);
+                errorMessage = error.message;
+            }
+        } else {
+            console.error("AI Workflow Action Unknown Error:", error);
+        }
+
+        return { success: false, error: errorMessage };
+    }
+}

app/api/search/route.ts

@@ -1,6 +1,7 @@
 
 import { NextResponse } from "next/server";
 import { auth } from "@/lib/auth";
+import { getEffectiveUserId } from "@/lib/auth-utils";
 import { db } from "@/db";
 import { businesses, emailTemplates, automationWorkflows } from "@/db/schema";
 import { ilike, or, eq, and } from "drizzle-orm";
@@ -19,7 +20,7 @@ export async function GET(req: Request) {
             return NextResponse.json({ results: [] });
         }
 
-        const userId = session.user.id;
+        const userId = await getEffectiveUserId(session.user.id);
         const searchPattern = `%${query}%`;
 
         // Parallelize queries for better performance

app/api/settings/route.ts

@@ -1,5 +1,6 @@
 import { NextResponse } from "next/server";
 import { auth } from "@/lib/auth";
+import { getEffectiveUserId } from "@/lib/auth-utils";
 import { db } from "@/db";
 import { users } from "@/db/schema";
 import { eq } from "drizzle-orm";
@@ -22,7 +23,7 @@ export async function GET() {
       return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
     }
 
-    const userId = session.user.id;
+    const userId = await getEffectiveUserId(session.user.id);
 
     // Fetch user with API keys
     const [user] = await db
@@ -81,7 +82,7 @@ export async function PATCH(request: Request) {
       return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
     }
 
-    const userId = session.user.id;
+    const userId = await getEffectiveUserId(session.user.id);
     const body = await request.json();
 
     const updateData: UpdateUserData = {

app/api/tasks/route.ts

@@ -1,7 +1,7 @@
 import { NextResponse } from "next/server";
 import { auth } from "@/lib/auth";
 import { db } from "@/db";
-import { scrapingJobs, automationWorkflows } from "@/db/schema";
+import { scrapingJobs, automationWorkflows, users } from "@/db/schema";
 import { eq, desc, and } from "drizzle-orm";
 
 export async function GET() {
@@ -12,6 +12,19 @@ export async function GET() {
         }
 
         const userId = session.user.id;
+        let queryUserId = userId;
+
+        if (userId === "admin-user") {
+            const adminEmail = process.env.ADMIN_EMAIL;
+            if (adminEmail) {
+                const existingUserByEmail = await db.query.users.findFirst({
+                    where: eq(users.email, adminEmail)
+                });
+                if (existingUserByEmail) {
+                    queryUserId = existingUserByEmail.id;
+                }
+            }
+        }
 
         // Fetch scraping jobs
         const jobs = await db
@@ -27,7 +40,7 @@ export async function GET() {
             })
             .from(scrapingJobs)
             .leftJoin(automationWorkflows, eq(scrapingJobs.workflowId, automationWorkflows.id))
-            .where(eq(scrapingJobs.userId, userId))
+            .where(eq(scrapingJobs.userId, queryUserId))
             .orderBy(desc(scrapingJobs.createdAt))
             .limit(100); // Limit results for performance
 
@@ -41,7 +54,7 @@ export async function GET() {
                 createdAt: automationWorkflows.createdAt,
             })
             .from(automationWorkflows)
-            .where(eq(automationWorkflows.userId, userId))
+            .where(eq(automationWorkflows.userId, queryUserId))
             .orderBy(desc(automationWorkflows.createdAt))
             .limit(100);
 
@@ -95,6 +108,19 @@ export async function DELETE(request: Request) {
         const id = searchParams.get("id");
         const type = searchParams.get("type");
         const userId = session.user.id;
+        let queryUserId = userId;
+
+        if (userId === "admin-user") {
+            const adminEmail = process.env.ADMIN_EMAIL;
+            if (adminEmail) {
+                const existingUserByEmail = await db.query.users.findFirst({
+                    where: eq(users.email, adminEmail)
+                });
+                if (existingUserByEmail) {
+                    queryUserId = existingUserByEmail.id;
+                }
+            }
+        }
 
         if (!id || !type) {
             return NextResponse.json({ error: "ID and type required" }, { status: 400 });
@@ -103,11 +129,11 @@ export async function DELETE(request: Request) {
         if (type === "workflow") {
             await db
                 .delete(automationWorkflows)
-                .where(and(eq(automationWorkflows.id, id), eq(automationWorkflows.userId, userId)));
+                .where(and(eq(automationWorkflows.id, id), eq(automationWorkflows.userId, queryUserId)));
         } else {
             await db
                 .delete(scrapingJobs)
-                .where(and(eq(scrapingJobs.id, id), eq(scrapingJobs.userId, userId)));
+                .where(and(eq(scrapingJobs.id, id), eq(scrapingJobs.userId, queryUserId)));
         }
 
         return NextResponse.json({ success: true });

app/api/templates/[templateId]/route.ts

@@ -1,6 +1,7 @@
 
 import { NextResponse } from "next/server";
 import { auth } from "@/lib/auth";
+import { getEffectiveUserId } from "@/lib/auth-utils";
 import { db } from "@/db";
 import { emailTemplates } from "@/db/schema";
 import { eq, and } from "drizzle-orm";
@@ -16,7 +17,7 @@ export async function PATCH(
     }
 
     const { templateId } = await params;
-    const userId = session.user.id;
+    const userId = await getEffectiveUserId(session.user.id);
     const body = await request.json();
     const { name, subject, body: emailBody, isDefault } = body;
 
@@ -72,7 +73,7 @@ export async function DELETE(
     }
 
     const { templateId } = await params;
-    const userId = session.user.id;
+    const userId = await getEffectiveUserId(session.user.id);
 
     if (!templateId) {
       return NextResponse.json({ error: "Template ID required" }, { status: 400 });

app/api/templates/generate/route.ts

@@ -1,5 +1,6 @@
 import { NextResponse } from "next/server";
 import { auth } from "@/lib/auth";
+import { getEffectiveUserId } from "@/lib/auth-utils";
 import { db } from "@/db";
 import { users } from "@/db/schema";
 import { eq } from "drizzle-orm";
@@ -12,7 +13,7 @@ export async function POST(request: Request) {
             return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
         }
 
-        const userId = session.user.id;
+        const userId = await getEffectiveUserId(session.user.id);
         const { businessType, purpose } = await request.json();
 
         if (!businessType || !purpose) {

app/api/workflows/[id]/route.ts

@@ -1,9 +1,59 @@
 import { NextResponse } from "next/server";
 import { auth } from "@/lib/auth";
 import { db } from "@/db";
-import { automationWorkflows } from "@/db/schema";
+import { automationWorkflows, users } from "@/db/schema";
 import { eq, and } from "drizzle-orm";
 import { SessionUser } from "@/types";
+import { Edge, Node } from "reactflow";
+
+export async function GET(
+  request: Request,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  try {
+    const session = await auth();
+    if (!session?.user) {
+      return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+    }
+
+    const { id } = await params;
+    const userId = (session.user as SessionUser).id;
+
+    let queryUserId = userId;
+
+    if (userId === "admin-user") {
+      const adminEmail = process.env.ADMIN_EMAIL;
+      if (adminEmail) {
+        const existingUserByEmail = await db.query.users.findFirst({
+          where: eq(users.email, adminEmail)
+        });
+        if (existingUserByEmail) {
+          queryUserId = existingUserByEmail.id;
+        }
+      }
+    }
+
+    const workflow = await db.query.automationWorkflows.findFirst({
+      where: and(
+        eq(automationWorkflows.id, id),
+        eq(automationWorkflows.userId, queryUserId)
+      )
+    });
+
+    if (!workflow) {
+      return NextResponse.json({ error: "Workflow not found" }, { status: 404 });
+    }
+
+    return NextResponse.json({ workflow });
+
+  } catch (error) {
+    console.error("Error fetching workflow:", error);
+    return NextResponse.json(
+      { error: "Failed to fetch workflow" },
+      { status: 500 }
+    );
+  }
+}
 
 export async function PATCH(
   request: Request,
@@ -19,14 +69,38 @@ export async function PATCH(
     const userId = (session.user as SessionUser).id;
     const body = await request.json();
 
-    // Toggle isActive or update priority
-    const updates: Partial<{ isActive: boolean; priority: string; updatedAt: Date }> = {
+    let queryUserId = userId;
+
+    if (userId === "admin-user") {
+      const adminEmail = process.env.ADMIN_EMAIL;
+      if (adminEmail) {
+        const existingUserByEmail = await db.query.users.findFirst({
+          where: eq(users.email, adminEmail)
+        });
+        if (existingUserByEmail) {
+          queryUserId = existingUserByEmail.id;
+        }
+      }
+    }
+
+     
+    const updates: Partial<{
+      name: string;
+      isActive: boolean;
+      priority: string;
+      nodes: Node[];
+      edges: Edge[];
+      targetBusinessType: string;
+      updatedAt: Date
+    }> = {
       updatedAt: new Date(),
     };
 
-    if (typeof body.isActive === "boolean") {
-      updates.isActive = body.isActive;
-    }
+    if (body.name) updates.name = body.name;
+    if (typeof body.isActive === "boolean") updates.isActive = body.isActive;
+    if (body.nodes) updates.nodes = body.nodes;
+    if (body.edges) updates.edges = body.edges;
+    if (body.targetBusinessType) updates.targetBusinessType = body.targetBusinessType;
 
     if (body.priority && ["low", "medium", "high"].includes(body.priority)) {
       updates.priority = body.priority;
@@ -39,7 +113,7 @@ export async function PATCH(
         .where(
           and(
             eq(automationWorkflows.id, id),
-            eq(automationWorkflows.userId, userId)
+            eq(automationWorkflows.userId, queryUserId)
           )
         );
 
@@ -69,12 +143,26 @@ export async function DELETE(
     const { id } = await params;
     const userId = (session.user as SessionUser).id;
 
+    let queryUserId = userId;
+
+    if (userId === "admin-user") {
+      const adminEmail = process.env.ADMIN_EMAIL;
+      if (adminEmail) {
+        const existingUserByEmail = await db.query.users.findFirst({
+          where: eq(users.email, adminEmail)
+        });
+        if (existingUserByEmail) {
+          queryUserId = existingUserByEmail.id;
+        }
+      }
+    }
+
     await db
       .delete(automationWorkflows)
       .where(
         and(
           eq(automationWorkflows.id, id),
-          eq(automationWorkflows.userId, userId)
+          eq(automationWorkflows.userId, queryUserId)
         )
       );
 

app/api/workflows/execute/route.ts

@@ -1,5 +1,6 @@
 import { auth } from "@/auth";
 import { executeWorkflowLoop } from "@/lib/workflow-executor";
+import { getEffectiveUserId } from "@/lib/auth-utils";
 import { NextResponse } from "next/server";
 
 export const POST = async (req: Request) => {
@@ -17,7 +18,8 @@ export const POST = async (req: Request) => {
       return new NextResponse("Workflow ID is required", { status: 400 });
     }
 
-    const result = await executeWorkflowLoop(workflowId, session.user.id);
+    const userId = await getEffectiveUserId(session.user.id);
+    const result = await executeWorkflowLoop(workflowId, userId);
 
     return NextResponse.json(result);
   } catch (error) {

app/api/workflows/route.ts

@@ -1,7 +1,7 @@
 import { NextResponse } from "next/server";
 import { auth } from "@/lib/auth";
 import { db } from "@/db";
-import { automationWorkflows } from "@/db/schema";
+import { automationWorkflows, users } from "@/db/schema";
 import { eq, and } from "drizzle-orm";
 import { SessionUser } from "@/types";
 
@@ -14,10 +14,24 @@ export async function GET() {
 
     const userId = (session.user as SessionUser).id;
 
+    let queryUserId = userId;
+
+    if (userId === "admin-user") {
+      const adminEmail = process.env.ADMIN_EMAIL;
+      if (adminEmail) {
+        const existingUserByEmail = await db.query.users.findFirst({
+          where: eq(users.email, adminEmail)
+        });
+        if (existingUserByEmail) {
+          queryUserId = existingUserByEmail.id;
+        }
+      }
+    }
+
     const workflows = await db
       .select()
       .from(automationWorkflows)
-      .where(eq(automationWorkflows.userId, userId))
+      .where(eq(automationWorkflows.userId, queryUserId))
       .orderBy(automationWorkflows.createdAt);
 
     return NextResponse.json({ workflows });
@@ -48,10 +62,44 @@ export async function POST(request: Request) {
       isActive,
     } = body;
 
+    // Fail-safe: Ensure admin user exists if this is the admin
+    let finalUserId = userId;
+
+    if (userId === "admin-user") {
+      // 1. Try to find by ID first
+      const existingUserById = await db.query.users.findFirst({
+        where: eq(users.id, userId)
+      });
+
+      if (!existingUserById) {
+        const adminEmail = process.env.ADMIN_EMAIL;
+        if (adminEmail) {
+          // 2. Try to find by Email
+          const existingUserByEmail = await db.query.users.findFirst({
+            where: eq(users.email, adminEmail)
+          });
+
+          if (existingUserByEmail) {
+            // Use the existing user's ID
+            finalUserId = existingUserByEmail.id;
+          } else {
+            // Create new admin user if absolutely disconnected
+            await db.insert(users).values({
+              id: userId,
+              name: "Admin",
+              email: adminEmail,
+              createdAt: new Date(),
+              updatedAt: new Date()
+            });
+          }
+        }
+      }
+    }
+
     const [workflow] = await db
       .insert(automationWorkflows)
       .values({
-        userId,
+        userId: finalUserId,
         name,
         targetBusinessType: targetBusinessType || "",
         keywords: keywords || [],

app/dashboard/workflows/builder/[id]/page.tsx

@@ -91,7 +91,7 @@ export default function WorkflowBuilderPage() {
     }
 
     return (
-        <div className="flex flex-col h-screen w-full bg-background">
+        <div className="flex flex-col h-screen w-full bg-background overflow-y-auto">
             {/* Header for Back button and Name (Immersive Mode) */}
             <div className="flex flex-col sm:flex-row items-start sm:items-center justify-between p-4 border-b shrink-0 gap-4">
                 <div className="flex items-center gap-4 w-full sm:w-auto">
@@ -124,7 +124,7 @@ export default function WorkflowBuilderPage() {
             </div>
 
             {/* Editor Area */}
-            <div className="flex-1 overflow-hidden">
+            <div className="flex-1 overflow-hidden h-screen">
                 <NodeEditor
                     initialNodes={(workflow.nodes as Node<NodeData>[]) || []}
                     initialEdges={(workflow.edges as Edge[]) || []}

app/dashboard/workflows/page.tsx

@@ -35,7 +35,7 @@ export default function WorkflowsPage() {
       </div>
 
       <div className="grid gap-4 md:grid-cols-2 lg:grid-cols-3">
-        {loading && workflows.length === 0 ? (
+        {loading ||workflows.length === 0 ? (
           // Show skeleton cards while loading
           Array.from({ length: 6 }).map((_, i) => (
             <Card key={i} className="animate-pulse">

app/globals.css

@@ -1,4 +1,5 @@
 @import "tailwindcss";
+@custom-variant dark (&:where(.dark, .dark *));
 
 @import './animations.css';
 
@@ -38,35 +39,33 @@
 
 @layer base {
   :root {
-    /* Rich Dark Theme by Default for "Futuristic" feel */
-    --background: 240 10% 3.9%;
-    --foreground: 0 0% 98%;
+    /* Light Mode Values */
+    --background: 0 0% 100%;
+    --foreground: 240 10% 3.9%;
 
-    /* Glass Effect Basics */
-    --card: 240 10% 3.9%; /* Base fallback */
-    --card-foreground: 0 0% 98%;
+    --card: 0 0% 100%;
+    --card-foreground: 240 10% 3.9%;
  
-    --popover: 240 10% 3.9%;
-    --popover-foreground: 0 0% 98%;
+    --popover: 0 0% 100%;
+    --popover-foreground: 240 10% 3.9%;
  
-    /* Vibrant Primary - Electric Violet/Blue */
     --primary: 263.4 70% 50.4%;
     --primary-foreground: 210 40% 98%;
  
-    --secondary: 240 3.7% 15.9%;
-    --secondary-foreground: 0 0% 98%;
+    --secondary: 240 4.8% 95.9%;
+    --secondary-foreground: 240 5.9% 10%;
  
-    --muted: 240 3.7% 15.9%;
-    --muted-foreground: 240 5% 64.9%;
+    --muted: 240 4.8% 95.9%;
+    --muted-foreground: 240 3.8% 46.1%;
  
-    --accent: 240 3.7% 15.9%;
-    --accent-foreground: 0 0% 98%;
+    --accent: 240 4.8% 95.9%;
+    --accent-foreground: 240 5.9% 10%;
  
-    --destructive: 0 62.8% 30.6%;
+    --destructive: 0 84.2% 60.2%;
     --destructive-foreground: 0 0% 98%;
  
-    --border: 240 3.7% 15.9%;
-    --input: 240 3.7% 15.9%;
+    --border: 240 5.9% 90%;
+    --input: 240 5.9% 90%;
     --ring: 263.4 70% 50.4%;
  
     --radius: 0.75rem;

components/dashboard/user-nav.tsx

@@ -8,7 +8,6 @@ import {
   DropdownMenuItem,
   DropdownMenuLabel,
   DropdownMenuSeparator,
-  DropdownMenuShortcut,
   DropdownMenuTrigger,
 } from "@/components/ui/dropdown-menu";
 import { Button } from "@/components/ui/button";
@@ -23,7 +22,7 @@ export function UserNav() {
   return (
     <DropdownMenu>
       <DropdownMenuTrigger asChild>
-        <Button variant="ghost" className="relative h-8 w-8 rounded-full cursor-pointer">
+        <Button variant="ghost" className="relative h-8 w-8 hover:scale-110 rounded-full cursor-pointer">
           <Avatar className="h-8 w-8">
             <AvatarImage src={user?.image || ""} alt={user?.name || ""} />
             <AvatarFallback>{user?.name?.charAt(0) || "U"}</AvatarFallback>
@@ -55,7 +54,7 @@ export function UserNav() {
           </DropdownMenuItem>
         </DropdownMenuGroup>
         <DropdownMenuSeparator />
-        <DropdownMenuItem onClick={() => signOut()} className="cursor-pointer">
+        <DropdownMenuItem onClick={() => signOut()} className="cursor-pointer text-destructive">
           <LogOut className="mr-2 h-4 w-4" />
           <span>Log out</span>
         </DropdownMenuItem>

components/node-editor/ai-workflow-dialog.tsx

@@ -0,0 +1,108 @@
+
+import React, { useState } from "react";
+import {
+    Dialog,
+    DialogContent,
+    DialogDescription,
+    DialogFooter,
+    DialogHeader,
+    DialogTitle,
+} from "@/components/ui/dialog";
+import { Button } from "@/components/ui/button";
+import { Textarea } from "@/components/ui/textarea";
+import { generateWorkflowAction } from "@/app/actions/workflow-actions";
+import { Loader2, Sparkles } from "lucide-react";
+import { Node, Edge } from "reactflow";
+import { NodeData } from "./node-editor";
+
+interface AiWorkflowDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    onGenerate: (nodes: Node<NodeData>[], edges: Edge[]) => void;
+}
+
+export function AiWorkflowDialog({
+    open,
+    onOpenChange,
+    onGenerate,
+}: AiWorkflowDialogProps) {
+    const [prompt, setPrompt] = useState("");
+    const [isGenerating, setIsGenerating] = useState(false);
+    const [error, setError] = useState<string | null>(null);
+
+    const handleGenerate = async () => {
+        if (!prompt.trim()) return;
+
+        setIsGenerating(true);
+        setError(null);
+
+        try {
+            const result = await generateWorkflowAction(prompt);
+
+            if (result.success && result.data) {
+                onGenerate(result.data.nodes, result.data.edges);
+                onOpenChange(false);
+                setPrompt("");
+            } else {
+                throw new Error(result.error || "Failed to generate workflow");
+            }
+        } catch (err: unknown) {
+            if (err instanceof Error) {
+                setError(err.message);
+            } else {
+                setError("Something went wrong");
+            }
+        } finally {
+            setIsGenerating(false);
+        }
+    };
+
+    return (
+        <Dialog open={open} onOpenChange={onOpenChange}>
+            <DialogContent className="sm:max-w-[500px]">
+                <DialogHeader>
+                    <DialogTitle className="flex items-center gap-2">
+                        <Sparkles className="h-5 w-5 text-indigo-500" />
+                        Generate Workflow with AI
+                    </DialogTitle>
+                    <DialogDescription>
+                        Describe the workflow you want to build, and AI will generate it for you.
+                    </DialogDescription>
+                </DialogHeader>
+
+                <div className="grid gap-4 py-4">
+                    <Textarea
+                        placeholder="E.g., Start with a webhook, wait 2 days, then send a welcome email if the user hasn't visited."
+                        value={prompt}
+                        onChange={(e) => setPrompt(e.target.value)}
+                        className="h-32"
+                    />
+                    {error && <p className="text-sm text-red-500">{error}</p>}
+                </div>
+
+                <DialogFooter>
+                    <Button variant="outline" onClick={() => onOpenChange(false)}>
+                        Cancel
+                    </Button>
+                    <Button
+                        onClick={handleGenerate}
+                        disabled={!prompt.trim() || isGenerating}
+                        className="gap-2"
+                    >
+                        {isGenerating ? (
+                            <>
+                                <Loader2 className="h-4 w-4 animate-spin" />
+                                Generating...
+                            </>
+                        ) : (
+                            <>
+                                <Sparkles className="h-4 w-4" />
+                                Generate
+                            </>
+                        )}
+                    </Button>
+                </DialogFooter>
+            </DialogContent>
+        </Dialog>
+    );
+}

components/node-editor/node-editor.tsx

@@ -18,7 +18,8 @@ import ReactFlow, {
 import "reactflow/dist/style.css";
 import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
 import { Button } from "@/components/ui/button";
-import { Plus, Save, Play, Copy, Trash2, Undo, Redo, FileText, Loader2, Download, Upload, HelpCircle, BookOpen, Hand, MousePointer2 } from "lucide-react";
+import { Plus, Save, Play, Copy, Trash2, Undo, Redo, FileText, Loader2, Download, Upload, HelpCircle, BookOpen, Hand, MousePointer2, Sparkles } from "lucide-react";
+import { AiWorkflowDialog } from "./ai-workflow-dialog";
 import { ImportWorkflowDialog } from "./import-workflow-dialog";
 import { NodeConfigDialog } from "./node-config-dialog";
 import { WorkflowNode } from "./workflow-node";
@@ -106,8 +107,10 @@ export function NodeEditor({
   const [selectedNodes, setSelectedNodes] = useState<Node<NodeData>[]>([]);
   const [isConfigOpen, setIsConfigOpen] = useState(false);
   const [isTemplatesOpen, setIsTemplatesOpen] = useState(false);
+
   const [isGuideOpen, setIsGuideOpen] = useState(false);
   const [isImportOpen, setIsImportOpen] = useState(false);
+  const [isAiDialogOpen, setIsAiDialogOpen] = useState(false);
   const [contextMenu, setContextMenu] = useState<{
     x: number;
     y: number;
@@ -441,6 +444,16 @@ export function NodeEditor({
     setIsTemplatesOpen(false);
   }, [setNodes, setEdges, saveToHistory]);
 
+  const handleAiGenerate = useCallback((generatedNodes: Node<NodeData>[], generatedEdges: Edge[]) => {
+    setNodes(generatedNodes);
+    setEdges(generatedEdges);
+    saveToHistory();
+    toast({
+      title: "Workflow Generated",
+      description: "AI successfully created the workflow structure.",
+    });
+  }, [setNodes, setEdges, saveToHistory, toast]);
+
   // Close context menu when clicking outside
   useEffect(() => {
     const handleClick = () => setContextMenu(null);
@@ -459,6 +472,22 @@ export function NodeEditor({
             <CardTitle className="flex flex-col sm:flex-row items-start sm:items-center justify-between gap-4">
             <span>Workflow Editor</span>
               <div className="flex flex-wrap gap-2 w-full sm:w-auto">
+                <Tooltip>
+                  <TooltipTrigger asChild>
+                    <Button
+                      onClick={() => setIsAiDialogOpen(true)}
+                      variant="outline"
+                      className="gap-2 text-indigo-600 border-indigo-200 hover:bg-indigo-50"
+                    >
+                      <Sparkles className="h-4 w-4" />
+                      AI Generate
+                    </Button>
+                  </TooltipTrigger>
+                  <TooltipContent>Generate workflow with AI</TooltipContent>
+                </Tooltip>
+
+                <div className="w-px h-6 bg-border mx-1 self-center" />
+
                 <Tooltip>
                   <TooltipTrigger asChild>
                     <Button
@@ -778,6 +807,11 @@ export function NodeEditor({
             setIsImportOpen(false);
           }}
         />
+        <AiWorkflowDialog
+          open={isAiDialogOpen}
+          onOpenChange={setIsAiDialogOpen}
+          onGenerate={handleAiGenerate}
+        />
     </div>
     </TooltipProvider>
   );

components/notification-bell.tsx

@@ -44,7 +44,7 @@ export function NotificationBell() {
         <Button
           variant="ghost"
           size="icon"
-          className="relative"
+          className="relative hover:scale-110"
         >
           <Bell className={cn(
             "h-5 w-5",

components/theme-switch.tsx

@@ -12,7 +12,7 @@ export function ThemeSwitch() {
             variant="ghost"
             size="icon"
             onClick={(e) => toggleTheme(e)}
-            className="relative cursor-pointer transition-colors hover:bg-accent"
+            className="relative cursor-pointer hover:scale-110 transition-colors hover:bg-accent"
             aria-label="Toggle theme"
         >
             <Sun className="h-5 w-5 rotate-0 scale-100 transition-all dark:-rotate-90 dark:scale-0" />

hooks/use-toast.ts

@@ -1,8 +1,9 @@
 import { toast as sonnerToast } from "sonner";
 
+import { useCallback } from "react";
+
 export function useToast() {
-  return {
-    toast: ({ title, description, variant = "default" }: { title: string; description?: string; variant?: "default" | "destructive" }) => {
+  const toast = useCallback(({ title, description, variant = "default" }: { title: string; description?: string; variant?: "default" | "destructive" }) => {
       if (variant === "destructive") {
         sonnerToast.error(title, {
           description,
@@ -12,6 +13,7 @@ export function useToast() {
           description,
         });
       }
-    },
-  };
+  }, []);
+
+  return { toast };
 }

lib/auth-utils.ts

@@ -0,0 +1,23 @@
+import { db } from "@/db";
+import { users } from "@/db/schema";
+import { eq } from "drizzle-orm";
+
+/**
+ * Resolves the effective User ID for the current session.
+ * If the user is the hardcoded "admin-user" from credentials auth,
+ * it attempts to resolve their real database ID via email.
+ */
+export async function getEffectiveUserId(sessionUserId: string): Promise<string> {
+    if (sessionUserId === "admin-user") {
+        const adminEmail = process.env.ADMIN_EMAIL;
+        if (adminEmail) {
+            const user = await db.query.users.findFirst({
+                where: eq(users.email, adminEmail)
+            });
+            if (user) {
+                return user.id;
+            }
+        }
+    }
+    return sessionUserId;
+}

lib/auth.ts

@@ -44,8 +44,30 @@ export const { handlers, signIn, signOut, auth } = NextAuth({
           credentials.email === adminEmail &&
           credentials.password === adminPassword
         ) {
+          // Ensure admin user exists in DB
+          const adminId = "admin-user";
+
+          try {
+            const existingAdmin = await db.query.users.findFirst({
+              where: eq(users.id, adminId)
+            });
+
+            if (!existingAdmin) {
+              await db.insert(users).values({
+                id: adminId,
+                name: "Admin",
+                email: adminEmail!,
+                createdAt: new Date(),
+                updatedAt: new Date()
+              });
+            }
+          } catch (error) {
+            console.error("Failed to ensure admin user exists:", error);
+            // Fallback to memory-only, but this might cause FK issues as seen
+          }
+
           return {
-            id: "admin-user",
+            id: adminId,
             name: "Admin",
             email: adminEmail,
             role: "admin",

lib/gemini.ts

@@ -1,4 +1,7 @@
+
 import { GoogleGenerativeAI } from "@google/generative-ai";
+import { Node, Edge } from "reactflow";
+
 
 export async function generateEmailTemplate(
   businessType: string,
@@ -117,3 +120,118 @@ export async function generateAIContent(prompt: string, apiKey?: string): Promis
     throw error;
   }
 }
+
+/**
+ * Generate a workflow JSON from a natural language prompt
+ */
+
+export async function generateWorkflowFromPrompt(
+  prompt: string,
+  apiKey?: string
+): Promise<{ nodes: Node[]; edges: Edge[] }> {
+  try {
+    const key = apiKey || process.env.GEMINI_API_KEY;
+    if (!key) {
+      throw new Error("Gemini API key not configured");
+    }
+
+    const genAI = new GoogleGenerativeAI(key);
+    // Models to try in order
+    const models = ["gemini-3-flash-preview", "gemini-2.0-flash", "gemini-1.5-flash", "gemini-1.5-pro"];
+    let lastError;
+
+    for (const modelName of models) {
+      try {
+        const model = genAI.getGenerativeModel({ model: modelName });
+
+        const systemPrompt = `
+              You are an expert automation architect. Your task is to generate a JSON object representing a workflow for a node-based automation editor (ReactFlow).
+        
+              Available Node Types:
+              - start: Entry point (always required)
+              - condition: Evaluates a condition (true/false paths)
+              - template: Sends an email template
+              - delay: Waits for a specified duration
+              - custom: Executes custom code
+              - gemini: AI processing task
+              - apiRequest: Makes an HTTP request
+              - agent: AI Agent with Excel capabilities
+              - webhook: Listens for external events
+              - schedule: Triggers on a schedule (cron)
+              - merge: Merges multiple paths
+              - splitInBatches: Loops through items
+              - filter: Filters data
+              - set: Sets variables
+              - scraper: Scrapes a website
+        
+              Schema Requirement:
+              Return a JSON object with two arrays: "nodes" and "edges".
+              
+              Node Structure:
+              {
+                "id": "string (unique, e.g., 'start-1', 'email-2')",
+                "type": "string (one of the available types)",
+                "data": { 
+                  "label": "string (descriptive name)",
+                  "type": "string (must match the outer type)",
+                  "config": {} (optional configuration based on node type)
+                },
+                "position": { "x": number, "y": number }
+              }
+        
+              Edge Structure:
+              {
+                "id": "string (unique, e.g., 'e1-2')",
+                "source": "string (source node id)",
+                "target": "string (target node id)",
+                "label": "string (optional, e.g., 'True' for condition)"
+              }
+        
+              Layout Rules:
+              - Arrange nodes logically.
+              - Use a vertical flow (y increases downwards).
+              - Center the 'start' node at x: 250, y: 0.
+              - Space nodes sufficiently (e.g., y + 150 for each step).
+              - For conditions, branch out left and right.
+        
+              User Prompt: "${prompt}"
+        
+              Response Format:
+              ONLY return the raw JSON object. Do not include markdown formatting (like \`\`\`json).
+            `;
+
+        const result = await model.generateContent(systemPrompt);
+        const response = result.response;
+        let text = response.text();
+
+        // Clean up potential markdown formatting
+        text = text.replace(/```json/g, "").replace(/```/g, "").trim();
+
+        try {
+          const workflowData = JSON.parse(text);
+          if (!workflowData.nodes || !workflowData.edges) {
+            throw new Error("Invalid workflow format generated");
+          }
+          return workflowData;
+        } catch {
+          console.warn(`Failed to parse workflow from ${modelName}:`, text);
+          // If specific parsing fails, maybe try another model? 
+          // Or just re-throw to be caught by the outer loop?
+          throw new Error("Failed to parse generated workflow");
+        }
+
+      } catch (error) {   
+        console.warn(`Gemini workflow generation failed with model ${modelName}:`, error);
+        lastError = error;
+        // Continue to next model
+      }
+    }
+
+    // If all models fail
+    throw lastError || new Error("Failed to generate workflow with all available Gemini models");
+
+  } catch (error) {
+    console.error("Error generating workflow from prompt:", error);
+    throw error;
+  }
+}