mcp-scraper 0.2.8 → 0.2.9

package/dist/{server-BTTDFPSQ.js → server-BKJ7LULQ.js}

@@ -15,45 +15,14 @@ import {
   harvestProblemResponse,
   insufficientBalanceResponse,
   serializeHarvestProblem
-} from "./chunk-IQOCZGJJ.js";
-import {
-  BrowserDriver,
-  MapsPlaceOptionsSchema,
-  MapsSearchOptionsSchema,
-  MapsSelectors,
-  RawMapsAboutAttributeSchema,
-  RawMapsHoursRowSchema,
-  RawMapsOverviewSchema,
-  RawMapsReviewStatsSchema,
-  browserServiceApiKey,
-  browserServiceProxyId,
-  buildYouTubeChannelVideosUrl,
-  deleteKernelProxyId,
-  harvest,
-  resolveKernelProxyId
-} from "./chunk-CQTAKXBN.js";
-import {
-  CaptureSerpPageSnapshotsInputSchema,
-  CaptureSerpSnapshotInputSchema,
-  HttpMcpToolExecutor,
-  buildPaaExtractorMcpServer,
-  configureReportSaving,
-  harvestTimeoutBudget,
-  liveWebToolAnnotations,
-  outputBaseDir
-} from "./chunk-6NEXSNSA.js";
-import {
-  CaptchaError,
-  RECAPTCHA_INSTRUCTIONS,
-  sanitizeVendorName
-} from "./chunk-M2S27J6Z.js";
-import "./chunk-I26QN7WQ.js";
+} from "./chunk-ROS67BNV.js";
 import {
   SiteAuditJobRowSchema,
   cancelJob,
   checkRateLimit,
   claimMonthlyFreeRefresh,
   completeJob,
+  completeWorkflowRunRecord,
   consumePasswordResetToken,
   countActiveJobsForUser,
   countActiveUsers,
@@ -61,10 +30,14 @@ import {
   createPasswordResetToken,
   createRunningJob,
   createUser,
+  createWorkflowRun,
+  createWorkflowSchedule,
   creditMc,
   deactivateUser,
   debitMc,
+  deleteWorkflowSchedule,
   failJob,
+  failWorkflowRunRecord,
   getDb,
   getJob,
   getLedger,
@@ -73,15 +46,27 @@ import {
   getUserById,
   getUserByStripeCustomerId,
   getUserStats,
+  getWorkflowArtifact,
+  getWorkflowRun,
+  getWorkflowSchedule,
   ledgerExistsForOperation,
   ledgerExistsForStripePI,
+  listDueWorkflowSchedules,
   listHarvestAttempts,
   listJobs,
   listRequestEvents,
   listUsers,
+  listWorkflowArtifacts,
+  listWorkflowRuns,
+  listWorkflowSchedules,
   logRequestEvent,
+  markWorkflowRunRunning,
+  markWorkflowScheduleRan,
+  patchWorkflowSchedule,
   reconcileBalanceMc,
   recordStripeEvent,
+  recordWorkflowWebhookDelivery,
+  replaceWorkflowArtifacts,
   revokeApiKey,
   rotateApiKey,
   setConcurrencySubId,
@@ -89,7 +74,47 @@ import {
   setPassword,
   setStripeCustomerId,
   verifyPassword
-} from "./chunk-D4CJBZBY.js";
+} from "./chunk-7GCCOT3M.js";
+import {
+  BrowserDriver,
+  MapsPlaceOptionsSchema,
+  MapsSearchOptionsSchema,
+  MapsSelectors,
+  RawMapsAboutAttributeSchema,
+  RawMapsHoursRowSchema,
+  RawMapsOverviewSchema,
+  RawMapsReviewStatsSchema,
+  browserServiceApiKey,
+  browserServiceProxyId,
+  buildYouTubeChannelVideosUrl,
+  deleteKernelProxyId,
+  harvest,
+  resolveKernelProxyId
+} from "./chunk-CQTAKXBN.js";
+import {
+  CaptureSerpPageSnapshotsInputSchema,
+  CaptureSerpSnapshotInputSchema,
+  HttpMcpToolExecutor,
+  buildPaaExtractorMcpServer,
+  configureReportSaving,
+  harvestTimeoutBudget,
+  liveWebToolAnnotations,
+  outputBaseDir
+} from "./chunk-XAY5U67D.js";
+import {
+  CaptchaError,
+  RECAPTCHA_INSTRUCTIONS,
+  sanitizeVendorName
+} from "./chunk-M2S27J6Z.js";
+import {
+  csvRecords,
+  listWorkflowDefinitions,
+  rowsToCsv,
+  runWorkflow,
+  workflowDefinition,
+  workflowOutputBaseDir
+} from "./chunk-L6IS63WS.js";
+import "./chunk-BJDCPCIE.js";
 
 // src/api/outbound-sanitize.ts
 var KEY_RENAMES = {
@@ -4848,7 +4873,7 @@ async function extractSite(opts) {
 }
 
 // src/api/server.ts
-import { Hono as Hono11 } from "hono";
+import { Hono as Hono12 } from "hono";
 import { serve as serveInngest } from "inngest/hono";
 
 // src/inngest/client.ts
@@ -10221,69 +10246,6 @@ import { mkdir as mkdir2, writeFile } from "fs/promises";
 import { join as join4 } from "path";
 import { z as z15 } from "zod";
 
-// src/directory/csv.ts
-function parseCsv(text) {
-  const rows = [];
-  let row = [];
-  let field = "";
-  let quoted = false;
-  for (let i = 0; i < text.length; i += 1) {
-    const ch = text[i];
-    const next = text[i + 1];
-    if (quoted) {
-      if (ch === '"' && next === '"') {
-        field += '"';
-        i += 1;
-      } else if (ch === '"') {
-        quoted = false;
-      } else {
-        field += ch;
-      }
-      continue;
-    }
-    if (ch === '"') {
-      quoted = true;
-    } else if (ch === ",") {
-      row.push(field);
-      field = "";
-    } else if (ch === "\n") {
-      row.push(field);
-      rows.push(row);
-      row = [];
-      field = "";
-    } else if (ch !== "\r") {
-      field += ch;
-    }
-  }
-  if (field.length > 0 || row.length > 0) {
-    row.push(field);
-    rows.push(row);
-  }
-  return rows;
-}
-function csvRecords(text) {
-  const rows = parseCsv(text).filter((row) => row.some((cell) => cell.trim() !== ""));
-  const header = rows[0]?.map((cell) => cell.trim()) ?? [];
-  return rows.slice(1).map((row) => {
-    const record = {};
-    for (let i = 0; i < header.length; i += 1) {
-      record[header[i]] = row[i] ?? "";
-    }
-    return record;
-  });
-}
-function csvCell(value) {
-  if (value === null || value === void 0) return "";
-  const text = String(value);
-  return /[",\n\r]/.test(text) ? `"${text.replace(/"/g, '""')}"` : text;
-}
-function rowsToCsv(headers, rows) {
-  return [
-    headers.join(","),
-    ...rows.map((row) => headers.map((header) => csvCell(row[header])).join(","))
-  ].join("\n") + "\n";
-}
-
 // src/directory/location-db.ts
 import { access, readFile } from "fs/promises";
 var POPULATION_YEARS = [2020, 2021, 2022, 2023, 2024, 2025];
@@ -10562,6 +10524,7 @@ function csvRowsFor(result) {
         result_position: null,
         business_name: null,
         review_stars: null,
+        review_count: null,
         category: null,
         address: null,
         phone: null,
@@ -10595,6 +10558,7 @@ function csvRowsFor(result) {
         result_position: business.position,
         business_name: business.name,
         review_stars: business.rating,
+        review_count: business.reviewCount,
         category: business.category,
         address: business.address,
         phone: business.phone,
@@ -10635,6 +10599,7 @@ async function saveDirectoryCsv(result) {
     "result_position",
     "business_name",
     "review_stars",
+    "review_count",
     "category",
     "address",
     "phone",
@@ -10737,8 +10702,360 @@ directoryApp.post("/run", createApiKeyAuth(), async (c) => {
   }
 });
 
-// src/api/serp-intelligence-routes.ts
+// src/api/workflow-routes.ts
+import { createHmac } from "crypto";
+import { readFile as readFile2 } from "fs/promises";
 import { Hono as Hono7 } from "hono";
+import { z as z16 } from "zod";
+var workflowApp = new Hono7();
+var WorkflowInputSchema = z16.record(z16.unknown()).default({});
+var WorkflowIdSchema = z16.string().min(1);
+var CadenceSchema = z16.enum(["daily", "weekly", "monthly"]);
+var ScheduleStatusSchema = z16.enum(["active", "paused"]);
+var RunBodySchema = z16.object({
+  workflowId: WorkflowIdSchema,
+  input: WorkflowInputSchema,
+  webhookUrl: z16.string().url().optional()
+});
+var ScheduleCreateSchema = z16.object({
+  workflowId: WorkflowIdSchema,
+  name: z16.string().min(1).max(120).optional(),
+  input: WorkflowInputSchema,
+  cadence: CadenceSchema.default("weekly"),
+  timezone: z16.string().min(1).max(64).default("UTC"),
+  webhookUrl: z16.string().url().optional(),
+  nextRunAt: z16.string().datetime().optional()
+});
+var SchedulePatchSchema = z16.object({
+  name: z16.string().min(1).max(120).optional(),
+  status: ScheduleStatusSchema.optional(),
+  input: WorkflowInputSchema.optional(),
+  cadence: CadenceSchema.optional(),
+  timezone: z16.string().min(1).max(64).optional(),
+  webhookUrl: z16.string().url().nullable().optional(),
+  nextRunAt: z16.string().datetime().nullable().optional()
+});
+function hostedWorkflowOutputDir() {
+  return workflowOutputBaseDir(process.env.MCP_SCRAPER_WORKFLOW_OUTPUT_DIR?.trim() || "/tmp/mcp-scraper-workflows");
+}
+function originFromUrl(url) {
+  const parsed = new URL(url);
+  return `${parsed.protocol}//${parsed.host}`;
+}
+function addCadence(fromIso, cadence) {
+  const next = new Date(fromIso);
+  if (!Number.isFinite(next.getTime())) return new Date(Date.now() + 24 * 60 * 60 * 1e3).toISOString();
+  if (cadence === "daily") next.setUTCDate(next.getUTCDate() + 1);
+  else if (cadence === "weekly") next.setUTCDate(next.getUTCDate() + 7);
+  else next.setUTCMonth(next.getUTCMonth() + 1);
+  return next.toISOString();
+}
+function defaultNextRunAt(cadence) {
+  return addCadence((/* @__PURE__ */ new Date()).toISOString(), cadence);
+}
+function validateWorkflowInput(workflowId, input) {
+  const definition = workflowDefinition(workflowId);
+  return definition.inputSchema.parse(input);
+}
+async function validateWebhookUrl(url) {
+  if (!url) return null;
+  const result = await validatePublicHttpUrl(url, { field: "webhookUrl", requireHttps: true });
+  if (result.error) throw new Error(result.error);
+  return url;
+}
+function runDownloadUrl(c, runId, artifactId) {
+  return `${originFromUrl(c.req.url)}/workflows/runs/${runId}/artifacts/${artifactId}`;
+}
+function exposeRun(c, run, artifacts = []) {
+  return {
+    ...run,
+    artifacts: artifacts.map((artifact) => ({
+      ...artifact,
+      downloadUrl: runDownloadUrl(c, run.id, artifact.id)
+    }))
+  };
+}
+async function persistRunArtifacts(runId, userId, manifest) {
+  if (!manifest) return [];
+  return replaceWorkflowArtifacts(runId, userId, manifest.artifacts);
+}
+async function readManifestFromSummary(summary) {
+  if (!summary.reportPath) return null;
+  const manifestPath = summary.reportPath.replace(/report\.html$/, "manifest.json");
+  try {
+    return JSON.parse(await readFile2(manifestPath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function webhookSignature(body, timestamp) {
+  const secret2 = process.env.MCP_SCRAPER_WEBHOOK_SECRET?.trim();
+  if (!secret2) return null;
+  return createHmac("sha256", secret2).update(`${timestamp}.${body}`).digest("hex");
+}
+async function deliverWorkflowWebhook(input) {
+  if (!input.webhookUrl) return;
+  const payload = {
+    event: input.run.status === "failed" ? "workflow.run.failed" : input.run.status === "partial" ? "workflow.run.partial" : "workflow.run.succeeded",
+    runId: input.run.id,
+    scheduleId: input.scheduleId,
+    workflowId: input.run.workflow_id,
+    status: input.run.status,
+    completedAt: input.run.completed_at ?? (/* @__PURE__ */ new Date()).toISOString(),
+    summary: {
+      title: input.summary?.title ?? input.run.workflow_id,
+      counts: input.summary?.counts ?? {},
+      warnings: input.summary?.warnings ?? [],
+      errors: input.summary?.errors ?? (input.run.error_message ? [input.run.error_message] : [])
+    },
+    artifacts: input.artifacts.map((artifact) => ({
+      kind: artifact.kind,
+      label: artifact.label,
+      path: artifact.path
+    }))
+  };
+  const body = JSON.stringify(payload);
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const headers = {
+    "Content-Type": "application/json",
+    "x-mcp-scraper-timestamp": timestamp
+  };
+  const signature = webhookSignature(body, timestamp);
+  if (signature) headers["x-mcp-scraper-signature"] = signature;
+  let lastError = null;
+  for (let attempt = 1; attempt <= 3; attempt++) {
+    try {
+      const res = await fetch(input.webhookUrl, { method: "POST", headers, body, signal: AbortSignal.timeout(15e3) });
+      if (res.ok) {
+        await recordWorkflowWebhookDelivery({ runId: input.run.id, scheduleId: input.scheduleId, userId: input.userId, webhookUrl: input.webhookUrl, status: "delivered", attempts: attempt });
+        return;
+      }
+      lastError = `HTTP ${res.status}`;
+    } catch (err) {
+      lastError = err instanceof Error ? err.message : String(err);
+    }
+    await new Promise((resolve) => setTimeout(resolve, attempt * 500));
+  }
+  await recordWorkflowWebhookDelivery({ runId: input.run.id, scheduleId: input.scheduleId, userId: input.userId, webhookUrl: input.webhookUrl, status: "failed", attempts: 3, lastError });
+}
+async function executeWorkflowRun(input) {
+  await markWorkflowRunRunning(input.runId);
+  try {
+    const summary = await runWorkflow(input.workflowId, input.workflowInput, {
+      apiKey: input.user.api_key,
+      apiUrl: input.apiUrl,
+      outputDir: hostedWorkflowOutputDir(),
+      runId: input.runId
+    });
+    const manifest = await readManifestFromSummary(summary);
+    await completeWorkflowRunRecord(input.runId, summary.status, manifest ?? { summary });
+    const run = await getWorkflowRun(input.runId, input.user.id);
+    if (!run) throw new Error("Workflow run disappeared after execution");
+    const artifacts = await persistRunArtifacts(input.runId, input.user.id, manifest);
+    await deliverWorkflowWebhook({ userId: input.user.id, run, scheduleId: input.scheduleId ?? null, webhookUrl: input.webhookUrl ?? null, summary, artifacts });
+    return { run, summary, artifacts };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    await failWorkflowRunRecord(input.runId, message, { error: message });
+    const run = await getWorkflowRun(input.runId, input.user.id);
+    if (!run) throw err;
+    await deliverWorkflowWebhook({ userId: input.user.id, run, scheduleId: input.scheduleId ?? null, webhookUrl: input.webhookUrl ?? null, summary: null, artifacts: [] });
+    throw err;
+  }
+}
+workflowApp.get("/definitions", createApiKeyAuth(), (c) => {
+  return c.json({ workflows: listWorkflowDefinitions() });
+});
+workflowApp.post("/run", createApiKeyAuth(), async (c) => {
+  const user = c.get("user");
+  const parsed = RunBodySchema.safeParse(await c.req.json().catch(() => ({})));
+  if (!parsed.success) return c.json({ error: parsed.error.issues[0]?.message ?? "Invalid request" }, 400);
+  let input;
+  let webhookUrl;
+  try {
+    input = validateWorkflowInput(parsed.data.workflowId, parsed.data.input);
+    webhookUrl = await validateWebhookUrl(parsed.data.webhookUrl);
+  } catch (err) {
+    return c.json({ error: err instanceof Error ? err.message : String(err) }, 400);
+  }
+  const run = await createWorkflowRun({ userId: user.id, workflowId: parsed.data.workflowId, workflowInput: input });
+  try {
+    const executed = await executeWorkflowRun({
+      runId: run.id,
+      user,
+      workflowId: parsed.data.workflowId,
+      workflowInput: input,
+      apiUrl: originFromUrl(c.req.url),
+      webhookUrl
+    });
+    return c.json({ run: exposeRun(c, executed.run, executed.artifacts), summary: executed.summary });
+  } catch (err) {
+    const failed = await getWorkflowRun(run.id, user.id);
+    return c.json({ run: failed, error: err instanceof Error ? err.message : String(err) }, 500);
+  }
+});
+workflowApp.get("/runs", createApiKeyAuth(), async (c) => {
+  const user = c.get("user");
+  const runs = await listWorkflowRuns(user.id);
+  return c.json({ runs });
+});
+workflowApp.get("/runs/:id", createApiKeyAuth(), async (c) => {
+  const user = c.get("user");
+  const run = await getWorkflowRun(c.req.param("id"), user.id);
+  if (!run) return c.json({ error: "Run not found" }, 404);
+  const artifacts = await listWorkflowArtifacts(run.id, user.id);
+  return c.json({ run: exposeRun(c, run, artifacts) });
+});
+workflowApp.get("/runs/:id/artifacts/:artifactId", createApiKeyAuth(), async (c) => {
+  const user = c.get("user");
+  const run = await getWorkflowRun(c.req.param("id"), user.id);
+  if (!run) return c.json({ error: "Run not found" }, 404);
+  const artifact = await getWorkflowArtifact(c.req.param("artifactId"), user.id);
+  if (!artifact || artifact.run_id !== run.id) return c.json({ error: "Artifact not found" }, 404);
+  try {
+    const content = await readFile2(artifact.path);
+    return new Response(content, {
+      headers: {
+        "Content-Type": artifact.content_type,
+        "Content-Disposition": `attachment; filename="${artifact.path.split("/").pop() || artifact.id}"`
+      }
+    });
+  } catch {
+    return c.json({ error: "Artifact file is no longer available" }, 410);
+  }
+});
+workflowApp.post("/schedules", createApiKeyAuth(), async (c) => {
+  const user = c.get("user");
+  const parsed = ScheduleCreateSchema.safeParse(await c.req.json().catch(() => ({})));
+  if (!parsed.success) return c.json({ error: parsed.error.issues[0]?.message ?? "Invalid request" }, 400);
+  let input;
+  let webhookUrl;
+  try {
+    input = validateWorkflowInput(parsed.data.workflowId, parsed.data.input);
+    webhookUrl = await validateWebhookUrl(parsed.data.webhookUrl);
+  } catch (err) {
+    return c.json({ error: err instanceof Error ? err.message : String(err) }, 400);
+  }
+  const schedule = await createWorkflowSchedule({
+    userId: user.id,
+    workflowId: parsed.data.workflowId,
+    name: parsed.data.name ?? workflowDefinition(parsed.data.workflowId).title,
+    workflowInput: input,
+    cadence: parsed.data.cadence,
+    timezone: parsed.data.timezone,
+    webhookUrl,
+    nextRunAt: parsed.data.nextRunAt ?? defaultNextRunAt(parsed.data.cadence)
+  });
+  return c.json({ schedule }, 201);
+});
+workflowApp.get("/schedules", createApiKeyAuth(), async (c) => {
+  const user = c.get("user");
+  return c.json({ schedules: await listWorkflowSchedules(user.id) });
+});
+workflowApp.patch("/schedules/:id", createApiKeyAuth(), async (c) => {
+  const user = c.get("user");
+  const existing = await getWorkflowSchedule(c.req.param("id"), user.id);
+  if (!existing) return c.json({ error: "Schedule not found" }, 404);
+  const parsed = SchedulePatchSchema.safeParse(await c.req.json().catch(() => ({})));
+  if (!parsed.success) return c.json({ error: parsed.error.issues[0]?.message ?? "Invalid request" }, 400);
+  let nextInput;
+  let webhookUrl;
+  try {
+    nextInput = parsed.data.input ? validateWorkflowInput(existing.workflow_id, parsed.data.input) : void 0;
+    webhookUrl = parsed.data.webhookUrl === void 0 ? void 0 : await validateWebhookUrl(parsed.data.webhookUrl);
+  } catch (err) {
+    return c.json({ error: err instanceof Error ? err.message : String(err) }, 400);
+  }
+  const schedule = await patchWorkflowSchedule({
+    id: existing.id,
+    userId: user.id,
+    name: parsed.data.name,
+    status: parsed.data.status,
+    workflowInput: nextInput,
+    cadence: parsed.data.cadence,
+    timezone: parsed.data.timezone,
+    webhookUrl,
+    nextRunAt: parsed.data.nextRunAt
+  });
+  return c.json({ schedule });
+});
+workflowApp.delete("/schedules/:id", createApiKeyAuth(), async (c) => {
+  const user = c.get("user");
+  const deleted = await deleteWorkflowSchedule(c.req.param("id"), user.id);
+  if (!deleted) return c.json({ error: "Schedule not found" }, 404);
+  return c.json({ ok: true });
+});
+workflowApp.post("/schedules/:id/run", createApiKeyAuth(), async (c) => {
+  const user = c.get("user");
+  const schedule = await getWorkflowSchedule(c.req.param("id"), user.id);
+  if (!schedule) return c.json({ error: "Schedule not found" }, 404);
+  const run = await createWorkflowRun({ userId: user.id, scheduleId: schedule.id, workflowId: schedule.workflow_id, workflowInput: schedule.input });
+  try {
+    const executed = await executeWorkflowRun({
+      runId: run.id,
+      user,
+      workflowId: schedule.workflow_id,
+      workflowInput: schedule.input,
+      apiUrl: originFromUrl(c.req.url),
+      scheduleId: schedule.id,
+      webhookUrl: schedule.webhook_url
+    });
+    return c.json({ run: exposeRun(c, executed.run, executed.artifacts), summary: executed.summary });
+  } catch (err) {
+    const failed = await getWorkflowRun(run.id, user.id);
+    return c.json({ run: failed, error: err instanceof Error ? err.message : String(err) }, 500);
+  }
+});
+async function dispatchDueWorkflowSchedules(apiUrl, limit = 3) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const due = await listDueWorkflowSchedules(now, limit);
+  const results = [];
+  for (const schedule of due) {
+    const user = await getUserById(schedule.user_id);
+    if (!user) {
+      results.push({ scheduleId: schedule.id, status: "failed", error: "User not found" });
+      continue;
+    }
+    const scheduledFor = schedule.next_run_at ?? now;
+    const run = await createWorkflowRun({
+      userId: user.id,
+      scheduleId: schedule.id,
+      workflowId: schedule.workflow_id,
+      workflowInput: schedule.input,
+      idempotencyKey: `${schedule.id}:${scheduledFor}`
+    });
+    await markWorkflowScheduleRan(schedule.id, now, addCadence(scheduledFor, schedule.cadence));
+    if (run.status !== "queued") {
+      results.push({ scheduleId: schedule.id, runId: run.id, status: run.status });
+      continue;
+    }
+    try {
+      const executed = await executeWorkflowRun({
+        runId: run.id,
+        user,
+        workflowId: schedule.workflow_id,
+        workflowInput: schedule.input,
+        apiUrl,
+        scheduleId: schedule.id,
+        webhookUrl: schedule.webhook_url
+      });
+      results.push({ scheduleId: schedule.id, runId: executed.run.id, status: executed.run.status });
+    } catch (err) {
+      results.push({ scheduleId: schedule.id, runId: run.id, status: "failed", error: err instanceof Error ? err.message : String(err) });
+    }
+  }
+  return { dispatched: results.length, results };
+}
+workflowApp.post("/cron/dispatch", async (c) => {
+  const secret2 = c.req.header("authorization");
+  if (!process.env.CRON_SECRET || secret2 !== `Bearer ${process.env.CRON_SECRET}`) {
+    return c.json({ error: "Unauthorized" }, 401);
+  }
+  return c.json(await dispatchDueWorkflowSchedules(originFromUrl(c.req.url)));
+});
+
+// src/api/serp-intelligence-routes.ts
+import { Hono as Hono8 } from "hono";
 
 // src/serp-intelligence/page-snapshot-extractor.ts
 import { createHash } from "crypto";
@@ -11050,7 +11367,7 @@ async function capturePageSnapshots(targets, options = {}) {
 }
 
 // src/serp-intelligence/schemas.ts
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 var SerpIntelligenceDeviceValues = ["desktop", "mobile"];
 var SerpIntelligenceProxyModeValues = ["location", "configured", "none"];
 var SerpIntelligenceAttemptOutcomeValues = [
@@ -11112,171 +11429,171 @@ function isPublicHttpUrl(value) {
     return false;
   }
 }
-var SerpIntelligencePublicHttpUrlSchema = z16.string().url().refine(isPublicHttpUrl, "url must be a public HTTP or HTTPS URL");
-var SerpIntelligenceCaptureBodySchema = z16.object({
-  query: z16.string().trim().min(1, "query is required"),
-  location: z16.string().trim().min(1).optional(),
-  gl: z16.string().trim().length(2).default("us"),
-  hl: z16.string().trim().length(2).default("en"),
-  device: z16.enum(SerpIntelligenceDeviceValues).default("desktop"),
-  proxyMode: z16.enum(SerpIntelligenceProxyModeValues).default("location"),
-  proxyZip: z16.string().regex(/^\d{5}$/).optional(),
-  pages: z16.number().int().min(1).max(2).default(1),
-  debug: z16.boolean().default(false),
-  includePageSnapshots: z16.boolean().default(false),
-  pageSnapshotLimit: z16.number().int().min(0).max(10).default(0)
+var SerpIntelligencePublicHttpUrlSchema = z17.string().url().refine(isPublicHttpUrl, "url must be a public HTTP or HTTPS URL");
+var SerpIntelligenceCaptureBodySchema = z17.object({
+  query: z17.string().trim().min(1, "query is required"),
+  location: z17.string().trim().min(1).optional(),
+  gl: z17.string().trim().length(2).default("us"),
+  hl: z17.string().trim().length(2).default("en"),
+  device: z17.enum(SerpIntelligenceDeviceValues).default("desktop"),
+  proxyMode: z17.enum(SerpIntelligenceProxyModeValues).default("location"),
+  proxyZip: z17.string().regex(/^\d{5}$/).optional(),
+  pages: z17.number().int().min(1).max(2).default(1),
+  debug: z17.boolean().default(false),
+  includePageSnapshots: z17.boolean().default(false),
+  pageSnapshotLimit: z17.number().int().min(0).max(10).default(0)
 }).strict();
-var SerpIntelligencePageSnapshotRequestSchema = z16.object({
+var SerpIntelligencePageSnapshotRequestSchema = z17.object({
   url: SerpIntelligencePublicHttpUrlSchema,
-  sourceKind: z16.enum(SerpPageSnapshotSourceKindValues).default("configured_target"),
-  sourcePosition: z16.number().int().min(1).optional()
+  sourceKind: z17.enum(SerpPageSnapshotSourceKindValues).default("configured_target"),
+  sourcePosition: z17.number().int().min(1).optional()
 }).strict();
-var SerpIntelligencePageSnapshotsBodySchema = z16.object({
-  urls: z16.array(SerpIntelligencePublicHttpUrlSchema).min(1).max(25),
-  targets: z16.array(SerpIntelligencePageSnapshotRequestSchema).min(1).max(25).optional(),
-  maxConcurrency: z16.number().int().min(1).max(5).default(2),
-  timeoutMs: z16.number().int().min(1e3).max(6e4).default(15e3),
-  debug: z16.boolean().default(false)
+var SerpIntelligencePageSnapshotsBodySchema = z17.object({
+  urls: z17.array(SerpIntelligencePublicHttpUrlSchema).min(1).max(25),
+  targets: z17.array(SerpIntelligencePageSnapshotRequestSchema).min(1).max(25).optional(),
+  maxConcurrency: z17.number().int().min(1).max(5).default(2),
+  timeoutMs: z17.number().int().min(1e3).max(6e4).default(15e3),
+  debug: z17.boolean().default(false)
 }).strict();
-var SerpIntelligenceAICitationSchema = z16.object({
-  text: z16.string(),
-  href: z16.string()
+var SerpIntelligenceAICitationSchema = z17.object({
+  text: z17.string(),
+  href: z17.string()
 }).strict();
-var SerpIntelligenceOrganicResultSchema = z16.object({
-  position: z16.number().int().min(1),
-  title: z16.string(),
-  url: z16.string(),
-  domain: z16.string(),
-  cite: z16.string().nullable(),
-  snippet: z16.string().nullable(),
-  isRedditStyle: z16.boolean(),
-  inlineRating: z16.object({
-    value: z16.string(),
-    count: z16.string()
+var SerpIntelligenceOrganicResultSchema = z17.object({
+  position: z17.number().int().min(1),
+  title: z17.string(),
+  url: z17.string(),
+  domain: z17.string(),
+  cite: z17.string().nullable(),
+  snippet: z17.string().nullable(),
+  isRedditStyle: z17.boolean(),
+  inlineRating: z17.object({
+    value: z17.string(),
+    count: z17.string()
   }).strict().nullable()
 }).strict();
-var SerpIntelligenceLocationEvidenceSchema = z16.object({
-  status: z16.enum(SerpIntelligenceLocalizationStatusValues),
-  expected: z16.object({
-    city: z16.string(),
-    regionCode: z16.string().nullable(),
-    canonicalLocation: z16.string()
+var SerpIntelligenceLocationEvidenceSchema = z17.object({
+  status: z17.enum(SerpIntelligenceLocalizationStatusValues),
+  expected: z17.object({
+    city: z17.string(),
+    regionCode: z17.string().nullable(),
+    canonicalLocation: z17.string()
   }).strict().nullable(),
-  candidates: z16.array(z16.object({
-    city: z16.string(),
-    regionCode: z16.string(),
-    count: z16.number().int().min(0),
-    examples: z16.array(z16.string())
+  candidates: z17.array(z17.object({
+    city: z17.string(),
+    regionCode: z17.string(),
+    count: z17.number().int().min(0),
+    examples: z17.array(z17.string())
   }).strict())
 }).strict();
-var SerpIntelligenceHarvestResultSchema = z16.object({
-  seed: z16.string(),
-  location: z16.string().nullable(),
-  extractedAt: z16.string(),
-  totalQuestions: z16.number().int().min(0),
-  surface: z16.enum(["web", "aim", "unknown"]),
-  aiOverview: z16.object({
-    detected: z16.boolean(),
-    text: z16.string().nullable(),
-    citations: z16.array(SerpIntelligenceAICitationSchema),
-    expanded: z16.boolean().optional(),
-    fullyExpanded: z16.boolean().optional(),
-    sections: z16.array(z16.string()).optional()
+var SerpIntelligenceHarvestResultSchema = z17.object({
+  seed: z17.string(),
+  location: z17.string().nullable(),
+  extractedAt: z17.string(),
+  totalQuestions: z17.number().int().min(0),
+  surface: z17.enum(["web", "aim", "unknown"]),
+  aiOverview: z17.object({
+    detected: z17.boolean(),
+    text: z17.string().nullable(),
+    citations: z17.array(SerpIntelligenceAICitationSchema),
+    expanded: z17.boolean().optional(),
+    fullyExpanded: z17.boolean().optional(),
+    sections: z17.array(z17.string()).optional()
   }).strict(),
-  aiMode: z16.object({
-    detected: z16.boolean(),
-    text: z16.string().nullable(),
-    citations: z16.array(SerpIntelligenceAICitationSchema)
+  aiMode: z17.object({
+    detected: z17.boolean(),
+    text: z17.string().nullable(),
+    citations: z17.array(SerpIntelligenceAICitationSchema)
   }).strict(),
-  tree: z16.array(z16.unknown()),
-  flat: z16.array(z16.unknown()),
-  videos: z16.array(z16.unknown()),
-  forums: z16.array(z16.unknown()),
-  organicResults: z16.array(SerpIntelligenceOrganicResultSchema),
-  localPack: z16.array(z16.unknown()),
-  entityIds: z16.object({
-    entities: z16.array(z16.object({
-      name: z16.string(),
-      kgId: z16.string().nullable(),
-      cid: z16.string().nullable(),
-      gcid: z16.string().nullable()
+  tree: z17.array(z17.unknown()),
+  flat: z17.array(z17.unknown()),
+  videos: z17.array(z17.unknown()),
+  forums: z17.array(z17.unknown()),
+  organicResults: z17.array(SerpIntelligenceOrganicResultSchema),
+  localPack: z17.array(z17.unknown()),
+  entityIds: z17.object({
+    entities: z17.array(z17.object({
+      name: z17.string(),
+      kgId: z17.string().nullable(),
+      cid: z17.string().nullable(),
+      gcid: z17.string().nullable()
     }).strict()),
-    kgIds: z16.array(z16.string()),
-    cids: z16.array(z16.string()),
-    gcids: z16.array(z16.string())
+    kgIds: z17.array(z17.string()),
+    cids: z17.array(z17.string()),
+    gcids: z17.array(z17.string())
   }).strict(),
-  stats: z16.object({
-    seed: z16.string(),
-    totalQuestions: z16.number().int().min(0),
-    maxDepthReached: z16.number().int().min(0),
-    durationMs: z16.number().min(0),
-    errorCount: z16.number().int().min(0)
+  stats: z17.object({
+    seed: z17.string(),
+    totalQuestions: z17.number().int().min(0),
+    maxDepthReached: z17.number().int().min(0),
+    durationMs: z17.number().min(0),
+    errorCount: z17.number().int().min(0)
   }).strict(),
-  diagnostics: z16.object({
-    completionStatus: z16.enum(["paa_found", "no_paa", "serp_only"]),
-    problem: z16.null(),
-    warnings: z16.array(z16.unknown()).optional(),
-    debug: z16.object({
+  diagnostics: z17.object({
+    completionStatus: z17.enum(["paa_found", "no_paa", "serp_only"]),
+    problem: z17.null(),
+    warnings: z17.array(z17.unknown()).optional(),
+    debug: z17.object({
       locationEvidence: SerpIntelligenceLocationEvidenceSchema.optional()
     }).passthrough().optional()
   }).passthrough(),
-  whatPeopleSaying: z16.array(z16.unknown())
+  whatPeopleSaying: z17.array(z17.unknown())
 }).strict();
-var SerpIntelligenceCaptureAttemptSchema = z16.object({
-  attemptNumber: z16.number().int().min(1),
-  outcome: z16.enum(SerpIntelligenceAttemptOutcomeValues),
-  startedAt: z16.string().optional(),
-  completedAt: z16.string().optional(),
-  durationMs: z16.number().min(0).optional(),
-  problemCode: z16.string().optional(),
-  message: z16.string().optional(),
-  kernelSessionId: z16.string().nullable().optional(),
-  cleanupSucceeded: z16.boolean().nullable().optional()
+var SerpIntelligenceCaptureAttemptSchema = z17.object({
+  attemptNumber: z17.number().int().min(1),
+  outcome: z17.enum(SerpIntelligenceAttemptOutcomeValues),
+  startedAt: z17.string().optional(),
+  completedAt: z17.string().optional(),
+  durationMs: z17.number().min(0).optional(),
+  problemCode: z17.string().optional(),
+  message: z17.string().optional(),
+  kernelSessionId: z17.string().nullable().optional(),
+  cleanupSucceeded: z17.boolean().nullable().optional()
 }).strict();
-var SerpPageSnapshotCaptureSchema = z16.object({
+var SerpPageSnapshotCaptureSchema = z17.object({
   url: SerpIntelligencePublicHttpUrlSchema,
   requestedUrl: SerpIntelligencePublicHttpUrlSchema,
   finalUrl: SerpIntelligencePublicHttpUrlSchema.nullable(),
-  sourceKind: z16.enum(SerpPageSnapshotSourceKindValues),
-  sourcePosition: z16.number().int().min(1).nullable(),
-  status: z16.enum(SerpPageFetchStatusValues),
-  fetchedVia: z16.enum(SerpPageFetchedViaValues).nullable(),
-  httpStatus: z16.number().int().min(100).max(599).nullable(),
-  contentType: z16.string().nullable(),
-  title: z16.string().nullable(),
+  sourceKind: z17.enum(SerpPageSnapshotSourceKindValues),
+  sourcePosition: z17.number().int().min(1).nullable(),
+  status: z17.enum(SerpPageFetchStatusValues),
+  fetchedVia: z17.enum(SerpPageFetchedViaValues).nullable(),
+  httpStatus: z17.number().int().min(100).max(599).nullable(),
+  contentType: z17.string().nullable(),
+  title: z17.string().nullable(),
   canonicalUrl: SerpIntelligencePublicHttpUrlSchema.nullable(),
-  metaDescription: z16.string().nullable(),
-  headings: z16.array(z16.object({
-    level: z16.number().int().min(1).max(6),
-    text: z16.string()
+  metaDescription: z17.string().nullable(),
+  headings: z17.array(z17.object({
+    level: z17.number().int().min(1).max(6),
+    text: z17.string()
   }).strict()).default([]),
-  artifact: z16.object({
-    htmlBlobUrl: z16.string().url().nullable(),
-    textBlobUrl: z16.string().url().nullable(),
-    markdownBlobUrl: z16.string().url().nullable(),
-    screenshotBlobUrl: z16.string().url().nullable(),
-    contentSha256: z16.string().nullable(),
-    capturedAt: z16.string().nullable()
+  artifact: z17.object({
+    htmlBlobUrl: z17.string().url().nullable(),
+    textBlobUrl: z17.string().url().nullable(),
+    markdownBlobUrl: z17.string().url().nullable(),
+    screenshotBlobUrl: z17.string().url().nullable(),
+    contentSha256: z17.string().nullable(),
+    capturedAt: z17.string().nullable()
   }).strict(),
-  error: z16.object({
-    code: z16.string(),
-    message: z16.string()
+  error: z17.object({
+    code: z17.string(),
+    message: z17.string()
   }).strict().nullable()
 }).strict();
-var SerpIntelligenceCaptureResponseSchema = z16.object({
+var SerpIntelligenceCaptureResponseSchema = z17.object({
   harvestResult: SerpIntelligenceHarvestResultSchema,
-  attempts: z16.array(SerpIntelligenceCaptureAttemptSchema),
+  attempts: z17.array(SerpIntelligenceCaptureAttemptSchema),
   locationEvidence: SerpIntelligenceLocationEvidenceSchema.nullable(),
-  pageSnapshotArtifacts: z16.array(SerpPageSnapshotCaptureSchema),
-  billing: z16.object({
-    creditsUsed: z16.number().min(0).optional(),
-    requestId: z16.string().optional(),
-    jobId: z16.string().optional()
+  pageSnapshotArtifacts: z17.array(SerpPageSnapshotCaptureSchema),
+  billing: z17.object({
+    creditsUsed: z17.number().min(0).optional(),
+    requestId: z17.string().optional(),
+    jobId: z17.string().optional()
   }).strict().optional()
 }).strict();
-var SerpIntelligencePageSnapshotsResponseSchema = z16.object({
-  pageSnapshotArtifacts: z16.array(SerpPageSnapshotCaptureSchema),
-  attempts: z16.array(SerpIntelligenceCaptureAttemptSchema).default([])
+var SerpIntelligencePageSnapshotsResponseSchema = z17.object({
+  pageSnapshotArtifacts: z17.array(SerpPageSnapshotCaptureSchema),
+  attempts: z17.array(SerpIntelligenceCaptureAttemptSchema).default([])
 }).strict();
 
 // src/serp-intelligence/serp-capture-service.ts
@@ -11448,7 +11765,7 @@ var SERP_INTELLIGENCE_RATE_LIMIT = 60;
 var SERP_INTELLIGENCE_RATE_WINDOW_SECONDS = 60;
 var POST_CAPTURE_ROUTE_LABEL = "POST /capture";
 var POST_PAGE_SNAPSHOTS_ROUTE_LABEL = "POST /page-snapshots";
-var serpIntelligenceApp = new Hono7();
+var serpIntelligenceApp = new Hono8();
 serpIntelligenceApp.use("*", createApiKeyAuth());
 function structuredError(input) {
   return {
@@ -11623,7 +11940,7 @@ serpIntelligenceApp.post("/page-snapshots", async (c) => {
 });
 
 // src/mcp/mcp-routes.ts
-import { Hono as Hono8 } from "hono";
+import { Hono as Hono9 } from "hono";
 import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
 configureReportSaving(false);
 function mcpAuthError() {
@@ -11653,7 +11970,7 @@ async function requireMcpCallerKey(c) {
   if (!user) return mcpAuthError();
   return callerKey;
 }
-var mcpApp = new Hono8();
+var mcpApp = new Hono9();
 function registerSerpIntelligenceCaptureTools(server, executor) {
   server.registerTool("capture_serp_snapshot", {
     title: "SERP Intelligence Snapshot",
@@ -11689,7 +12006,7 @@ mcpApp.all("/", async (c) => {
 });
 
 // src/api/browser-agent-routes.ts
-import { Hono as Hono9 } from "hono";
+import { Hono as Hono10 } from "hono";
 
 // src/api/browser-agent-db.ts
 import { randomUUID } from "crypto";
@@ -12210,7 +12527,7 @@ async function loadOpenSession(id, userId) {
   return row;
 }
 function buildBrowserAgentRoutes() {
-  const app2 = new Hono9();
+  const app2 = new Hono10();
   app2.use("*", async (c, next) => {
     await migrateBrowserAgent();
     return next();
@@ -12725,9 +13042,9 @@ if (state.key) { refreshSessions(); if (state.current) selectSession(state.curre
 
 // src/api/stripe-routes.ts
 import Stripe from "stripe";
-import { Hono as Hono10 } from "hono";
+import { Hono as Hono11 } from "hono";
 var stripe = new Stripe(process.env.STRIPE_SECRET_KEY, { apiVersion: "2026-02-25.clover" });
-var stripeApp = new Hono10();
+var stripeApp = new Hono11();
 stripeApp.post("/webhooks", async (c) => {
   const sig = c.req.header("stripe-signature");
   const body = await c.req.text();
@@ -12822,27 +13139,27 @@ import { getCookie, setCookie, deleteCookie } from "hono/cookie";
 import Stripe2 from "stripe";
 
 // src/api/billing-schemas.ts
-import { z as z17 } from "zod";
-var BillingCheckoutBodySchema = z17.object({
-  priceId: z17.string().min(1)
-});
-var FreeCreditBreakdownSchema = z17.object({
-  signup_grant_mc: z17.number().int().nonnegative(),
-  monthly_refresh_mc: z17.number().int().nonnegative(),
-  total_free_mc: z17.number().int().nonnegative(),
-  signup_grant_credits: z17.number().nonnegative(),
-  monthly_refresh_credits: z17.number().nonnegative(),
-  total_free_credits: z17.number().nonnegative()
-});
-var BillingBalanceResponseSchema = z17.object({
-  balance_mc: z17.number().int().nonnegative(),
-  balance_credits: z17.number().nonnegative(),
+import { z as z18 } from "zod";
+var BillingCheckoutBodySchema = z18.object({
+  priceId: z18.string().min(1)
+});
+var FreeCreditBreakdownSchema = z18.object({
+  signup_grant_mc: z18.number().int().nonnegative(),
+  monthly_refresh_mc: z18.number().int().nonnegative(),
+  total_free_mc: z18.number().int().nonnegative(),
+  signup_grant_credits: z18.number().nonnegative(),
+  monthly_refresh_credits: z18.number().nonnegative(),
+  total_free_credits: z18.number().nonnegative()
+});
+var BillingBalanceResponseSchema = z18.object({
+  balance_mc: z18.number().int().nonnegative(),
+  balance_credits: z18.number().nonnegative(),
   free_credits: FreeCreditBreakdownSchema,
-  ledger: z17.array(z17.any())
+  ledger: z18.array(z18.any())
 });
-var MonthlyRefreshSweepResultSchema = z17.object({
-  usersRefreshed: z17.number().int().nonnegative(),
-  totalMcGranted: z17.number().int().nonnegative()
+var MonthlyRefreshSweepResultSchema = z18.object({
+  usersRefreshed: z18.number().int().nonnegative(),
+  totalMcGranted: z18.number().int().nonnegative()
 });
 
 // src/api/credit-operations.ts
@@ -12943,7 +13260,7 @@ async function getFreeCreditBreakdown(userId) {
 }
 
 // src/api/session.ts
-import { createHmac, timingSafeEqual } from "crypto";
+import { createHmac as createHmac2, timingSafeEqual } from "crypto";
 var isProduction = () => process.env.NODE_ENV === "production" || process.env.VERCEL === "1";
 function getSessionSecret() {
   const configured = process.env.SESSION_SECRET?.trim();
@@ -12962,7 +13279,7 @@ function safeEqualHex(a, b) {
 }
 function signSession(userId) {
   const payload = String(userId);
-  const sig = createHmac("sha256", secret()).update(payload).digest("hex");
+  const sig = createHmac2("sha256", secret()).update(payload).digest("hex");
   return `${payload}.${sig}`;
 }
 function verifySession(token) {
@@ -12970,7 +13287,7 @@ function verifySession(token) {
   if (dot === -1) return null;
   const payload = token.slice(0, dot);
   const sig = token.slice(dot + 1);
-  const expected = createHmac("sha256", secret()).update(payload).digest("hex");
+  const expected = createHmac2("sha256", secret()).update(payload).digest("hex");
   if (!safeEqualHex(sig, expected)) return null;
   const id = parseInt(payload);
   return isNaN(id) ? null : id;
@@ -13053,7 +13370,7 @@ var sessionAuth = createMiddleware3(async (c, next) => {
   c.set("sessionUser", { ...refreshed, balance_mc: balanceMc });
   return next();
 });
-var app = new Hono11();
+var app = new Hono12();
 var STRIPE_API_VERSION = "2026-02-25.clover";
 function requireStripeSecret() {
   const secret2 = process.env.STRIPE_SECRET_KEY?.trim();
@@ -13699,13 +14016,14 @@ app.get("/cron/tick", async (c) => {
   if (!process.env.CRON_SECRET || secret2 !== `Bearer ${process.env.CRON_SECRET}`) {
     return c.json({ error: "Unauthorized" }, 401);
   }
-  const { drainQueue } = await import("./worker-5O44YBF4.js");
+  const { drainQueue } = await import("./worker-TDJQ6TH3.js");
   const budget = { maxJobs: 10, deadlineMs: Date.now() + 28e4 };
+  const workflowDispatchResult = await dispatchDueWorkflowSchedules(`${new URL(c.req.url).protocol}//${new URL(c.req.url).host}`);
   const [results, sweepResult] = await Promise.all([
     drainQueue(budget),
     runMonthlyRefreshSweep()
   ]);
-  return c.json({ drained: results.length, results, sweepResult });
+  return c.json({ drained: results.length, results, sweepResult, workflowDispatch: workflowDispatchResult });
 });
 app.on(["GET", "POST", "PUT"], "/api/inngest", serveInngest({ client: inngest, functions: [siteAuditFn] }));
 app.route("/api/internal/site-architecture-auditor", siteAuditApp);
@@ -13714,6 +14032,7 @@ app.route("/screenshot", screenshotApp);
 app.route("/facebook", facebookAdApp);
 app.route("/maps", mapsApp);
 app.route("/directory", directoryApp);
+app.route("/workflows", workflowApp);
 app.route("/serp-intelligence", serpIntelligenceApp);
 app.route("/mcp", mcpApp);
 app.route("/agent", buildBrowserAgentRoutes());
@@ -13825,4 +14144,4 @@ app.get("/blog/:slug/", (c) => {
 export {
   app
 };
-//# sourceMappingURL=server-BTTDFPSQ.js.map
+//# sourceMappingURL=server-BKJ7LULQ.js.map