feat: add after() pattern + distribution log for error recovery

- Use after() from next/server to return 200 immediately and run the
  heavy distribution pipeline (YouTube upload, Gemini, email, social)
  in the background. Prevents Vercel from killing the function mid-upload.
  Same pattern as sanity-content webhook route.

- Add distributionLog array field to automatedVideo schema. Each step
  (gemini-metadata, youtube-upload, youtube-short, email, x-twitter)
  logs success/failed/skipped with timestamps, error messages, and
  result IDs. Enables dashboard retry of failed steps.

- Non-fatal steps (email, X/Twitter) now log failures instead of
  silently swallowing them. YouTube upload failures are also logged
  but don't block the pipeline from marking published if at least
  the main video uploaded.

Author: Miriad

app/api/webhooks/sanity-distribute/route.ts

@@ -1,4 +1,4 @@
-import { type NextRequest, NextResponse } from "next/server";
+import { NextResponse, after } from "next/server";
 import { isValidSignature, SIGNATURE_HEADER_NAME } from "@sanity/webhook";
 import { writeClient } from "@/lib/sanity-write-client";
 import { generateWithGemini } from "@/lib/gemini";
@@ -41,10 +41,35 @@ interface AutomatedVideoDoc {
   youtubeShortId?: string;
   flaggedReason?: string;
   scheduledPublishAt?: string;
+  distributionLog?: DistributionLogEntry[];
+}
+
+interface DistributionLogEntry {
+  _key: string;
+  step: string;
+  status: "success" | "failed" | "skipped";
+  error?: string;
+  timestamp: string;
+  result?: string;
 }
 
 interface YouTubeMetadata { title: string; description: string; tags: string[]; }
 
+// ---------------------------------------------------------------------------
+// Distribution log helpers
+// ---------------------------------------------------------------------------
+
+function logEntry(step: string, status: "success" | "failed" | "skipped", opts?: { error?: string; result?: string }): DistributionLogEntry {
+  return {
+    _key: `${step}-${Date.now()}`,
+    step,
+    status,
+    error: opts?.error,
+    timestamp: new Date().toISOString(),
+    result: opts?.result,
+  };
+}
+
 // ---------------------------------------------------------------------------
 // Gemini metadata generation for long-form videos
 // ---------------------------------------------------------------------------
@@ -71,8 +96,7 @@ Return JSON:
 Include in the description:
 - Brief summary of what viewers will learn
 - Key topics covered
-- Links section placeholder (🔗 Links mentioned in this video:)
-- Social links placeholder
+- Links section placeholder
 - Relevant hashtags at the end`;
 
   const raw = await generateWithGemini(prompt);
@@ -97,79 +121,80 @@ async function updateStatus(docId: string, status: string, extra: Record<string,
   console.log(`[sanity-distribute] ${docId} -> ${status}`);
 }
 
-// ---------------------------------------------------------------------------
-// POST handler
-// ---------------------------------------------------------------------------
-
-export async function POST(req: NextRequest): Promise<NextResponse> {
-  const rawBody = await req.text();
-  const signature = req.headers.get(SIGNATURE_HEADER_NAME);
-
-  if (!WEBHOOK_SECRET) {
-    console.error("[sanity-distribute] Missing SANITY_WEBHOOK_SECRET");
-    return NextResponse.json({ error: "Server misconfigured" }, { status: 500 });
-  }
-
-  if (!signature || !(await isValidSignature(rawBody, signature, WEBHOOK_SECRET))) {
-    console.log("[sanity-distribute] Invalid signature");
-    return NextResponse.json({ error: "Invalid signature" }, { status: 401 });
-  }
-
-  let webhookPayload: WebhookPayload;
-  try { webhookPayload = JSON.parse(rawBody); } catch { return NextResponse.json({ error: "Invalid JSON" }, { status: 400 }); }
-
-  if (webhookPayload._type !== "automatedVideo") return NextResponse.json({ skipped: true, reason: "Not automatedVideo" });
-  if (webhookPayload.status !== "video_gen") return NextResponse.json({ skipped: true, reason: `Status "${webhookPayload.status}" != "video_gen"` });
-
-  const docId = webhookPayload._id;
-
-  // Fetch the full document from Sanity
-  const doc = await writeClient.fetch<AutomatedVideoDoc | null>(
-    `*[_id == $id][0]`,
-    { id: docId }
-  );
-
-  if (!doc) {
-    console.error(`[sanity-distribute] Document ${docId} not found`);
-    return NextResponse.json({ error: "Document not found" }, { status: 404 });
+async function appendDistributionLog(docId: string, entries: DistributionLogEntry[]): Promise<void> {
+  const ops = entries.map((entry) => ({
+    insert: { after: "distributionLog[-1]", items: [entry] },
+  }));
+  // Use setIfMissing to create the array if it doesn't exist, then append
+  let patch = writeClient.patch(docId).setIfMissing({ distributionLog: [] });
+  for (const entry of entries) {
+    patch = patch.append("distributionLog", [entry]);
   }
+  await patch.commit();
+}
 
-  if (doc.status !== "video_gen") {
-    return NextResponse.json({ skipped: true, reason: `Document status is "${doc.status}", not "video_gen"` });
-  }
-  if (doc.flaggedReason) {
-    return NextResponse.json({ skipped: true, reason: "Flagged" });
-  }
+// ---------------------------------------------------------------------------
+// Core distribution pipeline (runs inside after())
+// ---------------------------------------------------------------------------
 
-  console.log(`[sanity-distribute] Processing ${docId}: "${doc.title}"`);
+async function runDistribution(docId: string, doc: AutomatedVideoDoc): Promise<void> {
+  const log: DistributionLogEntry[] = [];
 
   try {
     await updateStatus(docId, "uploading");
 
     // Step 1: Generate long-form YouTube metadata via Gemini
     console.log("[sanity-distribute] Step 1/6 - Generating long-form metadata");
-    const metadata = await generateYouTubeMetadata(doc);
+    let metadata: YouTubeMetadata;
+    try {
+      metadata = await generateYouTubeMetadata(doc);
+      log.push(logEntry("gemini-metadata", "success"));
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      console.error("[sanity-distribute] Gemini metadata failed:", msg);
+      log.push(logEntry("gemini-metadata", "failed", { error: msg }));
+      // Fallback metadata so we can still upload
+      metadata = { title: doc.title, description: doc.title, tags: [] };
+    }
 
     // Step 2: Upload main video to YouTube
     let youtubeVideoId = "";
     if (doc.videoUrl) {
       console.log("[sanity-distribute] Step 2/6 - Uploading main video");
-      const r = await uploadVideo({ videoUrl: doc.videoUrl, title: metadata.title, description: metadata.description, tags: metadata.tags });
-      youtubeVideoId = r.videoId;
+      try {
+        const r = await uploadVideo({ videoUrl: doc.videoUrl, title: metadata.title, description: metadata.description, tags: metadata.tags });
+        youtubeVideoId = r.videoId;
+        log.push(logEntry("youtube-upload", "success", { result: youtubeVideoId }));
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        console.error("[sanity-distribute] YouTube upload failed:", msg);
+        log.push(logEntry("youtube-upload", "failed", { error: msg }));
+      }
+    } else {
+      log.push(logEntry("youtube-upload", "skipped", { error: "No videoUrl" }));
     }
 
     // Step 3: Generate Shorts-optimized metadata + upload Short
     let youtubeShortId = "";
     if (doc.shortUrl) {
       console.log("[sanity-distribute] Step 3/6 - Generating Shorts metadata + uploading");
-      const shortsMetadata = await generateShortsMetadata(generateWithGemini, doc);
-      const r = await uploadShort({
-        videoUrl: doc.shortUrl,
-        title: shortsMetadata.title,
-        description: shortsMetadata.description,
-        tags: shortsMetadata.tags,
-      });
-      youtubeShortId = r.videoId;
+      try {
+        const shortsMetadata = await generateShortsMetadata(generateWithGemini, doc);
+        const r = await uploadShort({
+          videoUrl: doc.shortUrl,
+          title: shortsMetadata.title,
+          description: shortsMetadata.description,
+          tags: shortsMetadata.tags,
+        });
+        youtubeShortId = r.videoId;
+        log.push(logEntry("youtube-short", "success", { result: youtubeShortId }));
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        console.error("[sanity-distribute] Short upload failed:", msg);
+        log.push(logEntry("youtube-short", "failed", { error: msg }));
+      }
+    } else {
+      log.push(logEntry("youtube-short", "skipped", { error: "No shortUrl" }));
     }
 
     // Step 4: Email notification (non-fatal)
@@ -182,7 +207,12 @@ export async function POST(req: NextRequest): Promise<NextResponse> {
         videoUrl: ytUrl,
         description: metadata.description.slice(0, 280),
       });
-    } catch (e) { console.warn("[sanity-distribute] Email error:", e); }
+      log.push(logEntry("email", "success"));
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      console.warn("[sanity-distribute] Email error:", msg);
+      log.push(logEntry("email", "failed", { error: msg }));
+    }
 
     // Step 5: Post to X/Twitter (non-fatal)
     console.log("[sanity-distribute] Step 5/6 - Posting to X/Twitter");
@@ -192,24 +222,175 @@ export async function POST(req: NextRequest): Promise<NextResponse> {
         youtubeUrl: ytUrl,
         tags: metadata.tags,
       });
-      if (!tweetResult.success) {
-        console.warn(`[sanity-distribute] Tweet failed: ${tweetResult.error}`);
+      if (tweetResult.success) {
+        log.push(logEntry("x-twitter", "success", { result: tweetResult.tweetId }));
+      } else {
+        log.push(logEntry("x-twitter", "failed", { error: tweetResult.error }));
       }
-    } catch (e) { console.warn("[sanity-distribute] X/Twitter error:", e); }
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      console.warn("[sanity-distribute] X/Twitter error:", msg);
+      log.push(logEntry("x-twitter", "failed", { error: msg }));
+    }
 
-    // Step 6: Mark published in Sanity
+    // Step 6: Mark published in Sanity + save distribution log
     console.log("[sanity-distribute] Step 6/6 - Marking published");
-    await updateStatus(docId, "published", {
-      youtubeId: youtubeVideoId || undefined,
-      youtubeShortId: youtubeShortId || undefined,
-    });
+    await writeClient
+      .patch(docId)
+      .set({
+        status: "published",
+        youtubeId: youtubeVideoId || undefined,
+        youtubeShortId: youtubeShortId || undefined,
+      })
+      .setIfMissing({ distributionLog: [] })
+      .append("distributionLog", log)
+      .commit();
 
     console.log(`[sanity-distribute] ✅ Distribution complete for ${docId}`);
-    return NextResponse.json({ success: true, docId, youtubeId: youtubeVideoId, youtubeShortId });
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     console.error(`[sanity-distribute] ❌ Failed ${docId}: ${msg}`);
-    try { await updateStatus(docId, "flagged", { flaggedReason: `Distribution error: ${msg}` }); } catch {}
-    return NextResponse.json({ error: "Distribution failed", details: msg }, { status: 500 });
+    log.push(logEntry("pipeline", "failed", { error: msg }));
+
+    try {
+      await writeClient
+        .patch(docId)
+        .set({
+          status: "flagged",
+          flaggedReason: `Distribution error: ${msg}`,
+        })
+        .setIfMissing({ distributionLog: [] })
+        .append("distributionLog", log)
+        .commit();
+    } catch {
+      // Last resort — at least try to save the log
+      console.error("[sanity-distribute] Failed to save error state");
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// POST handler
+// ---------------------------------------------------------------------------
+
+/**
+ * Sanity webhook handler for the distribution pipeline.
+ *
+ * Listens for automatedVideo documents transitioning to "video_gen" status
+ * and triggers YouTube upload, email notification, and social posting.
+ *
+ * Uses after() to return 200 immediately and run the heavy pipeline work
+ * in the background — prevents Vercel from killing the function mid-upload.
+ *
+ * Configure in Sanity: Webhook → POST → filter: `_type == "automatedVideo"`
+ * with projection: `{ _id, _type, status }`
+ */
+export async function POST(request: Request) {
+  try {
+    if (!WEBHOOK_SECRET) {
+      console.log("[sanity-distribute] Missing SANITY_WEBHOOK_SECRET environment variable");
+      return NextResponse.json(
+        { error: "Server misconfigured: missing webhook secret" },
+        { status: 500 }
+      );
+    }
+
+    // Read the raw body as text for signature verification
+    const rawBody = await request.text();
+    const signature = request.headers.get(SIGNATURE_HEADER_NAME);
+
+    if (!signature) {
+      console.log("[sanity-distribute] Missing signature header");
+      return NextResponse.json(
+        { error: "Missing signature" },
+        { status: 401 }
+      );
+    }
+
+    // Verify the webhook signature (same as sanity-content route)
+    const isValid = await isValidSignature(rawBody, signature, WEBHOOK_SECRET);
+
+    if (!isValid) {
+      console.log("[sanity-distribute] Invalid signature received");
+      return NextResponse.json(
+        { error: "Invalid signature" },
+        { status: 401 }
+      );
+    }
+
+    // Parse the verified body
+    let webhookPayload: WebhookPayload;
+    try {
+      webhookPayload = JSON.parse(rawBody);
+    } catch {
+      console.log("[sanity-distribute] Failed to parse webhook body");
+      return NextResponse.json(
+        { skipped: true, reason: "Invalid JSON body" },
+        { status: 200 }
+      );
+    }
+
+    console.log(`[sanity-distribute] Received: type=${webhookPayload._type}, id=${webhookPayload._id}, status=${webhookPayload.status}`);
+
+    if (webhookPayload._type !== "automatedVideo") {
+      return NextResponse.json(
+        { skipped: true, reason: `Not automatedVideo` },
+        { status: 200 }
+      );
+    }
+
+    if (webhookPayload.status !== "video_gen") {
+      return NextResponse.json(
+        { skipped: true, reason: `Status "${webhookPayload.status}" is not "video_gen"` },
+        { status: 200 }
+      );
+    }
+
+    const docId = webhookPayload._id;
+
+    // Fetch the full document from Sanity (webhook only sends minimal projection)
+    const doc = await writeClient.fetch<AutomatedVideoDoc | null>(
+      `*[_id == $id][0]`,
+      { id: docId }
+    );
+
+    if (!doc) {
+      console.error(`[sanity-distribute] Document ${docId} not found`);
+      return NextResponse.json({ error: "Document not found" }, { status: 404 });
+    }
+
+    // Re-check status from the actual document (race condition guard)
+    if (doc.status !== "video_gen") {
+      return NextResponse.json(
+        { skipped: true, reason: `Document status is "${doc.status}", not "video_gen"` },
+        { status: 200 }
+      );
+    }
+    if (doc.flaggedReason) {
+      return NextResponse.json(
+        { skipped: true, reason: "Flagged" },
+        { status: 200 }
+      );
+    }
+
+    // Use after() to run the distribution pipeline after the response is sent.
+    // On Vercel, serverless functions terminate after the response — fire-and-forget
+    // (promise.catch() without await) silently dies. after() keeps the function alive.
+    console.log(`[sanity-distribute] Triggering distribution for: ${docId}`);
+    after(async () => {
+      try {
+        await runDistribution(docId, doc);
+      } catch (error) {
+        console.error(`[sanity-distribute] Background processing error for ${docId}:`, error);
+      }
+    });
+
+    return NextResponse.json({ triggered: true, docId }, { status: 200 });
+  } catch (error) {
+    console.log("[sanity-distribute] Unexpected error processing webhook:", error);
+    return NextResponse.json(
+      { error: "Internal server error" },
+      { status: 500 }
+    );
   }
 }