mcp-scraper 0.8.0 → 0.10.0

package/dist/{server-WBDVVHR6.js → server-KTA7CFX6.js}

@@ -34,7 +34,7 @@ import {
   registerSerpIntelligenceCaptureTools,
   sanitizeAttempts,
   sanitizeHarvestResult
-} from "./chunk-ITJC3NN4.js";
+} from "./chunk-IRYBBEZJ.js";
 import {
   auditImages,
   buildLinkReport,
@@ -70,7 +70,7 @@ import {
   RawMapsOverviewSchema,
   RawMapsReviewStatsSchema
 } from "./chunk-XGIPATLV.js";
-import "./chunk-3MKSXDJ7.js";
+import "./chunk-B7BAJU7K.js";
 import {
   completeExtractJob,
   countSuccessfulPages,
@@ -20393,6 +20393,317 @@ 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,
+      readTools: cleanTools(row.readTools ?? row.read_tools),
+      vaultName: firstString(row, ["vaultName", "vault_name"], 100),
+      tableName: firstString(row, ["tableName", "table_name"], 100),
+      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;
+}
+async function callScheduleConnectionRead(identity, connectionId, tool, args) {
+  const body = await controlRequest("/api/internal/nango/connections/actions/read", {
+    method: "POST",
+    body: JSON.stringify({ identity, connectionId, tool, args: args ?? {} })
+  });
+  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;
@@ -21005,6 +21316,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");
@@ -21018,6 +21343,139 @@ 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-connections/actions/zoom/create-meeting", auth2, async (c) => {
+  const user = c.get("user");
+  const body = await c.req.json().catch(() => ({}));
+  const connectionId = providerConfigKeyFrom(body.connectionId);
+  if (!connectionId || typeof body.topic !== "string" || typeof body.startDateTime !== "string") {
+    return c.json({ ok: false, error: "connectionId, topic, and startDateTime are required." }, 400);
+  }
+  try {
+    const result = await callScheduleConnectionAction(user.email, connectionId, {
+      topic: body.topic,
+      startDateTime: body.startDateTime,
+      durationMinutes: typeof body.durationMinutes === "number" ? body.durationMinutes : 30,
+      timezone: typeof body.timezone === "string" ? body.timezone : void 0,
+      agenda: typeof body.agenda === "string" ? body.agenda : void 0
+    });
+    return c.json({ ok: true, result });
+  } catch (err) {
+    return scheduleConnectionError(c, err, "Unable to create the Zoom meeting.");
+  }
+});
+app.post("/schedule-connections/actions/read", auth2, async (c) => {
+  const user = c.get("user");
+  const body = await c.req.json().catch(() => ({}));
+  const connectionId = providerConfigKeyFrom(body.connectionId);
+  const tool = providerConfigKeyFrom(body.tool);
+  if (!connectionId || !tool) {
+    return c.json({ ok: false, error: "connectionId and tool are required." }, 400);
+  }
+  const args = body.args && typeof body.args === "object" && !Array.isArray(body.args) ? body.args : {};
+  try {
+    const result = await callScheduleConnectionRead(user.email, connectionId, tool, args);
+    return c.json({ ok: true, result });
+  } catch (err) {
+    return scheduleConnectionError(c, err, "Unable to read from this connection.");
+  }
+});
 app.post("/schedule-link", auth2, async (c) => {
   try {
     const user = c.get("user");
@@ -21036,15 +21494,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");
@@ -21054,6 +21555,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);
@@ -21072,8 +21600,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 {
@@ -22126,4 +22662,4 @@ app.get("/blog/:slug/", (c) => {
 export {
   app
 };
-//# sourceMappingURL=server-WBDVVHR6.js.map
+//# sourceMappingURL=server-KTA7CFX6.js.map