mcp-scraper 0.3.42 → 0.3.45

package/dist/{server-CZT7EULY.js → server-MKUN6NQZ.js}

@@ -16,7 +16,7 @@ import {
   renderLinkReport,
   sanitizeAttempts,
   sanitizeHarvestResult
-} from "./chunk-KPF64WST.js";
+} from "./chunk-E7BZFMWB.js";
 import {
   csvRecords,
   listWorkflowDefinitions,
@@ -29,7 +29,7 @@ import {
   workflowStepCount,
   workflowSupportsSteps
 } from "./chunk-NNEIXK5L.js";
-import "./chunk-OUZZNW3I.js";
+import "./chunk-NVTFLLEG.js";
 import {
   BROWSER_OPEN_MIN_BALANCE_MC,
   CONCURRENCY_PRICE_ID,
@@ -38,6 +38,8 @@ import {
   LedgerOperation,
   MC_COSTS,
   MC_PER_CREDIT,
+  MC_PER_USD,
+  MEMORY_AI_MARGIN_MULTIPLE,
   MEMORY_PLANS,
   MEMORY_PLAN_QUOTA,
   SCHEDULING_PLANS,
@@ -50,7 +52,7 @@ import {
   harvestProblemResponse,
   insufficientBalanceResponse,
   serializeHarvestProblem
-} from "./chunk-RXJHXBGG.js";
+} from "./chunk-BRVX6RDN.js";
 import {
   BrowserDriver,
   MapsSelectors,
@@ -63,7 +65,7 @@ import {
   recordVendorUsage,
   resolveKernelProxyId,
   runWithCostContext
-} from "./chunk-GMTS35L6.js";
+} from "./chunk-RXNHY3TF.js";
 import {
   CaptchaError,
   RECAPTCHA_INSTRUCTIONS,
@@ -159,7 +161,7 @@ import {
   setSubscriptionTier,
   setUserMemoryCreds,
   verifyPassword
-} from "./chunk-DVRPXPYH.js";
+} from "./chunk-FUVQR6GK.js";
 
 // src/blog/registry.ts
 var posts = [
@@ -5257,7 +5259,7 @@ async function extractSite(opts) {
 }
 
 // src/api/server.ts
-import { Hono as Hono18 } from "hono";
+import { Hono as Hono20 } from "hono";
 import { serve as serveInngest } from "inngest/hono";
 
 // src/inngest/client.ts
@@ -8287,8 +8289,28 @@ siteAuditApp.get("/jobs", async (c) => {
   return c.json(jobs);
 });
 
-// src/api/youtube-routes.ts
+// src/api/internal-memory-routes.ts
 import { Hono as Hono2 } from "hono";
+var internalMemoryApp = new Hono2();
+internalMemoryApp.post("/ai-debit", async (c) => {
+  const secret2 = c.req.header("x-internal-secret");
+  if (!secret2 || secret2 !== process.env.INTERNAL_MEMORY_DEBIT_SECRET) {
+    return c.json({ error: "unauthorized" }, 401);
+  }
+  const body = await c.req.json().catch(() => ({}));
+  if (!body.identity || typeof body.costUsd !== "number" || body.costUsd < 0) {
+    return c.json({ error: "invalid_request" }, 400);
+  }
+  const user = await getUserByEmail(body.identity.trim().toLowerCase());
+  if (!user) return c.json({ ok: false, reason: "no_user" }, 200);
+  const mc = Math.round(body.costUsd * MEMORY_AI_MARGIN_MULTIPLE * MC_PER_USD);
+  if (mc <= 0) return c.json({ ok: true, mc: 0, balance_mc: null }, 200);
+  const { ok, balance_mc } = await debitMc(user.id, mc, LedgerOperation.MEMORY_AI, `${body.source ?? "ai"}:${body.op ?? ""}`);
+  return c.json({ ok, mc, balance_mc, insufficient: !ok }, 200);
+});
+
+// src/api/youtube-routes.ts
+import { Hono as Hono3 } from "hono";
 
 // src/youtube/youtube-harvest.ts
 import { promises as fs } from "fs";
@@ -9280,7 +9302,7 @@ async function extendConcurrencyGate(lockId, ttlSeconds = DEFAULT_LOCK_TTL_SECON
 }
 
 // src/api/youtube-routes.ts
-var youtubeApp = new Hono2();
+var youtubeApp = new Hono3();
 youtubeApp.post("/harvest", createApiKeyAuth(), async (c) => {
   const raw = await c.req.json().catch(() => ({}));
   const parsed = YoutubeHarvestBodySchema.safeParse(raw);
@@ -9439,14 +9461,14 @@ function fmtTs(secs) {
 }
 
 // src/api/screenshot-routes.ts
-import { Hono as Hono3 } from "hono";
+import { Hono as Hono4 } from "hono";
 import { z as z12 } from "zod";
 var ScreenshotBodySchema = z12.object({
   url: z12.string().trim().min(1, "url is required"),
   device: z12.string().trim().optional(),
   allowLocal: z12.boolean().optional()
 });
-var screenshotApp = new Hono3();
+var screenshotApp = new Hono4();
 screenshotApp.use("*", createApiKeyAuth());
 screenshotApp.post("/", async (c) => {
   const raw = await c.req.json().catch(() => ({}));
@@ -9503,7 +9525,7 @@ screenshotApp.post("/", async (c) => {
 });
 
 // src/api/facebook-ad-routes.ts
-import { Hono as Hono4 } from "hono";
+import { Hono as Hono5 } from "hono";
 import { z as z13 } from "zod";
 
 // src/extractor/FacebookAdExtractor.ts
@@ -10502,7 +10524,7 @@ async function kernelLaunchOptsResidential() {
   }
   return { headless: true, kernelApiKey: browserServiceApiKey(), kernelProxyId: proxyId, viewport: { width: 1280, height: 900 }, locale: "en-US" };
 }
-var facebookAdApp = new Hono4();
+var facebookAdApp = new Hono5();
 facebookAdApp.post("/ad", createApiKeyAuth(), async (c) => {
   const raw = await c.req.json().catch(() => ({}));
   const parsed = FacebookAdBodySchema.safeParse(raw);
@@ -10835,7 +10857,7 @@ facebookAdApp.post("/media", createApiKeyAuth(), async (c) => {
 });
 
 // src/api/google-ads-routes.ts
-import { Hono as Hono5 } from "hono";
+import { Hono as Hono6 } from "hono";
 import { z as z14 } from "zod";
 
 // src/extractor/GoogleAdsExtractor.ts
@@ -11044,7 +11066,7 @@ async function kernelLaunchOptsResidential2() {
 function isBlockedMessage(msg) {
   return msg.toLowerCase().includes("blocked") || msg.toLowerCase().includes("captcha");
 }
-var googleAdsApp = new Hono5();
+var googleAdsApp = new Hono6();
 googleAdsApp.post("/search", createApiKeyAuth(), async (c) => {
   const raw = await c.req.json().catch(() => ({}));
   const parsed = GoogleAdsSearchBodySchema.safeParse(raw);
@@ -11156,7 +11178,7 @@ googleAdsApp.post("/transcribe", createApiKeyAuth(), async (c) => {
 });
 
 // src/api/instagram-routes.ts
-import { Hono as Hono6 } from "hono";
+import { Hono as Hono7 } from "hono";
 import { z as z15 } from "zod";
 import { createWriteStream as createWriteStream2, mkdirSync as mkdirSync3, statSync, writeFileSync as writeFileSync2 } from "fs";
 import { homedir as homedir3 } from "os";
@@ -11546,7 +11568,7 @@ var InstagramMediaDownloadBodySchema = z15.object({
   includeTranscript: z15.boolean().default(false),
   mux: z15.boolean().default(true)
 });
-var instagramApp = new Hono6();
+var instagramApp = new Hono7();
 function invalidRequest3(message) {
   return { error_code: "invalid_request", message };
 }
@@ -11820,7 +11842,7 @@ instagramApp.post("/media-download", createApiKeyAuth(), async (c) => {
 });
 
 // src/api/reddit-routes.ts
-import { Hono as Hono7 } from "hono";
+import { Hono as Hono8 } from "hono";
 import { z as z16 } from "zod";
 var RedditThreadBodySchema = z16.object({
   url: z16.string().trim().min(1, "url is required"),
@@ -11880,7 +11902,7 @@ var PARSE_REDDIT = `(() => {
   });
   return { title: title, author: author, score: score, postBody: postBody, blocked: blocked, numComments: comments.length, comments: comments };
 })()`;
-var redditApp = new Hono7();
+var redditApp = new Hono8();
 redditApp.post("/thread", createApiKeyAuth(), async (c) => {
   const raw = await c.req.json().catch(() => ({}));
   const parsed = RedditThreadBodySchema.safeParse(raw);
@@ -11914,11 +11936,11 @@ redditApp.post("/thread", createApiKeyAuth(), async (c) => {
           locale: "en-US"
         });
         const page = driver.getPage();
-        await page.goto(oldUrl, { waitUntil: "domcontentloaded", timeout: 45e3 });
+        await page.goto(oldUrl, { waitUntil: "domcontentloaded", timeout: attempt === 0 ? 3e4 : 45e3 });
         await page.waitForTimeout(2500);
         const data = await page.evaluate(PARSE_REDDIT);
         if (!data.blocked && (data.postBody || data.comments.length > 0)) {
-          result = { ...data, sourceUrl: body.url, oldRedditUrl: oldUrl, attempts: attempt + 1 };
+          result = { ...data, sourceUrl: body.url, oldRedditUrl: oldUrl, attempts: attempt + 1, proxied: Boolean(proxyId) };
         }
       } catch {
       } finally {
@@ -11947,8 +11969,231 @@ redditApp.post("/thread", createApiKeyAuth(), async (c) => {
   }
 });
 
+// src/api/video-routes.ts
+import { Hono as Hono9 } from "hono";
+import { z as z17 } from "zod";
+
+// src/api/memory.ts
+import { createCipheriv, createDecipheriv, randomBytes, scryptSync } from "crypto";
+
+// src/api/session.ts
+import { createHmac, timingSafeEqual } from "crypto";
+var isProduction = () => process.env.NODE_ENV === "production" || process.env.VERCEL === "1";
+function getSessionSecret() {
+  const configured = process.env.SESSION_SECRET?.trim();
+  if (configured) return configured;
+  if (isProduction()) throw new Error("SESSION_SECRET is not set \u2014 add it to your Vercel env vars (see src/api/env.ts)");
+  return "dev-secret-change-me";
+}
+var secret = () => getSessionSecret();
+function safeEqualHex(a, b) {
+  if (a.length !== b.length) return false;
+  try {
+    return timingSafeEqual(Buffer.from(a, "hex"), Buffer.from(b, "hex"));
+  } catch {
+    return false;
+  }
+}
+function signSession(userId) {
+  const payload = String(userId);
+  const sig = createHmac("sha256", secret()).update(payload).digest("hex");
+  return `${payload}.${sig}`;
+}
+function verifySession(token) {
+  const dot = token.lastIndexOf(".");
+  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");
+  if (!safeEqualHex(sig, expected)) return null;
+  const id = parseInt(payload);
+  return isNaN(id) ? null : id;
+}
+
+// src/api/memory.ts
+var MEMORY_BASE_URL = () => (process.env.MCP_MEMORY_BASE_URL ?? "https://mcp-memory-omega.vercel.app").replace(/\/$/, "");
+var ADMIN_KEY = () => process.env.MCP_MEMORY_ADMIN_KEY?.trim() ?? "";
+function isMemoryOperator(email) {
+  if (!email) return false;
+  const ops = (process.env.MEMORY_OPERATOR_IDENTITIES ?? "").split(",").map((s) => s.trim().toLowerCase()).filter(Boolean);
+  return ops.includes(email.trim().toLowerCase());
+}
+function encKey() {
+  return scryptSync(getSessionSecret(), "mcp-memory-key-v1", 32);
+}
+function encryptMemoryKey(secret2) {
+  const iv = randomBytes(12);
+  const cipher = createCipheriv("aes-256-gcm", encKey(), iv);
+  const enc = Buffer.concat([cipher.update(secret2, "utf8"), cipher.final()]);
+  const tag = cipher.getAuthTag();
+  return `${iv.toString("base64")}:${tag.toString("base64")}:${enc.toString("base64")}`;
+}
+function decryptMemoryKey(stored) {
+  try {
+    const [ivB, tagB, dataB] = stored.split(":");
+    const decipher = createDecipheriv("aes-256-gcm", encKey(), Buffer.from(ivB, "base64"));
+    decipher.setAuthTag(Buffer.from(tagB, "base64"));
+    return Buffer.concat([decipher.update(Buffer.from(dataB, "base64")), decipher.final()]).toString("utf8");
+  } catch {
+    return null;
+  }
+}
+async function memoryCall(toolName, args, userMemoryKey) {
+  try {
+    const res = await fetch(`${MEMORY_BASE_URL()}/api/mcp/memoryServer/tools/${toolName}/execute`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ data: { ...args, apiKey: userMemoryKey } })
+    });
+    const body = await res.json().catch(() => null);
+    if (!res.ok) return { ok: false, error: body?.error ?? `memory ${toolName} failed (${res.status})` };
+    if (body?.result) return body.result;
+    return { ok: false, error: body?.error ?? `memory ${toolName} returned no result` };
+  } catch (err) {
+    return { ok: false, error: err?.message ?? "memory call failed" };
+  }
+}
+function personalVault(user) {
+  return `mcp-${user.id}`;
+}
+function memoryIdentity(user) {
+  return user.email;
+}
+function resolveMemoryIdentity(user) {
+  return memoryIdentity(user);
+}
+function memoryPlanForReads(user) {
+  if (isMemoryOperator(user.email)) return "unlimited";
+  if (user.memory_plan === "pro" || user.memory_plan === "team") return user.memory_plan;
+  return "free";
+}
+async function provisionMemoryForUser(user) {
+  try {
+    const { key } = await getOrCreateUserMemoryKey(user);
+    if (key) await setMemoryProvisioned(user.id, true);
+  } catch {
+  }
+}
+async function getOrCreateUserMemoryKey(user) {
+  const creds = await getUserMemoryCreds(user.id);
+  if (creds.memory_key) {
+    const decrypted = decryptMemoryKey(creds.memory_key);
+    if (decrypted) return { key: decrypted };
+  }
+  const admin = ADMIN_KEY();
+  if (!admin) return { key: null, error: "memory not configured (MCP_MEMORY_ADMIN_KEY missing)" };
+  const identity = memoryIdentity(user);
+  const plan = isMemoryOperator(user.email) ? "unlimited" : (await getMemoryPlan(user.id)).plan;
+  const provisioned = await memoryCall(
+    "provisionDefaultsTool",
+    { granteeIdentity: identity, issueKey: true, plan },
+    admin
+  );
+  if (!provisioned.ok || !provisioned.secret) {
+    return { key: null, error: provisioned.error ?? "failed to provision default vaults" };
+  }
+  await setUserMemoryCreds(user.id, encryptMemoryKey(provisioned.secret), identity);
+  return { key: provisioned.secret };
+}
+async function syncMemoryKeyPlan(user, plan) {
+  const effectivePlan = isMemoryOperator(user.email) ? "unlimited" : plan;
+  const { key, error } = await getOrCreateUserMemoryKey(user);
+  if (!key) return { ok: false, error: error ?? "memory unavailable" };
+  const listed = await memoryCall(
+    "listKeysTool",
+    {},
+    key
+  );
+  if (!listed.ok || !listed.keys?.length) return { ok: false, error: listed.error ?? "no memory keys found" };
+  const target = listed.keys[0];
+  if (target.plan === effectivePlan) return { ok: true };
+  const res = await memoryCall("setScopeTool", { keyId: target.keyId, plan: effectivePlan }, key);
+  return { ok: res.ok, error: res.error };
+}
+async function syncScheduleEntitlement(user, enabled, quotaPerPeriod) {
+  const admin = ADMIN_KEY();
+  if (!admin) return { ok: false, error: "memory not configured (MCP_MEMORY_ADMIN_KEY missing)" };
+  const identity = resolveMemoryIdentity(user);
+  const res = await memoryCall("setScheduleEntitlementTool", {
+    granteeIdentity: identity,
+    enabled,
+    quotaPerPeriod,
+    mcpScraperApiKey: user.api_key
+  }, admin);
+  return { ok: res.ok, error: res.error };
+}
+
+// src/api/video-routes.ts
+var videoApp = new Hono9();
+var AnalyzeBodySchema = z17.object({
+  sourceUrl: z17.string().trim().url("sourceUrl must be a direct video file URL"),
+  intervalS: z17.number().min(1).max(30).optional(),
+  maxFrames: z17.number().int().min(1).max(120).optional(),
+  detail: z17.enum(["fast", "standard", "deep"]).optional(),
+  vault: z17.string().trim().min(1).optional()
+});
+function invalidRequest5(message) {
+  return { error_code: "invalid_request", message };
+}
+videoApp.post("/analyze", createApiKeyAuth(), async (c) => {
+  const parsed = AnalyzeBodySchema.safeParse(await c.req.json().catch(() => ({})));
+  if (!parsed.success) return c.json(invalidRequest5(parsed.error.issues[0]?.message ?? "invalid request"), 400);
+  const body = parsed.data;
+  const user = c.get("user");
+  const { key: memKey, error: memErr } = await getOrCreateUserMemoryKey(user);
+  if (!memKey) return c.json({ error_code: "memory_unavailable", message: memErr ?? "memory unavailable" }, 502);
+  const { ok, balance_mc } = await debitMc(user.id, MC_COSTS.video_analysis, LedgerOperation.VIDEO_ANALYSIS, body.sourceUrl);
+  if (!ok) return c.json(insufficientBalanceResponse(balance_mc, MC_COSTS.video_analysis), 402);
+  const started = await memoryCall(
+    "videoAnalyzeStartTool",
+    {
+      sourceUrl: body.sourceUrl,
+      intervalS: body.intervalS ?? 2,
+      maxFrames: body.maxFrames ?? 120,
+      detail: body.detail ?? "standard",
+      vault: body.vault ?? "Library"
+    },
+    memKey
+  );
+  if (!started.ok || !started.runId) {
+    await creditMc(user.id, MC_COSTS.video_analysis, LedgerOperation.VIDEO_ANALYSIS_REFUND, `start-failed:${body.sourceUrl}`);
+    return c.json({ error_code: "video_start_failed", message: started.error ?? "could not start analysis" }, 502);
+  }
+  return c.json({
+    ok: true,
+    runId: started.runId,
+    status: "queued",
+    message: 'Analysis started. Poll GET /video/status?runId=... every few seconds until status is "done".'
+  });
+});
+videoApp.post("/status", createApiKeyAuth(), async (c) => {
+  const rawBody = await c.req.json().catch(() => ({}));
+  const runId = rawBody.runId?.trim();
+  if (!runId) return c.json(invalidRequest5("runId is required"), 400);
+  const user = c.get("user");
+  const { key: memKey, error: memErr } = await getOrCreateUserMemoryKey(user);
+  if (!memKey) return c.json({ error_code: "memory_unavailable", message: memErr ?? "memory unavailable" }, 502);
+  const st = await memoryCall("videoAnalyzeStatusTool", { runId }, memKey);
+  if (!st.ok) return c.json({ error_code: "not_found", message: st.error ?? "run not found" }, 404);
+  if (st.status === "failed") {
+    const refundOp = `${LedgerOperation.VIDEO_ANALYSIS_REFUND}:${runId}`;
+    if (!await ledgerExistsForOperation(user.id, refundOp)) {
+      await creditMc(user.id, MC_COSTS.video_analysis, refundOp, `run-failed:${runId}`);
+    }
+  }
+  return c.json({
+    ok: true,
+    runId,
+    status: st.status ?? "unknown",
+    progress: st.progress ?? null,
+    frameCount: st.frameCount ?? null,
+    ...st.status === "done" ? { artifactPath: st.artifactPath ?? null, report: st.report ?? null } : {},
+    ...st.error ? { error: st.error } : {}
+  });
+});
+
 // src/api/maps-routes.ts
-import { Hono as Hono8 } from "hono";
+import { Hono as Hono10 } from "hono";
 
 // src/extractor/MapsNavigator.ts
 var MapsNavigator = class {
@@ -12123,7 +12368,7 @@ var MapsReviewCollector = class {
 };
 
 // src/extractor/MapsExtractor.ts
-import { z as z17 } from "zod";
+import { z as z18 } from "zod";
 var MapsExtractor = class {
   constructor(driver) {
     this.driver = driver;
@@ -12309,7 +12554,7 @@ var MapsExtractor = class {
       });
       return rows;
     }, { hoursTable: MapsSelectors.hoursTable, hoursTableAlt: MapsSelectors.hoursTableAlt });
-    const result = z17.array(RawMapsHoursRowSchema).safeParse(raw);
+    const result = z18.array(RawMapsHoursRowSchema).safeParse(raw);
     if (!result.success) {
       console.warn("[MapsExtractor] hours parse failed", result.error.flatten());
       return [];
@@ -12373,7 +12618,7 @@ var MapsExtractor = class {
       });
       return results;
     });
-    const result = z17.array(RawMapsAboutAttributeSchema).safeParse(raw);
+    const result = z18.array(RawMapsAboutAttributeSchema).safeParse(raw);
     if (!result.success) {
       console.warn("[MapsExtractor] about parse failed", result.error.flatten());
       return [];
@@ -12749,7 +12994,7 @@ function mapsErrorResponse(c, err, errorCode) {
     attempts: rotationError?.attempts ?? void 0
   }, retryable ? 503 : 500);
 }
-var mapsApp = new Hono8();
+var mapsApp = new Hono10();
 mapsApp.post("/search", createApiKeyAuth(), async (c) => {
   const user = c.get("user");
   const body = await c.req.json().catch(() => ({}));
@@ -12887,12 +13132,12 @@ mapsApp.post("/place", createApiKeyAuth(), async (c) => {
 });
 
 // src/api/directory-routes.ts
-import { Hono as Hono9 } from "hono";
+import { Hono as Hono11 } from "hono";
 
 // src/directory/directory-workflow.ts
 import { mkdir as mkdir2, writeFile } from "fs/promises";
 import { join as join6 } from "path";
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 
 // src/directory/location-db.ts
 import { access, readFile } from "fs/promises";
@@ -13053,24 +13298,24 @@ async function resolveDirectoryMarkets(options) {
 }
 
 // src/directory/directory-workflow.ts
-var DirectoryWorkflowOptionsSchema = z18.object({
-  query: z18.string().min(1),
-  state: z18.string().min(2).default("TN"),
-  minPopulation: z18.number().int().min(0).default(1e5),
-  populationYear: z18.union(POPULATION_YEARS.map((year) => z18.literal(year))).default(2025),
-  maxCities: z18.number().int().min(1).max(100).default(25),
-  maxResultsPerCity: z18.number().int().min(1).max(50).default(50),
-  concurrency: z18.number().int().min(1).max(5).default(5),
-  includeZipGroups: z18.boolean().default(true),
-  usZipsCsvPath: z18.string().optional(),
-  saveCsv: z18.boolean().default(true),
-  gl: z18.string().length(2).default("us"),
-  hl: z18.string().length(2).default("en"),
-  proxyMode: z18.enum(["location", "configured", "none"]).default(DEFAULT_MAPS_PROXY_MODE),
-  proxyZip: z18.string().regex(/^\d{5}$/).optional(),
-  debug: z18.boolean().default(false),
-  headless: z18.boolean().default(true),
-  kernelApiKey: z18.string().optional()
+var DirectoryWorkflowOptionsSchema = z19.object({
+  query: z19.string().min(1),
+  state: z19.string().min(2).default("TN"),
+  minPopulation: z19.number().int().min(0).default(1e5),
+  populationYear: z19.union(POPULATION_YEARS.map((year) => z19.literal(year))).default(2025),
+  maxCities: z19.number().int().min(1).max(100).default(25),
+  maxResultsPerCity: z19.number().int().min(1).max(50).default(50),
+  concurrency: z19.number().int().min(1).max(5).default(5),
+  includeZipGroups: z19.boolean().default(true),
+  usZipsCsvPath: z19.string().optional(),
+  saveCsv: z19.boolean().default(true),
+  gl: z19.string().length(2).default("us"),
+  hl: z19.string().length(2).default("en"),
+  proxyMode: z19.enum(["location", "configured", "none"]).default(DEFAULT_MAPS_PROXY_MODE),
+  proxyZip: z19.string().regex(/^\d{5}$/).optional(),
+  debug: z19.boolean().default(false),
+  headless: z19.boolean().default(true),
+  kernelApiKey: z19.string().optional()
 });
 function errorMessage(err) {
   return err instanceof Error ? err.message : String(err);
@@ -13291,7 +13536,7 @@ async function runDirectoryWorkflowFromPlan(options, plan) {
 }
 
 // src/api/directory-routes.ts
-var directoryApp = new Hono9();
+var directoryApp = new Hono11();
 directoryApp.post("/run", createApiKeyAuth(), async (c) => {
   const user = c.get("user");
   const body = await c.req.json().catch(() => ({}));
@@ -13362,37 +13607,37 @@ directoryApp.post("/run", createApiKeyAuth(), async (c) => {
 });
 
 // src/api/workflow-routes.ts
-import { createHmac } from "crypto";
+import { createHmac as createHmac2 } from "crypto";
 import { readFile as readFile2 } from "fs/promises";
-import { Hono as Hono10 } from "hono";
-import { z as z19 } from "zod";
-var workflowApp = new Hono10();
-var WorkflowInputSchema = z19.record(z19.unknown()).default({});
-var WorkflowIdSchema = z19.string().min(1);
-var CadenceSchema = z19.enum(["daily", "weekly", "monthly"]);
-var ScheduleStatusSchema = z19.enum(["active", "paused"]);
-var RunBodySchema = z19.object({
+import { Hono as Hono12 } from "hono";
+import { z as z20 } from "zod";
+var workflowApp = new Hono12();
+var WorkflowInputSchema = z20.record(z20.unknown()).default({});
+var WorkflowIdSchema = z20.string().min(1);
+var CadenceSchema = z20.enum(["daily", "weekly", "monthly"]);
+var ScheduleStatusSchema = z20.enum(["active", "paused"]);
+var RunBodySchema = z20.object({
   workflowId: WorkflowIdSchema,
   input: WorkflowInputSchema,
-  webhookUrl: z19.string().url().optional()
+  webhookUrl: z20.string().url().optional()
 });
-var ScheduleCreateSchema = z19.object({
+var ScheduleCreateSchema = z20.object({
   workflowId: WorkflowIdSchema,
-  name: z19.string().min(1).max(120).optional(),
+  name: z20.string().min(1).max(120).optional(),
   input: WorkflowInputSchema,
   cadence: CadenceSchema.default("weekly"),
-  timezone: z19.string().min(1).max(64).default("UTC"),
-  webhookUrl: z19.string().url().optional(),
-  nextRunAt: z19.string().datetime().optional()
+  timezone: z20.string().min(1).max(64).default("UTC"),
+  webhookUrl: z20.string().url().optional(),
+  nextRunAt: z20.string().datetime().optional()
 });
-var SchedulePatchSchema = z19.object({
-  name: z19.string().min(1).max(120).optional(),
+var SchedulePatchSchema = z20.object({
+  name: z20.string().min(1).max(120).optional(),
   status: ScheduleStatusSchema.optional(),
   input: WorkflowInputSchema.optional(),
   cadence: CadenceSchema.optional(),
-  timezone: z19.string().min(1).max(64).optional(),
-  webhookUrl: z19.string().url().nullable().optional(),
-  nextRunAt: z19.string().datetime().nullable().optional()
+  timezone: z20.string().min(1).max(64).optional(),
+  webhookUrl: z20.string().url().nullable().optional(),
+  nextRunAt: z20.string().datetime().nullable().optional()
 });
 function hostedWorkflowOutputDir() {
   return workflowOutputBaseDir(process.env.MCP_SCRAPER_WORKFLOW_OUTPUT_DIR?.trim() || "/tmp/mcp-scraper-workflows");
@@ -13450,7 +13695,7 @@ async function readManifestFromSummary(summary) {
 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");
+  return createHmac2("sha256", secret2).update(`${timestamp}.${body}`).digest("hex");
 }
 async function deliverWorkflowWebhook(input) {
   if (!input.webhookUrl) return;
@@ -13896,7 +14141,7 @@ workflowApp.post("/cron/dispatch", async (c) => {
 });
 
 // src/api/serp-intelligence-routes.ts
-import { Hono as Hono11 } from "hono";
+import { Hono as Hono13 } from "hono";
 
 // src/serp-intelligence/page-snapshot-extractor.ts
 import { createHash as createHash2 } from "crypto";
@@ -14208,7 +14453,7 @@ async function capturePageSnapshots(targets, options = {}) {
 }
 
 // src/serp-intelligence/schemas.ts
-import { z as z20 } from "zod";
+import { z as z21 } from "zod";
 var SerpIntelligenceDeviceValues = ["desktop", "mobile"];
 var SerpIntelligenceProxyModeValues = ["location", "configured", "none"];
 var SerpIntelligenceAttemptOutcomeValues = [
@@ -14270,171 +14515,171 @@ function isPublicHttpUrl(value) {
     return false;
   }
 }
-var SerpIntelligencePublicHttpUrlSchema = z20.string().url().refine(isPublicHttpUrl, "url must be a public HTTP or HTTPS URL");
-var SerpIntelligenceCaptureBodySchema = z20.object({
-  query: z20.string().trim().min(1, "query is required"),
-  location: z20.string().trim().min(1).optional(),
-  gl: z20.string().trim().length(2).default("us"),
-  hl: z20.string().trim().length(2).default("en"),
-  device: z20.enum(SerpIntelligenceDeviceValues).default("desktop"),
-  proxyMode: z20.enum(SerpIntelligenceProxyModeValues).default(DEFAULT_PROXY_MODE),
-  proxyZip: z20.string().regex(/^\d{5}$/).optional(),
-  pages: z20.number().int().min(1).max(2).default(1),
-  debug: z20.boolean().default(false),
-  includePageSnapshots: z20.boolean().default(false),
-  pageSnapshotLimit: z20.number().int().min(0).max(10).default(0)
+var SerpIntelligencePublicHttpUrlSchema = z21.string().url().refine(isPublicHttpUrl, "url must be a public HTTP or HTTPS URL");
+var SerpIntelligenceCaptureBodySchema = z21.object({
+  query: z21.string().trim().min(1, "query is required"),
+  location: z21.string().trim().min(1).optional(),
+  gl: z21.string().trim().length(2).default("us"),
+  hl: z21.string().trim().length(2).default("en"),
+  device: z21.enum(SerpIntelligenceDeviceValues).default("desktop"),
+  proxyMode: z21.enum(SerpIntelligenceProxyModeValues).default(DEFAULT_PROXY_MODE),
+  proxyZip: z21.string().regex(/^\d{5}$/).optional(),
+  pages: z21.number().int().min(1).max(2).default(1),
+  debug: z21.boolean().default(false),
+  includePageSnapshots: z21.boolean().default(false),
+  pageSnapshotLimit: z21.number().int().min(0).max(10).default(0)
 }).strict();
-var SerpIntelligencePageSnapshotRequestSchema = z20.object({
+var SerpIntelligencePageSnapshotRequestSchema = z21.object({
   url: SerpIntelligencePublicHttpUrlSchema,
-  sourceKind: z20.enum(SerpPageSnapshotSourceKindValues).default("configured_target"),
-  sourcePosition: z20.number().int().min(1).optional()
+  sourceKind: z21.enum(SerpPageSnapshotSourceKindValues).default("configured_target"),
+  sourcePosition: z21.number().int().min(1).optional()
 }).strict();
-var SerpIntelligencePageSnapshotsBodySchema = z20.object({
-  urls: z20.array(SerpIntelligencePublicHttpUrlSchema).min(1).max(25),
-  targets: z20.array(SerpIntelligencePageSnapshotRequestSchema).min(1).max(25).optional(),
-  maxConcurrency: z20.number().int().min(1).max(5).default(2),
-  timeoutMs: z20.number().int().min(1e3).max(6e4).default(15e3),
-  debug: z20.boolean().default(false)
+var SerpIntelligencePageSnapshotsBodySchema = z21.object({
+  urls: z21.array(SerpIntelligencePublicHttpUrlSchema).min(1).max(25),
+  targets: z21.array(SerpIntelligencePageSnapshotRequestSchema).min(1).max(25).optional(),
+  maxConcurrency: z21.number().int().min(1).max(5).default(2),
+  timeoutMs: z21.number().int().min(1e3).max(6e4).default(15e3),
+  debug: z21.boolean().default(false)
 }).strict();
-var SerpIntelligenceAICitationSchema = z20.object({
-  text: z20.string(),
-  href: z20.string()
+var SerpIntelligenceAICitationSchema = z21.object({
+  text: z21.string(),
+  href: z21.string()
 }).strict();
-var SerpIntelligenceOrganicResultSchema = z20.object({
-  position: z20.number().int().min(1),
-  title: z20.string(),
-  url: z20.string(),
-  domain: z20.string(),
-  cite: z20.string().nullable(),
-  snippet: z20.string().nullable(),
-  isRedditStyle: z20.boolean(),
-  inlineRating: z20.object({
-    value: z20.string(),
-    count: z20.string()
+var SerpIntelligenceOrganicResultSchema = z21.object({
+  position: z21.number().int().min(1),
+  title: z21.string(),
+  url: z21.string(),
+  domain: z21.string(),
+  cite: z21.string().nullable(),
+  snippet: z21.string().nullable(),
+  isRedditStyle: z21.boolean(),
+  inlineRating: z21.object({
+    value: z21.string(),
+    count: z21.string()
   }).strict().nullable()
 }).strict();
-var SerpIntelligenceLocationEvidenceSchema = z20.object({
-  status: z20.enum(SerpIntelligenceLocalizationStatusValues),
-  expected: z20.object({
-    city: z20.string(),
-    regionCode: z20.string().nullable(),
-    canonicalLocation: z20.string()
+var SerpIntelligenceLocationEvidenceSchema = z21.object({
+  status: z21.enum(SerpIntelligenceLocalizationStatusValues),
+  expected: z21.object({
+    city: z21.string(),
+    regionCode: z21.string().nullable(),
+    canonicalLocation: z21.string()
   }).strict().nullable(),
-  candidates: z20.array(z20.object({
-    city: z20.string(),
-    regionCode: z20.string(),
-    count: z20.number().int().min(0),
-    examples: z20.array(z20.string())
+  candidates: z21.array(z21.object({
+    city: z21.string(),
+    regionCode: z21.string(),
+    count: z21.number().int().min(0),
+    examples: z21.array(z21.string())
   }).strict())
 }).strict();
-var SerpIntelligenceHarvestResultSchema = z20.object({
-  seed: z20.string(),
-  location: z20.string().nullable(),
-  extractedAt: z20.string(),
-  totalQuestions: z20.number().int().min(0),
-  surface: z20.enum(["web", "aim", "unknown"]),
-  aiOverview: z20.object({
-    detected: z20.boolean(),
-    text: z20.string().nullable(),
-    citations: z20.array(SerpIntelligenceAICitationSchema),
-    expanded: z20.boolean().optional(),
-    fullyExpanded: z20.boolean().optional(),
-    sections: z20.array(z20.string()).optional()
+var SerpIntelligenceHarvestResultSchema = z21.object({
+  seed: z21.string(),
+  location: z21.string().nullable(),
+  extractedAt: z21.string(),
+  totalQuestions: z21.number().int().min(0),
+  surface: z21.enum(["web", "aim", "unknown"]),
+  aiOverview: z21.object({
+    detected: z21.boolean(),
+    text: z21.string().nullable(),
+    citations: z21.array(SerpIntelligenceAICitationSchema),
+    expanded: z21.boolean().optional(),
+    fullyExpanded: z21.boolean().optional(),
+    sections: z21.array(z21.string()).optional()
   }).strict(),
-  aiMode: z20.object({
-    detected: z20.boolean(),
-    text: z20.string().nullable(),
-    citations: z20.array(SerpIntelligenceAICitationSchema)
+  aiMode: z21.object({
+    detected: z21.boolean(),
+    text: z21.string().nullable(),
+    citations: z21.array(SerpIntelligenceAICitationSchema)
   }).strict(),
-  tree: z20.array(z20.unknown()),
-  flat: z20.array(z20.unknown()),
-  videos: z20.array(z20.unknown()),
-  forums: z20.array(z20.unknown()),
-  organicResults: z20.array(SerpIntelligenceOrganicResultSchema),
-  localPack: z20.array(z20.unknown()),
-  entityIds: z20.object({
-    entities: z20.array(z20.object({
-      name: z20.string(),
-      kgId: z20.string().nullable(),
-      cid: z20.string().nullable(),
-      gcid: z20.string().nullable()
+  tree: z21.array(z21.unknown()),
+  flat: z21.array(z21.unknown()),
+  videos: z21.array(z21.unknown()),
+  forums: z21.array(z21.unknown()),
+  organicResults: z21.array(SerpIntelligenceOrganicResultSchema),
+  localPack: z21.array(z21.unknown()),
+  entityIds: z21.object({
+    entities: z21.array(z21.object({
+      name: z21.string(),
+      kgId: z21.string().nullable(),
+      cid: z21.string().nullable(),
+      gcid: z21.string().nullable()
     }).strict()),
-    kgIds: z20.array(z20.string()),
-    cids: z20.array(z20.string()),
-    gcids: z20.array(z20.string())
+    kgIds: z21.array(z21.string()),
+    cids: z21.array(z21.string()),
+    gcids: z21.array(z21.string())
   }).strict(),
-  stats: z20.object({
-    seed: z20.string(),
-    totalQuestions: z20.number().int().min(0),
-    maxDepthReached: z20.number().int().min(0),
-    durationMs: z20.number().min(0),
-    errorCount: z20.number().int().min(0)
+  stats: z21.object({
+    seed: z21.string(),
+    totalQuestions: z21.number().int().min(0),
+    maxDepthReached: z21.number().int().min(0),
+    durationMs: z21.number().min(0),
+    errorCount: z21.number().int().min(0)
   }).strict(),
-  diagnostics: z20.object({
-    completionStatus: z20.enum(["paa_found", "no_paa", "serp_only"]),
-    problem: z20.null(),
-    warnings: z20.array(z20.unknown()).optional(),
-    debug: z20.object({
+  diagnostics: z21.object({
+    completionStatus: z21.enum(["paa_found", "no_paa", "serp_only"]),
+    problem: z21.null(),
+    warnings: z21.array(z21.unknown()).optional(),
+    debug: z21.object({
       locationEvidence: SerpIntelligenceLocationEvidenceSchema.optional()
     }).passthrough().optional()
   }).passthrough(),
-  whatPeopleSaying: z20.array(z20.unknown())
+  whatPeopleSaying: z21.array(z21.unknown())
 }).strict();
-var SerpIntelligenceCaptureAttemptSchema = z20.object({
-  attemptNumber: z20.number().int().min(1),
-  outcome: z20.enum(SerpIntelligenceAttemptOutcomeValues),
-  startedAt: z20.string().optional(),
-  completedAt: z20.string().optional(),
-  durationMs: z20.number().min(0).optional(),
-  problemCode: z20.string().optional(),
-  message: z20.string().optional(),
-  kernelSessionId: z20.string().nullable().optional(),
-  cleanupSucceeded: z20.boolean().nullable().optional()
+var SerpIntelligenceCaptureAttemptSchema = z21.object({
+  attemptNumber: z21.number().int().min(1),
+  outcome: z21.enum(SerpIntelligenceAttemptOutcomeValues),
+  startedAt: z21.string().optional(),
+  completedAt: z21.string().optional(),
+  durationMs: z21.number().min(0).optional(),
+  problemCode: z21.string().optional(),
+  message: z21.string().optional(),
+  kernelSessionId: z21.string().nullable().optional(),
+  cleanupSucceeded: z21.boolean().nullable().optional()
 }).strict();
-var SerpPageSnapshotCaptureSchema = z20.object({
+var SerpPageSnapshotCaptureSchema = z21.object({
   url: SerpIntelligencePublicHttpUrlSchema,
   requestedUrl: SerpIntelligencePublicHttpUrlSchema,
   finalUrl: SerpIntelligencePublicHttpUrlSchema.nullable(),
-  sourceKind: z20.enum(SerpPageSnapshotSourceKindValues),
-  sourcePosition: z20.number().int().min(1).nullable(),
-  status: z20.enum(SerpPageFetchStatusValues),
-  fetchedVia: z20.enum(SerpPageFetchedViaValues).nullable(),
-  httpStatus: z20.number().int().min(100).max(599).nullable(),
-  contentType: z20.string().nullable(),
-  title: z20.string().nullable(),
+  sourceKind: z21.enum(SerpPageSnapshotSourceKindValues),
+  sourcePosition: z21.number().int().min(1).nullable(),
+  status: z21.enum(SerpPageFetchStatusValues),
+  fetchedVia: z21.enum(SerpPageFetchedViaValues).nullable(),
+  httpStatus: z21.number().int().min(100).max(599).nullable(),
+  contentType: z21.string().nullable(),
+  title: z21.string().nullable(),
   canonicalUrl: SerpIntelligencePublicHttpUrlSchema.nullable(),
-  metaDescription: z20.string().nullable(),
-  headings: z20.array(z20.object({
-    level: z20.number().int().min(1).max(6),
-    text: z20.string()
+  metaDescription: z21.string().nullable(),
+  headings: z21.array(z21.object({
+    level: z21.number().int().min(1).max(6),
+    text: z21.string()
   }).strict()).default([]),
-  artifact: z20.object({
-    htmlBlobUrl: z20.string().url().nullable(),
-    textBlobUrl: z20.string().url().nullable(),
-    markdownBlobUrl: z20.string().url().nullable(),
-    screenshotBlobUrl: z20.string().url().nullable(),
-    contentSha256: z20.string().nullable(),
-    capturedAt: z20.string().nullable()
+  artifact: z21.object({
+    htmlBlobUrl: z21.string().url().nullable(),
+    textBlobUrl: z21.string().url().nullable(),
+    markdownBlobUrl: z21.string().url().nullable(),
+    screenshotBlobUrl: z21.string().url().nullable(),
+    contentSha256: z21.string().nullable(),
+    capturedAt: z21.string().nullable()
   }).strict(),
-  error: z20.object({
-    code: z20.string(),
-    message: z20.string()
+  error: z21.object({
+    code: z21.string(),
+    message: z21.string()
   }).strict().nullable()
 }).strict();
-var SerpIntelligenceCaptureResponseSchema = z20.object({
+var SerpIntelligenceCaptureResponseSchema = z21.object({
   harvestResult: SerpIntelligenceHarvestResultSchema,
-  attempts: z20.array(SerpIntelligenceCaptureAttemptSchema),
+  attempts: z21.array(SerpIntelligenceCaptureAttemptSchema),
   locationEvidence: SerpIntelligenceLocationEvidenceSchema.nullable(),
-  pageSnapshotArtifacts: z20.array(SerpPageSnapshotCaptureSchema),
-  billing: z20.object({
-    creditsUsed: z20.number().min(0).optional(),
-    requestId: z20.string().optional(),
-    jobId: z20.string().optional()
+  pageSnapshotArtifacts: z21.array(SerpPageSnapshotCaptureSchema),
+  billing: z21.object({
+    creditsUsed: z21.number().min(0).optional(),
+    requestId: z21.string().optional(),
+    jobId: z21.string().optional()
   }).strict().optional()
 }).strict();
-var SerpIntelligencePageSnapshotsResponseSchema = z20.object({
-  pageSnapshotArtifacts: z20.array(SerpPageSnapshotCaptureSchema),
-  attempts: z20.array(SerpIntelligenceCaptureAttemptSchema).default([])
+var SerpIntelligencePageSnapshotsResponseSchema = z21.object({
+  pageSnapshotArtifacts: z21.array(SerpPageSnapshotCaptureSchema),
+  attempts: z21.array(SerpIntelligenceCaptureAttemptSchema).default([])
 }).strict();
 
 // src/serp-intelligence/serp-capture-service.ts
@@ -14606,7 +14851,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 Hono11();
+var serpIntelligenceApp = new Hono13();
 serpIntelligenceApp.use("*", createApiKeyAuth());
 function structuredError(input) {
   return {
@@ -14775,7 +15020,7 @@ serpIntelligenceApp.post("/page-snapshots", async (c) => {
 });
 
 // src/mcp/mcp-routes.ts
-import { Hono as Hono12 } from "hono";
+import { Hono as Hono14 } from "hono";
 import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
 
 // src/mcp/mcp-oauth.ts
@@ -14859,7 +15104,7 @@ async function requireMcpCallerKey(c) {
   if (!user) return mcpAuthError();
   return callerKey;
 }
-var mcpApp = new Hono12();
+var mcpApp = new Hono14();
 mcpApp.all("/", async (c) => {
   try {
     const keyOrError = await requireMcpCallerKey(c);
@@ -14883,7 +15128,7 @@ mcpApp.all("/", async (c) => {
 });
 
 // src/api/browser-agent-routes.ts
-import { Hono as Hono13 } from "hono";
+import { Hono as Hono15 } from "hono";
 
 // src/api/browser-agent-db.ts
 import { randomUUID as randomUUID2 } from "crypto";
@@ -16317,7 +16562,7 @@ async function loadOpenSession(id, userId) {
   return row;
 }
 function buildBrowserAgentRoutes() {
-  const app2 = new Hono13();
+  const app2 = new Hono15();
   app2.use("*", async (c, next) => {
     await migrateBrowserAgent();
     return next();
@@ -17023,161 +17268,9 @@ if (state.key) { refreshSessions(); if (state.current) selectSession(state.curre
 
 // src/api/stripe-routes.ts
 import Stripe from "stripe";
-import { Hono as Hono14 } from "hono";
-
-// src/api/memory.ts
-import { createCipheriv, createDecipheriv, randomBytes, scryptSync } from "crypto";
-
-// src/api/session.ts
-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();
-  if (configured) return configured;
-  if (isProduction()) throw new Error("SESSION_SECRET is not set \u2014 add it to your Vercel env vars (see src/api/env.ts)");
-  return "dev-secret-change-me";
-}
-var secret = () => getSessionSecret();
-function safeEqualHex(a, b) {
-  if (a.length !== b.length) return false;
-  try {
-    return timingSafeEqual(Buffer.from(a, "hex"), Buffer.from(b, "hex"));
-  } catch {
-    return false;
-  }
-}
-function signSession(userId) {
-  const payload = String(userId);
-  const sig = createHmac2("sha256", secret()).update(payload).digest("hex");
-  return `${payload}.${sig}`;
-}
-function verifySession(token) {
-  const dot = token.lastIndexOf(".");
-  if (dot === -1) return null;
-  const payload = token.slice(0, dot);
-  const sig = token.slice(dot + 1);
-  const expected = createHmac2("sha256", secret()).update(payload).digest("hex");
-  if (!safeEqualHex(sig, expected)) return null;
-  const id = parseInt(payload);
-  return isNaN(id) ? null : id;
-}
-
-// src/api/memory.ts
-var MEMORY_BASE_URL = () => (process.env.MCP_MEMORY_BASE_URL ?? "https://mcp-memory-omega.vercel.app").replace(/\/$/, "");
-var ADMIN_KEY = () => process.env.MCP_MEMORY_ADMIN_KEY?.trim() ?? "";
-function isMemoryOperator(email) {
-  if (!email) return false;
-  const ops = (process.env.MEMORY_OPERATOR_IDENTITIES ?? "").split(",").map((s) => s.trim().toLowerCase()).filter(Boolean);
-  return ops.includes(email.trim().toLowerCase());
-}
-function encKey() {
-  return scryptSync(getSessionSecret(), "mcp-memory-key-v1", 32);
-}
-function encryptMemoryKey(secret2) {
-  const iv = randomBytes(12);
-  const cipher = createCipheriv("aes-256-gcm", encKey(), iv);
-  const enc = Buffer.concat([cipher.update(secret2, "utf8"), cipher.final()]);
-  const tag = cipher.getAuthTag();
-  return `${iv.toString("base64")}:${tag.toString("base64")}:${enc.toString("base64")}`;
-}
-function decryptMemoryKey(stored) {
-  try {
-    const [ivB, tagB, dataB] = stored.split(":");
-    const decipher = createDecipheriv("aes-256-gcm", encKey(), Buffer.from(ivB, "base64"));
-    decipher.setAuthTag(Buffer.from(tagB, "base64"));
-    return Buffer.concat([decipher.update(Buffer.from(dataB, "base64")), decipher.final()]).toString("utf8");
-  } catch {
-    return null;
-  }
-}
-async function memoryCall(toolName, args, userMemoryKey) {
-  try {
-    const res = await fetch(`${MEMORY_BASE_URL()}/api/mcp/memoryServer/tools/${toolName}/execute`, {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify({ data: { ...args, apiKey: userMemoryKey } })
-    });
-    const body = await res.json().catch(() => null);
-    if (!res.ok) return { ok: false, error: body?.error ?? `memory ${toolName} failed (${res.status})` };
-    if (body?.result) return body.result;
-    return { ok: false, error: body?.error ?? `memory ${toolName} returned no result` };
-  } catch (err) {
-    return { ok: false, error: err?.message ?? "memory call failed" };
-  }
-}
-function personalVault(user) {
-  return `mcp-${user.id}`;
-}
-function memoryIdentity(user) {
-  return user.email;
-}
-function resolveMemoryIdentity(user) {
-  return memoryIdentity(user);
-}
-function memoryPlanForReads(user) {
-  if (isMemoryOperator(user.email)) return "unlimited";
-  if (user.memory_plan === "pro" || user.memory_plan === "team") return user.memory_plan;
-  return "free";
-}
-async function provisionMemoryForUser(user) {
-  try {
-    const { key } = await getOrCreateUserMemoryKey(user);
-    if (key) await setMemoryProvisioned(user.id, true);
-  } catch {
-  }
-}
-async function getOrCreateUserMemoryKey(user) {
-  const creds = await getUserMemoryCreds(user.id);
-  if (creds.memory_key) {
-    const decrypted = decryptMemoryKey(creds.memory_key);
-    if (decrypted) return { key: decrypted };
-  }
-  const admin = ADMIN_KEY();
-  if (!admin) return { key: null, error: "memory not configured (MCP_MEMORY_ADMIN_KEY missing)" };
-  const identity = memoryIdentity(user);
-  const plan = isMemoryOperator(user.email) ? "unlimited" : (await getMemoryPlan(user.id)).plan;
-  const provisioned = await memoryCall(
-    "provisionDefaultsTool",
-    { granteeIdentity: identity, issueKey: true, plan },
-    admin
-  );
-  if (!provisioned.ok || !provisioned.secret) {
-    return { key: null, error: provisioned.error ?? "failed to provision default vaults" };
-  }
-  await setUserMemoryCreds(user.id, encryptMemoryKey(provisioned.secret), identity);
-  return { key: provisioned.secret };
-}
-async function syncMemoryKeyPlan(user, plan) {
-  const effectivePlan = isMemoryOperator(user.email) ? "unlimited" : plan;
-  const { key, error } = await getOrCreateUserMemoryKey(user);
-  if (!key) return { ok: false, error: error ?? "memory unavailable" };
-  const listed = await memoryCall(
-    "listKeysTool",
-    {},
-    key
-  );
-  if (!listed.ok || !listed.keys?.length) return { ok: false, error: listed.error ?? "no memory keys found" };
-  const target = listed.keys[0];
-  if (target.plan === effectivePlan) return { ok: true };
-  const res = await memoryCall("setScopeTool", { keyId: target.keyId, plan: effectivePlan }, key);
-  return { ok: res.ok, error: res.error };
-}
-async function syncScheduleEntitlement(user, enabled, quotaPerPeriod) {
-  const admin = ADMIN_KEY();
-  if (!admin) return { ok: false, error: "memory not configured (MCP_MEMORY_ADMIN_KEY missing)" };
-  const identity = resolveMemoryIdentity(user);
-  const res = await memoryCall("setScheduleEntitlementTool", {
-    granteeIdentity: identity,
-    enabled,
-    quotaPerPeriod,
-    mcpScraperApiKey: user.api_key
-  }, admin);
-  return { ok: res.ok, error: res.error };
-}
-
-// src/api/stripe-routes.ts
+import { Hono as Hono16 } from "hono";
 var stripe = new Stripe(process.env.STRIPE_SECRET_KEY, { apiVersion: "2026-02-25.clover" });
-var stripeApp = new Hono14();
+var stripeApp = new Hono16();
 stripeApp.post("/webhooks", async (c) => {
   const sig = c.req.header("stripe-signature");
   const body = await c.req.text();
@@ -17277,7 +17370,7 @@ async function resolveUser(customerId, emailFallback) {
 }
 
 // src/api/oauth-routes.ts
-import { Hono as Hono15 } from "hono";
+import { Hono as Hono17 } from "hono";
 import { getCookie, setCookie } from "hono/cookie";
 import { createHash as createHash3, randomBytes as randomBytes2, randomUUID as randomUUID3 } from "crypto";
 import { importPKCS8, exportJWK, SignJWT } from "jose";
@@ -17294,6 +17387,7 @@ function isScraperResource(resource) {
 var ACCESS_TTL_SECONDS = 3600;
 var REFRESH_TTL_SECONDS = 60 * 60 * 24 * 30;
 var CODE_TTL_SECONDS = 60;
+var ROTATION_GRACE_SECONDS = 120;
 var secureCookies = process.env.NODE_ENV === "production" || process.env.VERCEL === "1";
 var sessionCookieOptions = {
   httpOnly: true,
@@ -17445,7 +17539,7 @@ function redirectWithError(redirectUri, state, error) {
   if (state) u.searchParams.set("state", state);
   return new Response(null, { status: 302, headers: { Location: u.toString() } });
 }
-var oauthApp = new Hono15();
+var oauthApp = new Hono17();
 oauthApp.use("*", async (c, next) => {
   c.header("Access-Control-Allow-Origin", "*");
   c.header("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
@@ -17669,6 +17763,13 @@ oauthApp.post("/oauth/token", async (c) => {
     const refreshToken = get("refresh_token") ?? "";
     const clientId = get("client_id") ?? "";
     const record = await getRefresh(refreshToken);
+    if (record && record.revoked && record.replaced_by && record.rotated_at && Date.now() - new Date(record.rotated_at).getTime() < ROTATION_GRACE_SECONDS * 1e3 && (!clientId || record.client_id === clientId)) {
+      const graceUser = await getUserByEmail(record.identity);
+      const gracePlan = graceUser ? resolvePlan(graceUser) : "free";
+      const graceAudience = record.resource ?? RESOURCE();
+      const graceAccess = await mintAccessToken(record.identity, record.scope, gracePlan, graceAudience);
+      return c.json({ access_token: graceAccess, token_type: "Bearer", expires_in: ACCESS_TTL_SECONDS, refresh_token: record.replaced_by, scope: record.scope });
+    }
     if (!record || record.revoked) return tokenErrorResponse(c, "invalid_grant", "Refresh token is invalid or revoked", 400);
     if (new Date(record.expires_at).getTime() < Date.now()) return tokenErrorResponse(c, "invalid_grant", "Refresh token has expired", 400);
     if (clientId && record.client_id !== clientId) return tokenErrorResponse(c, "invalid_grant", "client_id mismatch", 400);
@@ -17692,8 +17793,8 @@ oauthApp.post("/oauth/token", async (c) => {
 });
 
 // src/api/chat-routes.ts
-import { Hono as Hono16 } from "hono";
-var chatApp = new Hono16();
+import { Hono as Hono18 } from "hono";
+var chatApp = new Hono18();
 function tokenOk(token) {
   return !!token && token.startsWith("mk_") && token.length > 10;
 }
@@ -18363,8 +18464,8 @@ loadChannels();
 }
 
 // src/api/schedule-routes.ts
-import { Hono as Hono17 } from "hono";
-var scheduleApp = new Hono17();
+import { Hono as Hono19 } from "hono";
+var scheduleApp = new Hono19();
 function tokenOk2(token) {
   return !!token && token.startsWith("mk_") && token.length > 10;
 }
@@ -19119,7 +19220,7 @@ var sessionAuth = createMiddleware3(async (c, next) => {
   c.set("sessionUser", { ...refreshed, balance_mc: balanceMc });
   return next();
 });
-var app = new Hono18();
+var app = new Hono20();
 var STRIPE_API_VERSION = "2026-02-25.clover";
 function requireStripeSecret() {
   const secret2 = process.env.STRIPE_SECRET_KEY?.trim();
@@ -19164,6 +19265,7 @@ function opForCostPath(p) {
   if (p.startsWith("/instagram/")) return "instagram";
   if (p === "/reddit/thread") return "reddit_thread";
   if (p.startsWith("/api/internal/site-architecture-auditor")) return "audit_site";
+  if (p.startsWith("/api/internal/memory")) return "memory_ai";
   if (p.startsWith("/agent/")) return "browser_session";
   return null;
 }
@@ -19241,6 +19343,27 @@ app.post("/auth/logout", requireAllowedOrigin, (c) => {
   deleteCookie(c, "session", { path: "/", secure: secureCookies2, sameSite: "Strict" });
   return c.json({ ok: true });
 });
+app.post("/account/delete", requireAllowedOrigin, sessionAuth, async (c) => {
+  const user = c.get("sessionUser");
+  const secret2 = requireStripeSecret();
+  if (secret2 && user.stripe_customer_id) {
+    const stripeClient = new Stripe2(secret2, { apiVersion: STRIPE_API_VERSION });
+    const subs = await stripeClient.subscriptions.list({ customer: user.stripe_customer_id, status: "all", limit: 100 });
+    for (const sub of subs.data) {
+      if (sub.status === "active" || sub.status === "trialing" || sub.status === "past_due") {
+        try {
+          await stripeClient.subscriptions.cancel(sub.id);
+        } catch (err) {
+          console.error("[account/delete] failed to cancel subscription", sub.id, err instanceof Error ? err.message : String(err));
+          return c.json({ error: "Could not cancel an active subscription \u2014 please try again or contact support." }, 500);
+        }
+      }
+    }
+  }
+  await deactivateUser(user.id);
+  deleteCookie(c, "session", { path: "/", secure: secureCookies2, sameSite: "Strict" });
+  return c.json({ ok: true });
+});
 app.post("/auth/forgot-password", requireAllowedOrigin, async (c) => {
   const { email } = await c.req.json();
   const normalizedEmail = email?.trim().toLowerCase();
@@ -20263,6 +20386,24 @@ app.post("/billing/subscribe", requireAllowedOrigin, sessionAuth, async (c) => {
     return c.json({ error: message }, 500);
   }
 });
+app.post("/billing/portal", requireAllowedOrigin, sessionAuth, async (c) => {
+  try {
+    const user = c.get("sessionUser");
+    if (!user.stripe_customer_id) return c.json({ error: "No billing account yet \u2014 subscribe first." }, 409);
+    const secret2 = requireStripeSecret();
+    if (!secret2) return c.json({ error: "Stripe is not configured." }, 503);
+    const stripeClient = new Stripe2(secret2, { apiVersion: STRIPE_API_VERSION });
+    const session = await stripeClient.billingPortal.sessions.create({
+      customer: user.stripe_customer_id,
+      return_url: `${appOrigin()}/billing`
+    });
+    return c.json({ url: session.url });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Unable to open billing portal.";
+    console.error("[billing/portal]", message);
+    return c.json({ error: message }, 500);
+  }
+});
 app.post("/billing/concurrency/terminal-checkout", auth2, async (c) => {
   try {
     const user = c.get("user");
@@ -20431,7 +20572,7 @@ 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-FNSBPP7Y.js");
+  const { drainQueue } = await import("./worker-4CVMSUZR.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, reapResult, expiredResult, blobCleanup] = await Promise.all([
@@ -20445,12 +20586,14 @@ app.get("/cron/tick", async (c) => {
 });
 app.on(["GET", "POST", "PUT"], "/api/inngest", serveInngest({ client: inngest, functions: [siteAuditFn, siteExtractFn] }));
 app.route("/api/internal/site-architecture-auditor", siteAuditApp);
+app.route("/api/internal/memory", internalMemoryApp);
 app.route("/youtube", youtubeApp);
 app.route("/screenshot", screenshotApp);
 app.route("/facebook", facebookAdApp);
 app.route("/google-ads", googleAdsApp);
 app.route("/instagram", instagramApp);
 app.route("/reddit", redditApp);
+app.route("/video", videoApp);
 app.route("/maps", mapsApp);
 app.route("/directory", directoryApp);
 app.route("/workflows", workflowApp);
@@ -20582,4 +20725,4 @@ app.get("/blog/:slug/", (c) => {
 export {
   app
 };
-//# sourceMappingURL=server-CZT7EULY.js.map
+//# sourceMappingURL=server-MKUN6NQZ.js.map