@nightowlsdev/connectors 1.0.0

package/dist/index.js

@@ -0,0 +1,647 @@
+// src/define.ts
+function defineConnector(spec) {
+  if (!spec.provider) throw new Error("defineConnector: provider is required");
+  const names = /* @__PURE__ */ new Set();
+  for (const a of spec.actions) {
+    if (names.has(a.name)) throw new Error(`defineConnector: duplicate action name '${a.name}'`);
+    names.add(a.name);
+    if (!a.op === !a.execute) throw new Error(`defineConnector: action '${a.name}' needs exactly one of { op, execute }`);
+  }
+  return spec;
+}
+
+// src/fence.ts
+function fenceConnectorOutput(raw) {
+  let text;
+  if (typeof raw === "string") {
+    text = raw;
+  } else {
+    try {
+      text = JSON.stringify(raw) ?? String(raw);
+    } catch {
+      text = String(raw);
+    }
+  }
+  return { fenced: `<connector-output untrusted="true">
+${text}
+</connector-output>` };
+}
+
+// src/materialize.ts
+function materializeConnectors(connectors, backend) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const def of connectors) {
+    for (const action of def.actions) {
+      if (seen.has(action.name)) {
+        throw new Error(
+          `materializeConnectors: duplicate connector action name '${action.name}' across connectors \u2014 action names must be unique (a collision would silently shadow another connector's action and route calls to the wrong connection)`
+        );
+      }
+      seen.add(action.name);
+    }
+  }
+  return async (ctx) => {
+    const all = [];
+    for (const def of connectors) {
+      try {
+        all.push(...await backend.materialize(def, ctx));
+      } catch (err) {
+        throw new Error(
+          `materializeConnectors: backend.materialize failed for provider '${def.provider}': ${err instanceof Error ? err.message : String(err)}`,
+          { cause: err }
+        );
+      }
+    }
+    return all;
+  };
+}
+
+// src/connectors/slack.ts
+import { z } from "zod";
+var slackConnector = defineConnector({
+  provider: "slack",
+  actions: [
+    {
+      name: "slack.post_message",
+      description: "Post a message to a Slack channel or thread.",
+      inputSchema: z.object({ channel: z.string(), text: z.string(), thread_ts: z.string().optional() }),
+      needsApproval: true,
+      // side-effecting: posts to a channel — must be SP5-gated
+      op: { method: "POST", path: "/chat.postMessage" }
+    },
+    {
+      name: "slack.search",
+      description: "Search Slack messages.",
+      inputSchema: z.object({ query: z.string(), count: z.number().optional() }),
+      needsApproval: false,
+      // read-only
+      op: { method: "GET", path: "/search.messages" }
+    }
+  ],
+  // Trigger events (K3): a Slack Events API `message` fires a run. `normalize` receives the full outer payload
+  // (event_callback) and distills it to a `summary` (the run prompt) + the structured fields.
+  events: [
+    {
+      type: "message",
+      normalize: (raw) => {
+        const outer = raw ?? {};
+        const ev = outer.event ?? {};
+        const s = (v) => typeof v === "string" ? v : "";
+        const channel = s(ev.channel);
+        const user = s(ev.user);
+        const text = s(ev.text);
+        return {
+          summary: `New Slack message from ${user || "someone"} in ${channel || "a channel"}: ${text}`,
+          channel,
+          user,
+          text,
+          ts: s(ev.ts)
+        };
+      }
+    }
+  ]
+});
+
+// src/connectors/linear.ts
+import { z as z2 } from "zod";
+var CREATE_ISSUE = (
+  /* GraphQL */
+  `
+  mutation CreateIssue($input: IssueCreateInput!) {
+    issueCreate(input: $input) { success issue { id identifier url title } }
+  }`
+);
+var ADD_COMMENT = (
+  /* GraphQL */
+  `
+  mutation AddComment($input: CommentCreateInput!) {
+    commentCreate(input: $input) { success comment { id url } }
+  }`
+);
+var SEARCH_ISSUES = (
+  /* GraphQL */
+  `
+  query SearchIssues($term: String!, $first: Int) {
+    issueSearch(query: $term, first: $first) { nodes { id identifier title url state { name } } }
+  }`
+);
+var str = (v) => typeof v === "string" ? v : "";
+var linearConnector = defineConnector({
+  provider: "linear",
+  actions: [
+    {
+      name: "linear.create_issue",
+      description: "Create a Linear issue.",
+      inputSchema: z2.object({ teamId: z2.string(), title: z2.string(), description: z2.string().optional() }),
+      needsApproval: true,
+      // side-effecting
+      execute: async (input, ctx) => {
+        const i = input;
+        return ctx.connection.proxy({
+          method: "POST",
+          path: "/graphql",
+          body: { query: CREATE_ISSUE, variables: { input: { teamId: i.teamId, title: i.title, description: i.description } } }
+        });
+      }
+    },
+    {
+      name: "linear.add_comment",
+      description: "Add a comment to a Linear issue.",
+      inputSchema: z2.object({ issueId: z2.string(), body: z2.string() }),
+      needsApproval: true,
+      // side-effecting
+      execute: async (input, ctx) => {
+        const i = input;
+        return ctx.connection.proxy({
+          method: "POST",
+          path: "/graphql",
+          body: { query: ADD_COMMENT, variables: { input: { issueId: i.issueId, body: i.body } } }
+        });
+      }
+    },
+    {
+      name: "linear.search_issues",
+      description: "Search Linear issues.",
+      inputSchema: z2.object({ term: z2.string(), first: z2.number().optional() }),
+      needsApproval: false,
+      // read-only
+      execute: async (input, ctx) => {
+        const i = input;
+        return ctx.connection.proxy({
+          method: "POST",
+          path: "/graphql",
+          body: { query: SEARCH_ISSUES, variables: { term: i.term, first: i.first ?? 10 } }
+        });
+      }
+    }
+  ],
+  // Trigger events (K5): a Linear webhook for an Issue or Comment. `normalize` receives the full webhook payload
+  // (`{ action, type, data, ... }`) and distills it to a `summary` (the run prompt) + structured fields.
+  events: [
+    {
+      type: "Issue",
+      normalize: (raw) => {
+        const p = raw ?? {};
+        const d = p.data ?? {};
+        return {
+          summary: `Linear issue ${str(p.action) || "event"}: ${str(d.identifier)} ${str(d.title)}`.trim(),
+          action: str(p.action),
+          identifier: str(d.identifier),
+          title: str(d.title),
+          url: str(d.url)
+        };
+      }
+    },
+    {
+      type: "Comment",
+      normalize: (raw) => {
+        const p = raw ?? {};
+        const d = p.data ?? {};
+        return { summary: `Linear comment ${str(p.action) || "event"}: ${str(d.body)}`.trim(), action: str(p.action), body: str(d.body), url: str(d.url) };
+      }
+    }
+  ]
+});
+
+// src/connectors/email.ts
+import { z as z3 } from "zod";
+var enc = new TextEncoder();
+function b64url(bytes) {
+  let s = "";
+  for (const b of bytes) s += String.fromCharCode(b);
+  return btoa(s).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function b64urlDecode(s) {
+  const b = atob(s.replace(/-/g, "+").replace(/_/g, "/"));
+  return Uint8Array.from(b, (c) => c.charCodeAt(0));
+}
+async function hmac(secret, msg) {
+  const key = await crypto.subtle.importKey("raw", enc.encode(secret), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+  return new Uint8Array(await crypto.subtle.sign("HMAC", key, enc.encode(msg)));
+}
+function timingEqual(a, b) {
+  if (a.length !== b.length) return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++) diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  return diff === 0;
+}
+function emailConnector(opts) {
+  return defineConnector({
+    provider: "email",
+    actions: [
+      {
+        name: "email.send",
+        description: "Send a plain-text email.",
+        inputSchema: z3.object({ to: z3.string(), subject: z3.string(), text: z3.string() }),
+        needsApproval: true,
+        // side-effecting + arbitrary recipient ⇒ always gated (human approves to + body)
+        execute: async (input, ctx) => {
+          const i = input;
+          return ctx.connection.proxy({ method: "POST", path: "/emails", body: { from: opts.from, to: i.to, subject: i.subject, text: i.text } });
+        }
+      }
+    ],
+    events: [{ type: "inbound", normalize: (raw) => raw }]
+  });
+}
+async function mintReplyToken(followupId, secret, opts) {
+  const payload = { f: followupId };
+  if (opts?.expiresInSec != null) payload.e = (opts.nowSec ?? Math.floor(Date.now() / 1e3)) + opts.expiresInSec;
+  const json = JSON.stringify(payload);
+  return `${b64url(enc.encode(json))}.${b64url(await hmac(secret, json))}`;
+}
+async function verifyReplyToken(token, secret, opts) {
+  const parts = token.split(".");
+  if (parts.length !== 2) return null;
+  const [payloadPart, sigPart] = parts;
+  if (!payloadPart || !sigPart) return null;
+  let json;
+  try {
+    json = new TextDecoder().decode(b64urlDecode(payloadPart));
+  } catch {
+    return null;
+  }
+  if (!timingEqual(b64url(await hmac(secret, json)), sigPart)) return null;
+  let payload;
+  try {
+    payload = JSON.parse(json);
+  } catch {
+    return null;
+  }
+  if (typeof payload.f !== "string") return null;
+  if (typeof payload.e === "number" && (opts?.nowSec ?? Math.floor(Date.now() / 1e3)) > payload.e) return null;
+  return payload.f;
+}
+function parseReplyToken(address) {
+  const m = /^[^+@\s]+\+([^@\s]+)@/.exec(address.trim());
+  return m?.[1] ?? null;
+}
+async function verifyInboundEmailSignature(input) {
+  if (!input.signature) return false;
+  const mac = await hmac(input.secret, input.payload);
+  const hex = [...mac].map((b) => b.toString(16).padStart(2, "0")).join("");
+  return timingEqual(hex, input.signature);
+}
+function emailQuestionDelivery(opts) {
+  const provider = opts.provider ?? "email";
+  const ttl = opts.tokenTtlSec ?? 604800;
+  return {
+    async deliver(q, ctx, route) {
+      if (route.channel !== "email") throw new Error(`emailQuestionDelivery: route is '${route.channel}', not email`);
+      const token = await mintReplyToken(q.followupId, opts.tokenSecret, { expiresInSec: ttl });
+      const connection = await opts.backend.resolveConnection({ provider }, ctx);
+      const res = await connection.proxy({
+        method: "POST",
+        path: "/emails",
+        // text ONLY (no html); the prompt is plain data inside a fixed template; reply_to carries the correlation.
+        body: { from: opts.from, to: route.target.to, subject: "A question for you", text: q.prompt, reply_to: opts.replyAddress(token) }
+      });
+      const messageId = res?.id;
+      if (!messageId) throw new Error("emailQuestionDelivery: send returned no message id");
+      return { channel: "email", ref: { message_id: messageId } };
+    }
+  };
+}
+
+// src/static-backend.ts
+import { defineTool } from "@nightowlsdev/core";
+function staticBackend(opts) {
+  const fetchImpl = opts.fetchImpl ?? fetch;
+  const resolveConnection = async (ref, ctx) => {
+    const conn = opts.connections[ref.provider];
+    if (!conn) throw new Error(`staticBackend: no connection configured for provider '${ref.provider}'`);
+    let token = conn.token;
+    if (token === void 0 && conn.secretRef) {
+      token = opts.secrets ? await opts.secrets.resolve(conn.secretRef, ctx) : void 0;
+      if (token === void 0) {
+        throw new Error(
+          `staticBackend: credential '${conn.secretRef}' for provider '${ref.provider}' could not be resolved (no SecretResolver configured, or the ref is unknown)`
+        );
+      }
+    }
+    const authHeader = conn.authHeader ?? ((t) => t ? { Authorization: `Bearer ${t}` } : {});
+    return {
+      accountId: conn.accountId ?? "default",
+      async proxy(req) {
+        const bodyless = req.method === "GET";
+        const path = req.path.startsWith("/") ? req.path : `/${req.path}`;
+        const url = new URL(conn.baseUrl.replace(/\/+$/, "") + path);
+        for (const [k, v] of Object.entries(req.query ?? {})) {
+          if (v === void 0 || v === null) continue;
+          url.searchParams.set(k, typeof v === "object" ? JSON.stringify(v) : String(v));
+        }
+        const headers = {
+          ...bodyless ? {} : { "content-type": "application/json" },
+          ...authHeader(token),
+          ...req.headers ?? {}
+        };
+        const res = await fetchImpl(url.toString(), {
+          method: req.method,
+          headers,
+          body: bodyless || req.body === void 0 ? void 0 : JSON.stringify(req.body)
+        });
+        const text = await res.text();
+        let parsed = text;
+        try {
+          parsed = text ? JSON.parse(text) : null;
+        } catch {
+        }
+        if (!res.ok) {
+          const snippet = text.length > 300 ? `${text.slice(0, 300)}\u2026` : text;
+          throw new Error(`staticBackend proxy ${req.method} ${req.path} -> ${res.status}${snippet ? `: ${snippet}` : ""}`);
+        }
+        return parsed;
+      }
+    };
+  };
+  return {
+    resolveConnection,
+    async materialize(def, _ctx) {
+      return def.actions.map((action) => {
+        const needsApproval = action.needsApproval ?? true;
+        const run = async (input, toolCtx) => {
+          const swarmCtx = {
+            tenantId: toolCtx.tenantId,
+            userId: toolCtx.userId,
+            runId: toolCtx.runId,
+            agentSlug: "",
+            threadId: ""
+          };
+          const connection = await resolveConnection({ provider: def.provider }, swarmCtx);
+          const op = action.op;
+          const result = action.execute ? await action.execute(input, { ...toolCtx, connection }) : (
+            // A GET op carries its input as query params (a body would make fetch throw); others as a body.
+            await connection.proxy(
+              op.method === "GET" ? { method: op.method, path: op.path, query: input ?? {} } : { method: op.method, path: op.path, body: input }
+            )
+          );
+          return fenceConnectorOutput(result);
+        };
+        const handle = defineTool({
+          name: action.name,
+          description: action.description ?? action.name,
+          inputSchema: action.inputSchema,
+          origin: "first-party",
+          needsApproval,
+          execute: run
+        });
+        return Object.assign(handle, { execute: run });
+      });
+    }
+  };
+}
+
+// src/nango-backend.ts
+import { defineTool as defineTool2 } from "@nightowlsdev/core";
+function nangoBackend(opts) {
+  const resolveConnection = async (ref, ctx) => {
+    const conn = await opts.resolveConnection(ref, ctx);
+    if (!conn) {
+      throw new Error(`nangoBackend: no connection for provider '${ref.provider}' (tenant must connect via OAuth)`);
+    }
+    return {
+      accountId: conn.accountId ?? "default",
+      async proxy(req) {
+        return opts.nango.proxy({
+          connectionId: conn.connectionId,
+          ...conn.providerConfigKey ? { providerConfigKey: conn.providerConfigKey } : {},
+          method: req.method,
+          path: req.path,
+          ...req.query ? { query: req.query } : {},
+          ...req.body !== void 0 ? { body: req.body } : {},
+          ...req.headers ? { headers: req.headers } : {}
+        });
+      }
+    };
+  };
+  return {
+    resolveConnection,
+    async materialize(def, _ctx) {
+      return def.actions.map((action) => {
+        if (!action.execute && !action.op) {
+          throw new Error(`nangoBackend: action '${action.name}' has neither op nor execute`);
+        }
+        const needsApproval = action.needsApproval ?? true;
+        const run = async (input, toolCtx) => {
+          const swarmCtx = {
+            tenantId: toolCtx.tenantId,
+            userId: toolCtx.userId,
+            runId: toolCtx.runId,
+            agentSlug: "",
+            threadId: ""
+          };
+          const connection = await resolveConnection({ provider: def.provider }, swarmCtx);
+          const op = action.op;
+          const result = action.execute ? await action.execute(input, { ...toolCtx, connection }) : (
+            // A GET op carries its input as query params; others as a body (same routing as staticBackend).
+            await connection.proxy(
+              op.method === "GET" ? { method: op.method, path: op.path, query: input ?? {} } : { method: op.method, path: op.path, body: input }
+            )
+          );
+          return fenceConnectorOutput(result);
+        };
+        const handle = defineTool2({
+          name: action.name,
+          description: action.description ?? action.name,
+          inputSchema: action.inputSchema,
+          origin: "first-party",
+          needsApproval,
+          execute: run
+        });
+        return Object.assign(handle, { execute: run });
+      });
+    }
+  };
+}
+
+// src/trigger.ts
+var hexFromBuffer = (buf) => [...new Uint8Array(buf)].map((b) => b.toString(16).padStart(2, "0")).join("");
+function safeEqual(a, b) {
+  if (a.length !== b.length) return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++) diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  return diff === 0;
+}
+async function verifySlackSignature(input) {
+  if (!input.signature || !input.timestamp) return { ok: false, reason: "missing signature/timestamp" };
+  const ts = Number(input.timestamp);
+  if (!Number.isFinite(ts)) return { ok: false, reason: "bad timestamp" };
+  const now = input.nowSec ?? Math.floor(Date.now() / 1e3);
+  if (Math.abs(now - ts) > (input.maxSkewSec ?? 300)) return { ok: false, reason: "stale timestamp" };
+  const enc2 = new TextEncoder();
+  const key = await crypto.subtle.importKey("raw", enc2.encode(input.signingSecret), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+  const mac = await crypto.subtle.sign("HMAC", key, enc2.encode(`v0:${input.timestamp}:${input.body}`));
+  const expected = `v0=${hexFromBuffer(mac)}`;
+  return safeEqual(expected, input.signature) ? { ok: true } : { ok: false, reason: "signature mismatch" };
+}
+async function verifyLinearSignature(input) {
+  if (!input.signature) return { ok: false, reason: "missing signature" };
+  const enc2 = new TextEncoder();
+  const key = await crypto.subtle.importKey("raw", enc2.encode(input.secret), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+  const mac = await crypto.subtle.sign("HMAC", key, enc2.encode(input.body));
+  return safeEqual(hexFromBuffer(mac), input.signature) ? { ok: true } : { ok: false, reason: "signature mismatch" };
+}
+var asRecord = (v) => typeof v === "object" && v !== null ? v : {};
+var asString = (v) => typeof v === "string" ? v : void 0;
+function triggerMessage(provider, eventType, normalized) {
+  const summary = asString(asRecord(normalized).summary);
+  return summary ?? `${provider} ${eventType} event`;
+}
+async function handleTriggerEvent(provider, rawPayload, opts) {
+  if (!opts.skipSignatureCheck) {
+    if (!opts.signingSecret) return { status: "rejected", reason: "no signing secret" };
+    const verified = await verifySlackSignature({
+      signingSecret: opts.signingSecret,
+      signature: opts.signature,
+      timestamp: opts.timestamp,
+      body: rawPayload,
+      nowSec: opts.nowSec?.(),
+      maxSkewSec: opts.maxSkewSec
+    });
+    if (!verified.ok) return { status: "rejected", reason: verified.reason };
+  }
+  let body;
+  try {
+    body = asRecord(JSON.parse(rawPayload));
+  } catch {
+    return { status: "rejected", reason: "invalid json" };
+  }
+  if (body.type === "url_verification") {
+    const challenge = asString(body.challenge);
+    return challenge ? { status: "challenge", challenge } : { status: "rejected", reason: "missing challenge" };
+  }
+  if (body.type !== "event_callback") return { status: "ignored", reason: `unhandled outer type ${String(body.type)}` };
+  const externalId = asString(body.event_id);
+  if (!externalId) return { status: "ignored", reason: "missing event_id" };
+  const inner = asRecord(body.event);
+  const eventType = asString(inner.type);
+  if (!eventType) return { status: "ignored", reason: "missing event.type" };
+  const workspaceId = asString(body.team_id);
+  if (!await opts.dedupe.markSeen({ provider, externalId })) return { status: "ignored", reason: "duplicate" };
+  const spec = opts.connector.events?.find((e) => e.type === eventType);
+  if (!spec) return { status: "ignored", reason: `no event spec for ${eventType}` };
+  const normalized = spec.normalize ? spec.normalize(body) : body;
+  const subs = await opts.lookupSubscriptions({ provider, workspaceId, eventType });
+  if (subs.length === 0) return { status: "ignored", reason: "no subscriptions" };
+  const fenced = fenceConnectorOutput(normalized).fenced;
+  const message = triggerMessage(provider, eventType, normalized);
+  const runs = [];
+  const failed = [];
+  for (const sub of subs) {
+    const runId = opts.mintRunId();
+    try {
+      await opts.enqueue(
+        {
+          message,
+          context: { trigger: { provider, type: eventType, externalId, payload: fenced } },
+          ...sub.workflow ? { workflow: sub.workflow } : {}
+        },
+        { tenantId: sub.orgId, userId: sub.ownerUserId, agentSlug: sub.agentSlug, threadId: sub.threadId, runId }
+      );
+      runs.push({ runId, agentSlug: sub.agentSlug });
+    } catch (err) {
+      failed.push({ agentSlug: sub.agentSlug, error: err instanceof Error ? err.message : String(err) });
+    }
+  }
+  return { status: "enqueued", runs, failed: failed.length };
+}
+
+// src/delivery.ts
+function escapeSlackText(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function renderSlackQuestion(prompt, _field) {
+  return {
+    blocks: [
+      { type: "section", text: { type: "plain_text", text: prompt, emoji: false } },
+      { type: "context", elements: [{ type: "plain_text", text: "Reply in thread to answer.", emoji: false }] }
+    ],
+    text: "You have a question to answer."
+    // fixed fallback; the prompt is ONLY in the inert plain_text block
+  };
+}
+function slackQuestionDelivery(opts) {
+  const provider = opts.provider ?? "slack";
+  return {
+    async deliver(q, ctx, route) {
+      if (route.channel !== "slack") throw new Error(`slackQuestionDelivery: route is '${route.channel}', not slack`);
+      const channelId = route.target.channelId;
+      const connection = await opts.backend.resolveConnection({ provider }, ctx);
+      const rendered = renderSlackQuestion(q.prompt, q.field);
+      const res = await connection.proxy({
+        method: "POST",
+        path: "/chat.postMessage",
+        body: { channel: channelId, blocks: rendered.blocks, text: rendered.text }
+      });
+      const deliveryTs = res?.ts;
+      if (!deliveryTs) throw new Error("slackQuestionDelivery: chat.postMessage returned no ts");
+      return { channel: "slack", ref: { team_id: route.target.teamId, channel_id: channelId, delivery_ts: deliveryTs } };
+    }
+  };
+}
+
+// src/inbound.ts
+function sanitizeReply(raw, opts) {
+  const maxChars = opts?.maxChars ?? 4e3;
+  const lines = raw.replace(/\r\n/g, "\n").split("\n");
+  const out = [];
+  for (const line of lines) {
+    if (/^\s*>/.test(line)) continue;
+    if (/^\s*--\s*$/.test(line)) break;
+    if (/^\s*On .+ wrote:\s*$/.test(line)) break;
+    out.push(line);
+  }
+  return out.join("\n").trim().slice(0, maxChars);
+}
+function correlateSlackInbound(event) {
+  const outer = event ?? {};
+  const ev = outer.event ?? {};
+  const s = (v) => typeof v === "string" ? v : void 0;
+  if (ev.subtype !== void 0 || ev.bot_id !== void 0) return null;
+  const teamId = s(outer.team_id);
+  const channelId = s(ev.channel);
+  const threadTs = s(ev.thread_ts);
+  const userId = s(ev.user);
+  const text = s(ev.text) ?? "";
+  if (!teamId || !channelId || !threadTs || !userId) return null;
+  return { teamId, channelId, threadTs, text, userId };
+}
+async function handleInboundReply(input, opts) {
+  if (!await opts.recordInboundOnce({ provider: input.provider, externalId: input.externalId })) {
+    return { status: "ignored", reason: "duplicate-transport" };
+  }
+  const corr = await opts.correlate(input);
+  if (!corr) return { status: "ignored", reason: "no-correlation" };
+  const auth = await opts.authorizeReplier({ tenantId: corr.tenantId, provider: input.provider, replier: input.replier });
+  if (!auth || auth.userId !== corr.approverUserId) return { status: "ignored", reason: "unauthorized-approver" };
+  const answer = (opts.sanitize ?? sanitizeReply)(input.text);
+  if (!answer) return { status: "ignored", reason: "empty-reply" };
+  if (!await opts.answerOnce(corr.followupId, corr.tenantId)) return { status: "ignored", reason: "already-answered" };
+  const ctx = await opts.resolveContext(corr);
+  const { runId } = await opts.resumeEnqueue({ runId: corr.runId, toolCallId: corr.toolCallId, followupId: corr.followupId, answer }, ctx);
+  return { status: "resumed", runId };
+}
+export {
+  correlateSlackInbound,
+  defineConnector,
+  emailConnector,
+  emailQuestionDelivery,
+  escapeSlackText,
+  fenceConnectorOutput,
+  handleInboundReply,
+  handleTriggerEvent,
+  linearConnector,
+  materializeConnectors,
+  mintReplyToken,
+  nangoBackend,
+  parseReplyToken,
+  renderSlackQuestion,
+  sanitizeReply,
+  slackConnector,
+  slackQuestionDelivery,
+  staticBackend,
+  verifyInboundEmailSignature,
+  verifyLinearSignature,
+  verifyReplyToken,
+  verifySlackSignature
+};

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@nightowlsdev/connectors",
+  "version": "1.0.0",
+  "type": "module",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cueplusplus/corale.git",
+    "directory": "packages/connectors"
+  },
+  "homepage": "https://github.com/cueplusplus/corale#readme",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "zod": "^4.0.0"
+  },
+  "peerDependencies": {
+    "@nightowlsdev/core": "0.4.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.12.4",
+    "tsup": "8.5.1",
+    "typescript": "6.0.3",
+    "vitest": "^3.2.0",
+    "@nightowlsdev/core": "0.4.0",
+    "@nightowlsdev/eslint-config": "0.0.0",
+    "@nightowlsdev/tsconfig": "0.0.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "lint": "eslint src"
+  }
+}