mcp-scraper 0.7.0 → 0.9.0

package/dist/{server-JNY4XPZE.js → server-E34MNLI3.js}

@@ -22,6 +22,7 @@ import {
 import {
   HttpMcpToolExecutor,
   MemoryMcpToolExecutor,
+  buildLinkGraph,
   buildPaaExtractorMcpServer,
   configureReportSaving,
   exportFanout,
@@ -33,11 +34,13 @@ import {
   registerSerpIntelligenceCaptureTools,
   sanitizeAttempts,
   sanitizeHarvestResult
-} from "./chunk-YGRZU7IR.js";
+} from "./chunk-FZG427QD.js";
 import {
   auditImages,
+  buildLinkReport,
+  computeIssues,
   getBlobStore
-} from "./chunk-GWRIO6JT.js";
+} from "./chunk-R7EETU7Z.js";
 import {
   browserServiceApiKey,
   browserServiceProfileName,
@@ -67,7 +70,7 @@ import {
   RawMapsOverviewSchema,
   RawMapsReviewStatsSchema
 } from "./chunk-XGIPATLV.js";
-import "./chunk-EGWJ74EX.js";
+import "./chunk-RD5JOAWS.js";
 import {
   completeExtractJob,
   countSuccessfulPages,
@@ -4780,7 +4783,8 @@ async function spiderSite(opts) {
     totalFound: results.length,
     durationMs: Date.now() - startMs,
     truncated: queue.length > 0 || results.length >= maxUrls,
-    browserRetries
+    browserRetries,
+    sitemapUrls: sitemapUrls.slice(0, maxUrls)
   };
 }
 
@@ -4904,6 +4908,23 @@ async function crawlWithRotation(urls, opts) {
   return urls.map((u) => byUrl.get(u) ?? { url: u, html: null, status: 0, via: "browser" });
 }
 
+// src/api/seo-audit.ts
+function buildSeoAudit(pages, startUrl) {
+  const { edges, metrics } = buildLinkGraph(pages, startUrl);
+  const issues = computeIssues(pages, metrics);
+  const { summary } = buildLinkReport(edges, [...metrics.values()], startUrl);
+  return {
+    issues,
+    linkSummary: summary,
+    pageMetrics: [...metrics.values()].map((m) => ({
+      url: m.url,
+      inboundInternal: m.inlinks,
+      outboundInternal: m.outlinksInternal,
+      orphan: m.orphan
+    }))
+  };
+}
+
 // src/api/site-extractor.ts
 var PIXEL_WIDTHS = { i: 4, l: 4, j: 4, ".": 4, ",": 4, "'": 4, t: 6, f: 6, r: 6, " ": 4, m: 14, w: 13, W: 16, M: 16 };
 function estimatePixels(s) {
@@ -4947,6 +4968,7 @@ function emptyPageData(url, status, via) {
     imageLinks: [],
     indexable: status === 200,
     indexabilityReason: status === 200 ? null : "non-200",
+    inSitemap: null,
     schemaTypes: [],
     canonicalUrl: null,
     internalLinks: 0,
@@ -4963,7 +4985,8 @@ function makeSeedSpider(startUrl, urls) {
     totalFound: urls.length,
     durationMs: 0,
     truncated: false,
-    browserRetries: 0
+    browserRetries: 0,
+    sitemapUrls: []
   };
 }
 var UA2 = "Mozilla/5.0 (compatible; ThorbitBot/1.0; +https://thorbit.ai)";
@@ -5134,6 +5157,7 @@ function parsePageData(url, html, status, via, resp) {
     imageLinks,
     indexable,
     indexabilityReason,
+    inSitemap: null,
     schemaTypes,
     canonicalUrl,
     internalLinks,
@@ -5147,11 +5171,11 @@ async function extractPagesRotating(urls, opts) {
   const fetched = await crawlWithRotation(urls, { apiKey: opts.kernelApiKey, concurrency: opts.concurrency, urlsPerBrowser: opts.urlsPerBrowser });
   return fetched.map((r) => r.html ? parsePageData(r.url, r.html, r.status || 200, "browser", { headers: r.headers, responseTimeMs: r.responseTimeMs, redirectUrl: r.redirectUrl }) : emptyPageData(r.url, r.status || null, "browser"));
 }
-async function discoverUrls(startUrl, maxPages, kernelApiKey) {
+async function discoverUrlsWithSitemap(startUrl, maxPages, kernelApiKey) {
   const sitemapUrls = await discoverSitemapUrls2(startUrl, maxPages);
-  if (sitemapUrls.length > 0) return sitemapUrls;
+  if (sitemapUrls.length > 0) return { urls: sitemapUrls, sitemapUrls };
   const spider = await spiderSite({ startUrl, maxUrls: maxPages, concurrency: 12, kernelApiKey });
-  return spider.urls.filter((u) => u.status === 200 || u.status === null).slice(0, maxPages).map((u) => u.url);
+  return { urls: spider.urls.filter((u) => u.status === 200 || u.status === null).slice(0, maxPages).map((u) => u.url), sitemapUrls: spider.sitemapUrls };
 }
 async function fetchAndParse(url, kernelApiKey) {
   const startedAt = Date.now();
@@ -5210,6 +5234,7 @@ async function extractSite(opts) {
   let browserRetries = 0;
   let truncated = false;
   let spider;
+  let sitemapUrls = [];
   if (rotating) {
     const browserConcurrency = Math.max(1, Math.min(opts.parallelism ?? 1, 8));
     const urlsPerBrowser = opts.rotateProxyEvery ?? 10;
@@ -5227,7 +5252,8 @@ async function extractSite(opts) {
       for (const u of opts.seedUrls) enqueue(u);
     } else {
       enqueue(opts.startUrl);
-      for (const u of await discoverSitemapUrls2(opts.startUrl, maxPages)) enqueue(u);
+      sitemapUrls = await discoverSitemapUrls2(opts.startUrl, maxPages);
+      for (const u of sitemapUrls) enqueue(u);
     }
     const waveCap = Math.max(browserConcurrency * urlsPerBrowser, 30);
     let done = 0;
@@ -5256,6 +5282,7 @@ async function extractSite(opts) {
     spider = makeSeedSpider(opts.startUrl, [...seen]);
   } else {
     spider = seeded ? makeSeedSpider(opts.startUrl, opts.seedUrls) : await spiderSite({ startUrl: opts.startUrl, maxUrls: maxPages, concurrency: 12, kernelApiKey: opts.kernelApiKey });
+    sitemapUrls = spider.sitemapUrls;
     const urlsToExtract = spider.urls.filter((u) => u.status === 200 || u.status === null).slice(0, maxPages).map((u) => u.url);
     browserRetries = spider.browserRetries;
     await runWithConcurrency(urlsToExtract, concurrency, async (url) => {
@@ -5265,10 +5292,17 @@ async function extractSite(opts) {
     });
     truncated = spider.truncated || pages.length >= maxPages;
   }
+  const sitemapSet = sitemapUrls.length > 0 ? new Set(sitemapUrls.map((u) => normalizeUrl(u, opts.startUrl) ?? u)) : null;
+  for (const p of pages) p.inSitemap = sitemapSet ? sitemapSet.has(normalizeUrl(p.url, opts.startUrl) ?? p.url) : null;
   let branding = null;
   if (opts.formats?.includes("branding") && opts.kernelApiKey) {
     branding = await extractBranding(opts.startUrl, opts.kernelApiKey).catch(() => null);
   }
+  const seoAudit = opts.formats?.includes("issues") ? buildSeoAudit(pages, opts.startUrl) : null;
+  let imageAudit = null;
+  if (opts.formats?.includes("images")) {
+    imageAudit = await auditImages(pages, { concurrency: 12, timeoutMs: 12e3 });
+  }
   return {
     startUrl: opts.startUrl,
     pages,
@@ -5277,7 +5311,9 @@ async function extractSite(opts) {
     durationMs: Date.now() - startMs,
     truncated,
     browserRetries,
-    branding
+    branding,
+    seoAudit,
+    imageAudit
   };
 }
 
@@ -7519,12 +7555,13 @@ var siteExtractFn = inngest.createFunction(
     const maxPages = Number(job.options.maxPages ?? 1e4);
     const concurrency = Number(job.options.concurrency ?? 1);
     const urlsPerBrowser = Number(job.options.urlsPerBrowser ?? job.options.rotateProxyEvery ?? 10);
-    const seed = await step.run("discover", async () => {
-      const discovered = await discoverUrls(job.startUrl, maxPages, key);
-      const out = discovered.length ? discovered : [job.startUrl];
-      await setExtractJobTotal(jobId, out.length);
-      return out;
+    const seedRaw = await step.run("discover", async () => {
+      const discovered = await discoverUrlsWithSitemap(job.startUrl, maxPages, key);
+      const urls = discovered.urls.length ? discovered.urls : [job.startUrl];
+      await setExtractJobTotal(jobId, urls.length);
+      return { urls, sitemapUrls: discovered.sitemapUrls };
     });
+    const seed = Array.isArray(seedRaw) ? { urls: seedRaw, sitemapUrls: [] } : seedRaw;
     const siteHost = (() => {
       try {
         return new URL(job.startUrl).hostname.replace(/^www\./, "");
@@ -7548,8 +7585,9 @@ var siteExtractFn = inngest.createFunction(
         return false;
       }
     };
-    const queue = [...seed];
-    const seen = new Set(seed.map(norm));
+    const sitemapSet = seed.sitemapUrls.length > 0 ? new Set(seed.sitemapUrls.map(norm)) : null;
+    const queue = [...seed.urls];
+    const seen = new Set(seed.urls.map(norm));
     let crawled = 0;
     const MAX_BATCHES = Math.ceil(maxPages / BATCH) + 30;
     for (let i = 0; i < MAX_BATCHES && crawled < maxPages && crawled < queue.length; i++) {
@@ -7557,7 +7595,7 @@ var siteExtractFn = inngest.createFunction(
       if (!batch.length) break;
       const newLinks = await step.run(`crawl-batch-${i}`, async () => {
         const pages = await extractPagesRotating(batch, { kernelApiKey: key, concurrency, urlsPerBrowser });
-        await saveExtractPages(jobId, pages);
+        await saveExtractPages(jobId, pages.map((p) => ({ ...p, inSitemap: sitemapSet ? sitemapSet.has(norm(p.url)) : null })));
         const found = [];
         for (const p of pages) for (const l of p.outlinks ?? []) {
           if (l.internal && l.href && sameSite(l.href)) found.push(l.href);
@@ -7581,9 +7619,13 @@ var siteExtractFn = inngest.createFunction(
       const pages = await getExtractedPages(jobId);
       return auditImages(pages, { concurrency: 12, timeoutMs: 12e3 });
     }) : null;
+    const seoAudit = Array.isArray(job.options.formats) && job.options.formats.includes("issues") ? await step.run("seo-audit", async () => {
+      const pages = await getExtractedPages(jobId);
+      return buildSeoAudit(pages, job.startUrl);
+    }) : null;
     const artifacts = await step.run("finalize", async () => {
-      const { assembleExtractArtifacts } = await import("./extract-bundle-COS56ZDO.js");
-      const stored = await assembleExtractArtifacts(job, { branding, imageAudit });
+      const { assembleExtractArtifacts } = await import("./extract-bundle-U4D5LW5W.js");
+      const stored = await assembleExtractArtifacts(job, { branding, imageAudit, seoAudit });
       await completeExtractJob(jobId, stored);
       return stored;
     });
@@ -9089,7 +9131,7 @@ var ExtractSiteBodySchema = z11.object({
   rotateProxies: z11.boolean().optional(),
   rotateProxyEvery: z11.number().int().min(1).max(100).optional(),
   background: z11.boolean().optional(),
-  formats: z11.array(z11.enum(["markdown", "links", "json", "images", "branding"])).optional()
+  formats: z11.array(z11.enum(["markdown", "links", "json", "images", "branding", "issues"])).optional()
 });
 var YoutubeHarvestBodySchema = z11.object({
   mode: z11.enum(["search", "channel"]),
@@ -20351,6 +20393,306 @@ async function dbUsage(identity, plan) {
   };
 }
 
+// src/api/nango-control.ts
+var DEFAULT_NANGO_CONTROL_URL = "https://mcp-scraper-scheduler.vercel.app";
+var DISABLED_NANGO_TOOLS = {
+  "google-mail": /* @__PURE__ */ new Set(["list-filters"]),
+  slack: /* @__PURE__ */ new Set(["search-files", "search-messages"])
+};
+var NangoControlError = class extends Error {
+  status;
+  constructor(message, status = 502) {
+    super(message);
+    this.name = "NangoControlError";
+    this.status = status;
+  }
+};
+var ScheduleConnectionValidationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ScheduleConnectionValidationError";
+  }
+};
+function controlBaseUrl() {
+  return (process.env.NANGO_CONTROL_URL?.trim() || DEFAULT_NANGO_CONTROL_URL).replace(/\/$/, "");
+}
+function controlSecret() {
+  const secret2 = process.env.SCHEDULE_INTEGRATIONS_SECRET?.trim();
+  if (!secret2) throw new NangoControlError("Scheduled service connections are not configured.", 503);
+  return secret2;
+}
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function unwrapData(value) {
+  if (isRecord(value) && isRecord(value.data)) return value.data;
+  return value;
+}
+function cleanString(value, max = 300) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed ? trimmed.slice(0, max) : null;
+}
+function firstString(record, keys, max = 300) {
+  for (const key of keys) {
+    const value = cleanString(record[key], max);
+    if (value) return value;
+  }
+  return null;
+}
+function cleanTools(value) {
+  if (!Array.isArray(value)) return [];
+  const tools = value.map((tool) => cleanString(tool, 200)).filter((tool) => !!tool);
+  return [...new Set(tools)].slice(0, 200);
+}
+function cleanStringArray(value, maxItems = 20, maxLength = 100) {
+  if (!Array.isArray(value)) return [];
+  const items = value.map((item) => cleanString(item, maxLength)).filter((item) => !!item);
+  return [...new Set(items)].slice(0, maxItems);
+}
+function cleanHttpsUrl(value) {
+  const candidate = cleanString(value, 2e3);
+  if (!candidate) return null;
+  try {
+    const url = new URL(candidate);
+    return url.protocol === "https:" ? url.toString() : null;
+  } catch {
+    return null;
+  }
+}
+function arrayFromPayload(value, keys) {
+  const unwrapped = unwrapData(value);
+  if (Array.isArray(unwrapped)) return unwrapped;
+  if (!isRecord(unwrapped)) return [];
+  for (const key of keys) {
+    if (Array.isArray(unwrapped[key])) return unwrapped[key];
+  }
+  return [];
+}
+async function controlRequest(path5, init) {
+  const response = await fetch(`${controlBaseUrl()}${path5}`, {
+    ...init,
+    headers: {
+      accept: "application/json",
+      authorization: `Bearer ${controlSecret()}`,
+      ...init?.body ? { "content-type": "application/json" } : {},
+      ...init?.headers ?? {}
+    },
+    signal: AbortSignal.timeout(2e4)
+  }).catch((err) => {
+    throw new NangoControlError(`Scheduled service connection control is unavailable: ${err instanceof Error ? err.message : "network error"}`);
+  });
+  const text = await response.text();
+  let body = {};
+  try {
+    body = text ? JSON.parse(text) : {};
+  } catch {
+    body = {};
+  }
+  if (!response.ok) {
+    const upstream = isRecord(body) ? cleanString(body.error, 300) : null;
+    throw new NangoControlError(upstream || `Scheduled service connection control failed (${response.status}).`);
+  }
+  return body;
+}
+function sanitizeScheduleConnectionSelections(value) {
+  if (value == null) return [];
+  if (!Array.isArray(value)) throw new ScheduleConnectionValidationError("connections must be an array.");
+  if (value.length > 20) throw new ScheduleConnectionValidationError("A scheduled action can use at most 20 service connections.");
+  const selections = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of value) {
+    if (!isRecord(item)) throw new ScheduleConnectionValidationError("Each service connection must be an object.");
+    const connectionId = firstString(item, ["connectionId", "connection_id"]);
+    const providerConfigKey = firstString(item, ["providerConfigKey", "provider_config_key", "integrationId", "integration_id"]);
+    const allowedTools = cleanTools(item.allowedTools ?? item.allowed_tools ?? item.allowedCapabilities ?? item.allowed_capabilities);
+    if (!connectionId || !providerConfigKey) throw new ScheduleConnectionValidationError("Each service connection needs a connectionId and providerConfigKey.");
+    if (allowedTools.length === 0) throw new ScheduleConnectionValidationError("Each selected service needs at least one allowed tool.");
+    const key = `${providerConfigKey}:${connectionId}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    selections.push({ connectionId, providerConfigKey, allowedTools });
+  }
+  return selections;
+}
+async function getNangoCatalog() {
+  const body = await controlRequest("/api/internal/nango/catalog");
+  const rows = arrayFromPayload(body, ["providers", "catalog", "integrations", "services"]);
+  const result = [];
+  for (const row of rows) {
+    if (!isRecord(row)) continue;
+    const providerConfigKey = firstString(row, ["providerConfigKey", "provider_config_key", "integrationId", "integration_id", "id"]);
+    if (!providerConfigKey) continue;
+    const provider = firstString(row, ["provider"]);
+    const label = firstString(row, ["label", "displayName", "display_name", "name"]) || providerConfigKey;
+    const description = firstString(row, ["description"], 500);
+    const logoUrl = cleanHttpsUrl(row.logoUrl ?? row.logo_url ?? row.logo);
+    const docsUrl = cleanHttpsUrl(row.docsUrl ?? row.docs_url ?? row.docs);
+    const authMode = firstString(row, ["authMode", "auth_mode"], 100);
+    const categories = cleanStringArray(row.categories);
+    const disabledTools = DISABLED_NANGO_TOOLS[providerConfigKey];
+    const safeDefaultAllowedTools = cleanTools(
+      row.safeDefaultAllowedTools ?? row.safe_default_allowed_tools ?? row.defaultAllowedTools ?? row.default_allowed_tools ?? row.allowedTools ?? row.allowed_tools
+    ).filter((tool) => !disabledTools?.has(tool));
+    result.push({
+      providerConfigKey,
+      provider,
+      label,
+      description,
+      logoUrl,
+      docsUrl,
+      authMode,
+      categories,
+      safeDefaultAllowedTools
+    });
+  }
+  return result;
+}
+async function getNangoConnections(identity) {
+  const query = new URLSearchParams({ identity }).toString();
+  const body = await controlRequest(`/api/internal/nango/connections?${query}`);
+  const rows = arrayFromPayload(body, ["connections"]);
+  const result = [];
+  for (const row of rows) {
+    if (!isRecord(row)) continue;
+    const connectionId = firstString(row, ["connectionId", "connection_id", "id"]);
+    const providerConfigKey = firstString(row, ["providerConfigKey", "provider_config_key", "integrationId", "integration_id", "provider"]);
+    if (!connectionId || !providerConfigKey) continue;
+    const provider = firstString(row, ["provider"]);
+    const label = firstString(row, ["label", "accountLabel", "account_label", "displayName", "display_name", "endUserEmail", "end_user_email"]) || providerConfigKey;
+    const rawStatus = firstString(row, ["status"], 64) || "connected";
+    const reconnectRequired = row.reconnectRequired === true || row.reconnect_required === true || rawStatus === "needs_reauth" || rawStatus === "reauth_required" || rawStatus === "invalid" || rawStatus === "error" || rawStatus === "revoked" || rawStatus === "disabled";
+    result.push({
+      connectionId,
+      providerConfigKey,
+      provider,
+      label,
+      status: reconnectRequired ? "needs_reauth" : "connected",
+      reconnectRequired,
+      actionsEnabled: row.actionsEnabled === true || row.actions_enabled === true,
+      createdAt: firstString(row, ["createdAt", "created_at"], 100),
+      updatedAt: firstString(row, ["updatedAt", "updated_at"], 100)
+    });
+  }
+  return result;
+}
+function sanitizeConnectSession(body) {
+  const data = unwrapData(body);
+  if (!isRecord(data)) throw new NangoControlError("The connection service returned an invalid connect session.");
+  const connectLink = firstString(data, ["connectLink", "connect_link"], 2e3);
+  if (!connectLink) throw new NangoControlError("The connection service did not return a connect link.");
+  return {
+    connectLink,
+    sessionToken: firstString(data, ["sessionToken", "session_token", "token"], 2e3),
+    expiresAt: firstString(data, ["expiresAt", "expires_at"], 100)
+  };
+}
+async function createNangoConnectSession(identity, providerConfigKey) {
+  const body = await controlRequest("/api/internal/nango/connect-session", {
+    method: "POST",
+    body: JSON.stringify({ identity, email: identity, provider: providerConfigKey })
+  });
+  return sanitizeConnectSession(body);
+}
+async function createNangoReconnectSession(identity, connectionId) {
+  const body = await controlRequest("/api/internal/nango/reconnect-session", {
+    method: "POST",
+    body: JSON.stringify({ identity, connectionId, email: identity })
+  });
+  return sanitizeConnectSession(body);
+}
+function sanitizeBindingRows(body, defaultScheduleActionId) {
+  const data = unwrapData(body);
+  const flattened = [];
+  if (isRecord(data) && isRecord(data.bindings) && !Array.isArray(data.bindings)) {
+    for (const [scheduleActionId, value] of Object.entries(data.bindings)) {
+      if (Array.isArray(value)) value.forEach((row) => flattened.push({ row, scheduleActionId }));
+    }
+  } else {
+    const rows = arrayFromPayload(data, ["bindings", "connections"]);
+    for (const row of rows) {
+      if (isRecord(row) && Array.isArray(row.connections)) {
+        const scheduleActionId = firstString(row, ["scheduleActionId", "schedule_action_id", "scheduleId", "schedule_id"]) || defaultScheduleActionId;
+        row.connections.forEach((connection) => flattened.push({ row: connection, scheduleActionId }));
+      } else {
+        flattened.push({ row, scheduleActionId: defaultScheduleActionId });
+      }
+    }
+  }
+  const result = [];
+  for (const item of flattened) {
+    if (!isRecord(item.row)) continue;
+    const connectionId = firstString(item.row, ["connectionId", "connection_id"]);
+    const providerConfigKey = firstString(item.row, ["providerConfigKey", "provider_config_key", "integrationId", "integration_id", "provider"]);
+    if (!connectionId || !providerConfigKey) continue;
+    result.push({
+      scheduleActionId: firstString(item.row, ["scheduleActionId", "schedule_action_id", "scheduleId", "schedule_id"]) || item.scheduleActionId,
+      connectionId,
+      providerConfigKey,
+      allowedTools: cleanTools(item.row.allowedTools ?? item.row.allowed_tools ?? item.row.allowedCapabilities ?? item.row.allowed_capabilities),
+      label: firstString(item.row, ["label", "accountLabel", "account_label", "displayName", "display_name"])
+    });
+  }
+  return result;
+}
+async function getScheduleConnectionBindings(identity, scheduleActionId) {
+  const query = new URLSearchParams({ identity, scheduleId: scheduleActionId });
+  const body = await controlRequest(`/api/internal/nango/bindings?${query.toString()}`);
+  return sanitizeBindingRows(body, scheduleActionId);
+}
+async function putScheduleConnectionBindings(identity, scheduleActionId, connections) {
+  const body = await controlRequest("/api/internal/nango/bindings", {
+    method: "PUT",
+    body: JSON.stringify({
+      identity,
+      scheduleId: scheduleActionId,
+      connections: connections.map((connection) => ({
+        connectionId: connection.connectionId,
+        allowedTools: connection.allowedTools
+      }))
+    })
+  });
+  const sanitized = sanitizeBindingRows(body, scheduleActionId);
+  const expectedByConnectionId = new Map(connections.map((connection) => [
+    connection.connectionId,
+    {
+      providerConfigKey: connection.providerConfigKey,
+      allowedTools: [...connection.allowedTools].sort()
+    }
+  ]));
+  const responseMatchesRequest = sanitized.length === connections.length && sanitized.every((binding) => {
+    const expected = expectedByConnectionId.get(binding.connectionId);
+    return !!expected && binding.scheduleActionId === scheduleActionId && binding.providerConfigKey === expected.providerConfigKey && [...binding.allowedTools].sort().join("\0") === expected.allowedTools.join("\0");
+  });
+  if (!responseMatchesRequest) {
+    throw new NangoControlError("Scheduled service connection control returned an invalid binding response.");
+  }
+  return sanitized;
+}
+async function deleteScheduleConnectionBindings(identity, scheduleActionId) {
+  await controlRequest("/api/internal/nango/bindings", {
+    method: "DELETE",
+    body: JSON.stringify({ identity, scheduleId: scheduleActionId })
+  });
+}
+async function setScheduleConnectionActionsEnabled(identity, connectionId, enabled) {
+  const body = await controlRequest("/api/internal/nango/connections/actions/enable", {
+    method: "POST",
+    body: JSON.stringify({ identity, connectionId, enabled })
+  });
+  const data = unwrapData(body);
+  if (!isRecord(data) || !isRecord(data.connection)) return enabled;
+  return data.connection.actionsEnabled === true;
+}
+async function callScheduleConnectionAction(identity, connectionId, input) {
+  const body = await controlRequest("/api/internal/nango/connections/actions/call", {
+    method: "POST",
+    body: JSON.stringify({ identity, connectionId, input })
+  });
+  const data = unwrapData(body);
+  return isRecord(data) ? data.result ?? data : data;
+}
+
 // src/api/server.ts
 var secureCookies2 = process.env.NODE_ENV === "production" || process.env.VERCEL === "1";
 var isProduction2 = secureCookies2;
@@ -20458,6 +20800,7 @@ app.use("*", async (c, next) => {
 });
 function opForCostPath(p) {
   if (p === "/harvest" || p === "/harvest/sync") return "harvest";
+  if (p === "/diff-page") return "diff_page";
   if (p === "/extract-url") return "page_scrape";
   if (p === "/extract-site") return "extract_site";
   if (p === "/map-urls") return "url_map";
@@ -20630,6 +20973,13 @@ app.get("/catalog", (c) => {
   c.header("Cache-Control", "public, max-age=60");
   return c.json(CATALOG);
 });
+app.get("/rates", (c) => {
+  const costs = CREDIT_COST_CATALOG.map(({ aliases, ...cost }) => ({
+    ...cost,
+    ...cost.notes ? { notes: cost.notes.replace(/ via fal\.ai/g, "") } : {}
+  }));
+  return c.json({ creditsPerDollarStarter: Math.round(1 / 15e-5), costs });
+});
 app.get("/me", async (c) => {
   const token = getCookie2(c, "session");
   if (!token) return c.json({ authenticated: false });
@@ -20955,6 +21305,20 @@ app.post("/schedule-checkout", auth2, async (c) => {
     return c.json({ error: message }, 500);
   }
 });
+function scheduleConnectionError(c, err, fallback) {
+  if (err instanceof ScheduleConnectionValidationError) return c.json({ ok: false, error: err.message }, 400);
+  if (err instanceof NangoControlError) return c.json({ ok: false, error: err.message }, err.status);
+  console.error("[schedule-connections]", err instanceof Error ? err.message : String(err));
+  return c.json({ ok: false, error: fallback }, 502);
+}
+function providerConfigKeyFrom(value) {
+  if (typeof value !== "string") return null;
+  const key = value.trim();
+  return key && key.length <= 200 ? key : null;
+}
+function bindingsForSchedule(bindings, scheduleActionId) {
+  return bindings.filter((binding) => binding.scheduleActionId === scheduleActionId);
+}
 app.get("/schedule-status", auth2, async (c) => {
   try {
     const user = c.get("user");
@@ -20968,6 +21332,103 @@ app.get("/schedule-status", auth2, async (c) => {
     return c.json({ error: message }, 500);
   }
 });
+app.get("/schedule-connection-catalog", auth2, async (c) => {
+  try {
+    return c.json({ ok: true, catalog: await getNangoCatalog() });
+  } catch (err) {
+    return scheduleConnectionError(c, err, "Unable to load the service connection catalog.");
+  }
+});
+app.get("/schedule-connections", auth2, async (c) => {
+  try {
+    const user = c.get("user");
+    return c.json({ ok: true, connections: await getNangoConnections(user.email) });
+  } catch (err) {
+    return scheduleConnectionError(c, err, "Unable to load service connections.");
+  }
+});
+app.post("/schedule-connections/session", auth2, async (c) => {
+  const user = c.get("user");
+  const body = await c.req.json().catch(() => ({}));
+  const providerConfigKey = providerConfigKeyFrom(body.providerConfigKey);
+  if (!providerConfigKey) return c.json({ ok: false, error: "providerConfigKey is required." }, 400);
+  try {
+    const session = await createNangoConnectSession(user.email, providerConfigKey);
+    return c.json({ ok: true, ...session });
+  } catch (err) {
+    return scheduleConnectionError(c, err, "Unable to start the service connection flow.");
+  }
+});
+app.post("/schedule-connections/:id/reconnect-session", auth2, async (c) => {
+  const user = c.get("user");
+  try {
+    const session = await createNangoReconnectSession(user.email, c.req.param("id"));
+    return c.json({ ok: true, ...session });
+  } catch (err) {
+    return scheduleConnectionError(c, err, "Unable to start the service reconnection flow.");
+  }
+});
+app.post("/schedule-connections/:id/enable-actions", auth2, async (c) => {
+  const user = c.get("user");
+  const body = await c.req.json().catch(() => ({}));
+  if (typeof body.enabled !== "boolean") return c.json({ ok: false, error: "enabled must be a boolean." }, 400);
+  try {
+    const actionsEnabled = await setScheduleConnectionActionsEnabled(user.email, c.req.param("id"), body.enabled);
+    return c.json({ ok: true, actionsEnabled });
+  } catch (err) {
+    return scheduleConnectionError(c, err, "Unable to update this connection's action setting.");
+  }
+});
+app.post("/schedule-connections/actions/slack/send-message", auth2, async (c) => {
+  const user = c.get("user");
+  const body = await c.req.json().catch(() => ({}));
+  const connectionId = providerConfigKeyFrom(body.connectionId);
+  if (!connectionId || typeof body.channel !== "string" || typeof body.text !== "string") {
+    return c.json({ ok: false, error: "connectionId, channel, and text are required." }, 400);
+  }
+  try {
+    const result = await callScheduleConnectionAction(user.email, connectionId, { channel: body.channel, text: body.text });
+    return c.json({ ok: true, result });
+  } catch (err) {
+    return scheduleConnectionError(c, err, "Unable to send the Slack message.");
+  }
+});
+app.post("/schedule-connections/actions/gmail/send-message", auth2, async (c) => {
+  const user = c.get("user");
+  const body = await c.req.json().catch(() => ({}));
+  const connectionId = providerConfigKeyFrom(body.connectionId);
+  if (!connectionId || typeof body.to !== "string" || typeof body.subject !== "string" || typeof body.body !== "string") {
+    return c.json({ ok: false, error: "connectionId, to, subject, and body are required." }, 400);
+  }
+  try {
+    const result = await callScheduleConnectionAction(user.email, connectionId, { to: body.to, subject: body.subject, body: body.body });
+    return c.json({ ok: true, result });
+  } catch (err) {
+    return scheduleConnectionError(c, err, "Unable to send the email.");
+  }
+});
+app.post("/schedule-connections/actions/google-calendar/create-event", auth2, async (c) => {
+  const user = c.get("user");
+  const body = await c.req.json().catch(() => ({}));
+  const connectionId = providerConfigKeyFrom(body.connectionId);
+  if (!connectionId || typeof body.summary !== "string" || typeof body.startDateTime !== "string" || typeof body.endDateTime !== "string") {
+    return c.json({ ok: false, error: "connectionId, summary, startDateTime, and endDateTime are required." }, 400);
+  }
+  const timeZone = typeof body.timeZone === "string" ? body.timeZone : void 0;
+  try {
+    const result = await callScheduleConnectionAction(user.email, connectionId, {
+      calendarId: typeof body.calendarId === "string" ? body.calendarId : "primary",
+      summary: body.summary,
+      description: typeof body.description === "string" ? body.description : void 0,
+      location: typeof body.location === "string" ? body.location : void 0,
+      start: { dateTime: body.startDateTime, timeZone },
+      end: { dateTime: body.endDateTime, timeZone }
+    });
+    return c.json({ ok: true, result });
+  } catch (err) {
+    return scheduleConnectionError(c, err, "Unable to create the calendar event.");
+  }
+});
 app.post("/schedule-link", auth2, async (c) => {
   try {
     const user = c.get("user");
@@ -20986,15 +21447,58 @@ app.get("/schedule-actions", auth2, async (c) => {
   const { key, error } = await getOrCreateUserMemoryKey(user);
   if (!key) return c.json({ ok: false, error: error ?? "memory unavailable" }, 503);
   const r = await memoryCall("listScheduledActionsTool", {}, key);
-  return c.json(r);
+  if (!r.ok || !Array.isArray(r.actions)) return c.json(r);
+  try {
+    const actions = await Promise.all(r.actions.map(async (action) => {
+      const id = typeof action.id === "string" ? action.id : "";
+      if (!id) return { ...action, connections: [] };
+      const bindings = await getScheduleConnectionBindings(user.email, id);
+      return { ...action, connections: bindingsForSchedule(bindings, id) };
+    }));
+    return c.json({
+      ...r,
+      actions
+    });
+  } catch (err) {
+    console.warn("[schedule-actions] connection bindings unavailable:", err instanceof Error ? err.message : String(err));
+    return c.json({
+      ...r,
+      actions: r.actions.map((action) => ({ ...action, connections: [] })),
+      connectionBindingsUnavailable: true
+    });
+  }
 });
 app.post("/schedule-actions", auth2, async (c) => {
   const user = c.get("user");
   const { key, error } = await getOrCreateUserMemoryKey(user);
   if (!key) return c.json({ ok: false, error: error ?? "memory unavailable" }, 503);
   const body = await c.req.json().catch(() => ({}));
-  const r = await memoryCall("createScheduledActionTool", body, key);
-  return c.json(r);
+  const hasConnections = Object.prototype.hasOwnProperty.call(body, "connections");
+  let connections;
+  try {
+    connections = sanitizeScheduleConnectionSelections(body.connections);
+  } catch (err) {
+    return scheduleConnectionError(c, err, "Invalid service connections.");
+  }
+  const actionBody = { ...body };
+  delete actionBody.connections;
+  const r = await memoryCall("createScheduledActionTool", actionBody, key);
+  if (!r.ok || !hasConnections) return c.json(r);
+  if (connections.length === 0) return c.json({ ...r, connections: [] });
+  if (!r.id) {
+    console.error("[schedule-actions] create returned no id while service connections were requested");
+    return c.json({ ok: false, error: "The scheduled action was created without a usable id; service connections were not attached." }, 502);
+  }
+  try {
+    const bound = await putScheduleConnectionBindings(user.email, r.id, connections);
+    return c.json({ ...r, connections: bound });
+  } catch (err) {
+    const rollback = await memoryCall("deleteScheduledActionTool", { id: r.id }, key).catch(() => ({ ok: false }));
+    if (!rollback.ok) console.error("[schedule-actions] failed to compensate action after connection binding failure", r.id);
+    const response = scheduleConnectionError(c, err, "The scheduled action was not created because its service connections could not be attached.");
+    response.headers.set("x-schedule-create-rolled-back", rollback.ok ? "true" : "false");
+    return response;
+  }
 });
 app.post("/schedule-actions/propose", auth2, async (c) => {
   const user = c.get("user");
@@ -21004,6 +21508,33 @@ app.post("/schedule-actions/propose", auth2, async (c) => {
   const r = await memoryCall("proposeScheduledActionTool", body, key);
   return c.json(r);
 });
+app.get("/schedule-actions/:id/connections", auth2, async (c) => {
+  try {
+    const user = c.get("user");
+    const scheduleActionId = c.req.param("id");
+    const bindings = await getScheduleConnectionBindings(user.email, scheduleActionId);
+    return c.json({ ok: true, connections: bindingsForSchedule(bindings, scheduleActionId) });
+  } catch (err) {
+    return scheduleConnectionError(c, err, "Unable to load scheduled action service connections.");
+  }
+});
+app.put("/schedule-actions/:id/connections", auth2, async (c) => {
+  const user = c.get("user");
+  const body = await c.req.json().catch(() => ({}));
+  let connections;
+  try {
+    connections = sanitizeScheduleConnectionSelections(body.connections);
+  } catch (err) {
+    return scheduleConnectionError(c, err, "Invalid service connections.");
+  }
+  try {
+    const scheduleActionId = c.req.param("id");
+    const bindings = await putScheduleConnectionBindings(user.email, scheduleActionId, connections);
+    return c.json({ ok: true, connections: bindings });
+  } catch (err) {
+    return scheduleConnectionError(c, err, "Unable to update scheduled action service connections.");
+  }
+});
 app.post("/schedule-actions/:id/pause", auth2, async (c) => {
   const user = c.get("user");
   const { key, error } = await getOrCreateUserMemoryKey(user);
@@ -21022,8 +21553,16 @@ app.delete("/schedule-actions/:id", auth2, async (c) => {
   const user = c.get("user");
   const { key, error } = await getOrCreateUserMemoryKey(user);
   if (!key) return c.json({ ok: false, error: error ?? "memory unavailable" }, 503);
-  const r = await memoryCall("deleteScheduledActionTool", { id: c.req.param("id") }, key);
-  return c.json(r);
+  const scheduleActionId = c.req.param("id");
+  const r = await memoryCall("deleteScheduledActionTool", { id: scheduleActionId }, key);
+  if (!r.ok) return c.json(r);
+  try {
+    await deleteScheduleConnectionBindings(user.email, scheduleActionId);
+    return c.json(r);
+  } catch (err) {
+    console.error("[schedule-actions] action deleted but connection binding cleanup failed", scheduleActionId, err instanceof Error ? err.message : String(err));
+    return c.json({ ...r, connectionBindingCleanupPending: true });
+  }
 });
 app.post("/schedule-link/revoke", auth2, async (c) => {
   try {
@@ -21905,7 +22444,7 @@ app.post("/api/internal/extract-refinalize/:id", async (c) => {
   }
   const jobId = c.req.param("id");
   const { getExtractJob: getExtractJob2, completeExtractJob: completeExtractJob2 } = await import("./site-extract-repository-NVSZH35Y.js");
-  const { assembleExtractArtifacts } = await import("./extract-bundle-COS56ZDO.js");
+  const { assembleExtractArtifacts } = await import("./extract-bundle-U4D5LW5W.js");
   const job = await getExtractJob2(jobId);
   if (!job) return c.json({ error: "job not found" }, 404);
   const stored = await assembleExtractArtifacts(job, {});
@@ -22076,4 +22615,4 @@ app.get("/blog/:slug/", (c) => {
 export {
   app
 };
-//# sourceMappingURL=server-JNY4XPZE.js.map
+//# sourceMappingURL=server-E34MNLI3.js.map