fix broken automation

.cursorrules

@@ -0,0 +1,14 @@
+<!-- BEGIN: AgentMemoryBootstrap -->
+## Cursor Memory Bootstrap
+
+When this workspace is loaded, initialize the shared memory context before
+continuing:
+
+1. Run `python ../../.Agent/scripts/mem.py ctx --agent cursor --max-tokens 4000`.
+2. Load the returned `<MEMORY_CONTEXT>` into working context before proceeding.
+3. If there is an active in-progress task, continue it unless the user redirects.
+4. Save checkpoints with `python ../../.Agent/scripts/mem.py cp "what was done. next step" --agent cursor`.
+5. Finish with `python ../../.Agent/scripts/mem.py done "summary"` and `python ../../.Agent/scripts/mem.py log <input> <output> --agent cursor --model <model>` when token counts are available.
+
+Reference: `../../.Agent/AGENT_MEMORY.md`
+<!-- END: AgentMemoryBootstrap -->

.gemini/GEMINI.md

@@ -0,0 +1,14 @@
+<!-- BEGIN: AgentMemoryBootstrap -->
+## Antigravity Memory Bootstrap
+
+When this workspace is loaded, initialize the shared memory context before
+continuing:
+
+1. Run `python ../../.Agent/scripts/mem.py ctx --agent antigravity --max-tokens 4000`.
+2. Load the returned `<MEMORY_CONTEXT>` into working context before proceeding.
+3. If there is an active in-progress task, continue it unless the user redirects.
+4. Save checkpoints with `python ../../.Agent/scripts/mem.py cp "what was done. next step" --agent antigravity`.
+5. Finish with `python ../../.Agent/scripts/mem.py done "summary"` and `python ../../.Agent/scripts/mem.py log <input> <output> --agent antigravity --model <model>` when token counts are available.
+
+Reference: `../../.Agent/AGENT_MEMORY.md`
+<!-- END: AgentMemoryBootstrap -->

.github/copilot-instructions.md

@@ -0,0 +1,14 @@
+<!-- BEGIN: AgentMemoryBootstrap -->
+## Copilot Memory Bootstrap
+
+When this workspace is loaded, initialize the shared memory context before
+continuing:
+
+1. Run `python ../../.Agent/scripts/mem.py ctx --agent copilot --max-tokens 4000`.
+2. Load the returned `<MEMORY_CONTEXT>` into working context before proceeding.
+3. If there is an active in-progress task, continue it unless the user redirects.
+4. Save checkpoints with `python ../../.Agent/scripts/mem.py cp "what was done. next step" --agent copilot`.
+5. Finish with `python ../../.Agent/scripts/mem.py done "summary"` and `python ../../.Agent/scripts/mem.py log <input> <output> --agent copilot --model <model>` when token counts are available.
+
+Reference: `../../.Agent/AGENT_MEMORY.md`
+<!-- END: AgentMemoryBootstrap -->

.vscode/tasks.json

@@ -0,0 +1,74 @@
+{
+  "version": "2.0.0",
+  "tasks": [
+    {
+      "label": "Mem: Init Session",
+      "type": "shell",
+      "command": "python",
+      "args": [
+        "../../.Agent/scripts/mem.py",
+        "init"
+      ],
+      "presentation": {
+        "reveal": "silent",
+        "panel": "shared",
+        "clear": true
+      },
+      "runOptions": {
+        "runOn": "folderOpen",
+        "instanceLimit": 1
+      }
+    },
+    {
+      "label": "Mem: Load Context",
+      "type": "shell",
+      "command": "python",
+      "args": [
+        "../../.Agent/scripts/mem.py",
+        "ctx",
+        "--agent",
+        "${input:memAgent}"
+      ],
+      "presentation": {
+        "reveal": "always",
+        "panel": "shared",
+        "clear": true
+      }
+    },
+    {
+      "label": "Mem: Status",
+      "type": "shell",
+      "command": "python",
+      "args": [
+        "../../.Agent/scripts/mem.py",
+        "status"
+      ],
+      "presentation": {
+        "reveal": "always",
+        "panel": "shared",
+        "clear": true
+      }
+    }
+  ],
+  "inputs": [
+    {
+      "id": "memAgent",
+      "type": "pickString",
+      "description": "Which agent context should be loaded?",
+      "options": [
+        "codex",
+        "copilot",
+        "cursor",
+        "claude",
+        "antigravity",
+        "claw",
+        "tiny-claw",
+        "pico-claw",
+        "micro-claw",
+        "nano-claw",
+        "rtiny-claw"
+      ],
+      "default": "codex"
+    }
+  ]
+}

.zed/settings.json

@@ -0,0 +1,16 @@
+{
+  "tasks": [
+    {
+      "label": "Mem: Status",
+      "command": "python ../../.Agent/scripts/mem.py status"
+    },
+    {
+      "label": "Mem: Load Context",
+      "command": "python ../../.Agent/scripts/mem.py ctx --agent codex"
+    },
+    {
+      "label": "Mem: Init Session",
+      "command": "python ../../.Agent/scripts/mem.py init"
+    }
+  ]
+}

AGENTS.md

@@ -0,0 +1,14 @@
+<!-- BEGIN: AgentMemoryBootstrap -->
+## Codex Memory Bootstrap
+
+When this workspace is loaded, initialize the shared memory context before
+continuing:
+
+1. Run `python ../../.Agent/scripts/mem.py ctx --agent codex --max-tokens 4000`.
+2. Load the returned `<MEMORY_CONTEXT>` into working context before proceeding.
+3. If there is an active in-progress task, continue it unless the user redirects.
+4. Save checkpoints with `python ../../.Agent/scripts/mem.py cp "what was done. next step" --agent codex`.
+5. Finish with `python ../../.Agent/scripts/mem.py done "summary"` and `python ../../.Agent/scripts/mem.py log <input> <output> --agent codex --model <model>` when token counts are available.
+
+Reference: `../../.Agent/AGENT_MEMORY.md`
+<!-- END: AgentMemoryBootstrap -->

CLAUDE.md

@@ -0,0 +1,14 @@
+<!-- BEGIN: AgentMemoryBootstrap -->
+## Claude Memory Bootstrap
+
+When this workspace is loaded, initialize the shared memory context before
+continuing:
+
+1. Run `python ../../.Agent/scripts/mem.py ctx --agent claude --max-tokens 4000`.
+2. Load the returned `<MEMORY_CONTEXT>` into working context before proceeding.
+3. If there is an active in-progress task, continue it unless the user redirects.
+4. Save checkpoints with `python ../../.Agent/scripts/mem.py cp "what was done. next step" --agent claude`.
+5. Finish with `python ../../.Agent/scripts/mem.py done "summary"` and `python ../../.Agent/scripts/mem.py log <input> <output> --agent claude --model <model>` when token counts are available.
+
+Reference: `../../.Agent/AGENT_MEMORY.md`
+<!-- END: AgentMemoryBootstrap -->

Dockerfile

@@ -1,10 +1,11 @@
 FROM node:20-slim AS base
 
-# Install necessary system dependencies for Puppeteer AND Redis
+# Install necessary system dependencies for Puppeteer and a local Redis-compatible backend.
 RUN apt-get update && apt-get install -y \
     chromium \
     git \
-    redis-server \
+    valkey \
+    valkey-redis-compat \
     # Dependencies for Puppeteer
     gconf-service \
     libasound2 \
@@ -86,5 +87,5 @@ ENV PORT=7860
 EXPOSE 7860
 
 
-# Start Redis and the App
+# Start Valkey, the worker, and the app
 CMD ["./start.sh"]

app/api/auth/otp/send/route.ts

@@ -1,5 +1,5 @@
 import { NextRequest, NextResponse } from "next/server";
-import { redis } from "@/lib/redis";
+import { getRedis } from "@/lib/redis";
 import { sendWhatsAppOTP } from "@/lib/whatsapp/client";
 import { db } from "@/db";
 import { users } from "@/db/schema";
@@ -32,6 +32,8 @@ export async function POST(req: NextRequest) {
     const code = Math.floor(100000 + Math.random() * 900000).toString();
 
     // Store in Redis (TTL 5 mins)
+    const redis = getRedis();
+
     if (!redis) {
       throw new Error("Redis client not initialized");
     }

app/api/health/route.ts

@@ -1,7 +1,7 @@
 import { NextResponse } from "next/server";
 import { db } from "@/db";
 import { sql } from "drizzle-orm";
-import { redis } from "@/lib/redis";
+import { getRedis } from "@/lib/redis";
 import { Logger } from "@/lib/logger";
 
 export const dynamic = "force-dynamic";
@@ -36,6 +36,8 @@ export async function GET(): Promise<NextResponse<HealthCheck>> {
   // Check Redis
   try {
     const redisStart = performance.now();
+    const redis = getRedis();
+
     if (redis) {
       await redis.ping();
       const redisLatency = Math.round(performance.now() - redisStart);

app/api/performance/metrics/route.ts

@@ -5,6 +5,7 @@ export async function GET() {
     try {
         // Get summary of web vitals and API metrics
         const summary = performanceMonitor.getSummary();
+        const apiMetrics = performanceMonitor.getAPIMetrics();
 
         return NextResponse.json({
             lcp: summary.lcp,
@@ -15,6 +16,7 @@ export async function GET() {
             cachedRequests: summary.cachedRequests,
             totalRequests: summary.totalRequests,
             cacheHitRate: summary.cacheHitRate,
+            apiMetrics,
         });
     } catch (error) {
         console.error("Failed to get performance metrics:", error);

app/api/social/automations/create/route.ts

@@ -2,7 +2,7 @@ import { NextRequest, NextResponse } from "next/server";
 import { auth } from "@/auth";
 import { db } from "@/db";
 import { socialAutomations, connectedAccounts } from "@/db/schema";
-import { eq } from "drizzle-orm";
+import { and, eq } from "drizzle-orm";
 
 export async function POST(req: NextRequest) {
   const session = await auth();
@@ -12,22 +12,38 @@ export async function POST(req: NextRequest) {
 
   try {
     const body = await req.json();
-    const { name, triggerType, keywords, actionType, responseTemplate } = body;
+    const {
+      name,
+      triggerType,
+      keywords,
+      actionType,
+      responseTemplate,
+      connectedAccountId,
+    } = body;
 
     if (!name || !triggerType || !actionType || !responseTemplate) {
       return NextResponse.json({ error: "Missing required fields" }, { status: 400 });
     }
 
-    // For whatsapp_command, we don't need a connected account as it uses the user's global WhatsApp config
+    const isWhatsAppTrigger =
+      triggerType === "whatsapp_command" || triggerType === "whatsapp_keyword";
+
     let accountId = null;
 
-    if (triggerType !== 'whatsapp_command') {
+    if (!isWhatsAppTrigger) {
+      if (!connectedAccountId) {
+        return NextResponse.json({ error: "Connected account is required" }, { status: 400 });
+      }
+
       const account = await db.query.connectedAccounts.findFirst({
-        where: eq(connectedAccounts.userId, session.user.id)
+        where: and(
+          eq(connectedAccounts.id, connectedAccountId),
+          eq(connectedAccounts.userId, session.user.id)
+        )
       });
 
       if (!account) {
-        return NextResponse.json({ error: "No connected social account found" }, { status: 400 });
+        return NextResponse.json({ error: "Connected social account not found" }, { status: 400 });
       }
       accountId = account.id;
     }

app/api/social/automations/route.ts

@@ -14,10 +14,20 @@ export async function GET() {
     try {
         const automations = await db.query.socialAutomations.findMany({
             where: eq(socialAutomations.userId, session.user.id),
-            orderBy: [desc(socialAutomations.createdAt)]
+            orderBy: [desc(socialAutomations.createdAt)],
+            with: {
+                account: true,
+            },
         });
 
-        return NextResponse.json(automations);
+        return NextResponse.json(
+            automations.map((automation) => ({
+                ...automation,
+                platform: automation.account?.provider || (
+                    automation.triggerType.startsWith("whatsapp_") ? "whatsapp" : "unassigned"
+                ),
+            }))
+        );
     } catch (error) {
         console.error("Error fetching automations:", error);
         return NextResponse.json({ error: "Failed to fetch automations" }, { status: 500 });

app/api/social/callback/[provider]/route.ts

@@ -78,39 +78,95 @@ export async function GET(
             const expiresSeconds = exchangeData.expires_in || 5184000; // 60 days fallback
             const expiresAt = new Date(Date.now() + expiresSeconds * 1000);
 
-            // 3. Fetch User Profile (to get name/id)
-            const meUrl = `https://graph.facebook.com/v19.0/me?fields=id,name,picture&access_token=${longLivedToken}`;
-            const meRes = await fetch(meUrl);
-            const meData = await meRes.json();
+            // 3. Fetch managed pages and linked Instagram business accounts.
+            const pagesUrl = `https://graph.facebook.com/v21.0/me/accounts?fields=id,name,picture{url},access_token,instagram_business_account{id,username,profile_picture_url}&access_token=${longLivedToken}`;
+            const pagesRes = await fetch(pagesUrl);
+            const pagesData = await pagesRes.json();
 
-            // 4. Save to DB
-            // Check if exists
-            const existingAccount = await db.query.connectedAccounts.findFirst({
-                where: and(
-                    eq(connectedAccounts.userId, userId),
-                    eq(connectedAccounts.provider, "facebook")
-                )
-            });
+            if (pagesData.error) {
+                throw new Error(pagesData.error.message);
+            }
 
-            if (existingAccount) {
-                await db.update(connectedAccounts).set({
-                    accessToken: longLivedToken,
-                    expiresAt: expiresAt,
-                    updatedAt: new Date(),
-                    name: meData.name,
-                    picture: meData.picture?.data?.url,
-                    providerAccountId: meData.id
-                }).where(eq(connectedAccounts.id, existingAccount.id));
-            } else {
-                await db.insert(connectedAccounts).values({
-                    userId: userId,
-                    provider: "facebook",
-                    providerAccountId: meData.id,
-                    accessToken: longLivedToken,
-                    expiresAt: expiresAt,
-                    name: meData.name,
-                    picture: meData.picture?.data?.url
+            const pages = pagesData.data || [];
+
+            if (pages.length === 0) {
+                throw new Error("No Facebook Pages found. Connect a Page with the required permissions first.");
+            }
+
+            for (const page of pages) {
+                const existingFacebookAccount = await db.query.connectedAccounts.findFirst({
+                    where: and(
+                        eq(connectedAccounts.userId, userId),
+                        eq(connectedAccounts.provider, "facebook"),
+                        eq(connectedAccounts.providerAccountId, page.id)
+                    )
                 });
+
+                const facebookPayload = {
+                    accessToken: page.access_token || longLivedToken,
+                    expiresAt,
+                    updatedAt: new Date(),
+                    name: page.name,
+                    picture: page.picture?.data?.url,
+                    metadata: {
+                        type: "facebook_page",
+                        source: "meta_oauth",
+                    },
+                };
+
+                if (existingFacebookAccount) {
+                    await db
+                        .update(connectedAccounts)
+                        .set(facebookPayload)
+                        .where(eq(connectedAccounts.id, existingFacebookAccount.id));
+                } else {
+                    await db.insert(connectedAccounts).values({
+                        userId,
+                        provider: "facebook",
+                        providerAccountId: page.id,
+                        ...facebookPayload,
+                    });
+                }
+
+                const instagramAccount = page.instagram_business_account;
+
+                if (instagramAccount?.id) {
+                    const existingInstagramAccount = await db.query.connectedAccounts.findFirst({
+                        where: and(
+                            eq(connectedAccounts.userId, userId),
+                            eq(connectedAccounts.provider, "instagram"),
+                            eq(connectedAccounts.providerAccountId, instagramAccount.id)
+                        )
+                    });
+
+                    const instagramPayload = {
+                        accessToken: page.access_token || longLivedToken,
+                        expiresAt,
+                        updatedAt: new Date(),
+                        name: instagramAccount.username || page.name,
+                        picture: instagramAccount.profile_picture_url || page.picture?.data?.url,
+                        metadata: {
+                            type: "instagram_business",
+                            pageId: page.id,
+                            pageName: page.name,
+                            source: "meta_oauth",
+                        },
+                    };
+
+                    if (existingInstagramAccount) {
+                        await db
+                            .update(connectedAccounts)
+                            .set(instagramPayload)
+                            .where(eq(connectedAccounts.id, existingInstagramAccount.id));
+                    } else {
+                        await db.insert(connectedAccounts).values({
+                            userId,
+                            provider: "instagram",
+                            providerAccountId: instagramAccount.id,
+                            ...instagramPayload,
+                        });
+                    }
+                }
             }
 
             return NextResponse.redirect(new URL("/dashboard/settings?success=connected", effectiveBaseUrl));

app/api/social/connect/[provider]/route.ts

@@ -31,9 +31,14 @@ export async function GET(
     const scope = [
       "pages_show_list",
       "pages_read_engagement",
+      "pages_manage_engagement",
+      "pages_manage_metadata",
       "pages_manage_posts", // For posting
+      "pages_messaging",
       "instagram_basic", // For IG info
       "instagram_content_publish", // For IG posting
+      "instagram_manage_comments",
+      "instagram_manage_messages",
       "business_management", // General access
     ].join(",");
 

app/api/social/posts/create/route.ts

@@ -2,7 +2,7 @@ import { NextRequest, NextResponse } from "next/server";
 import { auth } from "@/auth";
 import { db } from "@/db";
 import { socialPosts, connectedAccounts } from "@/db/schema";
-import { eq } from "drizzle-orm";
+import { and, eq } from "drizzle-orm";
 import { socialPublisher } from "@/lib/social/publisher";
 const { publishToFacebook, publishToInstagram } = socialPublisher;
 
@@ -22,7 +22,10 @@ export async function POST(req: NextRequest) {
 
     // 1. Fetch Connected Account to get Access Token
     const account = await db.query.connectedAccounts.findFirst({
-      where: eq(connectedAccounts.id, connectedAccountId)
+      where: and(
+        eq(connectedAccounts.id, connectedAccountId),
+        eq(connectedAccounts.userId, session.user.id)
+      )
     });
 
     if (!account) {
@@ -61,10 +64,10 @@ export async function POST(req: NextRequest) {
       platform,
       status: "published",
       publishedAt: new Date(),
-      platformPostId: result?.id
+      platformPostId: typeof result === "string" ? result : result?.id
     });
 
-    return NextResponse.json({ success: true, postId: result?.id });
+    return NextResponse.json({ success: true, postId: typeof result === "string" ? result : result?.id });
 
   } catch (error: unknown) {
     const msg = error instanceof Error ? error.message : String(error);

app/api/social/posts/route.ts

@@ -52,7 +52,10 @@ export async function POST(req: NextRequest) {
         for (const accountId of platforms) {
             // Fetch account details
             const account = await db.query.connectedAccounts.findFirst({
-                where: eq(connectedAccounts.id, accountId)
+                where: and(
+                    eq(connectedAccounts.id, accountId),
+                    eq(connectedAccounts.userId, userId)
+                )
             });
 
             if (!account) {
@@ -94,29 +97,22 @@ export async function POST(req: NextRequest) {
 
                 const payload = {
                     content,
-                    title, // Pass title
                     mediaUrl: fullMediaUrl,
                     accessToken: account.accessToken,
                     providerAccountId: account.providerAccountId,
                     refreshToken: account.refreshToken || undefined
                 };
 
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                const provider = account.provider as any;
-
-                if (provider === "facebook") {
+                if (account.provider === "facebook") {
                     platformPostId = await socialPublisher.publishToFacebook(payload);
-                } else if (provider === "instagram") {
-                    const metadata = account.metadata as Record<string, unknown> | null;
-                    if (provider === "facebook" && metadata?.type === "instagram") {
-                        platformPostId = await socialPublisher.publishToFacebook(payload);
-                    } else {
-                        platformPostId = await socialPublisher.publishToFacebook(payload);
-                    }
-                } else if (provider === "linkedin") {
+                } else if (account.provider === "instagram") {
+                    platformPostId = await socialPublisher.publishToInstagram(payload);
+                } else if (account.provider === "linkedin") {
                     platformPostId = await socialPublisher.publishToLinkedin(payload);
-                } else if (provider === "youtube") {
+                } else if (account.provider === "youtube") {
                     platformPostId = await socialPublisher.publishToYoutube(payload);
+                } else {
+                    throw new Error(`Unsupported publishing provider: ${account.provider}`);
                 }
 
                 // Update DB Success

app/api/social/webhooks/facebook/route.ts

@@ -1,244 +1,313 @@
-/**
- * Facebook Webhook Handler
- * Handles real-time webhook events from Facebook/Instagram
- */
+import crypto from "crypto";
 
+import { and, eq, inArray } from "drizzle-orm";
 import { NextRequest, NextResponse } from "next/server";
+
 import { db } from "@/db";
-import { socialAutomations, connectedAccounts } from "@/db/schema";
-import { eq } from "drizzle-orm";
-import crypto from "crypto";
-/**
- * GET handler for webhook verification
- * Facebook requires this for webhook setup
- */
-export async function GET(request: NextRequest) {
-    const searchParams = request.nextUrl.searchParams;
+import { connectedAccounts, socialAutomations } from "@/db/schema";
+import { buildSocialEventKey, claimSocialEvent } from "@/lib/social/event-dedupe";
 
-    const mode = searchParams.get("hub.mode");
-    const token = searchParams.get("hub.verify_token");
-    const challenge = searchParams.get("hub.challenge");
+const VERIFY_TOKEN = process.env.FACEBOOK_WEBHOOK_VERIFY_TOKEN || "autoloop_webhook_token_2026";
 
-    // Verify token (should match the one set in Facebook App dashboard)
-    const VERIFY_TOKEN = process.env.FACEBOOK_WEBHOOK_VERIFY_TOKEN || "autoloop_webhook_token_2024";
+export async function GET(request: NextRequest) {
+  const searchParams = request.nextUrl.searchParams;
+  const mode = searchParams.get("hub.mode");
+  const token = searchParams.get("hub.verify_token");
+  const challenge = searchParams.get("hub.challenge");
 
-    if (mode === "subscribe" && token === VERIFY_TOKEN) {
-        console.log("✅ Webhook verified");
-        return new NextResponse(challenge, { status: 200 });
-    } else {
-        console.error("❌ Webhook verification failed");
-        return NextResponse.json({ error: "Verification failed" }, { status: 403 });
-    }
+  if (mode === "subscribe" && token === VERIFY_TOKEN) {
+    return new NextResponse(challenge, { status: 200 });
+  }
+
+  return NextResponse.json({ error: "Verification failed" }, { status: 403 });
 }
 
-/**
- * POST handler for webhook events
- * Receives real-time updates from Facebook/Instagram
- */
 export async function POST(request: NextRequest) {
-    try {
-        const body = await request.json();
-
-        console.log("📨 Received webhook event:", JSON.stringify(body, null, 2));
-
-        // Verify the webhook signature (recommended for production)
-        // const signature = request.headers.get("x-hub-signature-256");
-        // if (!verifySignature(body, signature)) {
-        //   return NextResponse.json({ error: "Invalid signature" }, { status: 403 });
-        // }
-
-        // Process each entry in the webhook
-        if (body.object === "page" || body.object === "instagram") {
-            for (const entry of body.entry || []) {
-                // Handle different webhook fields
-                if (entry.changes) {
-                    for (const change of entry.changes) {
-                        await handleWebhookChange(change, entry.id);
-                    }
-                }
-
-                if (entry.messaging) {
-                    for (const message of entry.messaging) {
-                        await handleMessagingEvent(message, entry.id);
-                    }
-                }
-            }
+  try {
+    const rawBody = await request.text();
+    const signature = request.headers.get("x-hub-signature-256");
+
+    if (!verifySignature(rawBody, signature)) {
+      return NextResponse.json({ error: "Invalid signature" }, { status: 403 });
+    }
+
+    const body = JSON.parse(rawBody);
+
+    if (body.object !== "page" && body.object !== "instagram") {
+      return NextResponse.json({ success: true }, { status: 200 });
+    }
+
+    for (const entry of body.entry || []) {
+      if (entry.changes) {
+        for (const change of entry.changes) {
+          await handleWebhookChange(change, entry.id);
         }
+      }
 
-        // Facebook expects a 200 OK response
-        return NextResponse.json({ success: true }, { status: 200 });
-    } catch (error) {
-        console.error("❌ Error processing webhook:", error);
-        // Still return 200 to prevent Facebook from retrying
-        return NextResponse.json({ success: false }, { status: 200 });
+      if (entry.messaging) {
+        for (const message of entry.messaging) {
+          await handleMessagingEvent(message, entry.id);
+        }
+      }
     }
+
+    return NextResponse.json({ success: true }, { status: 200 });
+  } catch (error) {
+    console.error("Error processing Meta webhook:", error);
+    return NextResponse.json({ success: false }, { status: 200 });
+  }
 }
 
-/**
- * Handle webhook change events (comments, posts, etc.)
- */
-async function handleWebhookChange(change: Record<string, unknown>, pageId: string) {
-    const { field, value } = change;
-
-    console.log(`📝 Webhook change: ${field}`, value);
-
-    switch (field) {
-        case "comments":
-            await handleCommentEvent(value as Record<string, unknown>, pageId);
-            break;
-        case "feed":
-            await handleFeedEvent(value as Record<string, unknown>, pageId);
-            break;
-        case "mentions":
-            await handleMentionEvent(value as Record<string, unknown>, pageId);
-            break;
-        default:
-            console.log(`ℹ️ Unhandled webhook field: ${field}`);
-    }
+async function handleWebhookChange(change: Record<string, unknown>, providerAccountId: string) {
+  const field = String(change.field || "");
+  const value = (change.value || {}) as Record<string, unknown>;
+
+  if (field === "comments" || field === "feed") {
+    await handleCommentEvent(value, providerAccountId);
+    return;
+  }
+
+  if (field === "mentions") {
+    await handleMentionEvent(value, providerAccountId);
+  }
 }
 
-/**
- * Handle comment events
- */
-async function handleCommentEvent(value: Record<string, unknown>, pageId: string) {
-    const commentData = value as {
-        id?: string;
-        post_id?: string;
-        message?: string;
-        from?: { id: string; name: string };
-        created_time?: string;
-        parent_id?: string; // For comment replies
-    };
-
-    if (!commentData.message || !commentData.from) {
-        console.log("⚠️ Incomplete comment data");
-        return;
-    }
+async function handleCommentEvent(value: Record<string, unknown>, providerAccountId: string) {
+  const account = await findAccount(providerAccountId);
 
-    console.log(`💬 New comment: "${commentData.message.substring(0, 50)}..." by ${commentData.from.name}`);
+  if (!account) {
+    return;
+  }
 
-    // Find matching automations
-    const account = await db.query.connectedAccounts.findFirst({
-        where: eq(connectedAccounts.providerAccountId, pageId),
-    });
+  const commentId = String(value.comment_id || value.id || "");
+  const message = String(value.message || "");
+
+  if (!commentId || !message) {
+    return;
+  }
+
+  const eventKey = buildSocialEventKey(account.provider, account.id, "comment", commentId);
+  const claimed = await claimSocialEvent(eventKey);
+
+  if (!claimed) {
+    return;
+  }
+
+  const author = (value.from || {}) as { id?: string; name?: string };
+  const automations = await db.query.socialAutomations.findMany({
+    where: and(
+      eq(socialAutomations.connectedAccountId, account.id),
+      eq(socialAutomations.isActive, true),
+      inArray(socialAutomations.triggerType, ["comment_keyword", "any_comment"])
+    ),
+  });
 
-    if (!account) {
-        console.log(`⚠️ No account found for page ${pageId}`);
-        return;
+  for (const automation of automations) {
+    const matchedKeyword = automation.keywords?.find((keyword) =>
+      message.toLowerCase().includes(keyword.toLowerCase())
+    );
+
+    if (!matchedKeyword && automation.triggerType !== "any_comment") {
+      continue;
     }
 
-    const automations = await db.query.socialAutomations.findMany({
-        where: eq(socialAutomations.connectedAccountId, account.id),
-    });
+    const replyText = (automation.responseTemplate || "Thanks for your comment!")
+      .replace(/\{keyword\}/g, matchedKeyword || "")
+      .replace(/\{author\}/g, author.name || "there")
+      .replace(/\{comment\}/g, message);
 
-    // Check each automation for keyword matches
-    for (const automation of automations) {
-        if (!automation.isActive) continue;
+    if (automation.actionType === "reply_comment") {
+      await replyToComment(commentId, replyText, account.accessToken, account.provider);
+    } else if (automation.actionType === "send_dm" && author.id) {
+      await sendDirectMessage(author.id, replyText, account.accessToken, account.provider);
+    }
+  }
+}
 
-        if (automation.triggerType !== "comment_keyword" && automation.triggerType !== "any_comment") {
-            continue;
-        }
+async function handleMentionEvent(value: Record<string, unknown>, providerAccountId: string) {
+  const account = await findAccount(providerAccountId);
 
-        // Check keywords
-        const keywords = automation.keywords || [];
-        const matchedKeyword = keywords.find(keyword =>
-            commentData.message!.toLowerCase().includes(keyword.toLowerCase())
-        );
-
-        if (matchedKeyword || automation.triggerType === "any_comment") {
-            console.log(`✅ Matched automation: "${automation.name}"`);
-
-            // Execute auto-reply
-            await executeAutoReplyToComment(
-                commentData.id!,
-                automation.responseTemplate || "Thank you for your comment!",
-                account.accessToken,
-                account.provider
-            );
-        }
+  if (!account) {
+    return;
+  }
+
+  const mentionId = String(value.media_id || value.id || "");
+
+  if (!mentionId) {
+    return;
+  }
+
+  const eventKey = buildSocialEventKey(account.provider, account.id, "mention", mentionId);
+  const claimed = await claimSocialEvent(eventKey);
+
+  if (!claimed) {
+    return;
+  }
+
+  const automations = await db.query.socialAutomations.findMany({
+    where: and(
+      eq(socialAutomations.connectedAccountId, account.id),
+      eq(socialAutomations.isActive, true),
+      eq(socialAutomations.triggerType, "story_mention")
+    ),
+  });
+
+  for (const automation of automations) {
+    if (automation.actionType !== "send_dm") {
+      continue;
+    }
+
+    const mentionerId = String(value.from || value.mentioned_by || "");
+
+    if (!mentionerId) {
+      continue;
     }
+
+    await sendDirectMessage(
+      mentionerId,
+      automation.responseTemplate || "Thanks for the mention!",
+      account.accessToken,
+      account.provider
+    );
+  }
 }
 
-/**
- * Handle feed events (new posts)
- */
-async function handleFeedEvent(value: Record<string, unknown>, pageId: string) {
-    console.log(`📰 Feed event for page ${pageId}`);
-    // Could trigger automations based on new posts
+async function handleMessagingEvent(message: Record<string, unknown>, providerAccountId: string) {
+  const account = await findAccount(providerAccountId);
+
+  if (!account) {
+    return;
+  }
+
+  const senderId = String((message.sender as { id?: string } | undefined)?.id || "");
+  const messageText = String((message.message as { text?: string } | undefined)?.text || "");
+  const messageId = String((message.message as { mid?: string } | undefined)?.mid || "");
+
+  if (!senderId || !messageText || !messageId) {
+    return;
+  }
+
+  const eventKey = buildSocialEventKey(account.provider, account.id, "dm", messageId);
+  const claimed = await claimSocialEvent(eventKey);
+
+  if (!claimed) {
+    return;
+  }
+
+  const automations = await db.query.socialAutomations.findMany({
+    where: and(
+      eq(socialAutomations.connectedAccountId, account.id),
+      eq(socialAutomations.isActive, true),
+      eq(socialAutomations.triggerType, "dm_keyword")
+    ),
+  });
+
+  for (const automation of automations) {
+    const matched = automation.keywords?.some((keyword) =>
+      messageText.toLowerCase().includes(keyword.toLowerCase())
+    );
+
+    if (!matched) {
+      continue;
+    }
+
+    const replyText = (automation.responseTemplate || "Thanks for your message!")
+      .replace(/\{author\}/g, senderId)
+      .replace(/\{comment\}/g, messageText);
+
+    await sendDirectMessage(senderId, replyText, account.accessToken, account.provider);
+  }
 }
 
-/**
- * Handle mention events
- */
-async function handleMentionEvent(value: Record<string, unknown>, pageId: string) {
-    console.log(`@️ Mention event for page ${pageId}`);
-    // Could trigger automations based on mentions
+async function findAccount(providerAccountId: string) {
+  return db.query.connectedAccounts.findFirst({
+    where: eq(connectedAccounts.providerAccountId, providerAccountId),
+  });
 }
 
-/**
- * Handle messaging events (DMs)
- */
-async function handleMessagingEvent(message: Record<string, unknown>, pageId: string) {
-    console.log(`📬 Messaging event for page ${pageId}`, message);
-    // Could handle DM-based automations
+async function replyToComment(
+  commentId: string,
+  replyText: string,
+  accessToken: string,
+  provider: string
+) {
+  const url =
+    provider === "instagram"
+      ? `https://graph.facebook.com/v21.0/${commentId}/replies`
+      : `https://graph.facebook.com/v21.0/${commentId}/comments`;
+
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      message: replyText,
+      access_token: accessToken,
+    }),
+  });
+
+  const data = await response.json();
+
+  if (!response.ok || data.error) {
+    throw new Error(data.error?.message || "Failed to post comment reply");
+  }
 }
 
-/**
- * Execute auto-reply to a comment
- */
-async function executeAutoReplyToComment(
-    commentId: string,
-    replyText: string,
-    accessToken: string,
-    provider: string
+async function sendDirectMessage(
+  recipientId: string,
+  replyText: string,
+  accessToken: string,
+  provider: string
 ) {
-    try {
-        let url = "";
-
-        if (provider === "facebook") {
-            url = `https://graph.facebook.com/v21.0/${commentId}/comments`;
-        } else if (provider === "instagram") {
-            url = `https://graph.facebook.com/v21.0/${commentId}/replies`;
-        } else {
-            console.log(`⚠️ Platform ${provider} not supported`);
-            return;
-        }
+  if (provider === "linkedin") {
+    const response = await fetch("https://api.linkedin.com/v2/messages", {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        "Content-Type": "application/json",
+        "X-Restli-Protocol-Version": "2.0.0",
+      },
+      body: JSON.stringify({
+        recipients: [`urn:li:person:${recipientId}`],
+        subject: "Message from AutoLoop",
+        body: replyText,
+      }),
+    });
 
-        const response = await fetch(url, {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({
-                message: replyText,
-                access_token: accessToken,
-            }),
-        });
-
-        const data = await response.json();
-
-        if (data.error) {
-            console.error("❌ Error posting reply:", data.error);
-        } else {
-            console.log(`✅ Auto-reply posted successfully`);
-        }
-    } catch (error) {
-        console.error("❌ Error in executeAutoReplyToComment:", error);
+    if (!response.ok) {
+      const data = await response.text();
+      throw new Error(`LinkedIn DM failed: ${data}`);
     }
+
+    return;
+  }
+
+  const response = await fetch("https://graph.facebook.com/v21.0/me/messages", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      recipient: { id: recipientId },
+      message: { text: replyText },
+      access_token: accessToken,
+    }),
+  });
+
+  const data = await response.json();
+
+  if (!response.ok || data.error) {
+    throw new Error(data.error?.message || "Failed to send direct message");
+  }
 }
 
-/**
- * Verify webhook signature (optional but recommended)
- * Currently unused but kept for future implementation
- */
-/* eslint-disable @typescript-eslint/no-unused-vars */
-function verifySignature(body: unknown, signature: string | null): boolean {
-    if (!signature) return false;
-    const APP_SECRET = process.env.FACEBOOK_APP_SECRET || "";
-
-    const expectedSignature = "sha256=" + crypto
-        .createHmac("sha256", APP_SECRET)
-        .update(JSON.stringify(body))
-        .digest("hex");
-
-    return signature === expectedSignature;
+function verifySignature(rawBody: string, signature: string | null): boolean {
+  const appSecret = process.env.FACEBOOK_APP_SECRET;
+
+  if (!appSecret || !signature) {
+    return true;
+  }
+
+  const expectedSignature =
+    "sha256=" +
+    crypto.createHmac("sha256", appSecret).update(rawBody).digest("hex");
+
+  return signature === expectedSignature;
 }
-/* eslint-enable @typescript-eslint/no-unused-vars */

app/api/webhooks/facebook/route.ts

@@ -1,125 +1 @@
-import { NextRequest, NextResponse } from "next/server";
-import { db } from "@/db";
-import { socialAutomations, connectedAccounts } from "@/db/schema";
-import { eq, and } from "drizzle-orm";
-// Not implemented yet, but will be referenced
-// import { replyToComment, sendPrivateMessage } from "@/lib/social/publisher"; 
-
-// Verification Token for Facebook to verify our endpoint
-const VERIFY_TOKEN = process.env.FACEBOOK_WEBHOOK_VERIFY_TOKEN || "autoloop_verify_token";
-
-export async function GET(req: NextRequest) {
-  const { searchParams } = new URL(req.url);
-  const mode = searchParams.get("hub.mode");
-  const token = searchParams.get("hub.verify_token");
-  const challenge = searchParams.get("hub.challenge");
-
-  if (mode && token) {
-    if (mode === "subscribe" && token === VERIFY_TOKEN) {
-      console.log("WEBHOOK_VERIFIED");
-      return new NextResponse(challenge, { status: 200 });
-    } else {
-      return new NextResponse("Forbidden", { status: 403 });
-    }
-  }
-  return new NextResponse("Bad Request", { status: 400 });
-}
-
-export async function POST(req: NextRequest) {
-  try {
-    const body = await req.json();
-
-    if (body.object === "page" || body.object === "instagram") {
-      // Process each entry
-      for (const entry of body.entry) {
-        const entryId = entry.id; // Page ID or IG Business ID
-
-        // Find connected account for this ID to get access token? 
-        // We might need to look up automations FIRST by accountId.
-
-        // Handle Messaging (DMs)
-        if (entry.messaging) {
-          for (const event of entry.messaging) {
-            // event.sender.id, event.message.text
-            await handleMessagingEvent(entryId, event);
-          }
-        }
-
-        // Handle Feed (Comments)
-        if (entry.changes) {
-          for (const change of entry.changes) {
-            if (change.field === "feed" || change.field === "comments") {
-              await handleFeedEvent(entryId, change.value);
-            }
-          }
-        }
-      }
-      return new NextResponse("EVENT_RECEIVED", { status: 200 });
-    }
-
-    return new NextResponse("Not Found", { status: 404 });
-
-  } catch (error: unknown) {
-    console.error("Webhook Error:", error instanceof Error ? error.message : String(error));
-    return new NextResponse("Internal Server Error", { status: 500 });
-  }
-}
-async function handleMessagingEvent(accountId: string, event: unknown) {
-  const evt = event as { sender?: { id?: string }; message?: { text?: string } };
-  const messageText = evt.message?.text;
-
-  if (!messageText) return;
-
-  // Find automations for this account
-  const account = await db.query.connectedAccounts.findFirst({
-    where: eq(connectedAccounts.providerAccountId, accountId)
-  });
-
-  if (!account) return;
-
-  const automations = await db.query.socialAutomations.findMany({
-    where: and(
-      eq(socialAutomations.connectedAccountId, account.id),
-      eq(socialAutomations.isActive, true),
-      eq(socialAutomations.triggerType, "dm_keyword")
-    )
-  });
-
-  for (const auto of automations) {
-    if (auto.keywords && auto.keywords.some(k => messageText.toLowerCase().includes(k.toLowerCase()))) {
-      console.log(`Matched DM Rule: ${auto.name}`);
-    }
-  }
-}
-
-async function handleFeedEvent(accountId: string, change: unknown) {
-  const ch = change as { item?: string; verb?: string; message?: string; comment_id?: string; post_id?: string };
-  if (ch.item !== "comment" && ch.verb !== "add") return;
-
-  const messageText = ch.message || "";
-
-  const account = await db.query.connectedAccounts.findFirst({
-    where: eq(connectedAccounts.providerAccountId, accountId)
-  });
-
-  if (!account) return;
-
-  const automations = await db.query.socialAutomations.findMany({
-    where: and(
-      eq(socialAutomations.connectedAccountId, account.id),
-      eq(socialAutomations.isActive, true)
-    )
-  });
-
-  for (const auto of automations) {
-    let isMatch = false;
-    if (auto.triggerType === "any_comment") isMatch = true;
-    if (auto.triggerType === "comment_keyword" && auto.keywords) {
-      isMatch = auto.keywords.some(k => messageText.toLowerCase().includes(k.toLowerCase()));
-    }
-
-    if (isMatch) {
-      console.log(`Matched Feed Rule: ${auto.name}`);
-    }
-  }
-}
+export { GET, POST } from "@/app/api/social/webhooks/facebook/route";

app/dashboard/businesses/page.tsx

@@ -36,7 +36,7 @@ export default function BusinessesPage() {
     const [selectedIds, setSelectedIds] = useState<string[]>([]);
     const [isModalOpen, setIsModalOpen] = useState(false);
     const [deleteDialogOpen, setDeleteDialogOpen] = useState(false);
-    const [csrfToken, setCsrfToken] = useState("");
+    const [csrfToken] = useState(() => generateCsrfToken());
 
     // Pagination state
     const [currentPage, setCurrentPage] = useState(1);
@@ -59,11 +59,6 @@ export default function BusinessesPage() {
     const { get: getBusinessesApi, loading: loadingBusinesses } = useApi<{ businesses: Business[], totalPages: number, page: number }>();
     const { get: getCategoriesApi } = useApi<{ categories: string[] }>();
 
-    // Generate CSRF token on mount
-    useEffect(() => {
-        setCsrfToken(generateCsrfToken());
-    }, []);
-
     // Debounce effect
     useEffect(() => {
         const timer = setTimeout(() => {

app/dashboard/social/automations/new/page.tsx

@@ -1,147 +1,261 @@
 "use client";
 
-import { useState } from "react";
+import { useEffect, useMemo, useState } from "react";
+import Link from "next/link";
+import { useRouter } from "next/navigation";
+import { ArrowLeft, Loader2 } from "lucide-react";
+import { toast } from "sonner";
+
 import { Button } from "@/components/ui/button";
 import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
 import { Input } from "@/components/ui/input";
 import { Label } from "@/components/ui/label";
-import { Textarea } from "@/components/ui/textarea";
 import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select";
-import { toast } from "sonner";
-import { useRouter } from "next/navigation";
-import { Loader2, ArrowLeft } from "lucide-react";
-import Link from "next/link";
+import { Textarea } from "@/components/ui/textarea";
 
-// Mock accounts for now or implement fetching
-// We'll reuse the pattern: UI Client Component + Server Action later
-// For MVP speed, let's hardcode account selection or make it "All Accounts"
+interface ConnectedAccount {
+  id: string;
+  provider: string;
+  name?: string | null;
+  providerAccountId: string;
+}
 
 export default function NewAutomationPage() {
-    const router = useRouter();
-    const [submitting, setSubmitting] = useState(false);
-
-    // Form State
-    const [name, setName] = useState("");
-    const [triggerType, setTriggerType] = useState("comment_keyword");
-    const [keywords, setKeywords] = useState("");
-    const [actionType, setActionType] = useState("reply_comment");
-    const [responseTemplate, setResponseTemplate] = useState("");
-
-    const handleSubmit = async () => {
-        if (!name || !responseTemplate) {
-            toast.error("Please fill required fields");
-            return;
+  const router = useRouter();
+
+  const [submitting, setSubmitting] = useState(false);
+  const [accounts, setAccounts] = useState<ConnectedAccount[]>([]);
+  const [loadingAccounts, setLoadingAccounts] = useState(true);
+
+  const [name, setName] = useState("");
+  const [triggerType, setTriggerType] = useState("comment_keyword");
+  const [keywords, setKeywords] = useState("");
+  const [actionType, setActionType] = useState("reply_comment");
+  const [responseTemplate, setResponseTemplate] = useState("");
+  const [connectedAccountId, setConnectedAccountId] = useState("");
+
+  const isWhatsAppTrigger = triggerType === "whatsapp_keyword" || triggerType === "whatsapp_command";
+
+  useEffect(() => {
+    let active = true;
+
+    async function loadAccounts() {
+      try {
+        const response = await fetch("/api/settings");
+        const data = await response.json();
+
+        if (!response.ok) {
+          throw new Error(data.error || "Failed to load connected accounts");
         }
 
-        setSubmitting(true);
-        try {
-            // Need an API endpoint to save this
-            // We'll create app/api/social/automations/create/route.ts next
-            const res = await fetch("/api/social/automations/create", {
-                method: "POST",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify({
-                    name,
-                    triggerType,
-                    keywords: keywords.split(",").map(k => k.trim()).filter(k => k),
-                    actionType,
-                    responseTemplate
-                })
-            });
-
-            const data = await res.json(); // Fixed: parse response
-            if (!res.ok) throw new Error(data.error);
-
-            toast.success("Rule created successfully!");
-            router.push("/dashboard/social/automations");
-        } catch (error: unknown) {
-            const msg = error instanceof Error ? error.message : String(error);
-            toast.error(msg || "Failed to create rule");
-        } finally {
-            setSubmitting(false); // Fixed: ensure loader stops
+        if (!active) {
+          return;
+        }
+
+        const socialAccounts = (data.connectedAccounts || []).filter((account: ConnectedAccount) =>
+          ["facebook", "instagram", "linkedin"].includes(account.provider)
+        );
+
+        setAccounts(socialAccounts);
+
+        if (socialAccounts.length > 0) {
+          setConnectedAccountId(socialAccounts[0].id);
+        }
+      } catch (error) {
+        console.error(error);
+        toast.error("Failed to load connected accounts");
+      } finally {
+        if (active) {
+          setLoadingAccounts(false);
         }
+      }
+    }
+
+    loadAccounts();
+
+    return () => {
+      active = false;
     };
+  }, []);
+
+  const availableActions = useMemo(() => {
+    if (triggerType === "any_comment" || triggerType === "comment_keyword") {
+      return [
+        { value: "reply_comment", label: "Reply to Comment" },
+        { value: "send_dm", label: "Send Private Message" },
+      ];
+    }
+
+    return [
+      { value: "send_dm", label: "Send Private Message" },
+    ];
+  }, [triggerType]);
+
+  useEffect(() => {
+    if (!availableActions.some((action) => action.value === actionType)) {
+      setActionType(availableActions[0].value);
+    }
+  }, [actionType, availableActions]);
+
+  const handleSubmit = async () => {
+    if (!name || !responseTemplate) {
+      toast.error("Please fill the required fields");
+      return;
+    }
+
+    if (!isWhatsAppTrigger && !connectedAccountId) {
+      toast.error("Please select a connected account");
+      return;
+    }
+
+    setSubmitting(true);
+
+    try {
+      const response = await fetch("/api/social/automations/create", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          name,
+          triggerType,
+          keywords: keywords
+            .split(",")
+            .map((keyword) => keyword.trim())
+            .filter(Boolean),
+          actionType,
+          responseTemplate,
+          connectedAccountId: isWhatsAppTrigger ? null : connectedAccountId,
+        }),
+      });
+
+      const data = await response.json();
+
+      if (!response.ok) {
+        throw new Error(data.error || "Failed to create automation rule");
+      }
 
-    return (
-        <div className="max-w-2xl mx-auto p-6 space-y-6">
-            <div className="flex items-center gap-4">
-                <Button variant="ghost" size="icon" asChild>
-                    <Link href="/dashboard/social/automations"><ArrowLeft className="h-4 w-4" /></Link>
-                </Button>
-                <h1 className="text-2xl font-bold">Create Automation Rule</h1>
+      toast.success("Rule created successfully");
+      router.push("/dashboard/social/automations");
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      toast.error(message || "Failed to create rule");
+    } finally {
+      setSubmitting(false);
+    }
+  };
+
+  return (
+    <div className="max-w-2xl mx-auto p-6 space-y-6">
+      <div className="flex items-center gap-4">
+        <Button variant="ghost" size="icon" asChild>
+          <Link href="/dashboard/social/automations">
+            <ArrowLeft className="h-4 w-4" />
+          </Link>
+        </Button>
+        <h1 className="text-2xl font-bold">Create Automation Rule</h1>
+      </div>
+
+      <Card>
+        <CardHeader>
+          <CardTitle>Rule Configuration</CardTitle>
+        </CardHeader>
+        <CardContent className="space-y-4">
+          <div className="space-y-2">
+            <Label>Rule Name</Label>
+            <Input
+              placeholder="e.g. Pricing Auto-Reply"
+              value={name}
+              onChange={(event) => setName(event.target.value)}
+            />
+          </div>
+
+          <div className="grid grid-cols-1 gap-4 md:grid-cols-2">
+            <div className="space-y-2">
+              <Label>Trigger</Label>
+              <Select value={triggerType} onValueChange={setTriggerType}>
+                <SelectTrigger>
+                  <SelectValue />
+                </SelectTrigger>
+                <SelectContent>
+                  <SelectItem value="comment_keyword">Comment Keyword</SelectItem>
+                  <SelectItem value="dm_keyword">DM Keyword</SelectItem>
+                  <SelectItem value="story_mention">Story Mention</SelectItem>
+                  <SelectItem value="any_comment">Any Comment</SelectItem>
+                  <SelectItem value="whatsapp_keyword">WhatsApp Keyword</SelectItem>
+                  <SelectItem value="whatsapp_command">WhatsApp Command</SelectItem>
+                </SelectContent>
+              </Select>
+            </div>
+
+            <div className="space-y-2">
+              <Label>Action</Label>
+              <Select value={actionType} onValueChange={setActionType}>
+                <SelectTrigger>
+                  <SelectValue />
+                </SelectTrigger>
+                <SelectContent>
+                  {availableActions.map((action) => (
+                    <SelectItem key={action.value} value={action.value}>
+                      {action.label}
+                    </SelectItem>
+                  ))}
+                </SelectContent>
+              </Select>
             </div>
+          </div>
+
+          {!isWhatsAppTrigger && (
+            <div className="space-y-2">
+              <Label>Connected Account</Label>
+              <Select
+                value={connectedAccountId}
+                onValueChange={setConnectedAccountId}
+                disabled={loadingAccounts || accounts.length === 0}
+              >
+                <SelectTrigger>
+                  <SelectValue placeholder={loadingAccounts ? "Loading accounts..." : "Select an account"} />
+                </SelectTrigger>
+                <SelectContent>
+                  {accounts.map((account) => (
+                    <SelectItem key={account.id} value={account.id}>
+                      {(account.name || account.providerAccountId) + ` (${account.provider})`}
+                    </SelectItem>
+                  ))}
+                </SelectContent>
+              </Select>
+            </div>
+          )}
+
+          {(triggerType === "comment_keyword" || triggerType === "dm_keyword" || triggerType === "whatsapp_keyword" || triggerType === "whatsapp_command") && (
+            <div className="space-y-2">
+              <Label>
+                {triggerType === "whatsapp_command"
+                  ? "Commands (comma separated)"
+                  : "Keywords (comma separated)"}
+              </Label>
+              <Input
+                placeholder={triggerType === "whatsapp_command" ? "/start, /menu" : "price, cost, how much"}
+                value={keywords}
+                onChange={(event) => setKeywords(event.target.value)}
+              />
+            </div>
+          )}
+
+          <div className="space-y-2">
+            <Label>Response Message</Label>
+            <Textarea
+              placeholder="Hi there! Here is the information you asked for..."
+              className="min-h-[120px]"
+              value={responseTemplate}
+              onChange={(event) => setResponseTemplate(event.target.value)}
+            />
+          </div>
 
-            <Card>
-                <CardHeader>
-                    <CardTitle>Rule Configuration</CardTitle>
-                </CardHeader>
-                <CardContent className="space-y-4">
-                    <div className="space-y-2">
-                        <Label>Rule Name</Label>
-                        <Input
-                            placeholder="e.g. Pricing Auto-Reply"
-                            value={name}
-                            onChange={(e) => setName(e.target.value)}
-                        />
-                    </div>
-
-                    <div className="grid grid-cols-2 gap-4">
-                        <div className="space-y-2">
-                            <Label>Trigger</Label>
-                            <Select value={triggerType} onValueChange={setTriggerType}>
-                                <SelectTrigger>
-                                    <SelectValue />
-                                </SelectTrigger>
-                                <SelectContent>
-                                    <SelectItem value="comment_keyword">Comment Keyword</SelectItem>
-                                    <SelectItem value="dm_keyword">DM Keyword</SelectItem>
-                                    <SelectItem value="any_comment">Any Comment</SelectItem>
-                                    <SelectItem value="whatsapp_keyword">WhatsApp Message</SelectItem>
-                                </SelectContent>
-                            </Select>
-                        </div>
-
-                        <div className="space-y-2">
-                            <Label>Action</Label>
-                            <Select value={actionType} onValueChange={setActionType}>
-                                <SelectTrigger>
-                                    <SelectValue />
-                                </SelectTrigger>
-                                <SelectContent>
-                                    <SelectItem value="reply_comment">Reply to Comment</SelectItem>
-                                    <SelectItem value="send_dm">Send Private Message</SelectItem>
-                                </SelectContent>
-                            </Select>
-                        </div>
-                    </div>
-
-                    {(triggerType === "comment_keyword" || triggerType === "dm_keyword") && (
-                        <div className="space-y-2">
-                            <Label>Keywords (comma separated)</Label>
-                            <Input
-                                placeholder="price, cost, how much"
-                                value={keywords}
-                                onChange={(e) => setKeywords(e.target.value)}
-                            />
-                        </div>
-                    )}
-
-                    <div className="space-y-2">
-                        <Label>Response Message</Label>
-                        <Textarea
-                            placeholder="Hi there! Our pricing starts at..."
-                            className="min-h-[100px]"
-                            value={responseTemplate}
-                            onChange={(e) => setResponseTemplate(e.target.value)}
-                        />
-                    </div>
-
-                    <Button onClick={handleSubmit} className="w-full" disabled={submitting}>
-                        {submitting && <Loader2 className="mr-2 h-4 w-4 animate-spin" />}
-                        Create Rule
-                    </Button>
-                </CardContent>
-            </Card>
-        </div>
-    );
+          <Button onClick={handleSubmit} className="w-full" disabled={submitting}>
+            {submitting && <Loader2 className="mr-2 h-4 w-4 animate-spin" />}
+            Create Rule
+          </Button>
+        </CardContent>
+      </Card>
+    </div>
+  );
 }

app/dashboard/social/automations/page.tsx

@@ -16,11 +16,23 @@ export default async function AutomationsPage() {
     const automations = await db.query.socialAutomations.findMany({
         where: eq(socialAutomations.userId, session.user.id),
         with: {
-            // We haven't defined relation in schema relations.ts yet, so usually we'd fetch manually or define relations.
-            // For now, let's just fetch plain. We might lack account name in UI.
+            account: true,
         }
     });
 
+    const getActionLabel = (actionType: string) => {
+        if (actionType === "reply_comment") return "Reply to Comment";
+        if (actionType === "send_dm") return "Send Direct Message";
+        if (actionType === "whatsapp_reply") return "Send WhatsApp Reply";
+        return actionType;
+    };
+
+    const getPlatformLabel = (triggerType: string, provider?: string | null) => {
+        if (provider) return provider;
+        if (triggerType.startsWith("whatsapp_")) return "whatsapp";
+        return "unassigned";
+    };
+
     return (
         <div className="flex flex-col gap-6 p-6">
             <div className="flex items-center justify-between">
@@ -33,7 +45,7 @@ export default async function AutomationsPage() {
                     </Button>
                     <h1 className="text-3xl font-bold tracking-tight">Social Automations</h1>
                     <p className="text-muted-foreground">
-                        Automatically reply to comments and DMs based on keywords.
+                        Automatically handle comments, DMs, mentions, and WhatsApp replies.
                     </p>
                 </div>
                 <Button asChild>
@@ -49,9 +61,14 @@ export default async function AutomationsPage() {
                         <CardHeader className="pb-3">
                             <div className="flex justify-between items-start">
                                 <CardTitle className="text-lg">{auto.name}</CardTitle>
-                                <Badge variant={auto.isActive ? "default" : "secondary"}>
-                                    {auto.isActive ? "Active" : "Paused"}
-                                </Badge>
+                                <div className="flex items-center gap-2">
+                                    <Badge variant="outline" className="capitalize">
+                                        {getPlatformLabel(auto.triggerType, auto.account?.provider)}
+                                    </Badge>
+                                    <Badge variant={auto.isActive ? "default" : "secondary"}>
+                                        {auto.isActive ? "Active" : "Paused"}
+                                    </Badge>
+                                </div>
                             </div>
                             <CardDescription>
                                 Trigger: <span className="font-mono text-xs">{auto.triggerType}</span>
@@ -61,8 +78,18 @@ export default async function AutomationsPage() {
                             <div className="text-sm space-y-2">
                                 <div className="flex items-center gap-2 text-muted-foreground">
                                     <Zap className="h-3 w-3" />
-                                    <span>Action: {auto.actionType === "reply_comment" ? "Reply to Comment" : "Send DM"}</span>
+                                    <span>Action: {getActionLabel(auto.actionType)}</span>
                                 </div>
+                                {auto.account?.name && (
+                                    <div className="text-xs text-muted-foreground">
+                                        Account: {auto.account.name}
+                                    </div>
+                                )}
+                                {auto.keywords && auto.keywords.length > 0 && (
+                                    <div className="text-xs text-muted-foreground">
+                                        Keywords: {auto.keywords.join(", ")}
+                                    </div>
+                                )}
                                 <div className="p-2 bg-muted rounded text-xs truncate">
                                     {auto.responseTemplate}
                                 </div>

components/performance-dashboard.tsx

@@ -1,21 +1,11 @@
 "use client";
 
-import React, { useEffect, useState } from "react";
-import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card";
-import { BarChart, Bar, XAxis, YAxis, CartesianGrid, Tooltip, Legend, ResponsiveContainer } from "recharts";
+import React, { useEffect, useMemo, useState } from "react";
+import { Bar, BarChart, Legend, ResponsiveContainer, Tooltip, XAxis, YAxis } from "recharts";
 import { AlertCircle, CheckCircle, TrendingUp } from "lucide-react";
-import { assessWebVitals } from "@/lib/performance-monitoring";
 
-interface PerformanceMetrics {
-    lcp: number;
-    cls: number;
-    fid: number;
-    avgAPITime: number;
-    slowRequests: number;
-    cachedRequests: number;
-    totalRequests: number;
-    cacheHitRate: number;
-}
+import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card";
+import { assessWebVitals, type APIMetric, type PerformanceSummary } from "@/lib/performance-monitoring";
 
 interface WebVitalsStatus {
     lcp: { value: number; status: "good" | "needs-improvement" | "poor" };
@@ -23,21 +13,42 @@ interface WebVitalsStatus {
     fid: { value: number; status: "good" | "needs-improvement" | "poor" };
 }
 
+interface MetricsResponse extends PerformanceSummary {
+    apiMetrics: APIMetric[];
+}
+
+interface AggregatedApiMetric {
+    endpoint: string;
+    avgDuration: number;
+    maxDuration: number;
+}
+
 export function PerformanceDashboard() {
-    const [metrics, setMetrics] = useState<PerformanceMetrics | null>(null);
+    const [metrics, setMetrics] = useState<PerformanceSummary | null>(null);
     const [vitalsStatus, setVitalsStatus] = useState<WebVitalsStatus | null>(null);
-    const [apiMetrics, setApiMetrics] = useState<any[]>([]);
+    const [apiMetrics, setApiMetrics] = useState<APIMetric[]>([]);
     const [loading, setLoading] = useState(true);
 
     useEffect(() => {
-        // Fetch metrics from server
         async function fetchMetrics() {
             try {
                 const response = await fetch("/api/performance/metrics");
-                if (response.ok) {
-                    const data = await response.json();
-                    setMetrics(data);
+                if (!response.ok) {
+                    throw new Error("Failed to fetch performance metrics");
                 }
+
+                const data: MetricsResponse = await response.json();
+                setMetrics({
+                    lcp: data.lcp,
+                    cls: data.cls,
+                    fid: data.fid,
+                    avgAPITime: data.avgAPITime,
+                    slowRequests: data.slowRequests,
+                    cachedRequests: data.cachedRequests,
+                    totalRequests: data.totalRequests,
+                    cacheHitRate: data.cacheHitRate,
+                });
+                setApiMetrics(data.apiMetrics || []);
             } catch (error) {
                 console.error("Failed to fetch metrics:", error);
             } finally {
@@ -45,16 +56,37 @@ export function PerformanceDashboard() {
             }
         }
 
-        // Assess Web Vitals
-        const vitals = assessWebVitals();
-        setVitalsStatus(vitals as WebVitalsStatus);
-        fetchMetrics();
+        setVitalsStatus(assessWebVitals() as WebVitalsStatus);
+        void fetchMetrics();
+
+        const interval = setInterval(() => {
+            void fetchMetrics();
+        }, 30000);
 
-        // Refresh metrics every 30 seconds
-        const interval = setInterval(fetchMetrics, 30000);
         return () => clearInterval(interval);
     }, []);
 
+    const aggregatedApiMetrics = useMemo<AggregatedApiMetric[]>(() => {
+        const byEndpoint = new Map<string, { total: number; count: number; max: number }>();
+
+        for (const metric of apiMetrics) {
+            const current = byEndpoint.get(metric.endpoint) || { total: 0, count: 0, max: 0 };
+            current.total += metric.duration;
+            current.count += 1;
+            current.max = Math.max(current.max, metric.duration);
+            byEndpoint.set(metric.endpoint, current);
+        }
+
+        return Array.from(byEndpoint.entries())
+            .map(([endpoint, data]) => ({
+                endpoint,
+                avgDuration: data.total / data.count,
+                maxDuration: data.max,
+            }))
+            .sort((a, b) => b.avgDuration - a.avgDuration)
+            .slice(0, 10);
+    }, [apiMetrics]);
+
     const getStatusColor = (status: string) => {
         switch (status) {
             case "good":
@@ -70,23 +102,25 @@ export function PerformanceDashboard() {
 
     const getStatusIcon = (status: string) => {
         if (status === "good") {
-            return <CheckCircle className="w-4 h-4 text-green-600" />;
+            return <CheckCircle className="h-4 w-4 text-green-600" />;
         }
+
         if (status === "poor") {
-            return <AlertCircle className="w-4 h-4 text-red-600" />;
+            return <AlertCircle className="h-4 w-4 text-red-600" />;
         }
-        return <TrendingUp className="w-4 h-4 text-yellow-600" />;
+
+        return <TrendingUp className="h-4 w-4 text-yellow-600" />;
     };
 
     if (loading) {
         return (
             <div className="space-y-6">
                 <div className="grid gap-4 md:grid-cols-3">
-                    {Array.from({ length: 3 }).map((_, i) => (
-                        <Card key={i}>
+                    {Array.from({ length: 3 }).map((_, index) => (
+                        <Card key={index}>
                             <CardHeader className="space-y-2">
-                                <div className="h-4 w-24 bg-muted animate-pulse rounded" />
-                                <div className="h-8 w-32 bg-muted animate-pulse rounded" />
+                                <div className="h-4 w-24 animate-pulse rounded bg-muted" />
+                                <div className="h-8 w-32 animate-pulse rounded bg-muted" />
                             </CardHeader>
                         </Card>
                     ))}
@@ -97,7 +131,6 @@ export function PerformanceDashboard() {
 
     return (
         <div className="space-y-6">
-            {/* Web Vitals Summary */}
             <div className="grid gap-4 md:grid-cols-3">
                 {vitalsStatus && (
                     <>
@@ -109,12 +142,10 @@ export function PerformanceDashboard() {
                             <CardContent>
                                 <div className="flex items-center justify-between">
                                     <div>
-                                        <p className="text-2xl font-bold">
-                                            {vitalsStatus.lcp.value.toFixed(0)}ms
-                                        </p>
+                                        <p className="text-2xl font-bold">{vitalsStatus.lcp.value.toFixed(0)}ms</p>
                                         <p className={`text-xs font-medium ${getStatusColor(vitalsStatus.lcp.status)}`}>
                                             {vitalsStatus.lcp.status === "good"
-                                                ? "Good (≤2500ms)"
+                                                ? "Good (<=2500ms)"
                                                 : vitalsStatus.lcp.status === "needs-improvement"
                                                     ? "Needs Improvement (2500-4000ms)"
                                                     : "Poor (>4000ms)"}
@@ -133,12 +164,10 @@ export function PerformanceDashboard() {
                             <CardContent>
                                 <div className="flex items-center justify-between">
                                     <div>
-                                        <p className="text-2xl font-bold">
-                                            {vitalsStatus.cls.value.toFixed(3)}
-                                        </p>
+                                        <p className="text-2xl font-bold">{vitalsStatus.cls.value.toFixed(3)}</p>
                                         <p className={`text-xs font-medium ${getStatusColor(vitalsStatus.cls.status)}`}>
                                             {vitalsStatus.cls.status === "good"
-                                                ? "Good (≤0.1)"
+                                                ? "Good (<=0.1)"
                                                 : vitalsStatus.cls.status === "needs-improvement"
                                                     ? "Needs Improvement (0.1-0.25)"
                                                     : "Poor (>0.25)"}
@@ -157,12 +186,10 @@ export function PerformanceDashboard() {
                             <CardContent>
                                 <div className="flex items-center justify-between">
                                     <div>
-                                        <p className="text-2xl font-bold">
-                                            {vitalsStatus.fid.value.toFixed(0)}ms
-                                        </p>
+                                        <p className="text-2xl font-bold">{vitalsStatus.fid.value.toFixed(0)}ms</p>
                                         <p className={`text-xs font-medium ${getStatusColor(vitalsStatus.fid.status)}`}>
                                             {vitalsStatus.fid.status === "good"
-                                                ? "Good (≤100ms)"
+                                                ? "Good (<=100ms)"
                                                 : vitalsStatus.fid.status === "needs-improvement"
                                                     ? "Needs Improvement (100-300ms)"
                                                     : "Poor (>300ms)"}
@@ -176,7 +203,6 @@ export function PerformanceDashboard() {
                 )}
             </div>
 
-            {/* API Performance */}
             {metrics && (
                 <>
                     <div className="grid gap-4 md:grid-cols-2">
@@ -187,9 +213,7 @@ export function PerformanceDashboard() {
                             <CardContent className="space-y-4">
                                 <div>
                                     <p className="text-xs text-muted-foreground">Average Response Time</p>
-                                    <p className="text-2xl font-bold">
-                                        {metrics.avgAPITime.toFixed(0)}ms
-                                    </p>
+                                    <p className="text-2xl font-bold">{metrics.avgAPITime.toFixed(0)}ms</p>
                                 </div>
                                 <div>
                                     <p className="text-xs text-muted-foreground">Slow Requests (&gt;1s)</p>
@@ -205,9 +229,7 @@ export function PerformanceDashboard() {
                             <CardContent className="space-y-4">
                                 <div>
                                     <p className="text-xs text-muted-foreground">Cache Hit Rate</p>
-                                    <p className="text-2xl font-bold">
-                                        {metrics.cacheHitRate.toFixed(1)}%
-                                    </p>
+                                    <p className="text-2xl font-bold">{metrics.cacheHitRate.toFixed(1)}%</p>
                                 </div>
                                 <div>
                                     <p className="text-xs text-muted-foreground">Cached Requests</p>
@@ -219,17 +241,15 @@ export function PerformanceDashboard() {
                         </Card>
                     </div>
 
-                    {/* API Performance Breakdown */}
                     <Card>
                         <CardHeader>
                             <CardTitle>Request Distribution</CardTitle>
                             <CardDescription>API endpoint response times distribution</CardDescription>
                         </CardHeader>
                         <CardContent>
-                            <div className="w-full h-80">
+                            <div className="h-80 w-full">
                                 <ResponsiveContainer width="100%" height="100%">
-                                    <BarChart data={apiMetrics.slice(0, 10)}>
-                                        <CartesianGrid strokeDasharray="3 3" />
+                                    <BarChart data={aggregatedApiMetrics}>
                                         <XAxis dataKey="endpoint" angle={-45} textAnchor="end" height={80} />
                                         <YAxis />
                                         <Tooltip />
@@ -244,14 +264,13 @@ export function PerformanceDashboard() {
                 </>
             )}
 
-            {/* Performance Tips */}
             <Card>
                 <CardHeader>
                     <CardTitle className="text-sm font-medium">Performance Tips</CardTitle>
                 </CardHeader>
                 <CardContent className="space-y-3">
                     <div className="flex gap-3">
-                        <CheckCircle className="w-4 h-4 text-green-600 shrink-0 mt-0.5" />
+                        <CheckCircle className="mt-0.5 h-4 w-4 shrink-0 text-green-600" />
                         <div>
                             <p className="text-sm font-medium">Enable Caching</p>
                             <p className="text-xs text-muted-foreground">
@@ -261,7 +280,7 @@ export function PerformanceDashboard() {
                     </div>
 
                     <div className="flex gap-3">
-                        <AlertCircle className="w-4 h-4 text-yellow-600 shrink-0 mt-0.5" />
+                        <AlertCircle className="mt-0.5 h-4 w-4 shrink-0 text-yellow-600" />
                         <div>
                             <p className="text-sm font-medium">Monitor Slow Requests</p>
                             <p className="text-xs text-muted-foreground">
@@ -271,7 +290,7 @@ export function PerformanceDashboard() {
                     </div>
 
                     <div className="flex gap-3">
-                        <CheckCircle className="w-4 h-4 text-green-600 shrink-0 mt-0.5" />
+                        <CheckCircle className="mt-0.5 h-4 w-4 shrink-0 text-green-600" />
                         <div>
                             <p className="text-sm font-medium">Bundle Analysis</p>
                             <p className="text-xs text-muted-foreground">

components/settings/social-settings.tsx

@@ -306,7 +306,7 @@ export function SocialSettings({ connectedAccounts, automations = [] }: SocialSe
               </CardDescription>
             </div>
             <Button asChild>
-              <Link href="/dashboard/social/create-automation">
+              <Link href="/dashboard/social/automations/new">
                 <Plus className="h-4 w-4 mr-2" />
                 Add Rule
               </Link>

lib/auth.ts

@@ -123,7 +123,8 @@ export const { handlers, signIn, signOut, auth } = NextAuth({
         if (!phoneNumber || !code) return null;
 
         // Import dynamically to avoid circular deps if any
-        const { redis } = await import("@/lib/redis");
+        const { getRedis } = await import("@/lib/redis");
+        const redis = getRedis();
 
         // Verify Code
         if (!redis) {

lib/cache-manager.ts

@@ -1,4 +1,4 @@
-import { redis } from "@/lib/redis";
+import { getRedis } from "@/lib/redis";
 import { Logger } from "@/lib/logger";
 
 /**
@@ -13,6 +13,8 @@ export async function getCached<T>(
     fetcher: () => Promise<T>,
     ttl = 300
 ): Promise<T> {
+    const redis = getRedis();
+
     if (!redis) {
         return fetcher(); // No Redis, always fetch fresh
     }
@@ -42,6 +44,8 @@ export async function getCached<T>(
  * @param pattern - Pattern to match (e.g., "businesses:user_123:*")
  */
 export async function invalidateCache(pattern: string) {
+    const redis = getRedis();
+
     if (!redis) return;
 
     try {
@@ -69,6 +73,8 @@ export async function setCache<T>(
     data: T,
     ttl = 300
 ): Promise<void> {
+    const redis = getRedis();
+
     if (!redis) return;
 
     try {
@@ -88,6 +94,8 @@ export async function setCache<T>(
  * @returns Cached data or null
  */
 export async function getCache<T>(key: string): Promise<T | null> {
+    const redis = getRedis();
+
     if (!redis) return null;
 
     try {
@@ -107,6 +115,8 @@ export async function getCache<T>(key: string): Promise<T | null> {
  * @param key - Cache key to delete
  */
 export async function deleteCache(key: string): Promise<void> {
+    const redis = getRedis();
+
     if (!redis) return;
 
     try {

lib/environment-config.ts

@@ -101,7 +101,7 @@ export function isDevelopment(): boolean {
  */
 export function isFeatureEnabled(featureName: string): boolean {
     const env = getEnv();
-    const value = (env as Record<string, any>)[featureName];
+    const value = env[featureName as keyof Environment] as unknown;
     // Validate on import
     if (typeof window === "undefined") {
         try {

lib/performance-monitoring.ts

@@ -2,20 +2,15 @@
 
 import { useEffect, useState } from "react";
 
-/**
- * Performance Monitoring Utilities
- * Tracks Web Vitals (LCP, FID, CLS) and API response times
- */
-
 interface PerformanceMetric {
     name: string;
     value: number;
     unit: string;
     timestamp: number;
-    context?: Record<string, any>;
+    context?: Record<string, unknown>;
 }
 
-interface APIMetric {
+export interface APIMetric {
     endpoint: string;
     method: string;
     duration: number;
@@ -24,127 +19,139 @@ interface APIMetric {
     cached?: boolean;
 }
 
+export interface PerformanceSummary {
+    lcp: number;
+    cls: number;
+    fid: number;
+    avgAPITime: number;
+    slowRequests: number;
+    cachedRequests: number;
+    totalRequests: number;
+    cacheHitRate: number;
+}
+
+interface LargestContentfulPaintEntry extends PerformanceEntry {
+    element?: Element | null;
+    url?: string;
+}
+
+interface LayoutShiftEntry extends PerformanceEntry {
+    hadRecentInput: boolean;
+    value: number;
+}
+
+interface FirstInputEntry extends PerformanceEntry {
+    processingStart: number;
+}
+
 class PerformanceMonitor {
     private metrics: PerformanceMetric[] = [];
     private apiMetrics: APIMetric[] = [];
     private isEnabled = typeof window !== "undefined";
 
-    /**
-     * Initialize Web Vitals tracking
-     * Measures: LCP (Largest Contentful Paint), FID (First Input Delay), CLS (Cumulative Layout Shift)
-     */
     initWebVitals() {
-        if (!this.isEnabled) return;
-
-        // Track LCP (Largest Contentful Paint)
-        const observer = new PerformanceObserver((list) => {
-            for (const entry of list.getEntries()) {
-                if (entry.entryType === "largest-contentful-paint") {
-                    this.recordMetric({
-                        name: "LCP",
-                        value: entry.startTime,
-                        unit: "ms",
-                        timestamp: Date.now(),
-                        context: {
-                            element: (entry as any).element?.tagName,
-                            url: (entry as any).url,
-                        },
-                    });
+        if (!this.isEnabled || typeof PerformanceObserver === "undefined") {
+            return;
+        }
+
+        const lcpObserver = new PerformanceObserver((list) => {
+            for (const entry of list.getEntries() as LargestContentfulPaintEntry[]) {
+                if (entry.entryType !== "largest-contentful-paint") {
+                    continue;
                 }
+
+                this.recordMetric({
+                    name: "LCP",
+                    value: entry.startTime,
+                    unit: "ms",
+                    timestamp: Date.now(),
+                    context: {
+                        element: entry.element?.tagName,
+                        url: entry.url,
+                    },
+                });
             }
         });
 
-        observer.observe({ entryTypes: ["largest-contentful-paint"] });
+        lcpObserver.observe({ entryTypes: ["largest-contentful-paint"] });
 
-        // Track CLS (Cumulative Layout Shift)
         let clsValue = 0;
         const clsObserver = new PerformanceObserver((list) => {
-            for (const entry of list.getEntries()) {
-                if (!(entry as any).hadRecentInput) {
-                    clsValue += (entry as any).value;
-                    this.recordMetric({
-                        name: "CLS",
-                        value: clsValue,
-                        unit: "score",
-                        timestamp: Date.now(),
-                    });
+            for (const entry of list.getEntries() as LayoutShiftEntry[]) {
+                if (entry.hadRecentInput) {
+                    continue;
                 }
+
+                clsValue += entry.value;
+                this.recordMetric({
+                    name: "CLS",
+                    value: clsValue,
+                    unit: "score",
+                    timestamp: Date.now(),
+                });
             }
         });
 
         clsObserver.observe({ entryTypes: ["layout-shift"] });
 
-        // Track FID (First Input Delay)
         const fidObserver = new PerformanceObserver((list) => {
-            for (const entry of list.getEntries()) {
-                if (entry.entryType === "first-input") {
-                    this.recordMetric({
-                        name: "FID",
-                        value: (entry as any).processingDuration,
-                        unit: "ms",
-                        timestamp: Date.now(),
-                    });
+            for (const entry of list.getEntries() as FirstInputEntry[]) {
+                if (entry.entryType !== "first-input") {
+                    continue;
                 }
+
+                this.recordMetric({
+                    name: "FID",
+                    value: entry.processingStart - entry.startTime,
+                    unit: "ms",
+                    timestamp: Date.now(),
+                });
             }
         });
 
         fidObserver.observe({ entryTypes: ["first-input"] });
     }
 
-    /**
-     * Track API request performance
-     * Called from API interceptor or fetch wrapper
-     */
     recordAPIMetric(metric: APIMetric) {
         this.apiMetrics.push(metric);
 
-        // Keep only last 100 metrics in memory
         if (this.apiMetrics.length > 100) {
             this.apiMetrics.shift();
         }
 
-        // Send slow requests (>1s) to monitoring service
         if (metric.duration > 1000) {
             this.reportSlowRequest(metric);
         }
     }
 
-    /**
-     * Record custom performance metric
-     */
     recordMetric(metric: PerformanceMetric) {
         this.metrics.push(metric);
 
-        // Keep only last 100 metrics in memory
         if (this.metrics.length > 100) {
             this.metrics.shift();
         }
 
-        // Log metrics that exceed thresholds
         if (metric.name === "LCP" && metric.value > 2500) {
             console.warn(`LCP exceeded threshold: ${metric.value.toFixed(2)}ms`);
         }
+
         if (metric.name === "CLS" && metric.value > 0.1) {
             console.warn(`CLS exceeded threshold: ${metric.value.toFixed(3)}`);
         }
     }
 
-    /**
-     * Get performance summary for dashboard
-     */
-    getSummary() {
-        const lcp = this.metrics.find((m) => m.name === "LCP");
-        const cls = this.metrics.find((m) => m.name === "CLS");
-        const fid = this.metrics.find((m) => m.name === "FID");
+    getSummary(): PerformanceSummary {
+        const lcp = this.metrics.find((metric) => metric.name === "LCP");
+        const cls = this.metrics.find((metric) => metric.name === "CLS");
+        const fid = this.metrics.find((metric) => metric.name === "FID");
 
         const avgAPITime =
             this.apiMetrics.length > 0
-                ? this.apiMetrics.reduce((sum, m) => sum + m.duration, 0) /
-                this.apiMetrics.length
+                ? this.apiMetrics.reduce((sum, metric) => sum + metric.duration, 0) / this.apiMetrics.length
                 : 0;
 
-        const slowRequests = this.apiMetrics.filter((m) => m.duration > 1000).length;
-        const cachedRequests = this.apiMetrics.filter((m) => m.cached).length;
+        const slowRequests = this.apiMetrics.filter((metric) => metric.duration > 1000).length;
+        const cachedRequests = this.apiMetrics.filter((metric) => metric.cached).length;
 
         return {
             lcp: lcp?.value || 0,
@@ -161,35 +168,15 @@ class PerformanceMonitor {
         };
     }
 
-    /**
-     * Get all API metrics for analytics
-     */
     getAPIMetrics() {
         return [...this.apiMetrics];
     }
 
-    /**
-     * Report slow or failed requests to monitoring service
-     */
-    private reportSlowRequest(metric: APIMetric) {
-        // In production, send to Sentry or performance monitoring service
-        if (typeof window !== "undefined" && (window as any).__SENTRY__) {
-            // Sentry integration point
-            console.debug("Slow API request detected:", metric);
-        }
-    }
-
-    /**
-     * Clear metrics (useful for testing or reset)
-     */
     clearMetrics() {
         this.metrics = [];
         this.apiMetrics = [];
     }
 
-    /**
-     * Export metrics for analysis
-     */
     exportMetrics() {
         return {
             webVitals: this.metrics,
@@ -198,37 +185,38 @@ class PerformanceMonitor {
             timestamp: Date.now(),
         };
     }
+
+    private reportSlowRequest(metric: APIMetric) {
+        if (typeof window === "undefined") {
+            return;
+        }
+
+        const sentryWindow = window as Window & { __SENTRY__?: unknown };
+
+        if (sentryWindow.__SENTRY__) {
+            console.debug("Slow API request detected:", metric);
+        }
+    }
 }
 
-// Singleton instance
 export const performanceMonitor = new PerformanceMonitor();
 
-/**
- * Hook to use performance monitoring in React components
- */
 export function usePerformanceMonitoring() {
-    const [metrics, setMetrics] = useState<any>(null);
+    const [metrics, setMetrics] = useState<PerformanceSummary>(() => performanceMonitor.getSummary());
 
     useEffect(() => {
         performanceMonitor.initWebVitals();
 
-        // Update metrics every 5 seconds
         const interval = setInterval(() => {
             setMetrics(performanceMonitor.getSummary());
         }, 5000);
 
-        // Initial read
-        setMetrics(performanceMonitor.getSummary());
-
         return () => clearInterval(interval);
     }, []);
 
     return metrics;
 }
 
-/**
- * Wrapper for fetch to automatically track performance
- */
 export async function fetchWithMetrics(
     url: string,
     options?: RequestInit & { cached?: boolean }
@@ -266,10 +254,6 @@ export async function fetchWithMetrics(
     }
 }
 
-/**
- * Get Core Web Vitals assessment
- * Returns: Good, Needs Improvement, or Poor
- */
 export function assessWebVitals() {
     const summary = performanceMonitor.getSummary();
 
@@ -288,4 +272,3 @@ export function assessWebVitals() {
         },
     };
 }
-

lib/queue.ts

@@ -1,25 +1,22 @@
-// TypeScript ESLint configuration overrides for necessary 'any' types
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Queue, Worker, Job } from "bullmq";
-import { redis as connection } from "./redis";
-import Redis from "ioredis";
-import { db } from "@/db";
-import { emailLogs, businesses, emailTemplates, users } from "@/db/schema";
-import { eq, sql, and, gte, lt } from "drizzle-orm";
-import { interpolateTemplate, sendColdEmail } from "./email";
-import type { ScraperSourceName } from "./scrapers/types";
-
-// Ensure we have a valid Redis instance for BullMQ (even if disconnected/null in lib/redis)
-const safeConnection = connection || new Redis({
-  maxRetriesPerRequest: null,
-  lazyConnect: true
-});
+import { Job, Queue, Worker } from "bullmq";
+import { and, eq, gte, isNull, lt, or, sql } from "drizzle-orm";
+import type Redis from "ioredis";
 
-// Email queue
-export const emailQueue = new Queue("email-outreach", { connection: safeConnection as any });
-
-// Scraping queue
-export const scrapingQueue = new Queue("google-maps-scraping", { connection: safeConnection as any });
+import { db } from "@/db";
+import {
+  automationWorkflows,
+  businesses,
+  emailLogs,
+  emailTemplates,
+  notifications,
+  users,
+  workflowExecutionLogs,
+} from "@/db/schema";
+import { interpolateTemplate, sendColdEmail } from "@/lib/email";
+import { getRedis } from "@/lib/redis";
+import { sendWhatsAppMessage } from "@/lib/whatsapp/client";
+import type { ScraperSourceName } from "@/lib/scrapers/types";
 
 interface EmailJobData {
   userId: string;
@@ -37,28 +34,89 @@ interface ScrapingJobData {
   sources?: ScraperSourceName[];
 }
 
-/**
- * Add email to queue
- */
+interface WorkflowJobData {
+  workflowId: string;
+  userId: string;
+  businessId: string;
+  executionId: string;
+}
+
+interface QueueStats {
+  waiting: number;
+  active: number;
+  completed: number;
+  failed: number;
+}
+
+interface QueueWorkers {
+  emailWorker: Worker<EmailJobData>;
+  scrapingWorker: Worker<ScrapingJobData>;
+  workflowWorker: Worker<WorkflowJobData>;
+}
+
+let queueConnection: Redis | null = null;
+let emailQueueInstance: Queue<EmailJobData> | null = null;
+let scrapingQueueInstance: Queue<ScrapingJobData> | null = null;
+let workflowQueueInstance: Queue<WorkflowJobData> | null = null;
+let workerBundle: QueueWorkers | null = null;
+
+function getQueueConnection(): Redis {
+  if (queueConnection) {
+    return queueConnection;
+  }
+
+  const connection = getRedis();
+
+  if (!connection) {
+    throw new Error("Redis/Valkey is required for queue operations.");
+  }
+
+  queueConnection = connection;
+  return connection;
+}
+
+function getEmailQueue() {
+  if (!emailQueueInstance) {
+    emailQueueInstance = new Queue<EmailJobData>("email-outreach", {
+      connection: getQueueConnection() as any,
+    });
+  }
+
+  return emailQueueInstance;
+}
+
+function getScrapingQueue() {
+  if (!scrapingQueueInstance) {
+    scrapingQueueInstance = new Queue<ScrapingJobData>("google-maps-scraping", {
+      connection: getQueueConnection() as any,
+    });
+  }
+
+  return scrapingQueueInstance;
+}
+
+function getWorkflowQueue() {
+  if (!workflowQueueInstance) {
+    workflowQueueInstance = new Queue<WorkflowJobData>("workflow-execution", {
+      connection: getQueueConnection() as any,
+    });
+  }
+
+  return workflowQueueInstance;
+}
+
 export async function queueEmail(data: EmailJobData) {
-  await emailQueue.add(
-    "send-email",
-    data,
-    {
-      attempts: 3,
-      backoff: {
-        type: "exponential",
-        delay: 2000,
-      },
-    }
-  );
+  await getEmailQueue().add("send-email", data, {
+    attempts: 3,
+    backoff: {
+      type: "exponential",
+      delay: 2000,
+    },
+  });
 }
 
-/**
- * Add scraping job to queue
- */
 export async function queueScraping(params: ScrapingJobData) {
-  await scrapingQueue.add("scrape-google-maps", params, {
+  await getScrapingQueue().add("scrape-google-maps", params, {
     attempts: 3,
     backoff: { type: "exponential", delay: 2000 },
     removeOnComplete: { count: 100 },
@@ -66,602 +124,558 @@ export async function queueScraping(params: ScrapingJobData) {
   });
 }
 
-/**
- * Email worker - processes email sending jobs
- */
-export const emailWorker = new Worker(
-  "email-outreach",
-  async (job: Job<EmailJobData>) => {
-    const { userId, businessId, templateId, accessToken } = job.data;
+export async function queueWorkflowExecution(data: WorkflowJobData) {
+  await ensureWorkflowExecutionQueued(data);
+}
 
-    try {
-      // Get business details
-      const [business] = await db
-        .select()
-        .from(businesses)
-        .where(eq(businesses.id, businessId))
-        .limit(1);
+async function ensureWorkflowExecutionQueued(data: WorkflowJobData) {
+  const queue = getWorkflowQueue();
+  const existingJob = await queue.getJob(data.executionId);
 
-      if (!business) {
-        throw new Error("Business not found");
-      }
+  if (existingJob) {
+    return existingJob;
+  }
 
-      // Get template
-      const [template] = await db
-        .select()
-        .from(emailTemplates)
-        .where(eq(emailTemplates.id, templateId))
-        .limit(1);
+  return queue.add("execute-workflow", data, {
+    jobId: data.executionId,
+    attempts: 3,
+    backoff: {
+      type: "exponential",
+      delay: 2000,
+    },
+    removeOnComplete: { count: 100 },
+    removeOnFail: { count: 200 },
+  });
+}
 
-      if (!template) {
-        throw new Error("Template not found");
-      }
-      // Check daily limit (50 emails/day)
-      const startOfDay = new Date();
-      startOfDay.setHours(0, 0, 0, 0);
-
-      const endOfDay = new Date();
-      endOfDay.setHours(23, 59, 59, 999);
-
-      const [usage] = await db
-        .select({ count: sql<number>`count(*)` })
-        .from(emailLogs)
-        .where(
-          and(
-            eq(emailLogs.userId, userId),
-            eq(emailLogs.status, "sent"),
-            gte(emailLogs.sentAt, startOfDay),
-            lt(emailLogs.sentAt, endOfDay)
-          )
-        );
-
-      if (usage && usage.count >= 50) {
-        // Calculate time until next day
-        const now = new Date();
-        const tomorrow = new Date(now);
-        tomorrow.setDate(tomorrow.getDate() + 1);
-        tomorrow.setHours(0, 0, 0, 0);
-        const delay = tomorrow.getTime() - now.getTime() + 60000; // 1 min buffer
-
-        console.log(`⚠️ Daily email limit reached (${usage.count}/50). Delaying job ${job.id} by ${Math.round(delay / 1000 / 60)} minutes.`);
-
-        await job.moveToDelayed(Date.now() + delay, job.token);
-        return { delayed: true, reason: "Daily limit reached" };
-      }
+async function processEmailJob(job: Job<EmailJobData>) {
+  const { userId, businessId, templateId, accessToken } = job.data;
 
-      const sender = await db.query.users.findFirst({
-        where: eq(users.id, userId),
-      });
+  try {
+    const [business] = await db
+      .select()
+      .from(businesses)
+      .where(eq(businesses.id, businessId))
+      .limit(1);
+
+    if (!business) {
+      throw new Error("Business not found");
+    }
+
+    const [template] = await db
+      .select()
+      .from(emailTemplates)
+      .where(eq(emailTemplates.id, templateId))
+      .limit(1);
 
-      if (!sender) throw new Error("Sender not found");
+    if (!template) {
+      throw new Error("Template not found");
+    }
 
-      // Send emails
-      // Send email
-      // Log email immediately to get the ID for tracking
-      const [logEntry] = await db.insert(emailLogs).values({
+    const startOfDay = new Date();
+    startOfDay.setHours(0, 0, 0, 0);
+
+    const endOfDay = new Date();
+    endOfDay.setHours(23, 59, 59, 999);
+
+    const [usage] = await db
+      .select({ count: sql<number>`count(*)` })
+      .from(emailLogs)
+      .where(
+        and(
+          eq(emailLogs.userId, userId),
+          eq(emailLogs.status, "sent"),
+          gte(emailLogs.sentAt, startOfDay),
+          lt(emailLogs.sentAt, endOfDay)
+        )
+      );
+
+    if (usage && usage.count >= 50) {
+      const now = new Date();
+      const tomorrow = new Date(now);
+      tomorrow.setDate(tomorrow.getDate() + 1);
+      tomorrow.setHours(0, 0, 0, 0);
+      const delay = tomorrow.getTime() - now.getTime() + 60000;
+
+      console.log(
+        `Daily email limit reached (${usage.count}/50). Delaying job ${job.id} by ${Math.round(
+          delay / 1000 / 60
+        )} minutes.`
+      );
+
+      await job.moveToDelayed(Date.now() + delay, job.token);
+      return { delayed: true, reason: "Daily limit reached" };
+    }
+
+    const sender = await db.query.users.findFirst({
+      where: eq(users.id, userId),
+    });
+
+    if (!sender) {
+      throw new Error("Sender not found");
+    }
+
+    const [logEntry] = await db
+      .insert(emailLogs)
+      .values({
         userId,
         businessId: business.id,
         templateId: template.id,
         subject: interpolateTemplate(template.subject, business, sender),
-        body: "", // Will update after sending
+        body: "",
         status: "pending",
         errorMessage: null,
         sentAt: null,
-      }).returning();
+      })
+      .returning();
+
+    const trackingDomain = process.env.NEXT_PUBLIC_APP_URL || "http://localhost:3000";
+    const pixelUrl = `${trackingDomain}/api/tracking/open?id=${logEntry.id}`;
+    const trackingPixel =
+      `<img src="${pixelUrl}" alt="" width="1" height="1" style="display:none;" />`;
+
+    let finalBody = interpolateTemplate(template.body, business, sender);
+    finalBody = finalBody.replace(/href=["']([^"']+)["']/g, (_match, url) => {
+      const encodedUrl = encodeURIComponent(url);
+      const trackingUrl = `${trackingDomain}/api/tracking/click?id=${logEntry.id}&url=${encodedUrl}`;
+      return `href="${trackingUrl}"`;
+    });
+    finalBody += trackingPixel;
 
-      const trackingDomain = process.env.NEXT_PUBLIC_APP_URL || "http://localhost:3000";
+    await db.update(emailLogs).set({ body: finalBody }).where(eq(emailLogs.id, logEntry.id));
 
-      // Inject Open Tracking Pixel
-      const pixelUrl = `${trackingDomain}/api/tracking/open?id=${logEntry.id}`;
-      const trackingPixel = `<img src="${pixelUrl}" alt="" width="1" height="1" style="display:none;" />`;
+    const emailResult = await sendColdEmail(business, template, accessToken, sender);
+    const success = emailResult.success;
+    const error = emailResult.error;
 
-      let finalBody = interpolateTemplate(template.body, business, sender);
+    await db
+      .update(emailLogs)
+      .set({
+        status: success ? "sent" : "failed",
+        errorMessage: error,
+        sentAt: success ? new Date() : null,
+      })
+      .where(eq(emailLogs.id, logEntry.id));
+
+    await db
+      .update(businesses)
+      .set({
+        emailSent: true,
+        emailSentAt: new Date(),
+        emailStatus: success ? "sent" : "failed",
+        updatedAt: new Date(),
+      })
+      .where(eq(businesses.id, business.id));
+
+    if (!success) {
+      throw new Error(error || "Failed to send email");
+    }
 
-      // Inject Click Tracking (Basic implementation: rewrite hrefs)
-      finalBody = finalBody.replace(/href=["']([^"']+)["']/g, (match, url) => {
-        const encodedUrl = encodeURIComponent(url);
-        const trackingUrl = `${trackingDomain}/api/tracking/click?id=${logEntry.id}&url=${encodedUrl}`;
-        return `href="${trackingUrl}"`;
-      });
+    return { success: true, businessId };
+  } catch (error: unknown) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+
+    await db.insert(emailLogs).values({
+      userId,
+      businessId,
+      templateId,
+      subject: "Cold Outreach",
+      body: "Failed to send",
+      status: "failed",
+      errorMessage,
+    });
 
-      // Append pixel
-      finalBody += trackingPixel;
+    throw new Error(errorMessage);
+  }
+}
 
-      // Update body in log
-      await db.update(emailLogs).set({ body: finalBody }).where(eq(emailLogs.id, logEntry.id));
+async function processScrapingJob(job: Job<ScrapingJobData>) {
+  const { userId, jobId, keywords, location, sources = ["google-maps"] } = job.data;
+  console.log(`Starting scraping job ${job.id} for record ${jobId}`);
 
-      // Rename destructured variables to avoid conflict or use different scope
-      const emailResult = await sendColdEmail(
-        business,
-        template,
-        accessToken,
-        sender
-      );
+  const { scrapingJobs } = await import("@/db/schema");
+  const { eq } = await import("drizzle-orm");
+  const { scrapeMultiSource } = await import("./scrapers");
 
-      const success = emailResult.success;
-      const error = emailResult.error;
+  try {
+    let [jobRecord] = await db
+      .select()
+      .from(scrapingJobs)
+      .where(eq(scrapingJobs.id, jobId))
+      .limit(1);
+
+    if (!jobRecord) {
+      throw new Error(`Job ${jobId} not found`);
+    }
 
-      // Update log status
-      await db.update(emailLogs).set({
-        status: success ? "sent" : "failed",
-        errorMessage: error,
-        sentAt: success ? new Date() : null
-      }).where(eq(emailLogs.id, logEntry.id));
-
-      // Update business status
-      await db
-        .update(businesses)
-        .set({
-          emailSent: true,
-          emailSentAt: new Date(),
-          emailStatus: success ? "sent" : "failed",
-          updatedAt: new Date(),
-        })
-        .where(eq(businesses.id, business.id));
-
-      if (!success) {
-        throw new Error(error || "Failed to send email");
-      }
+    await db.update(scrapingJobs).set({ status: "running" }).where(eq(scrapingJobs.id, jobId));
 
-      return { success: true, businessId };
-    } catch (error: unknown) {
-      // Log failure
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      await db.insert(emailLogs).values({
-        userId,
-        businessId,
-        templateId,
-        subject: "Cold Outreach",
-        body: "Failed to send",
-        status: "failed",
-        errorMessage,
-      });
+    let totalFound = jobRecord.businessesFound || 0;
+    let loopCount = 0;
+    const maxLoops = 50;
 
-      throw new Error(errorMessage);
-    }
-  },
-  { connection: safeConnection as any }
-);
-
-/**
- * Scraping worker - processes Google Maps and Google Search scraping jobs
- */
-export const scrapingWorker = new Worker(
-  "google-maps-scraping",
-  async (job: Job<ScrapingJobData>) => {
-    const { userId, jobId, keywords, location, sources = ["google-maps"] } = job.data;
-    console.log(`\n🚀 Starting scraping job: ${job.id}`);
-    console.log(`   Job ID: ${jobId}`);
-
-    // Import scraping jobs schema and dependencies
-    const { scrapingJobs } = await import("@/db/schema");
-    const { eq } = await import("drizzle-orm");
-    const { scrapeMultiSource } = await import("./scrapers");
+    while (true) {
+      loopCount += 1;
 
-    try {
-      // Find the scraping job
-      let [jobRecord] = await db
+      [jobRecord] = await db
         .select()
         .from(scrapingJobs)
         .where(eq(scrapingJobs.id, jobId))
         .limit(1);
 
-      if (!jobRecord) throw new Error(`Job ${jobId} not found`);
-
-      // Update to running status
-      await db
-        .update(scrapingJobs)
-        .set({ status: "running" })
-        .where(eq(scrapingJobs.id, jobId));
-
-      console.log(`   ✓ Status updated to running`);
-
-      // Indefinite Loop State
-      let totalFound = jobRecord.businessesFound || 0;
-      let loopCount = 0;
-      const MAX_LOOPS = 50; // Safety cap to prevent infinite billing/resource usage for now (user can restart)
+      if (!jobRecord) {
+        break;
+      }
 
-      // Indefinite scraping loop
-      while (true) {
-        loopCount++;
+      if (jobRecord.status === "paused") {
+        await new Promise((resolve) => setTimeout(resolve, 5000));
+        continue;
+      }
 
-        // 1. Check current status from DB (in case user paused/stopped)
-        [jobRecord] = await db
-          .select()
-          .from(scrapingJobs)
-          .where(eq(scrapingJobs.id, jobId))
-          .limit(1);
+      if (jobRecord.status === "failed" || jobRecord.status === "completed") {
+        break;
+      }
 
-        if (!jobRecord) break; // Should not happen
+      const jitter = Math.floor(Math.random() * 5000);
+      await new Promise((resolve) => setTimeout(resolve, 2000 + jitter));
 
-        // Handle Control Signals
-        if (jobRecord.status === "paused") {
-          console.log(`   ⏸️ Job paused by user. Waiting...`);
-          // Wait for 5 seconds then check again
-          await new Promise(resolve => setTimeout(resolve, 5000));
-          continue;
-        }
+      const results = await scrapeMultiSource(
+        {
+          keywords,
+          location,
+          limit: 20,
+          sources,
+        },
+        userId
+      );
 
-        if (jobRecord.status === "failed" || jobRecord.status === "completed") {
-          console.log(`   🛑 Job stopped by user (Status: ${jobRecord.status})`);
-          break;
+      if (results.length > 0) {
+        const businessesToInsert = results.map((business) => ({
+          ...business,
+          userId,
+          category: business.category || "Unknown",
+          emailStatus: business.emailStatus || null,
+        }));
+
+        try {
+          await db.insert(businesses).values(businessesToInsert).onConflictDoNothing();
+        } catch (error: unknown) {
+          console.error(
+            "Failed to insert scraped businesses:",
+            error instanceof Error ? error.message : String(error)
+          );
+
+          await db.insert(businesses).values(businessesToInsert).catch((fallbackError: unknown) => {
+            console.error(
+              "Fallback insert failed:",
+              fallbackError instanceof Error ? fallbackError.message : String(fallbackError)
+            );
+          });
         }
 
-        // 2. Perform Scraping
-        console.log(`   🔄 Loop ${loopCount}: Scraping...`);
-
-        // Add random jitter to avoid patterns
-        const jitter = Math.floor(Math.random() * 5000);
-        await new Promise(resolve => setTimeout(resolve, 2000 + jitter));
-
-        const results = await scrapeMultiSource(
-          {
-            keywords, // Improvement: Rotate keywords or add pagination in future
-            location,
-            limit: 20, // Smaller batch per loop
-            sources
-          },
-          userId
-        );
-
-        // 3. Save Results
-        if (results.length > 0) {
-          console.log(`   💾 Saving ${results.length} businesses...`);
-
-          // Map results to match DB schema (add userId, ensure category)
-          const businessesToInsert = results.map(b => ({
-            ...b,
-            userId,
-            category: b.category || "Unknown",
-            emailStatus: b.emailStatus || null,
-          }));
-
-          // Use INSERT ON CONFLICT DO NOTHING approach
-          try {
-            await db.insert(businesses).values(businessesToInsert).onConflictDoNothing();
-          } catch (e: unknown) {
-            console.error("  ❌ Failed to insert businesses (onConflictDoNothing):", e instanceof Error ? e.message : String(e));
-            // Fallback if onConflictDoNothing is not supported by driver or schema setup
-            await db.insert(businesses).values(businessesToInsert).catch((err: unknown) => {
-              console.error("  ❌ Fallback insert also failed:", err instanceof Error ? err.message : String(err));
-            });
-          }
-
-          totalFound += results.length;
-
-          // Update progress
-          await db
-            .update(scrapingJobs)
-            .set({
-              businessesFound: totalFound
-            })
-            .where(eq(scrapingJobs.id, jobId));
-        }
+        totalFound += results.length;
 
-        // Break if we hit safety limit
-        if (loopCount >= MAX_LOOPS) {
-          console.log(`   ⚠️ Reached safety limit of ${MAX_LOOPS} loops. Finishing.`);
-          break;
-        }
+        await db
+          .update(scrapingJobs)
+          .set({ businessesFound: totalFound })
+          .where(eq(scrapingJobs.id, jobId));
+      }
 
-        // Yield control briefly
-        await new Promise(resolve => setTimeout(resolve, 1000));
+      if (loopCount >= maxLoops) {
+        break;
       }
 
-      // Final completion update
-      await db
-        .update(scrapingJobs)
-        .set({
-          status: "completed",
-          businessesFound: totalFound,
-          completedAt: new Date(),
-        })
-        .where(eq(scrapingJobs.id, jobId));
-
-      console.log(`✅ Scraping completed: ${totalFound} total businesses found`);
-      return { success: true, count: totalFound };
-
-    } catch (error: unknown) {
-      console.error(`❌ Job failed:`, error instanceof Error ? error.message : String(error));
-      await db
-        .update(scrapingJobs)
-        .set({ status: "failed", completedAt: new Date() })
-        .where(eq(scrapingJobs.id, jobId));
-      throw new Error(error instanceof Error ? error.message : String(error));
+      await new Promise((resolve) => setTimeout(resolve, 1000));
     }
-  },
-  {
-    connection: safeConnection as any,
-    concurrency: 5 // Allow 5 concurrent jobs
-  }
-);
 
-// Event listeners for scraping worker
-scrapingWorker.on("completed", (job) => {
-  console.log(`✅ Scraping job ${job.id} completed`);
-});
+    await db
+      .update(scrapingJobs)
+      .set({
+        status: "completed",
+        businessesFound: totalFound,
+        completedAt: new Date(),
+      })
+      .where(eq(scrapingJobs.id, jobId));
 
-scrapingWorker.on("failed", (job, err) => {
-  console.error(`❌ Scraping job ${job?.id} failed:`, err);
-});
+    return { success: true, count: totalFound };
+  } catch (error: unknown) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`Scraping job ${job.id} failed:`, message);
 
+    const { scrapingJobs } = await import("@/db/schema");
+    const { eq } = await import("drizzle-orm");
 
-/**
- * Workflow execution queue
- */
-export const workflowQueue = new Queue("workflow-execution", { connection: safeConnection as any });
+    await db
+      .update(scrapingJobs)
+      .set({ status: "failed", completedAt: new Date() })
+      .where(eq(scrapingJobs.id, jobId));
 
-interface WorkflowJobData {
-  workflowId: string;
-  userId: string;
-  businessId: string;
-  executionId: string;
+    throw new Error(message);
+  }
 }
 
-/**
- * Add workflow execution to queue
- */
-export async function queueWorkflowExecution(data: WorkflowJobData) {
-  await workflowQueue.add(
-    "execute-workflow",
-    data,
-    {
-      attempts: 3,
-      backoff: {
-        type: "exponential",
-        delay: 2000,
-      },
-      removeOnComplete: { count: 100 },
-      removeOnFail: { count: 200 },
-    }
-  );
-}
+async function processWorkflowJob(job: Job<WorkflowJobData>) {
+  const { workflowId, userId, businessId, executionId } = job.data;
+  console.log(`Processing workflow job ${job.id} (execution ${executionId})`);
 
-/**
- * Workflow worker - processes workflow execution jobs
- */
-export const workflowWorker = new Worker(
-  "workflow-execution",
-  async (job: Job<WorkflowJobData>) => {
-    const { workflowId, userId, businessId, executionId } = job.data;
-    console.log(`\n🚀 Processing workflow job ${job.id} (ExecID: ${executionId})`);
-
-    // Dynamic import to avoid circular dependencies if any
-    const { WorkflowExecutor } = await import("./workflow-executor");
-    const { automationWorkflows, workflowExecutionLogs } = await import("@/db/schema");
-    const { eq } = await import("drizzle-orm");
-    const { db } = await import("@/db");
+  const { WorkflowExecutor } = await import("./workflow-executor");
 
-    try {
-      // 1. Fetch Workflow & Business Data
-      const workflow = await db.query.automationWorkflows.findFirst({
-        where: eq(automationWorkflows.id, workflowId)
-      });
+  try {
+    await db
+      .update(workflowExecutionLogs)
+      .set({
+        status: "running",
+        startedAt: new Date(),
+        updatedAt: new Date(),
+      })
+      .where(eq(workflowExecutionLogs.id, executionId));
+
+    const workflow = await db.query.automationWorkflows.findFirst({
+      where: eq(automationWorkflows.id, workflowId),
+    });
 
-      if (!workflow) throw new Error("Workflow not found");
+    if (!workflow) {
+      throw new Error("Workflow not found");
+    }
 
-      const business = await db.query.businesses.findFirst({
-        where: eq(businesses.id, businessId)
-      });
+    const business = await db.query.businesses.findFirst({
+      where: eq(businesses.id, businessId),
+    });
 
-      if (!business) throw new Error("Business not found");
+    if (!business) {
+      throw new Error("Business not found");
+    }
 
-      // 2. Instantiate Executor
-      // Import types dynamically or assume they are available
-      // specific type imports might be needed if strictly typed
+    const executor = new WorkflowExecutor(workflow.nodes as any, workflow.edges as any, {
+      businessId: business.id,
+      businessData: business as any,
+      variables: {},
+      userId,
+      workflowId: workflow.id,
+    });
 
-      const executor = new WorkflowExecutor(
-        workflow.nodes as any,
-        workflow.edges as any,
-        {
-          businessId: business.id,
-          businessData: business as any,
-          variables: {},
-          userId,
-          workflowId: workflow.id,
-        }
-      );
+    const result = await executor.execute();
+    const finalState = executor.getVariables();
+
+    await db
+      .update(workflowExecutionLogs)
+      .set({
+        status: result.success ? "success" : "failed",
+        logs: JSON.stringify(result.logs),
+        state: finalState,
+        completedAt: new Date(),
+        updatedAt: new Date(),
+      })
+      .where(eq(workflowExecutionLogs.id, executionId));
+
+    if (!result.success) {
+      throw new Error("Workflow execution logic returned failure");
+    }
 
-      // 3. Execute
-      const result = await executor.execute();
-      const finalState = executor.getVariables();
-
-      // 4. Update Status based on result
-      await db
-        .update(workflowExecutionLogs)
-        .set({
-          status: result.success ? "success" : "failed",
-          logs: JSON.stringify(result.logs),
-          state: finalState,
-          completedAt: new Date(),
-        })
-        .where(eq(workflowExecutionLogs.id, executionId));
-
-      if (result.success) {
-        // Update Workflow lastRunAt and executionCount
-        await db
-          .update(automationWorkflows)
-          .set({
-            lastRunAt: new Date(),
-            executionCount: (workflow.executionCount || 0) + 1
-          })
-          .where(eq(automationWorkflows.id, workflowId));
-      } else {
-        throw new Error("Workflow execution logic returned failure");
-      }
+    await db
+      .update(automationWorkflows)
+      .set({
+        lastRunAt: new Date(),
+        executionCount: (workflow.executionCount || 0) + 1,
+      })
+      .where(eq(automationWorkflows.id, workflowId));
+
+    return { success: true };
+  } catch (error: unknown) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`Workflow job ${job.id} failed:`, message);
+
+    await db
+      .update(workflowExecutionLogs)
+      .set({
+        status: "failed",
+        error: message,
+        completedAt: new Date(),
+        updatedAt: new Date(),
+      })
+      .where(eq(workflowExecutionLogs.id, executionId));
 
-      return { success: true };
+    throw new Error(message);
+  }
+}
 
-    } catch (error: unknown) {
-      const msg = error instanceof Error ? error.message : String(error);
-      console.error(`❌ Workflow job ${job.id} failed:`, msg);
+function attachCommonWorkerListeners<T>(worker: Worker<T>, label: string) {
+  worker.on("completed", (job) => {
+    console.log(`${label} job ${job.id} completed`);
+  });
 
-      // Update log to failed
-      await db
-        .update(workflowExecutionLogs)
-        .set({
-          status: "failed",
-          error: msg,
-          completedAt: new Date(),
-        })
-        .where(eq(workflowExecutionLogs.id, executionId));
+  worker.on("failed", (job, err) => {
+    console.error(`${label} job ${job?.id} failed:`, err.message);
+  });
+}
 
-      throw new Error(msg);
+async function attachWorkflowFailureListener(worker: Worker<WorkflowJobData>) {
+  worker.on("failed", async (job, err) => {
+    if (!job || job.attemptsMade < (job.opts.attempts ?? 0)) {
+      return;
     }
-  },
-  { connection: safeConnection as any, concurrency: 10 }
-);
-
-workflowWorker.on("completed", (job) => {
-  console.log(`✅ Workflow job ${job.id} completed`);
-});
-
-workflowWorker.on("failed", async (job, err) => {
-  console.error(`❌ Workflow job ${job?.id} failed:`, err);
-
-  // Example: Check attempts and notify if max reached
-  if (job && job.attemptsMade >= job.opts.attempts!) {
-    const { notifications, users } = await import("@/db/schema");
-    const { db } = await import("@/db");
-    const { eq } = await import("drizzle-orm");
-    const { sendWhatsAppMessage } = await import("@/lib/whatsapp/client");
 
-    // 1. Create In-App Notification
     await db.insert(notifications).values({
       userId: job.data.userId,
-      title: "Workflow Complete Failure",
+      title: "Workflow Failure",
       message: `Workflow ${job.data.workflowId} failed after ${job.opts.attempts} attempts. Error: ${err.message}`,
       level: "error",
-      category: "workflow"
+      category: "workflow",
     });
 
-    // 2. Send WhatsApp Alert if User has phone number
     try {
       const user = await db.query.users.findFirst({
-        where: eq(users.id, job.data.userId)
+        where: eq(users.id, job.data.userId),
       });
 
-      if (user && user.phone) {
-        // Using a text message for internal alerts (or use a template if enforced)
-        // System alerts usually need a utility template like "alert_notification"
-        // For MVP: text
+      if (user?.phone) {
         await sendWhatsAppMessage({
           to: user.phone,
-          text: `🚨 Critical Alert: Workflow ${job.data.executionId} FAILED.\nError: ${err.message}`
+          text: `Critical alert: workflow ${job.data.executionId} failed. Error: ${err.message}`,
         });
-        console.log(`📱 WhatsApp Alert sent to ${user.phone}`);
       }
-    } catch (waError) {
-      console.error("Failed to send WhatsApp alert:", waError);
+    } catch (whatsAppError) {
+      console.error("Failed to send workflow WhatsApp alert:", whatsAppError);
     }
-  }
-});
+  });
+}
 
+function createWorkers(): QueueWorkers {
+  const connection = getQueueConnection();
 
-/**
- * Queue statistics
- */
-export async function getQueueStats() {
-  const [emailStats, scrapingStats, workflowStats] = await Promise.all([
-    Promise.all([
-      emailQueue.getWaitingCount(),
-      emailQueue.getActiveCount(),
-      emailQueue.getCompletedCount(),
-      emailQueue.getFailedCount(),
-    ]).then(([waiting, active, completed, failed]) => ({
-      waiting,
-      active,
-      completed,
-      failed,
-    })),
-    Promise.all([
-      scrapingQueue.getWaitingCount(),
-      scrapingQueue.getActiveCount(),
-      scrapingQueue.getCompletedCount(),
-      scrapingQueue.getFailedCount(),
-    ]).then(([waiting, active, completed, failed]) => ({
-      waiting,
-      active,
-      completed,
-      failed,
-    })),
-    Promise.all([
-      workflowQueue.getWaitingCount(),
-      workflowQueue.getActiveCount(),
-      workflowQueue.getCompletedCount(),
-      workflowQueue.getFailedCount(),
-    ]).then(([waiting, active, completed, failed]) => ({
-      waiting,
-      active,
-      completed,
-      failed,
-    })),
-  ]);
+  const emailWorker = new Worker<EmailJobData>("email-outreach", processEmailJob, {
+    connection: connection as any,
+  });
+
+  const scrapingWorker = new Worker<ScrapingJobData>("google-maps-scraping", processScrapingJob, {
+    connection: connection as any,
+    concurrency: 5,
+  });
+
+  const workflowWorker = new Worker<WorkflowJobData>(
+    "workflow-execution",
+    processWorkflowJob,
+    {
+      connection: connection as any,
+      concurrency: 10,
+    }
+  );
+
+  attachCommonWorkerListeners(emailWorker, "Email");
+  attachCommonWorkerListeners(scrapingWorker, "Scraping");
+  attachCommonWorkerListeners(workflowWorker, "Workflow");
+  void attachWorkflowFailureListener(workflowWorker);
 
   return {
-    email: emailStats,
-    scraping: scrapingStats,
-    workflow: workflowStats
+    emailWorker,
+    scrapingWorker,
+    workflowWorker,
   };
 }
 
-// Event handlers
-emailWorker.on("completed", (job) => {
-  console.log(`✅ Email job ${job.id} completed`);
-});
-
-emailWorker.on("failed", (job, err) => {
-  console.error(`❌ Email job ${job?.id} failed:`, err.message);
-});
+async function recoverIncompleteWorkflowExecutions() {
+  const recoverableExecutions = await db.query.workflowExecutionLogs.findMany({
+    where: and(
+      or(
+        eq(workflowExecutionLogs.status, "pending"),
+        eq(workflowExecutionLogs.status, "running")
+      ),
+      isNull(workflowExecutionLogs.completedAt)
+    ),
+    columns: {
+      id: true,
+      workflowId: true,
+      userId: true,
+      businessId: true,
+      status: true,
+    },
+  });
 
+  if (recoverableExecutions.length === 0) {
+    return 0;
+  }
 
+  let recoveredCount = 0;
 
-/**
- * Initialize and return queue workers for use in a dedicated worker process.
- * Workers are created on import; this function ensures listeners are attached
- * and returns the worker instances for any external orchestration.
- */
-export async function startWorker() {
-  try {
-    // attach idempotent markers to avoid duplicate listeners
-    if (!(emailWorker as any).__started) {
-      emailWorker.on("completed", (job) => {
-        console.log(`✅ Email job ${job.id} completed`);
-      });
-      emailWorker.on("failed", (job, err) => {
-        console.error(`❌ Email job ${job?.id} failed:`, (err as Error).message ?? String(err));
-      });
-      (emailWorker as any).__started = true;
+  for (const execution of recoverableExecutions) {
+    if (!execution.businessId) {
+      continue;
     }
 
-    if (!(scrapingWorker as any).__started) {
-      scrapingWorker.on("completed", (job) => {
-        console.log(`✅ Scraping job ${job.id} completed`);
-      });
-      scrapingWorker.on("failed", (job, err) => {
-        console.error(`❌ Scraping job ${job?.id} failed:`, (err as Error).message ?? String(err));
-      });
-      (scrapingWorker as any).__started = true;
-    }
+    await db
+      .update(workflowExecutionLogs)
+      .set({
+        status: "pending",
+        error: null,
+        updatedAt: new Date(),
+      })
+      .where(eq(workflowExecutionLogs.id, execution.id));
+
+    await ensureWorkflowExecutionQueued({
+      workflowId: execution.workflowId,
+      userId: execution.userId,
+      businessId: execution.businessId,
+      executionId: execution.id,
+    });
 
-    if (!(workflowWorker as any).__started) {
-      workflowWorker.on("completed", (job) => {
-        console.log(`✅ Workflow job ${job.id} completed`);
-      });
-      workflowWorker.on("failed", (job, err) => {
-        console.error(`❌ Workflow job ${job?.id} failed:`, (err as Error).message ?? String(err));
-      });
-      (workflowWorker as any).__started = true;
-    }
+    recoveredCount += 1;
+  }
+
+  console.log(`Recovered ${recoveredCount} incomplete workflow executions from Postgres.`);
+  return recoveredCount;
+}
+
+async function getQueueSnapshot(queue: Queue<any, any, string>): Promise<QueueStats> {
+  const [waiting, active, completed, failed] = await Promise.all([
+    queue.getWaitingCount(),
+    queue.getActiveCount(),
+    queue.getCompletedCount(),
+    queue.getFailedCount(),
+  ]);
+
+  return {
+    waiting,
+    active,
+    completed,
+    failed,
+  };
+}
+
+export async function getQueueStats() {
+  try {
+    const [emailStats, scrapingStats, workflowStats] = await Promise.all([
+      getQueueSnapshot(getEmailQueue()),
+      getQueueSnapshot(getScrapingQueue()),
+      getQueueSnapshot(getWorkflowQueue()),
+    ]);
 
     return {
-      emailWorker,
-      scrapingWorker,
-      workflowWorker,
+      email: emailStats,
+      scraping: scrapingStats,
+      workflow: workflowStats,
     };
-  } catch (err) {
-    console.error("Failed to start workers:", err);
-    throw err;
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("Redis/Valkey is required")) {
+      return {
+        email: { waiting: 0, active: 0, completed: 0, failed: 0 },
+        scraping: { waiting: 0, active: 0, completed: 0, failed: 0 },
+        workflow: { waiting: 0, active: 0, completed: 0, failed: 0 },
+      };
+    }
+
+    throw error;
   }
 }
 
+export async function startWorker() {
+  if (process.env.START_QUEUE_WORKERS !== "true") {
+    throw new Error("Queue workers are disabled in this process.");
+  }
+
+  if (!workerBundle) {
+    workerBundle = createWorkers();
+    await recoverIncompleteWorkflowExecutions();
+  }
+
+  return workerBundle;
+}

lib/rate-limit.ts

@@ -1,4 +1,4 @@
-import { redis } from "@/lib/redis";
+import { getRedis } from "@/lib/redis";
 import { NextResponse } from "next/server";
 import { NextRequest } from "next/server";
 
@@ -52,6 +52,8 @@ export class RateLimiter {
    * @returns { success: boolean, remaining: number, reset: number }
    */
   static async check(key: string, config: RateLimitConfig) {
+    const redis = getRedis();
+
     if (!redis) {
       console.warn("Redis not available, skipping rate limit check");
       return { success: true, remaining: 1, reset: 0 };
@@ -95,6 +97,8 @@ export class RateLimiter {
    * Cleanup rate limit key (clear from Redis)
    */
   static async cleanup(key: string) {
+    const redis = getRedis();
+
     if (redis) {
       await redis.del(key);
     }
@@ -105,6 +109,8 @@ export class RateLimiter {
  * Legacy rate limit function for backward compatibility
  */
 export async function rateLimit(request: Request, context: string = "general") {
+  const redis = getRedis();
+
   if (!redis) return null; // Skip if no Redis
 
   const ip = request.headers.get("x-forwarded-for") || "unknown";
@@ -147,6 +153,8 @@ export async function checkRateLimit(
   reset: number;
   response?: NextResponse;
 }> {
+  const redis = getRedis();
+
   if (!redis) {
     return { limited: false, remaining: 999, reset: 0 };
   }
@@ -193,6 +201,7 @@ export async function getRemainingEmails(userId: string): Promise<number> {
   // Limit: 50 emails per day
   const key = `email_limit:${userId}`;
   const config = RATE_LIMIT_CONFIG.email;
+  const redis = getRedis();
 
   if (!redis) return 50;
 

lib/redis.ts

@@ -1,57 +1,109 @@
-import Redis from "ioredis";
+import Redis, { type RedisOptions } from "ioredis";
 
-let redis: Redis | null = null;
-let connectionAttempted = false;
+let redisClient: Redis | null = null;
+let initializationAttempted = false;
+
+function getBaseOptions(): RedisOptions {
+  return {
+    maxRetriesPerRequest: null,
+    retryStrategy: (times) => {
+      if (times > 3) {
+        console.warn("Redis/Valkey connection failed after retries, continuing without queue cache");
+        return null;
+      }
+
+      return Math.min(times * 100, 1000);
+    },
+    lazyConnect: true,
+    enableOfflineQueue: false,
+  };
+}
+
+function createClient(): Redis | null {
+  const redisUrl = process.env.REDIS_URL?.trim();
+
+  if (redisUrl) {
+    return new Redis(redisUrl, getBaseOptions());
+  }
+
+  if (process.env.REDIS_HOST || process.env.REDIS_PORT || process.env.REDIS_PASSWORD) {
+    return new Redis({
+      ...getBaseOptions(),
+      host: process.env.REDIS_HOST || "127.0.0.1",
+      port: parseInt(process.env.REDIS_PORT || "6379", 10),
+      password: process.env.REDIS_PASSWORD,
+    });
+  }
+
+  return null;
+}
+
+function attachListeners(client: Redis) {
+  client.on("error", (err) => {
+    console.warn("Redis/Valkey error:", err.message);
+  });
+
+  client.on("end", () => {
+    console.warn("Redis/Valkey connection closed");
+  });
+}
 
 export function getRedis(): Redis | null {
-  if (connectionAttempted) {
-    return redis;
+  if (initializationAttempted) {
+    return redisClient;
   }
 
+  initializationAttempted = true;
+
   try {
-    connectionAttempted = true;
+    const client = createClient();
 
-    // Don't attempt connection if no Redis URL is provided
-    if (!process.env.REDIS_URL && !process.env.REDIS_HOST) {
-      console.warn("Redis not configured, continuing without Redis");
+    if (!client) {
+      console.warn("Redis/Valkey not configured, continuing without queue cache");
+      redisClient = null;
       return null;
     }
 
-    redis = new Redis({
-      host: process.env.REDIS_HOST || "localhost",
-      port: parseInt(process.env.REDIS_PORT || "6379"),
-      password: process.env.REDIS_PASSWORD,
-      // BullMQ requires this to be null
-      maxRetriesPerRequest: null,
-      retryStrategy: (times) => {
-        if (times > 3) {
-          console.warn("Redis connection failed after retries, continuing without Redis");
-          return null; // Stop retrying
-        }
-        return Math.min(times * 50, 200);
-      },
-      lazyConnect: true,
-      enableOfflineQueue: false,
-    });
+    attachListeners(client);
+    redisClient = client;
+    return redisClient;
+  } catch (error) {
+    console.warn("Failed to initialize Redis/Valkey:", error);
+    redisClient = null;
+    return null;
+  }
+}
 
-    // Attempt to connect (non-blocking)
-    redis.connect().catch((err) => {
-      console.warn("Redis connection failed:", err.message);
-      redis = null;
-    });
+export async function connectRedis(): Promise<Redis | null> {
+  const client = getRedis();
 
-    redis.on("error", (err) => {
-      console.warn("Redis error:", err.message);
-    });
+  if (!client) {
+    return null;
+  }
+
+  if (client.status === "ready" || client.status === "connecting" || client.status === "connect") {
+    return client;
+  }
 
-    return redis;
+  try {
+    await client.connect();
+    return client;
   } catch (error) {
-    console.warn("Failed to initialize Redis:", error);
-    redis = null;
+    console.warn(
+      "Redis/Valkey connection failed:",
+      error instanceof Error ? error.message : String(error)
+    );
+
+    if (redisClient === client) {
+      redisClient = null;
+      initializationAttempted = false;
+    }
+
     return null;
   }
 }
 
-// For backward compatibility
-redis = getRedis();
-export { redis };
+export function resetRedisClient() {
+  redisClient = null;
+  initializationAttempted = false;
+}

lib/social/event-dedupe.ts

@@ -0,0 +1,45 @@
+import { getRedis } from "@/lib/redis";
+
+const DEFAULT_TTL_SECONDS = 60 * 60 * 24 * 7;
+
+export function buildSocialEventKey(
+  provider: string,
+  accountId: string,
+  eventType: string,
+  eventId: string
+) {
+  return `social:event:${provider}:${accountId}:${eventType}:${eventId}`;
+}
+
+export async function claimSocialEvent(
+  eventKey: string,
+  ttlSeconds = DEFAULT_TTL_SECONDS
+): Promise<boolean> {
+  const redis = getRedis();
+
+  if (!redis) {
+    return true;
+  }
+
+  try {
+    const result = await redis.set(eventKey, "1", "EX", ttlSeconds, "NX");
+    return result === "OK";
+  } catch (error) {
+    console.error("Failed to claim social event:", error);
+    return true;
+  }
+}
+
+export async function releaseSocialEvent(eventKey: string): Promise<void> {
+  const redis = getRedis();
+
+  if (!redis) {
+    return;
+  }
+
+  try {
+    await redis.del(eventKey);
+  } catch (error) {
+    console.error("Failed to release social event:", error);
+  }
+}

lib/validations.ts

@@ -71,8 +71,15 @@ export const controlScrapingSchema = z.object({
 
 export const createSocialAutomationSchema = z.object({
   name: z.string().min(1, "Automation name is required").max(100),
-  connectedAccountId: z.string().min(1, "Connected account is required"),
-  triggerType: z.enum(["comment_keyword", "dm_keyword", "story_mention", "any_comment"]),
+  connectedAccountId: z.string().min(1, "Connected account is required").optional(),
+  triggerType: z.enum([
+    "comment_keyword",
+    "dm_keyword",
+    "story_mention",
+    "any_comment",
+    "whatsapp_keyword",
+    "whatsapp_command",
+  ]),
   keywords: z.array(z.string()).optional(),
   actionType: z.enum(["reply_comment", "send_dm", "whatsapp_reply"]),
   responseTemplate: z.string().min(1, "Response template is required").max(1000),

lib/whatsapp/client.ts

@@ -7,6 +7,8 @@ interface SendMessageParams {
   templateLanguage?: string;
   templateComponents?: unknown[];
   text?: string;
+  phoneId?: string;
+  accessToken?: string;
 }
 
 const PHONE_ID = process.env.WHATSAPP_PHONE_ID;
@@ -16,8 +18,8 @@ const ACCESS_TOKEN = process.env.WHATSAPP_ACCESS_TOKEN;
  * Send a WhatsApp Message via Meta Cloud API
  */
 export async function sendWhatsAppMessage(payload: SendMessageParams): Promise<{ success: boolean; id?: string; error?: string }> {
-  const phoneId = PHONE_ID;
-  const token = ACCESS_TOKEN;
+  const phoneId = payload.phoneId || PHONE_ID;
+  const token = payload.accessToken || ACCESS_TOKEN;
 
   if (!phoneId || !token) {
     return { success: false, error: "Missing WhatsApp Credentials" };

lib/whatsapp/webhook.ts

@@ -1,6 +1,7 @@
+import { and, eq } from "drizzle-orm";
+
 import { db } from "@/db";
-import { socialAutomations, whatsappMessages } from "@/db/schema";
-import { eq, and } from "drizzle-orm";
+import { socialAutomations, users, whatsappMessages } from "@/db/schema";
 import { sendWhatsAppMessage } from "./client";
 
 interface WhatsAppChange {
@@ -41,33 +42,26 @@ interface WhatsAppStatus {
   status: string;
   timestamp: string;
   recipient_id: string;
-  conversation?: {
-    id: string;
-    expiration_timestamp?: string;
-    origin?: {
-      type: string;
-    };
-  };
-  pricing?: {
-    billable: boolean;
-    pricing_model: string;
-    category: string;
-  };
 }
 
 export async function handleWhatsAppEvent(body: WhatsAppWebhookBody) {
-  if (body.object === "whatsapp_business_account") {
-    for (const entry of body.entry) {
-      for (const change of entry.changes) {
-        if (change.value.messages) {
-          for (const message of change.value.messages) {
-            await processMessage(message);
-          }
+  if (body.object !== "whatsapp_business_account") {
+    return;
+  }
+
+  for (const entry of body.entry) {
+    for (const change of entry.changes) {
+      const phoneNumberId = change.value.metadata.phone_number_id;
+
+      if (change.value.messages) {
+        for (const message of change.value.messages) {
+          await processMessage(message, phoneNumberId);
         }
-        if (change.value.statuses) {
-          for (const status of change.value.statuses) {
-            await processStatusUpdate(status);
-          }
+      }
+
+      if (change.value.statuses) {
+        for (const status of change.value.statuses) {
+          await processStatusUpdate(status);
         }
       }
     }
@@ -75,87 +69,100 @@ export async function handleWhatsAppEvent(body: WhatsAppWebhookBody) {
 }
 
 async function processStatusUpdate(status: WhatsAppStatus) {
-  // status: { id: 'wamid.HBg...', status: 'sent'|'delivered'|'read', timestamp: '...', recipient_id: '...' }
-  const { id, status: newStatus } = status;
-
   try {
-    await db.update(whatsappMessages)
-      .set({ status: newStatus, updatedAt: new Date() })
-      .where(eq(whatsappMessages.wamid, id));
-
-    // console.log(`🔄 Message ${id} status: ${newStatus}`);
+    await db
+      .update(whatsappMessages)
+      .set({ status: status.status, updatedAt: new Date() })
+      .where(eq(whatsappMessages.wamid, status.id));
   } catch (error) {
-    console.error(`Failed to update status for ${id}:`, error);
+    console.error(`Failed to update status for ${status.id}:`, error);
   }
 }
 
-async function processMessage(message: WhatsAppMessage) {
-  const senderPhone = message.from; // e.g., "15551234567"
+async function processMessage(message: WhatsAppMessage, phoneNumberId: string) {
+  const senderPhone = message.from;
   const messageId = message.id;
-  const timestamp = new Date(parseInt(message.timestamp) * 1000);
-
-  let text = "";
-  const type = message.type; // 'text', 'button', 'interactive'
+  const timestamp = new Date(parseInt(message.timestamp, 10) * 1000);
 
-  if (type === "text" && message.text) {
-    text = message.text.body;
-  } else {
-    // For now, capture type as text but body might be empty or description
-    text = `[${type} message]`;
-  }
-
-  console.log(`📩 WhatsApp Message from ${senderPhone}: ${text}`);
+  const text =
+    message.type === "text" && message.text
+      ? message.text.body
+      : `[${message.type} message]`;
 
-  // 1. Log Inbound Message
   try {
-    // Check if exists (dedup logic if needed, but wamid is unique)
-    await db.insert(whatsappMessages).values({
-      wamid: messageId,
-      phoneNumber: senderPhone,
-      direction: "inbound",
-      type: type,
-      status: "received",
-      body: text,
-      createdAt: timestamp,
-      updatedAt: timestamp
-    }).onConflictDoNothing({ target: whatsappMessages.wamid });
+    await db
+      .insert(whatsappMessages)
+      .values({
+        wamid: messageId,
+        phoneNumber: senderPhone,
+        direction: "inbound",
+        type: message.type,
+        status: "received",
+        body: text,
+        createdAt: timestamp,
+        updatedAt: timestamp,
+      })
+      .onConflictDoNothing({ target: whatsappMessages.wamid });
   } catch (error) {
-    console.error("Failed to log inbound message:", error);
+    console.error("Failed to log inbound WhatsApp message:", error);
+  }
+
+  if (message.type !== "text") {
+    return;
   }
 
-  if (type !== "text") return; // Only automate text for now
+  const user = await db.query.users.findFirst({
+    where: eq(users.whatsappBusinessPhone, phoneNumberId),
+    columns: {
+      id: true,
+      whatsappBusinessPhone: true,
+      whatsappAccessToken: true,
+    },
+  });
+
+  if (!user) {
+    console.warn(`No WhatsApp-configured user found for phone number id ${phoneNumberId}`);
+    return;
+  }
 
-  // 2. Find Automation Rules (Auto-Reply & Commands)
   const rules = await db.query.socialAutomations.findMany({
     where: and(
+      eq(socialAutomations.userId, user.id),
       eq(socialAutomations.isActive, true)
-    )
+    ),
   });
 
   for (const rule of rules) {
     let matched = false;
 
     if (rule.triggerType === "whatsapp_keyword") {
-      if (rule.keywords && rule.keywords.some(k => text.toLowerCase().includes(k.toLowerCase()))) {
-        matched = true;
-      }
+      matched = !!rule.keywords?.some((keyword) =>
+        text.toLowerCase().includes(keyword.toLowerCase())
+      );
     } else if (rule.triggerType === "whatsapp_command") {
-      if (rule.keywords && rule.keywords.some(k => text.toLowerCase().trim() === k.toLowerCase().trim() || text.toLowerCase().startsWith(k.toLowerCase() + " "))) {
-        matched = true;
-      }
+      matched = !!rule.keywords?.some((keyword) => {
+        const normalizedKeyword = keyword.toLowerCase().trim();
+        const normalizedText = text.toLowerCase().trim();
+        return (
+          normalizedText === normalizedKeyword ||
+          normalizedText.startsWith(`${normalizedKeyword} `)
+        );
+      });
     }
 
-    if (matched) {
-      console.log(`✅ Matched WhatsApp Rule: ${rule.name} (${rule.triggerType})`);
+    if (!matched) {
+      continue;
+    }
 
-      // Send Reply
-      await sendWhatsAppMessage({
-        to: senderPhone,
-        text: rule.responseTemplate || ""
-      });
+    await sendWhatsAppMessage({
+      to: senderPhone,
+      text: rule.responseTemplate || "",
+      phoneId: user.whatsappBusinessPhone || undefined,
+      accessToken: user.whatsappAccessToken || undefined,
+    });
 
-      // Stop after first match? Maybe for commands, yes.
-      if (rule.triggerType === "whatsapp_command") break;
+    if (rule.triggerType === "whatsapp_command") {
+      break;
     }
   }
 }

lib/workers/index.ts

@@ -1,24 +1,42 @@
 /**
- * Server configuration to start background workers
- * This should be called when the server starts
+ * Dedicated worker runtime.
+ * Only the worker process should call these functions.
  */
 
-import { startSocialAutomationWorker } from "@/lib/workers/social-automation";
+import { Logger } from "@/lib/logger";
+import { startTriggerProcessor } from "@/lib/workflow-triggers";
+import { startSocialAutomationWorker, stopSocialAutomationWorker } from "@/lib/workers/social-automation";
+import { startScheduledPostWorker, stopScheduledPostWorker } from "@/lib/workers/scheduled-posts";
+
+let started = false;
 
 export async function startBackgroundWorkers() {
-  console.log("🚀 Starting background workers...");
+  if (started) {
+    return;
+  }
 
-  try {
-    // Start social automation worker
-    await startSocialAutomationWorker();
+  started = true;
+
+  Logger.info("Starting background automation services");
+
+  startTriggerProcessor();
+  startScheduledPostWorker();
 
-    console.log("✅ All background workers started successfully");
-  } catch (error) {
-    console.error("❌ Error starting background workers:", error);
+  if (process.env.ENABLE_SOCIAL_POLLING === "true") {
+    await startSocialAutomationWorker();
   }
+
+  Logger.info("Background automation services started", {
+    socialPolling: process.env.ENABLE_SOCIAL_POLLING === "true",
+  });
 }
 
-// Auto-start workers in production
-if (process.env.NODE_ENV === "production" || process.env.START_WORKERS === "true") {
-  startBackgroundWorkers();
+export function stopBackgroundWorkers() {
+  stopScheduledPostWorker();
+
+  if (process.env.ENABLE_SOCIAL_POLLING === "true") {
+    stopSocialAutomationWorker();
+  }
+
+  started = false;
 }

lib/workers/scheduled-posts.ts

@@ -0,0 +1,153 @@
+import { and, eq, lte } from "drizzle-orm";
+
+import { db } from "@/db";
+import { connectedAccounts, socialPosts } from "@/db/schema";
+import { claimSocialEvent, buildSocialEventKey, releaseSocialEvent } from "@/lib/social/event-dedupe";
+import { socialPublisher } from "@/lib/social/publisher";
+import { Logger } from "@/lib/logger";
+
+const CHECK_INTERVAL_MS = 30 * 1000;
+
+let intervalId: NodeJS.Timeout | null = null;
+let isRunning = false;
+
+async function publishScheduledPost(post: typeof socialPosts.$inferSelect) {
+  if (!post.connectedAccountId) {
+    await db
+      .update(socialPosts)
+      .set({
+        status: "failed",
+        error: "Scheduled post is missing a connected account",
+        updatedAt: new Date(),
+      })
+      .where(eq(socialPosts.id, post.id));
+    return;
+  }
+
+  const lockKey = buildSocialEventKey(post.platform, post.connectedAccountId, "scheduled-post", post.id);
+  const claimed = await claimSocialEvent(lockKey, 60 * 10);
+
+  if (!claimed) {
+    return;
+  }
+
+  try {
+    const account = await db.query.connectedAccounts.findFirst({
+      where: eq(connectedAccounts.id, post.connectedAccountId),
+    });
+
+    if (!account) {
+      throw new Error("Connected account not found");
+    }
+
+    await db
+      .update(socialPosts)
+      .set({
+        status: "publishing",
+        updatedAt: new Date(),
+      })
+      .where(and(eq(socialPosts.id, post.id), eq(socialPosts.status, "scheduled")));
+
+    const mediaUrl = post.mediaUrls?.[0];
+    const payload = {
+      content: post.content || post.title || "",
+      mediaUrl,
+      accessToken: account.accessToken,
+      providerAccountId: account.providerAccountId,
+      refreshToken: account.refreshToken || undefined,
+    };
+
+    let platformPostId: string | null = null;
+
+    if (account.provider === "facebook") {
+      platformPostId = await socialPublisher.publishToFacebook(payload);
+    } else if (account.provider === "instagram") {
+      platformPostId = await socialPublisher.publishToInstagram(payload);
+    } else if (account.provider === "linkedin") {
+      platformPostId = await socialPublisher.publishToLinkedin(payload);
+    } else if (account.provider === "youtube") {
+      platformPostId = (await socialPublisher.publishToYoutube(payload)) || null;
+    } else {
+      throw new Error(`Unsupported scheduled publishing provider: ${account.provider}`);
+    }
+
+    await db
+      .update(socialPosts)
+      .set({
+        status: "published",
+        platformPostId,
+        publishedAt: new Date(),
+        error: null,
+        updatedAt: new Date(),
+      })
+      .where(eq(socialPosts.id, post.id));
+
+    Logger.info("Scheduled post published", {
+      postId: post.id,
+      platform: account.provider,
+      platformPostId,
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+
+    await db
+      .update(socialPosts)
+      .set({
+        status: "failed",
+        error: message,
+        updatedAt: new Date(),
+      })
+      .where(eq(socialPosts.id, post.id));
+
+    Logger.error("Scheduled post publish failed", error, {
+      postId: post.id,
+    });
+  } finally {
+    await releaseSocialEvent(lockKey);
+  }
+}
+
+export async function processScheduledPostsOnce() {
+  const now = new Date();
+
+  const duePosts = await db.query.socialPosts.findMany({
+    where: and(
+      eq(socialPosts.status, "scheduled"),
+      lte(socialPosts.scheduledAt, now)
+    ),
+    limit: 25,
+  });
+
+  for (const post of duePosts) {
+    await publishScheduledPost(post);
+  }
+}
+
+export function startScheduledPostWorker(intervalMs = CHECK_INTERVAL_MS) {
+  if (isRunning) {
+    return;
+  }
+
+  isRunning = true;
+
+  processScheduledPostsOnce().catch((error) => {
+    Logger.error("Initial scheduled post run failed", error);
+  });
+
+  intervalId = setInterval(() => {
+    processScheduledPostsOnce().catch((error) => {
+      Logger.error("Scheduled post worker run failed", error);
+    });
+  }, intervalMs);
+
+  Logger.info("Scheduled post worker started", { intervalMs });
+}
+
+export function stopScheduledPostWorker() {
+  if (intervalId) {
+    clearInterval(intervalId);
+    intervalId = null;
+  }
+
+  isRunning = false;
+}

package.json

@@ -11,11 +11,11 @@
     "build:analyze": "ANALYZE=true next build",
     "start": "next start",
     "start:all": "tsx server.ts",
-    "lint": "next lint",
+    "lint": "eslint .",
     "db:generate": "drizzle-kit generate",
     "db:push": "drizzle-kit push",
     "db:studio": "drizzle-kit studio",
-    "worker": "tsx workers.ts",
+    "worker": "tsx scripts/worker.ts",
     "type-check": "tsc --noEmit",
     "postinstall": "npx puppeteer browsers install chrome",
     "log:build": "tsx scripts/view-logs.ts build",

scripts/worker.ts

@@ -1,58 +1,56 @@
-
 /**
- * Dedicated Worker Entrypoint for Horizontal Scaling
- * Run this in a separate process/container to offload queue processing from the web server.
- * Usage: npx tsx scripts/worker.ts
+ * Dedicated worker entrypoint.
+ * Run this in a separate process/container to handle queue jobs and background automation.
  */
 
-import { startWorker } from "@/lib/queue";
-import { redis } from "@/lib/redis";
+process.env.START_QUEUE_WORKERS = "true";
 
 async function main() {
-    console.log("🚀 Starting dedicated worker process...");
-
-    if (!redis) {
-        console.error("❌ Redis is required for the worker.");
-        process.exit(1);
-    }
-
-    // Load environment
-    console.log(`🔌 Connected to DB and Redis at ${process.env.REDIS_URL}`);
-
-    // Start the queue worker
-    // Assuming startWorker is the function that initializes BullMQ workers
-    // If queue.ts exports individual workers, we would initialize them here.
-    // For this codebase, we import the existing queue initialization logic.
-
-    try {
-        await startWorker();
-        console.log("✅ Worker started successfully. Listening for jobs...");
-
-        // Self-ping optimization to keep server alive (every 5 minutes)
-        const APP_URL = process.env.NEXT_PUBLIC_APP_URL || "http://localhost:7860";
-        console.log(`⏰ Setting up self-ping to ${APP_URL}/api/health every 5 minutes`);
-
-        setInterval(async () => {
-            try {
-                const healthUrl = `${APP_URL}/api/health`;
-                // Use fetch to ping the health endpoint
-                // We don't care about the response, just hitting the route
-                await fetch(healthUrl);
-                // Optional: console.log(`pinged ${healthUrl}`);
-            } catch (pingError) {
-                console.error("Self-ping failed:", pingError);
-            }
-        }, 5 * 60 * 1000); // 5 minutes
-    } catch (err: unknown) {
-        console.error("❌ Failed to start worker:", err);
-        process.exit(1);
-    }
-
-    // Keep process alive
-    process.on('SIGTERM', async () => {
-        console.log('🛑 Worker received SIGTERM, shutting down...');
-        process.exit(0);
-    });
+  const { connectRedis } = await import("@/lib/redis");
+
+  console.log("Starting dedicated worker process...");
+
+  const redis = await connectRedis();
+
+  if (!redis) {
+    console.error("Redis/Valkey is required for the worker process.");
+    process.exit(1);
+  }
+
+  try {
+    await redis.ping();
+  } catch (error) {
+    console.error("Queue backend is unreachable:", error);
+    process.exit(1);
+  }
+
+  const { startWorker } = await import("@/lib/queue");
+  const { startBackgroundWorkers, stopBackgroundWorkers } = await import("@/lib/workers");
+
+  try {
+    const workers = await startWorker();
+    await startBackgroundWorkers();
+
+    console.log("Worker process is online.");
+
+    const shutdown = async () => {
+      console.log("Stopping worker process...");
+      stopBackgroundWorkers();
+      await workers.emailWorker.close();
+      await workers.scrapingWorker.close();
+      await workers.workflowWorker.close();
+      process.exit(0);
+    };
+
+    process.on("SIGTERM", shutdown);
+    process.on("SIGINT", shutdown);
+  } catch (error) {
+    console.error("Failed to start worker:", error);
+    process.exit(1);
+  }
 }
 
-main();
+main().catch((error) => {
+  console.error("Worker bootstrap failed:", error);
+  process.exit(1);
+});

server.ts

@@ -1,171 +1,49 @@
 import "dotenv/config";
+
 import { createServer } from "http";
-import { spawn } from "child_process";
-import { parse } from "url";
-import { Socket } from "net";
 import next from "next";
+import { parse } from "url";
+
 import { validateEnvironmentVariables } from "./lib/validate-env";
 
-// Ignore "frame list" errors (often from ws/zlib in dev environments)
 process.on("uncaughtException", (err) => {
-    if (err.message && err.message.includes("frame list")) {
-        // Safe to ignore
-        return;
-    }
-    console.error("Uncaught Exception:", err);
-    process.exit(1);
+  if (err.message && err.message.includes("frame list")) {
+    return;
+  }
+
+  console.error("Uncaught Exception:", err);
+  process.exit(1);
 });
 
 const dev = process.env.NODE_ENV !== "production";
-console.log(`[Server] NODE_ENV: ${process.env.NODE_ENV}`);
-console.log(`[Server] Is Dev Mode: ${dev}`);
-
 const hostname = "0.0.0.0";
 const port = parseInt(process.env.PORT || "7860", 10);
 
-// Initialize Next.js app
-const app = next({ dev, hostname, port });
-const handle = app.getRequestHandler();
-
-// Trigger processor import - also dynamic later? No, this one is fine but safer to move inside
-// import { startTriggerProcessor } from "./lib/workflow-triggers";
-
-console.log("🚀 Starting Custom Server (Next.js + Workers)...");
+console.log(`[Server] NODE_ENV: ${process.env.NODE_ENV}`);
+console.log(`[Server] Is Dev Mode: ${dev}`);
+console.log("Starting AutoLoop web server...");
 
 validateEnvironmentVariables();
 
-app.prepare().then(async () => {
-    // 1. Try to start Local Redis (if available and not connecting to external)
-    // Default to localhost if REDIS_URL is not set
-    const useLocalRedis = !process.env.REDIS_URL || process.env.REDIS_URL.includes("localhost") || process.env.REDIS_URL.includes("127.0.0.1");
-
-    if (useLocalRedis) {
-        // Force the env var so the app connects to it securely
-        if (!process.env.REDIS_URL) {
-            process.env.REDIS_URL = "redis://localhost:6379";
-        }
-
-        console.log(`🔄 Checking for local Redis on ${process.env.REDIS_URL}...`);
-
-        // Check if Redis is already running
-        const isRedisRunning = await new Promise<boolean>((resolve) => {
-            const client = new Socket();
-            const redisUrl = new URL(process.env.REDIS_URL!);
-            const port = parseInt(redisUrl.port || "6379");
-            const host = redisUrl.hostname || "localhost";
-
-            client.connect(port, host, () => {
-                client.end();
-                resolve(true);
-            });
-
-            client.on("error", () => {
-                resolve(false);
-            });
-        });
-
-        if (isRedisRunning) {
-            console.log("✅ Local Redis service detected. Skipping auto-spawn.");
-        } else {
-            console.log(`🔄 Attempting to start local Redis server...`);
-            try {
-            // Check if redis-server is in PATH (simple spawn attempt)
-                const redisProcess = spawn("redis-server", [], {
-                    stdio: "ignore", // Run in background
-                    detached: true,
-                    shell: true // Try with shell=true for better window path handling
-                });
-
-                redisProcess.on("error", (err) => {
-                    console.warn(`⚠️  Could not auto-start 'redis-server': ${err.message}`);
-                    console.warn("⚠️  App will proceed, but background jobs may fail if Redis is not running.");
-                });
-
-                if (redisProcess.pid) {
-                    console.log(`✅ Started local Redis process (PID: ${redisProcess.pid})`);
-                    redisProcess.unref();
-
-                    process.on("exit", () => {
-                        try { process.kill(redisProcess.pid!); } catch { }
-                    });
-                }
-                // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            } catch (spawnError) {
-                console.warn("⚠️  Failed to spawn redis-server. Make sure it is installed.");
-            }
-        }
-    }
-
-    // Dynamic Import of Workers/Triggers AFTER Redis env/process is handled
-    console.log("👷 Initializing Background Workers...");
-
-    // Start Triggers
-    if (process.env.NODE_ENV === "production" || process.env.ENABLE_TRIGGERS === "true") {
-        import("./lib/workflow-triggers").then(({ startTriggerProcessor }) => {
-            startTriggerProcessor();
-        });
-    }
+const app = next({ dev, hostname, port });
+const handle = app.getRequestHandler();
 
-    // Start Workers
+app.prepare().then(() => {
+  createServer(async (req, res) => {
     try {
-        const { emailWorker, scrapingWorker } = await import("./lib/queue");
-        console.log(`✅ Email Worker ID: ${emailWorker.id}`);
-        console.log(`✅ Scraping Worker ID: ${scrapingWorker.id}`);
-
-        // Graceful Shutdown
-        const shutdown = async () => {
-            console.log("🛑 Shutting down server and workers...");
-            await emailWorker.close();
-            await scrapingWorker.close();
-            process.exit(0);
-        };
-
-        process.on("SIGTERM", shutdown);
-        process.on("SIGINT", shutdown);
-
-    } catch (e) {
-        console.error("❌ Failed to initialize workers (Redis likely missing):", e);
-    // Do not crash server, just run without workers
+      const parsedUrl = parse(req.url!, true);
+      await handle(req, res, parsedUrl);
+    } catch (err) {
+      console.error("Error occurred handling", req.url, err);
+      res.statusCode = 500;
+      res.end("internal server error");
     }
-
-    // 2. Start HTTP Server
-    createServer(async (req, res) => {
-        try {
-            const parsedUrl = parse(req.url!, true);
-            await handle(req, res, parsedUrl);
-        } catch (err) {
-            console.error("Error occurred handling", req.url, err);
-            res.statusCode = 500;
-            res.end("internal server error");
-        }
+  })
+    .once("error", (err) => {
+      console.error(err);
+      process.exit(1);
     })
-        .once("error", (err) => {
-            console.error(err);
-            process.exit(1);
-        })
-        .listen(port, () => {
-            console.log(`> Ready on http://${hostname}:${port}`);
-        });
-
-    // 3. Keep-Alive Mechanism
-    const KEEP_ALIVE_INTERVAL = 14 * 60 * 1000; // 14 minutes
-
-    if (process.env.ENABLE_KEEP_ALIVE === "true") {
-        console.log("💓 Keep-Alive mechanism enabled");
-
-        const performHealthCheck = async () => {
-            try {
-                const url = `http://${hostname}:${port}/api/health`;
-                // console.log(`💓 Sending keep-alive ping to ${url}`);
-                const response = await fetch(url);
-                await response.json();
-                // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            } catch (error) {
-                // Silent catch
-            }
-        };
-
-        setTimeout(performHealthCheck, 30000);
-        setInterval(performHealthCheck, KEEP_ALIVE_INTERVAL);
-    }
+    .listen(port, () => {
+      console.log(`> Ready on http://${hostname}:${port}`);
+    });
 });

start.sh

@@ -1,13 +1,63 @@
 #!/bin/bash
 
-# Start Redis in the background
-echo "🚀 Starting Local Redis..."
-redis-server --daemonize yes
+set -euo pipefail
+
+QUEUE_DIR="${QUEUE_DIR:-/data/valkey}"
+QUEUE_CONFIG="/tmp/valkey.conf"
+QUEUE_BIN="valkey-server"
+QUEUE_CLI="valkey-cli"
+
+if ! command -v "${QUEUE_BIN}" >/dev/null 2>&1; then
+  QUEUE_BIN="redis-server"
+  QUEUE_CLI="redis-cli"
+fi
+
+if [ ! -d "$(dirname "${QUEUE_DIR}")" ] || [ ! -w "$(dirname "${QUEUE_DIR}")" ]; then
+  QUEUE_DIR="/tmp/valkey"
+fi
+
+mkdir -p "${QUEUE_DIR}"
+
+if [ -z "${REDIS_URL:-}" ]; then
+  export REDIS_URL="redis://127.0.0.1:6379"
+fi
+
+cat > "${QUEUE_CONFIG}" <<EOF
+bind 127.0.0.1
+port 6379
+dir ${QUEUE_DIR}
+appendonly yes
+save 60 1000
+daemonize yes
+EOF
+
+echo "Starting local queue backend with ${QUEUE_BIN}..."
+"${QUEUE_BIN}" "${QUEUE_CONFIG}"
 
-# Wait a moment for Redis to initialize
 sleep 2
 
-# Start the Next.js App in production mode + Workers
-echo "🚀 Starting Production App + Workers..."
-# Use tsx with production environment
-exec npx tsx server.ts
+cleanup() {
+  if [ -n "${WORKER_PID:-}" ] && kill -0 "${WORKER_PID}" >/dev/null 2>&1; then
+    kill "${WORKER_PID}" >/dev/null 2>&1 || true
+  fi
+
+  if [ -n "${SERVER_PID:-}" ] && kill -0 "${SERVER_PID}" >/dev/null 2>&1; then
+    kill "${SERVER_PID}" >/dev/null 2>&1 || true
+  fi
+
+  if command -v "${QUEUE_CLI}" >/dev/null 2>&1; then
+    "${QUEUE_CLI}" shutdown nosave >/dev/null 2>&1 || true
+  fi
+}
+
+trap cleanup EXIT INT TERM
+
+echo "Starting dedicated automation worker..."
+pnpm worker &
+WORKER_PID=$!
+
+echo "Starting web server..."
+pnpm start:all &
+SERVER_PID=$!
+
+wait -n "${WORKER_PID}" "${SERVER_PID}"

types/social-workflow.ts

@@ -159,7 +159,9 @@ export type SocialTriggerType =
     | 'comment_keyword'
     | 'dm_keyword'
     | 'story_mention'
-    | 'any_comment';
+    | 'any_comment'
+    | 'whatsapp_keyword'
+    | 'whatsapp_command';
 
 export type SocialActionType = 
     | 'reply_comment'

workers.ts

@@ -1,29 +0,0 @@
-/**
- * Worker initialization file
- * Start the BullMQ workers for background job processing
- * 
- * Run this in a separate process: node workers.js
- */
-
-import { emailWorker, scrapingWorker } from "./lib/queue";
-
-console.log("🚀 Starting BullMQ workers...");
-console.log("📧 Email worker: Ready");
-console.log("🔍 Scraping worker: Ready");
-
-// Graceful shutdown
-process.on("SIGTERM", async () => {
-  console.log("⏸️  Stopping workers...");
-  await emailWorker.close();
-  await scrapingWorker.close();
-  process.exit(0);
-});
-
-process.on("SIGINT", async () => {
-  console.log("⏸️  Stopping workers...");
-  await emailWorker.close();
-  await scrapingWorker.close();
-  process.exit(0);
-});
-
-console.log("✅ Workers are running. Press Ctrl+C to stop.");