@opentag/slack 0.1.0 → 0.3.0

package/dist/index.js

@@ -1,14 +1,24 @@
+// src/events.ts
+import { parseThreadActionCommand } from "@opentag/core";
+
 // src/normalize.ts
 import { commandFromRawText } from "@opentag/core";
-function stripSlackAppMention(text, botUserId) {
-  const patterns = botUserId ? [new RegExp(`^<@${botUserId}>\\s*`, "i"), /^<@[^>]+>\s*/] : [/^<@[^>]+>\s*/];
-  for (const pattern of patterns) {
-    const stripped = text.replace(pattern, "").trim();
-    if (stripped !== text.trim()) {
-      return stripped.length > 0 ? stripped : null;
-    }
+var LEADING_MENTION_RUN = /^(?:<@[^>]+>\s*)+/;
+var MENTION_TOKEN = /<@([^>]+)>/g;
+function stripSlackAppMention(text2, botUserId) {
+  const run = text2.match(LEADING_MENTION_RUN);
+  if (!run) return null;
+  const leadingRun = run[0];
+  if (botUserId) {
+    const mentionedIds = leadingRun.match(MENTION_TOKEN) ?? [];
+    const botIsMentioned = mentionedIds.some((token) => {
+      const id = token.slice(2, -1).split("|")[0] ?? "";
+      return id.toLowerCase() === botUserId.toLowerCase();
+    });
+    if (!botIsMentioned) return null;
   }
-  return null;
+  const stripped = text2.slice(leadingRun.length).trim();
+  return stripped.length > 0 ? stripped : null;
 }
 function encodeSlackThreadKey(input) {
   return `${input.teamId}|${input.channelId}|${input.threadTs}`;
@@ -20,18 +30,27 @@ function parseSlackThreadKey(threadKey) {
   }
   return { teamId, channelId, threadTs };
 }
-function permissionsForIntent(intent) {
+var UNKNOWN_WRITE_VERB_PATTERN = /\b(add|append|apply|change|commit|create|delete|edit|fix|modify|open\s+a?\s*pr|pull\s+request|remove|update|write)\b/i;
+var REPO_WRITE_TARGET_PATTERN = /\b(repo|repository|code|file|files|branch|commit|diff|patch|readme|pr|pull\s+request|package\.json|pnpm|npm|test|build)\b|(?:^|\s)[./\w-]+\.(?:cjs|css|gitignore|go|html|js|json|jsx|lock|md|mjs|py|rb|rs|sh|toml|ts|tsx|txt|yaml|yml)\b|(?:^|[\s`'"(])(?:[./\w-]+\/)?(?:Dockerfile|Makefile|Procfile|Rakefile|Gemfile|Brewfile|Justfile|Taskfile|\.dockerignore|\.env(?:\.[\w-]+)?|\.gitignore|\.npmrc)(?=$|[\s`'",.):])/i;
+function commandLooksRepoWriteCapable(command) {
+  return UNKNOWN_WRITE_VERB_PATTERN.test(command.rawText) && REPO_WRITE_TARGET_PATTERN.test(command.rawText);
+}
+function permissionsForCommand(command) {
   const permissions = [
     {
       scope: "chat:postMessage",
       reason: "reply in the originating Slack thread"
     },
+    {
+      scope: "reactions:write",
+      reason: "mark the originating Slack message as received without posting a thread reply"
+    },
     {
       scope: "runner:local",
       reason: "execute the run on a paired local daemon"
     }
   ];
-  if (intent === "fix" || intent === "run") {
+  if (command.intent === "fix" || command.intent === "run" || command.intent === "unknown" && commandLooksRepoWriteCapable(command)) {
     permissions.push(
       {
         scope: "repo:read",
@@ -49,11 +68,50 @@ function permissionsForIntent(intent) {
   }
   return permissions;
 }
+function contextPointersForCommand(command) {
+  const context = [];
+  for (const reference of command.parsed?.references ?? []) {
+    if (reference.kind === "url") {
+      context.push({
+        kind: "url",
+        uri: reference.uri,
+        visibility: "organization",
+        title: reference.title ?? "Command URL reference"
+      });
+      continue;
+    }
+    if (reference.kind === "file" || reference.kind === "path") {
+      context.push({
+        kind: "file",
+        uri: reference.uri,
+        ...reference.line ? { line: reference.line } : {},
+        ...reference.startLine ? { startLine: reference.startLine } : {},
+        ...reference.endLine ? { endLine: reference.endLine } : {},
+        visibility: "organization",
+        title: referenceTitle(reference)
+      });
+    }
+  }
+  return context;
+}
+function referenceTitle(reference) {
+  return reference.title ?? "Command file reference";
+}
+function commandMetadata(command) {
+  if (!command.parsed) return {};
+  return {
+    commandParser: command.parsed.version,
+    commandDiagnostics: command.parsed.diagnostics,
+    ...command.parsed.approval ? { approval: command.parsed.approval } : {},
+    ...command.parsed.network ? { network: command.parsed.network } : {}
+  };
+}
 function normalizeSlackAppMention(input) {
   const rawText = stripSlackAppMention(input.text, input.botUserId);
   if (!rawText) return null;
   const command = commandFromRawText(rawText);
   const replyThreadTs = input.threadTs ?? input.ts;
+  const agentId = input.agentId ?? "opentag";
   return {
     id: `evt_slack_app_mention_${input.eventId}`,
     source: "slack",
@@ -67,12 +125,14 @@ function normalizeSlackAppMention(input) {
     },
     target: {
       mention: input.botUserId ? `<@${input.botUserId}>` : "<@app>",
-      agentId: "opentag"
+      agentId,
+      ...command.parsed?.executorHint ? { executorHint: command.parsed.executorHint } : {}
     },
     command,
     context: [
       {
-        kind: "url",
+        provider: "slack",
+        kind: "message",
         uri: `slack://team/${input.teamId}/channel/${input.channelId}/message/${input.ts}`,
         visibility: "organization",
         title: "Slack message"
@@ -82,9 +142,10 @@ function normalizeSlackAppMention(input) {
         uri: input.text,
         visibility: "organization",
         title: "Slack message text"
-      }
+      },
+      ...contextPointersForCommand(command)
     ],
-    permissions: permissionsForIntent(command.intent),
+    permissions: permissionsForCommand(command),
     callback: {
       provider: "slack",
       uri: input.callbackUri ?? "https://slack.com/api/chat.postMessage",
@@ -98,16 +159,799 @@ function normalizeSlackAppMention(input) {
       teamId: input.teamId,
       channelId: input.channelId,
       messageTs: input.ts,
-      repoProvider: "github",
+      ...input.appId ? { slackAppId: input.appId } : {},
+      ...input.botUserId ? { slackBotUserId: input.botUserId } : {},
+      ...commandMetadata(command),
+      repoProvider: input.binding.repoProvider ?? "github",
       owner: input.binding.owner,
       repo: input.binding.repo
     }
   };
 }
+
+// src/render.ts
+import { suggestedActionCandidatesFromResult } from "@opentag/core";
+var MAX_SLACK_SUGGESTED_ACTION_CANDIDATES = 20;
+function buildSlackSuggestedActionButtonValue(input) {
+  return JSON.stringify(input);
+}
+function parseSlackSuggestedActionButtonValue(value) {
+  try {
+    const parsed = JSON.parse(value);
+    if (parsed.version !== 1 || typeof parsed.command !== "string" || parsed.command.trim().length === 0 || typeof parsed.proposalId !== "string" || parsed.proposalId.length === 0 || typeof parsed.intentId !== "string" || parsed.intentId.length === 0) {
+      return null;
+    }
+    return {
+      version: 1,
+      command: parsed.command.trim(),
+      proposalId: parsed.proposalId,
+      intentId: parsed.intentId
+    };
+  } catch {
+    return null;
+  }
+}
+function escapeSlackText(text2) {
+  return text2.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function markdownToSlackMrkdwn(text2) {
+  const links = [];
+  const withoutLinks = text2.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_match, label, url) => {
+    const token = `\0SLACK_LINK_${links.length}\0`;
+    links.push(`<${url}|${escapeSlackText(label)}>`);
+    return token;
+  });
+  const converted = escapeSlackText(withoutLinks).replace(/\*\*(.+?)\*\*/g, "*$1*").replace(/__(.+?)__/g, "*$1*");
+  return links.reduce((output, link, index) => output.replace(`\0SLACK_LINK_${index}\0`, link), converted);
+}
+function renderSlackAcknowledgement(runId) {
+  void runId;
+  return "Working on it.";
+}
+function slackSourceReceiptReactionName(state) {
+  if (state === "received") return "eyes";
+  return "eyes";
+}
+function createSlackReactionPayload(input) {
+  return {
+    channel: input.channelId,
+    timestamp: input.messageTs,
+    name: input.name
+  };
+}
+function nextActionSummary(result) {
+  if (!result.nextAction) return void 0;
+  if (typeof result.nextAction === "string") return result.nextAction;
+  return result.nextAction.summary;
+}
+function stringParam(params, key) {
+  const value = params?.[key];
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function stringArrayParam(params, key) {
+  const value = params?.[key];
+  if (!Array.isArray(value)) return [];
+  return value.filter((item) => typeof item === "string" && item.length > 0);
+}
+function renderVerificationParams(params) {
+  const value = params?.["verification"];
+  if (!Array.isArray(value)) return [];
+  return value.map((item) => {
+    if (!item || typeof item !== "object" || Array.isArray(item)) return void 0;
+    const command = item["command"];
+    const outcome = item["outcome"];
+    return typeof command === "string" && typeof outcome === "string" ? `   - \`${command}\`: ${outcome}` : void 0;
+  }).filter((line) => Boolean(line));
+}
+function renderSuggestedActionDetails(params, action) {
+  if (action !== "create_pull_request") return [];
+  const lines = [];
+  const title = stringParam(params, "title");
+  const head = stringParam(params, "head") ?? stringParam(params, "branch");
+  const base = stringParam(params, "base") ?? stringParam(params, "baseBranch");
+  const changedFiles = stringArrayParam(params, "changedFiles");
+  const risks = stringArrayParam(params, "risks");
+  const verification = renderVerificationParams(params);
+  if (title) lines.push(`   Title: ${markdownToSlackMrkdwn(title)}`);
+  if (head || base) lines.push(`   Branch: \`${head ?? "unknown"}\` -> \`${base ?? "main"}\``);
+  if (changedFiles.length > 0) lines.push(`   Changed files: ${changedFiles.map((file) => `\`${file}\``).join(", ")}`);
+  if (risks.length > 0) {
+    lines.push("   Risks:");
+    for (const risk of risks) {
+      lines.push(`   - ${markdownToSlackMrkdwn(risk)}`);
+    }
+  }
+  if (verification.length > 0) {
+    lines.push("   Verification:");
+    lines.push(...verification);
+  }
+  return lines;
+}
+function truncateSlackText(text2, maxLength) {
+  const normalized = text2.replace(/\s+/g, " ").trim();
+  if (normalized.length <= maxLength) return normalized;
+  return `${normalized.slice(0, Math.max(0, maxLength - 1)).trimEnd()}\u2026`;
+}
+function firstMarkdownSection(text2, heading) {
+  const pattern = new RegExp(`\\*\\*${heading}:\\*\\*\\s*([\\s\\S]*?)(?=\\n\\s*\\n\\*\\*[^*]+:\\*\\*|\\n\\s*\\n[A-Z][^\\n]{0,60}:|$)`, "i");
+  const match = text2.match(pattern);
+  return match?.[1]?.trim();
+}
+function compactSlackSummary(summary) {
+  const whatChanged = firstMarkdownSection(summary, "What changed");
+  const firstParagraph = summary.split(/\n\s*\n/).map((part) => part.trim()).find(Boolean);
+  const selected = whatChanged ?? firstParagraph ?? summary;
+  return truncateSlackText(selected.replace(/^\*\*[^*]+:\*\*\s*/i, ""), 360);
+}
+function compactNextAction(nextAction) {
+  return truncateSlackText(nextAction, 180);
+}
+function renderSuggestedActionCandidateLines(candidate) {
+  const lines = [`${candidate.index}. *${markdownToSlackMrkdwn(candidate.intent.summary)}*`];
+  const details = renderSuggestedActionDetails(candidate.intent.params, candidate.intent.action).filter((line) => line.trim().startsWith("Branch:") || line.trim().startsWith("Changed files:")).map((line) => line.replace(/^\s+/, ""));
+  lines.push(...details);
+  if (candidate.proposalPreconditions?.length) {
+    lines.push(`Preconditions: ${candidate.proposalPreconditions.length} check(s) in the audit log.`);
+  }
+  return lines;
+}
+function renderSuggestedActionsMarkdown(result) {
+  const candidates = suggestedActionCandidatesFromResult(result);
+  if (candidates.length === 0) return [];
+  const lines = ["*Suggested actions*"];
+  const visibleCandidates = candidates.slice(0, MAX_SLACK_SUGGESTED_ACTION_CANDIDATES);
+  for (const candidate of visibleCandidates) {
+    lines.push("", ...renderSuggestedActionCandidateLines(candidate));
+  }
+  const remainingCount = candidates.length - visibleCandidates.length;
+  if (remainingCount > 0) {
+    lines.push("", `Showing first ${visibleCandidates.length} of ${candidates.length} actions. Reply with an action number for the rest.`);
+  }
+  lines.push("", "Use the buttons below, or reply `apply 1`, `approve 1`, or `reject 1`.");
+  return lines;
+}
+function createSuggestedActionButtons(candidate) {
+  return [
+    {
+      type: "button",
+      text: { type: "plain_text", text: `Apply ${candidate.index}`, emoji: true },
+      action_id: `opentag:apply:${candidate.index}`,
+      value: buildSlackSuggestedActionButtonValue({
+        version: 1,
+        command: `apply ${candidate.index}`,
+        proposalId: candidate.proposalId,
+        intentId: candidate.intent.intentId
+      }),
+      style: "primary"
+    },
+    {
+      type: "button",
+      text: { type: "plain_text", text: "Approve", emoji: true },
+      action_id: `opentag:approve:${candidate.index}`,
+      value: buildSlackSuggestedActionButtonValue({
+        version: 1,
+        command: `approve ${candidate.index}`,
+        proposalId: candidate.proposalId,
+        intentId: candidate.intent.intentId
+      })
+    },
+    {
+      type: "button",
+      text: { type: "plain_text", text: "Reject", emoji: true },
+      action_id: `opentag:reject:${candidate.index}`,
+      value: buildSlackSuggestedActionButtonValue({
+        version: 1,
+        command: `reject ${candidate.index}`,
+        proposalId: candidate.proposalId,
+        intentId: candidate.intent.intentId
+      }),
+      style: "danger"
+    }
+  ];
+}
+function renderSlackFinalResult(result) {
+  const lines = [`*Finished: ${result.conclusion}.*`, markdownToSlackMrkdwn(compactSlackSummary(result.summary))];
+  if (result.verification?.length) {
+    lines.push(
+      `Verified: ${result.verification.slice(0, 3).map((check) => `\`${markdownToSlackMrkdwn(check.command)}\` ${markdownToSlackMrkdwn(check.outcome)}`).join(", ")}`
+    );
+  }
+  const nextAction = nextActionSummary(result);
+  if (nextAction && !result.suggestedChanges?.length) {
+    lines.push(`Next: ${markdownToSlackMrkdwn(compactNextAction(nextAction))}`);
+  }
+  const suggestedActions = renderSuggestedActionsMarkdown(result);
+  if (suggestedActions.length > 0) {
+    lines.push("", ...suggestedActions);
+  }
+  return lines.join("\n");
+}
+function createSlackFinalResultBlocks(result) {
+  const blocks = [
+    {
+      type: "section",
+      text: {
+        type: "mrkdwn",
+        text: `*Finished: ${result.conclusion}.*
+${markdownToSlackMrkdwn(compactSlackSummary(result.summary))}`
+      }
+    }
+  ];
+  if (result.verification?.length) {
+    blocks.push({
+      type: "section",
+      text: {
+        type: "mrkdwn",
+        text: `Verified: ${markdownToSlackMrkdwn(
+          result.verification.slice(0, 3).map((check) => `\`${check.command}\` ${check.outcome}`).join(", ")
+        )}`
+      }
+    });
+  }
+  const nextAction = nextActionSummary(result);
+  const suggestedActionCandidates = suggestedActionCandidatesFromResult(result);
+  if (nextAction && suggestedActionCandidates.length === 0) {
+    blocks.push({
+      type: "section",
+      text: {
+        type: "mrkdwn",
+        text: `Next: ${markdownToSlackMrkdwn(compactNextAction(nextAction))}`
+      }
+    });
+  }
+  if (suggestedActionCandidates.length > 0) {
+    blocks.push({ type: "divider" });
+    blocks.push({
+      type: "section",
+      text: {
+        type: "mrkdwn",
+        text: "*Suggested actions*\nChoose an action in this thread. Details stay in the OpenTag audit log."
+      }
+    });
+    const visibleCandidates = suggestedActionCandidates.slice(0, MAX_SLACK_SUGGESTED_ACTION_CANDIDATES);
+    for (const candidate of visibleCandidates) {
+      blocks.push({
+        type: "section",
+        text: {
+          type: "mrkdwn",
+          text: renderSuggestedActionCandidateLines(candidate).join("\n")
+        }
+      });
+      blocks.push({
+        type: "actions",
+        block_id: `opentag_actions_${candidate.index}`,
+        elements: createSuggestedActionButtons(candidate)
+      });
+    }
+    const remainingCount = suggestedActionCandidates.length - visibleCandidates.length;
+    if (remainingCount > 0) {
+      blocks.push({
+        type: "section",
+        text: {
+          type: "mrkdwn",
+          text: `Showing first ${visibleCandidates.length} of ${suggestedActionCandidates.length} actions. Reply with an action number for the rest.`
+        }
+      });
+    }
+  }
+  return blocks;
+}
+function createSlackPostMessagePayload(input) {
+  return {
+    channel: input.channelId,
+    text: markdownToSlackMrkdwn(input.text),
+    thread_ts: input.threadTs,
+    ...input.blocks?.length ? { blocks: input.blocks } : {}
+  };
+}
+function createSlackUpdateMessagePayload(input) {
+  return {
+    channel: input.channelId,
+    text: markdownToSlackMrkdwn(input.text),
+    ts: input.messageTs,
+    ...input.blocks?.length ? { blocks: input.blocks } : {}
+  };
+}
+
+// src/events.ts
+function json(body, status = 200) {
+  return { kind: "json", status, body };
+}
+function text(body, status = 200) {
+  return { kind: "text", status, body };
+}
+function createSlackEventProcessor(input) {
+  async function processBlockActions(payload, slackApp) {
+    const action = payload.actions?.find((candidate) => {
+      if (candidate.action_id?.startsWith("opentag:")) return true;
+      return typeof candidate.value === "string" && parseSlackSuggestedActionButtonValue(candidate.value) !== null;
+    });
+    if (!action) {
+      return json({ ok: true });
+    }
+    const parsedValue = typeof action.value === "string" ? parseSlackSuggestedActionButtonValue(action.value) : null;
+    const rawText = parsedValue?.command ?? (typeof action.value === "string" && parseThreadActionCommand(action.value) ? action.value.trim() : void 0);
+    if (!rawText || !parseThreadActionCommand(rawText)) {
+      return json({ error: "invalid_interactive_action" }, 400);
+    }
+    if (!input.submitThreadAction) {
+      return json({ ok: true });
+    }
+    const teamId = payload.team?.id;
+    const userId = payload.user?.id;
+    const channelId = payload.channel?.id ?? payload.container?.channel_id;
+    const messageTs = payload.message?.ts ?? payload.container?.message_ts;
+    const threadTs = payload.message?.thread_ts ?? payload.container?.thread_ts ?? messageTs;
+    if (!teamId || !userId || !channelId || !messageTs || !threadTs) {
+      return json({ error: "invalid_interactive_payload" }, 400);
+    }
+    const binding = await input.resolveChannelBinding({
+      teamId,
+      channelId
+    });
+    if (!binding) {
+      return json({ ok: true, ignored: "unbound_channel" });
+    }
+    await input.submitThreadAction({
+      id: `approval_slack_block_${payload.trigger_id ?? `${action.action_id ?? "action"}_${action.action_ts ?? messageTs}`}`,
+      rawText,
+      actor: {
+        provider: "slack",
+        providerUserId: userId,
+        handle: payload.user?.username ?? payload.user?.name ?? userId,
+        organizationId: teamId
+      },
+      callback: {
+        provider: "slack",
+        uri: slackApp.callbackUri ?? "https://slack.com/api/chat.postMessage",
+        threadKey: encodeSlackThreadKey({
+          teamId,
+          channelId,
+          threadTs
+        })
+      },
+      metadata: {
+        source: "slack_button",
+        teamId,
+        channelId,
+        messageTs,
+        ...payload.api_app_id ? { slackAppId: payload.api_app_id } : {},
+        ...action.action_id ? { actionId: action.action_id } : {},
+        ...action.block_id ? { blockId: action.block_id } : {},
+        ...action.action_ts ? { actionTs: action.action_ts } : {},
+        ...parsedValue ? { proposalId: parsedValue.proposalId, intentId: parsedValue.intentId } : {},
+        repoProvider: binding.repoProvider ?? "github",
+        owner: binding.owner,
+        repo: binding.repo
+      }
+    });
+    return json({ ok: true });
+  }
+  return {
+    async process(payload, slackApp) {
+      if (payload.type === "block_actions") {
+        return processBlockActions(payload, slackApp);
+      }
+      if (payload.type === "url_verification") {
+        return text(payload.challenge ?? "");
+      }
+      if (payload.type !== "event_callback" || !payload.event || !["app_mention", "message"].includes(payload.event.type)) {
+        return json({ ok: true });
+      }
+      if (payload.event.type === "message" && (payload.event.subtype || payload.event.bot_id)) {
+        return json({ ok: true });
+      }
+      if (!payload.team_id || !payload.event.channel || !payload.event.user || !payload.event.text || !payload.event.ts || !payload.event_id) {
+        return json({ error: "invalid_event_payload" }, 400);
+      }
+      const rawThreadActionText = payload.event.type === "app_mention" ? stripSlackAppMention(payload.event.text, payload.authorizations?.[0]?.user_id) : payload.event.text.trim();
+      if (payload.event.type === "message" && (!rawThreadActionText || !parseThreadActionCommand(rawThreadActionText))) {
+        return json({ ok: true });
+      }
+      const binding = await input.resolveChannelBinding({
+        teamId: payload.team_id,
+        channelId: payload.event.channel
+      });
+      if (!binding) {
+        return json({ ok: true, ignored: "unbound_channel" });
+      }
+      if (rawThreadActionText && parseThreadActionCommand(rawThreadActionText) && input.submitThreadAction) {
+        await input.submitThreadAction({
+          id: `approval_slack_${payload.event_id}`,
+          rawText: rawThreadActionText,
+          actor: {
+            provider: "slack",
+            providerUserId: payload.event.user,
+            handle: payload.event.user,
+            organizationId: payload.team_id
+          },
+          callback: {
+            provider: "slack",
+            uri: slackApp.callbackUri ?? "https://slack.com/api/chat.postMessage",
+            threadKey: encodeSlackThreadKey({
+              teamId: payload.team_id,
+              channelId: payload.event.channel,
+              threadTs: payload.event.thread_ts ?? payload.event.ts
+            })
+          },
+          metadata: {
+            teamId: payload.team_id,
+            channelId: payload.event.channel,
+            messageTs: payload.event.ts,
+            ...payload.api_app_id ? { slackAppId: payload.api_app_id } : {},
+            ...payload.authorizations?.[0]?.user_id ? { slackBotUserId: payload.authorizations[0].user_id } : {},
+            repoProvider: binding.repoProvider ?? "github",
+            owner: binding.owner,
+            repo: binding.repo
+          }
+        });
+        return json({ ok: true });
+      }
+      if (payload.event.type !== "app_mention") {
+        return json({ ok: true });
+      }
+      const event = normalizeSlackAppMention({
+        teamId: payload.team_id,
+        channelId: payload.event.channel,
+        userId: payload.event.user,
+        text: payload.event.text,
+        ts: payload.event.ts,
+        eventId: payload.event_id,
+        eventTime: payload.event_time ?? Math.floor(Date.parse(input.now()) / 1e3),
+        agentId: slackApp.agentId,
+        binding,
+        ...payload.api_app_id ? { appId: payload.api_app_id } : {},
+        ...payload.event.thread_ts ? { threadTs: payload.event.thread_ts } : {},
+        ...payload.authorizations?.[0]?.user_id ? { botUserId: payload.authorizations[0].user_id } : {},
+        ...slackApp.callbackUri ? { callbackUri: slackApp.callbackUri } : {}
+      });
+      if (!event) {
+        return json({ ok: true, ignored: "empty_command" });
+      }
+      await input.createRun(event);
+      return json({ ok: true });
+    }
+  };
+}
+
+// src/ingress.ts
+import { createHmac, timingSafeEqual } from "crypto";
+import { serve } from "@hono/node-server";
+import { Hono } from "hono";
+
+// src/dispatcher-events.ts
+import { randomUUID } from "crypto";
+import { createOpenTagClient } from "@opentag/client";
+function createSlackDispatcherEventProcessorInput(config) {
+  const dispatcherClient = createOpenTagClient({
+    dispatcherUrl: config.dispatcherUrl,
+    ...config.dispatcherToken ? { pairingToken: config.dispatcherToken } : {}
+  });
+  return {
+    async resolveChannelBinding(input) {
+      try {
+        const { binding } = await dispatcherClient.getChannelBinding({
+          provider: "slack",
+          accountId: input.teamId,
+          conversationId: input.channelId
+        });
+        return {
+          teamId: binding.accountId,
+          channelId: binding.conversationId,
+          repoProvider: binding.repoProvider,
+          owner: binding.owner,
+          repo: binding.repo
+        };
+      } catch (error) {
+        if (error instanceof Error && error.message.includes("channel_binding_not_found")) {
+          return null;
+        }
+        throw error;
+      }
+    },
+    async createRun(event) {
+      const runId = `run_${randomUUID()}`;
+      const created = await dispatcherClient.createRun({ runId, event });
+      return created.outcome === "run_created" ? { runId: created.run.id } : { runId };
+    },
+    async submitThreadAction(action) {
+      await dispatcherClient.submitThreadAction(action);
+    },
+    now: () => (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
+// src/ingress.ts
+function computeSlackSignature(input) {
+  const base = `v0:${input.timestamp}:${input.rawBody}`;
+  const digest = createHmac("sha256", input.signingSecret).update(base).digest("hex");
+  return `v0=${digest}`;
+}
+function verifySlackSignature(input) {
+  const expected = computeSlackSignature(input);
+  const expectedBuffer = Buffer.from(expected);
+  const actualBuffer = Buffer.from(input.signature);
+  return expectedBuffer.length === actualBuffer.length && timingSafeEqual(expectedBuffer, actualBuffer);
+}
+function verifySlackTimestamp(input) {
+  const timestampSeconds = Number(input.timestamp);
+  if (!Number.isFinite(timestampSeconds)) return false;
+  const toleranceSeconds = input.toleranceSeconds ?? 300;
+  const ageSeconds = Math.abs(Math.floor(input.nowMs / 1e3) - timestampSeconds);
+  return ageSeconds <= toleranceSeconds;
+}
+function createSlackEventsApp(input) {
+  const app = new Hono();
+  const processor = createSlackEventProcessor(input);
+  function parseSlackPayload(rawBody, contentType) {
+    try {
+      if (contentType?.includes("application/x-www-form-urlencoded") || rawBody.startsWith("payload=")) {
+        const interactivePayload = new URLSearchParams(rawBody).get("payload");
+        if (!interactivePayload) return null;
+        return JSON.parse(interactivePayload);
+      }
+      return JSON.parse(rawBody);
+    } catch {
+      return null;
+    }
+  }
+  function resolveSlackApp(inputValue) {
+    const candidates = inputValue.apiAppId ? input.slackApps.filter((candidate) => !candidate.appId || candidate.appId === inputValue.apiAppId) : input.slackApps;
+    if (candidates.length === 0) {
+      return { error: "unknown_slack_app" };
+    }
+    const slackApp = candidates.find(
+      (candidate) => verifySlackSignature({
+        signingSecret: candidate.signingSecret,
+        timestamp: inputValue.timestamp,
+        rawBody: inputValue.rawBody,
+        signature: inputValue.signature
+      })
+    );
+    return slackApp ? { slackApp } : { error: "invalid_signature" };
+  }
+  app.post("/slack/events", async (c) => {
+    const timestamp = c.req.header("x-slack-request-timestamp");
+    const signature = c.req.header("x-slack-signature");
+    if (!timestamp || !signature) {
+      return c.json({ error: "missing_signature_headers" }, 401);
+    }
+    if (!verifySlackTimestamp({ timestamp, nowMs: input.clock?.() ?? Date.now() })) {
+      return c.json({ error: "stale_signature_timestamp" }, 401);
+    }
+    const rawBody = await c.req.text();
+    const payload = parseSlackPayload(rawBody, c.req.header("content-type"));
+    if (!payload) {
+      return c.json({ error: "invalid_json" }, 400);
+    }
+    const resolvedSlackApp = resolveSlackApp({
+      rawBody,
+      signature,
+      timestamp,
+      ...payload.api_app_id ? { apiAppId: payload.api_app_id } : {}
+    });
+    if ("error" in resolvedSlackApp) {
+      return c.json({ error: resolvedSlackApp.error }, 401);
+    }
+    const result = await processor.process(payload, resolvedSlackApp.slackApp);
+    if (result.kind === "text") {
+      return c.text(result.body, result.status);
+    }
+    return c.json(result.body, result.status);
+  });
+  return app;
+}
+function startSlackIngress(config) {
+  const port = config.port ?? 3040;
+  const server = serve({
+    fetch: createSlackEventsApp({
+      slackApps: [
+        {
+          signingSecret: config.signingSecret,
+          agentId: config.agentId ?? "opentag",
+          ...config.appId ? { appId: config.appId } : {},
+          ...config.callbackUri ? { callbackUri: config.callbackUri } : {}
+        }
+      ],
+      ...createSlackDispatcherEventProcessorInput(config)
+    }).fetch,
+    port
+  });
+  return {
+    url: `http://localhost:${port}`,
+    server,
+    close() {
+      return new Promise((resolve, reject) => {
+        server.close((error) => {
+          if (error) {
+            reject(error);
+            return;
+          }
+          resolve();
+        });
+      });
+    }
+  };
+}
+
+// src/socket-mode.ts
+import WebSocket from "ws";
+var SLACK_CONNECTIONS_OPEN_URL = "https://slack.com/api/apps.connections.open";
+var DEFAULT_RECONNECT_DELAY_MS = 1e3;
+var TERMINAL_SLACK_ERROR_CODES = [
+  "invalid_auth",
+  "not_authed",
+  "account_inactive",
+  "token_revoked",
+  "token_expired",
+  "not_allowed_token_type",
+  "no_permission",
+  "missing_scope",
+  "ekm_access_denied"
+];
+function isTerminalSlackAuthError(error) {
+  if (!(error instanceof Error)) return false;
+  return TERMINAL_SLACK_ERROR_CODES.some((code) => error.message.includes(code));
+}
+function rawDataToString(data) {
+  if (typeof data === "string") return data;
+  if (Buffer.isBuffer(data)) return data.toString("utf8");
+  if (Array.isArray(data)) return Buffer.concat(data).toString("utf8");
+  if (data instanceof ArrayBuffer) return Buffer.from(data).toString("utf8");
+  return Buffer.from(data).toString("utf8");
+}
+async function openSlackSocketUrl(input) {
+  const response = await input.fetchImpl(SLACK_CONNECTIONS_OPEN_URL, {
+    method: "POST",
+    headers: {
+      authorization: `Bearer ${input.appToken}`
+    }
+  });
+  const body = await response.json().catch(() => ({}));
+  if (!response.ok || !body.ok || !body.url) {
+    const reason = body.error ?? `http_${response.status}`;
+    throw new Error(`Slack Socket Mode connection failed: ${reason}`);
+  }
+  return body.url;
+}
+function parseSocketEnvelope(data) {
+  try {
+    return JSON.parse(rawDataToString(data));
+  } catch {
+    return null;
+  }
+}
+async function handleSocketMessage(input) {
+  const envelope = parseSocketEnvelope(input.data);
+  if (!envelope?.envelope_id) {
+    input.logError("[slack] ignored Socket Mode envelope without envelope_id");
+    return;
+  }
+  input.socket.send(JSON.stringify({ envelope_id: envelope.envelope_id }));
+  if (!envelope.payload) {
+    return;
+  }
+  if (input.slackApp.appId && envelope.payload.api_app_id && envelope.payload.api_app_id !== input.slackApp.appId) {
+    return;
+  }
+  if (envelope.type !== "events_api" && envelope.payload.type !== "block_actions") {
+    return;
+  }
+  await input.processor.process(envelope.payload, input.slackApp);
+}
+function wait(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function startSlackSocketModeApp(input, dependencies = {}) {
+  const fetchImpl = dependencies.fetchImpl ?? fetch;
+  const createWebSocket = dependencies.createWebSocket ?? ((url) => new WebSocket(url));
+  const reconnectDelayMs = dependencies.reconnectDelayMs ?? DEFAULT_RECONNECT_DELAY_MS;
+  const log = dependencies.log ?? ((message) => console.log(message));
+  const logError = dependencies.logError ?? ((message, error) => error ? console.error(message, error) : console.error(message));
+  const processor = createSlackEventProcessor(input);
+  let closed = false;
+  let activeSocket;
+  async function runOneConnection(socketUrl) {
+    await new Promise((resolve) => {
+      const socket = createWebSocket(socketUrl);
+      activeSocket = socket;
+      let settled = false;
+      const finish = () => {
+        if (settled) return;
+        settled = true;
+        if (activeSocket === socket) activeSocket = void 0;
+        resolve();
+      };
+      socket.once("open", () => {
+        log("[slack] Socket Mode connected");
+      });
+      socket.on("message", (data) => {
+        void handleSocketMessage({
+          data,
+          socket,
+          processor,
+          slackApp: input.slackApp,
+          logError
+        }).catch((error) => {
+          logError("[slack] failed to handle Socket Mode event:", error);
+        });
+      });
+      socket.once("close", finish);
+      socket.once("error", (error) => {
+        if (!closed) {
+          logError("[slack] Socket Mode connection error:", error);
+        }
+        socket.close();
+        finish();
+      });
+    });
+  }
+  const startPromise = (async () => {
+    while (!closed) {
+      try {
+        const socketUrl = await openSlackSocketUrl({ appToken: input.appToken, fetchImpl });
+        await runOneConnection(socketUrl);
+      } catch (error) {
+        if (isTerminalSlackAuthError(error)) {
+          if (!closed) {
+            logError("[slack] terminal Socket Mode auth/config error, aborting:", error);
+          }
+          throw error;
+        }
+        if (!closed) {
+          logError("[slack] failed to open Socket Mode connection, retrying:", error);
+        }
+      }
+      if (!closed) {
+        await wait(reconnectDelayMs);
+      }
+    }
+  })();
+  return {
+    startPromise,
+    async close() {
+      closed = true;
+      activeSocket?.close();
+      await startPromise.catch(() => void 0);
+    }
+  };
+}
+function startSlackSocketModeIngress(config, dependencies = {}) {
+  return startSlackSocketModeApp(
+    {
+      appToken: config.appToken,
+      slackApp: {
+        agentId: config.agentId ?? "opentag",
+        ...config.appId ? { appId: config.appId } : {},
+        ...config.callbackUri ? { callbackUri: config.callbackUri } : {}
+      },
+      ...createSlackDispatcherEventProcessorInput(config)
+    },
+    dependencies
+  );
+}
 export {
+  buildSlackSuggestedActionButtonValue,
+  computeSlackSignature,
+  createSlackEventProcessor,
+  createSlackEventsApp,
+  createSlackFinalResultBlocks,
+  createSlackPostMessagePayload,
+  createSlackReactionPayload,
+  createSlackUpdateMessagePayload,
   encodeSlackThreadKey,
+  markdownToSlackMrkdwn,
   normalizeSlackAppMention,
+  parseSlackSuggestedActionButtonValue,
   parseSlackThreadKey,
-  stripSlackAppMention
+  renderSlackAcknowledgement,
+  renderSlackFinalResult,
+  slackSourceReceiptReactionName,
+  startSlackIngress,
+  startSlackSocketModeApp,
+  startSlackSocketModeIngress,
+  stripSlackAppMention,
+  verifySlackSignature,
+  verifySlackTimestamp
 };
 //# sourceMappingURL=index.js.map