@cursor/july 0.1.1

package/dist/channels/slack/manifest.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Generate importable Slack app manifests (dev + prod).
+ *
+ * Import at https://api.slack.com/apps -> Create New App -> From a manifest.
+ * Always Socket Mode — no Events Request URL.
+ */
+import type { SlackManifestOptions } from "./types.js";
+export interface SlackAppManifest {
+    display_information: {
+        name: string;
+        description?: string;
+    };
+    features: {
+        bot_user: {
+            display_name: string;
+            always_online: boolean;
+        };
+        assistant_view?: {
+            assistant_description: string;
+            suggested_prompts: Array<{
+                title: string;
+                message: string;
+            }>;
+        };
+        app_home?: {
+            home_tab_enabled: boolean;
+            messages_tab_enabled: boolean;
+            messages_tab_read_only_enabled: boolean;
+        };
+    };
+    oauth_config: {
+        scopes: {
+            bot: string[];
+        };
+    };
+    settings: {
+        event_subscriptions: {
+            bot_events: string[];
+        };
+        interactivity: {
+            is_enabled: boolean;
+        };
+        org_deploy_enabled: boolean;
+        socket_mode_enabled: boolean;
+        token_rotation_enabled: boolean;
+        is_mcp_enabled: boolean;
+    };
+}
+/**
+ * Build a Slack app manifest suitable for Create from Manifest.
+ */
+export declare function buildSlackManifest(options: SlackManifestOptions): SlackAppManifest;
+export declare function buildSlackManifestPair(options: Omit<SlackManifestOptions, "env">): {
+    dev: SlackAppManifest;
+    prod: SlackAppManifest;
+};
+//# sourceMappingURL=manifest.d.ts.map

package/dist/channels/slack/manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../../../src/channels/slack/manifest.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEvD,MAAM,WAAW,gBAAgB;IAC/B,mBAAmB,EAAE;QACnB,IAAI,EAAE,MAAM,CAAC;QACb,WAAW,CAAC,EAAE,MAAM,CAAC;KACtB,CAAC;IACF,QAAQ,EAAE;QACR,QAAQ,EAAE;YACR,YAAY,EAAE,MAAM,CAAC;YACrB,aAAa,EAAE,OAAO,CAAC;SACxB,CAAC;QACF,cAAc,CAAC,EAAE;YACf,qBAAqB,EAAE,MAAM,CAAC;YAC9B,iBAAiB,EAAE,KAAK,CAAC;gBAAE,KAAK,EAAE,MAAM,CAAC;gBAAC,OAAO,EAAE,MAAM,CAAA;aAAE,CAAC,CAAC;SAC9D,CAAC;QACF,QAAQ,CAAC,EAAE;YACT,gBAAgB,EAAE,OAAO,CAAC;YAC1B,oBAAoB,EAAE,OAAO,CAAC;YAC9B,8BAA8B,EAAE,OAAO,CAAC;SACzC,CAAC;KACH,CAAC;IACF,YAAY,EAAE;QACZ,MAAM,EAAE;YACN,GAAG,EAAE,MAAM,EAAE,CAAC;SACf,CAAC;KACH,CAAC;IACF,QAAQ,EAAE;QACR,mBAAmB,EAAE;YACnB,UAAU,EAAE,MAAM,EAAE,CAAC;SACtB,CAAC;QACF,aAAa,EAAE;YACb,UAAU,EAAE,OAAO,CAAC;SACrB,CAAC;QACF,kBAAkB,EAAE,OAAO,CAAC;QAC5B,mBAAmB,EAAE,OAAO,CAAC;QAC7B,sBAAsB,EAAE,OAAO,CAAC;QAChC,cAAc,EAAE,OAAO,CAAC;KACzB,CAAC;CACH;AAyCD;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,oBAAoB,GAC5B,gBAAgB,CA0ElB;AAED,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,IAAI,CAAC,oBAAoB,EAAE,KAAK,CAAC,GACzC;IACD,GAAG,EAAE,gBAAgB,CAAC;IACtB,IAAI,EAAE,gBAAgB,CAAC;CACxB,CAKA"}

package/dist/channels/slack/manifest.js

@@ -0,0 +1,110 @@
+/**
+ * Generate importable Slack app manifests (dev + prod).
+ *
+ * Import at https://api.slack.com/apps -> Create New App -> From a manifest.
+ * Always Socket Mode — no Events Request URL.
+ */
+const BOT_SCOPES = [
+    "app_mentions:read",
+    "assistant:write",
+    "channels:history",
+    "chat:write",
+    "groups:history",
+    "im:history",
+    "im:read",
+    "im:write",
+    "mpim:history",
+    "users:read",
+];
+const BOT_EVENTS = ["app_mention", "message.im"];
+function appSlug(name) {
+    const base = name
+        .toLowerCase()
+        .replace(/[^a-zA-Z0-9_-]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 32);
+    return base.length > 0 ? base : "agent";
+}
+function isBennyApp(name) {
+    return appSlug(name) === "benny";
+}
+function toBotDisplayName(name, env) {
+    const fallback = appSlug(name);
+    // The Cursor Automations Benny already owns @benny in the Anysphere
+    // workspace, so the agent-serve Benny app must use @benny-dev in both
+    // envs (not only the usual -dev suffix on the dev profile).
+    if (fallback === "benny") {
+        return "benny-dev";
+    }
+    return env === "dev" ? `${fallback}-dev`.slice(0, 35) : fallback;
+}
+/**
+ * Build a Slack app manifest suitable for Create from Manifest.
+ */
+export function buildSlackManifest(options) {
+    var _a, _b;
+    const env = options.env;
+    const benny = isBennyApp(options.name);
+    // Benny's app title matches its handle so the Install App UI shows
+    // benny-dev (not "benny (dev)" / "Benny").
+    const displayName = benny
+        ? "benny-dev"
+        : env === "dev"
+            ? `${options.name} (dev)`
+            : options.name;
+    const botName = (_a = options.botDisplayName) !== null && _a !== void 0 ? _a : toBotDisplayName(options.name, env);
+    const includeAssistant = options.assistant !== false;
+    const botScopes = includeAssistant
+        ? [...BOT_SCOPES]
+        : BOT_SCOPES.filter((scope) => scope !== "assistant:write");
+    const botEvents = options.channelPosts === true
+        ? [...BOT_EVENTS, "message.channels", "message.groups"]
+        : [...BOT_EVENTS];
+    const suggested = options.suggestedPrompts !== undefined ? options.suggestedPrompts : [];
+    return {
+        display_information: Object.assign({ name: displayName }, (options.description === undefined
+            ? {}
+            : { description: options.description })),
+        features: Object.assign({ bot_user: {
+                display_name: botName,
+                always_online: true,
+            }, app_home: {
+                home_tab_enabled: false,
+                messages_tab_enabled: true,
+                messages_tab_read_only_enabled: false,
+            } }, (includeAssistant
+            ? {
+                assistant_view: {
+                    assistant_description: (_b = options.description) !== null && _b !== void 0 ? _b : `${options.name} agent served by agent-serve`,
+                    suggested_prompts: suggested,
+                },
+            }
+            : {})),
+        oauth_config: {
+            scopes: {
+                bot: botScopes,
+            },
+        },
+        settings: {
+            event_subscriptions: {
+                bot_events: botEvents,
+            },
+            interactivity: {
+                is_enabled: options.interactivity === true,
+            },
+            // Benny installs org-wide in the Cursor FE & ADM workspace.
+            org_deploy_enabled: benny,
+            // Always Socket Mode — agent-serve has no Events Request URL path.
+            // (Do not set false even if Slack's empty-app stub defaults to off.)
+            socket_mode_enabled: true,
+            token_rotation_enabled: false,
+            is_mcp_enabled: false,
+        },
+    };
+}
+export function buildSlackManifestPair(options) {
+    return {
+        dev: buildSlackManifest(Object.assign(Object.assign({}, options), { env: "dev" })),
+        prod: buildSlackManifest(Object.assign(Object.assign({}, options), { env: "prod" })),
+    };
+}

package/dist/channels/slack/pr-ref.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Best-effort GitHub PR references from free-form chat (Slack, etc.).
+ */
+export interface GithubPrRef {
+    /** Normalized URL `https://github.com/owner/repo/pull/N`. */
+    url: string;
+    /** Compact `owner/repo#N`. */
+    label: string;
+    owner: string;
+    repo: string;
+    number: number;
+}
+/**
+ * Find the first GitHub PR URL or `owner/repo#N` in `text`.
+ * Returns `undefined` when none is present.
+ */
+export declare function extractGithubPrRef(text: string): GithubPrRef | undefined;
+//# sourceMappingURL=pr-ref.d.ts.map

package/dist/channels/slack/pr-ref.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pr-ref.d.ts","sourceRoot":"","sources":["../../../src/channels/slack/pr-ref.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,WAAW,WAAW;IAC1B,6DAA6D;IAC7D,GAAG,EAAE,MAAM,CAAC;IACZ,8BAA8B;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS,CA+BxE"}

package/dist/channels/slack/pr-ref.js

@@ -0,0 +1,36 @@
+/**
+ * Best-effort GitHub PR references from free-form chat (Slack, etc.).
+ */
+/**
+ * Find the first GitHub PR URL or `owner/repo#N` in `text`.
+ * Returns `undefined` when none is present.
+ */
+export function extractGithubPrRef(text) {
+    const urlMatch = text.match(/https?:\/\/(?:www\.)?github\.com\/([\w.-]+)\/([\w.-]+)\/pull\/(\d+)/i);
+    if (urlMatch !== null) {
+        const owner = urlMatch[1];
+        const repo = urlMatch[2];
+        const number = Number(urlMatch[3]);
+        return {
+            owner,
+            repo,
+            number,
+            url: `https://github.com/${owner}/${repo}/pull/${number}`,
+            label: `${owner}/${repo}#${number}`,
+        };
+    }
+    const hashMatch = text.match(/\b([\w.-]+)\/([\w.-]+)#(\d+)\b/);
+    if (hashMatch === null) {
+        return undefined;
+    }
+    const owner = hashMatch[1];
+    const repo = hashMatch[2];
+    const number = Number(hashMatch[3]);
+    return {
+        owner,
+        repo,
+        number,
+        url: `https://github.com/${owner}/${repo}/pull/${number}`,
+        label: `${owner}/${repo}#${number}`,
+    };
+}

package/dist/channels/slack/setup.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Slack setup guide printed by `agent-serve slack setup`.
+ *
+ * Mirrors the Cursor skill at skills/setup-slack/SKILL.md.
+ */
+export interface SlackSetupPhase {
+    id: string;
+    actor: "agent" | "human";
+    title: string;
+    steps: string[];
+}
+export declare const SLACK_SETUP_PHASES: SlackSetupPhase[];
+export declare function formatSlackSetupGuide(): string;
+//# sourceMappingURL=setup.d.ts.map

package/dist/channels/slack/setup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setup.d.ts","sourceRoot":"","sources":["../../../src/channels/slack/setup.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB;AAED,eAAO,MAAM,kBAAkB,EAAE,eAAe,EA4D/C,CAAC;AAEF,wBAAgB,qBAAqB,IAAI,MAAM,CAqB9C"}

package/dist/channels/slack/setup.js

@@ -0,0 +1,86 @@
+/**
+ * Slack setup guide printed by `agent-serve slack setup`.
+ *
+ * Mirrors the Cursor skill at skills/setup-slack/SKILL.md.
+ */
+export const SLACK_SETUP_PHASES = [
+    {
+        id: "generate",
+        actor: "agent",
+        title: "Generate channel + manifests",
+        steps: [
+            "agent-serve slack init --dir . --name My Agent",
+            "Manifests default to Socket Mode (no public Request URL).",
+        ],
+    },
+    {
+        id: "createApps",
+        actor: "human",
+        title: "Create two Slack apps from manifests",
+        steps: [
+            "Open https://api.slack.com/apps -> Create New App from a manifest",
+            "Paste .agent-serve/slack/manifest.dev.json -> create the *dev* app",
+            "Repeat with manifest.prod.json for the *prod* app",
+        ],
+    },
+    {
+        id: "install",
+        actor: "human",
+        title: "Install + mint App-Level Token",
+        steps: [
+            "Install to Workspace; copy Bot User OAuth Token (xoxb-...)",
+            "App-Level Tokens: create token with connections:write; copy xapp-...",
+        ],
+    },
+    {
+        id: "env",
+        actor: "agent",
+        title: "Wire environment",
+        steps: [
+            "Write per-agent tokens into .env.local (see .agent-serve/slack/env.example)",
+            "Multi-agent: <PREFIX>_SLACK_BOT_TOKEN + <PREFIX>_SLACK_APP_TOKEN",
+            "Single agent: SLACK_BOT_TOKEN + SLACK_APP_TOKEN (--no-prefix)",
+            "agent-serve slack doctor --prefix <PREFIX>",
+        ],
+    },
+    {
+        id: "serve",
+        actor: "agent",
+        title: "Serve",
+        steps: [
+            "agent-serve serve --dir . --dev",
+            "Confirm log: [agent-serve/slack] Socket Mode connected",
+        ],
+    },
+    {
+        id: "smoke",
+        actor: "human",
+        title: "Smoke test",
+        steps: [
+            "Invite the bot to a channel",
+            "@mention it or DM it",
+            "Confirm logs: inbound → session start → reply delivered",
+            "Confirm streaming reply and rotating status",
+        ],
+    },
+];
+export function formatSlackSetupGuide() {
+    const lines = [
+        "agent-serve — Slack setup (Socket Mode)",
+        "",
+        "Goal: importable dev + prod Slack apps over Socket Mode (no public URL).",
+        "App-Level Token (xapp-...) + Bot Token (xoxb-...) required.",
+        "",
+    ];
+    for (const [index, phase] of SLACK_SETUP_PHASES.entries()) {
+        lines.push(`## Phase ${index} — ${phase.title} (${phase.actor})`);
+        for (const step of phase.steps) {
+            lines.push(`  - ${step}`);
+        }
+        lines.push("");
+    }
+    lines.push("Status file: .agent-serve/slack/setup-status.json");
+    lines.push("Skill (Cursor): packages/agent-serve/skills/setup-slack/SKILL.md");
+    lines.push("");
+    return lines.join("\n");
+}

package/dist/channels/slack/slack-channel.d.ts

@@ -0,0 +1,15 @@
+/**
+ * `slackChannel()` — platform channel pack for Slack (Socket Mode).
+ *
+ * Inbound events arrive over a WebSocket (`SLACK_APP_TOKEN`); no public
+ * Request URL or Events HTTP route is required. When `toolApprovals`
+ * is enabled, Approve/Deny buttons arrive as Socket Mode `interactive`
+ * envelopes.
+ */
+import type { ChannelDefinition } from "../../types.js";
+import type { SlackChannelOptions, SlackChannelState } from "./types.js";
+/**
+ * Create a Slack channel. Author as `agent/channels/slack.ts` default export.
+ */
+export declare function slackChannel(options?: SlackChannelOptions): ChannelDefinition<SlackChannelState>;
+//# sourceMappingURL=slack-channel.d.ts.map

package/dist/channels/slack/slack-channel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slack-channel.d.ts","sourceRoot":"","sources":["../../../src/channels/slack/slack-channel.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EACV,iBAAiB,EAMlB,MAAM,gBAAgB,CAAC;AAuCxB,OAAO,KAAK,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAEzE;;GAEG;AACH,wBAAgB,YAAY,CAC1B,OAAO,GAAE,mBAAwB,GAChC,iBAAiB,CAAC,iBAAiB,CAAC,CAsTtC"}

package/dist/channels/slack/slack-channel.js

@@ -0,0 +1,281 @@
+/**
+ * `slackChannel()` — platform channel pack for Slack (Socket Mode).
+ *
+ * Inbound events arrive over a WebSocket (`SLACK_APP_TOKEN`); no public
+ * Request URL or Events HTTP route is required. When `toolApprovals`
+ * is enabled, Approve/Deny buttons arrive as Socket Mode `interactive`
+ * envelopes.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { allowAll, defineChannel } from "../../channels.js";
+import { slackContinuationKey } from "./api.js";
+import { createChannelPostWatcher, resolveChannelNames, SlackChannelAllowlist, } from "./channel-watch.js";
+import { credentialsFromEnv, slackEnvKeys, tryResolveAppToken, tryResolveBotToken, } from "./credentials.js";
+import { createPendingSlackApiTransport, registerSlackCursorAccountRuntime, } from "./cursor-account.js";
+import { buildDefaultEvents, defaultOnAppMention, defaultOnChannelPost, defaultOnDirectMessage, } from "./defaults.js";
+import { dispatchInboundFromEventBody, dispatchInboundMessage, emptySlackChannelState, } from "./dispatch.js";
+import { createEventIdDedupe } from "./event-id-dedupe.js";
+import { dispatchInteractiveFromPayload } from "./interactive.js";
+import { createSlackLogger } from "./log.js";
+import { startSlackSocketMode, } from "./socket-mode.js";
+import { buildToolApprovalEvents } from "./tool-approval-events.js";
+/**
+ * Create a Slack channel. Author as `agent/channels/slack.ts` default export.
+ */
+export function slackChannel(options = {}) {
+    var _a, _b, _c;
+    var _d, _e, _f, _g, _h;
+    const cursorAccount = options.cursorAccount === true;
+    if (cursorAccount) {
+        // Token pair and the Cursor connection are different Slack apps —
+        // they can't be mixed on one channel definition.
+        if (options.credentials !== undefined || options.envPrefix !== undefined) {
+            throw new Error("slackChannel({ cursorAccount: true }) uses the Cursor account's Slack connection — do not also set credentials/envPrefix. Author a second slack channel file for a dedicated Slack app.");
+        }
+        // Channel watching is Socket Mode only — cursorAccount agents must be
+        // explicitly addressed (@mention, DM, or claimed-thread reply).
+        if (((_a = options.engagement) === null || _a === void 0 ? void 0 : _a.channelPosts) !== undefined) {
+            throw new Error("slackChannel({ cursorAccount: true }) does not support engagement.channelPosts — agents must be explicitly addressed (@mention, DM, or claimed-thread reply). Channel watching is Socket Mode only.");
+        }
+        // Mentions/DMs are always routed by the backend. Disabling them
+        // client-side would black-hole events the webhook already stole from
+        // native Cursor handling — reject at construction instead.
+        if (((_b = options.engagement) === null || _b === void 0 ? void 0 : _b.mentions) === false) {
+            throw new Error("slackChannel({ cursorAccount: true }) cannot set engagement.mentions to false — the Cursor Slack relay always delivers mention and claimed-thread traffic.");
+        }
+        if (((_c = options.engagement) === null || _c === void 0 ? void 0 : _c.directMessages) === false) {
+            throw new Error("slackChannel({ cursorAccount: true }) cannot set engagement.directMessages to false — DM continuity is part of the Cursor Slack connection.");
+        }
+        // Tool approvals / interactivity ride Slack Socket Mode `interactive`
+        // envelopes; the Cursor connection does not relay Block Kit clicks, so
+        // there is no backend tap to route Approve/Deny over cursorAccount.
+        // Reject at construction (same posture as channelPosts) instead of
+        // silently dropping clicks. Approvals stay available on a dedicated
+        // Socket Mode Slack app channel.
+        if (options.toolApprovals === true) {
+            throw new Error("slackChannel({ cursorAccount: true }) does not support toolApprovals — Approve/Deny clicks are not relayed over the Cursor Slack connection. Tool approvals are Socket Mode only (author a dedicated Slack app channel for them).");
+        }
+        if (options.interactivity === true) {
+            throw new Error("slackChannel({ cursorAccount: true }) does not support interactivity — interactive Block Kit clicks are not relayed over the Cursor Slack connection. Interactivity is Socket Mode only.");
+        }
+    }
+    const accountTransport = cursorAccount
+        ? createPendingSlackApiTransport()
+        : undefined;
+    const credentials = accountTransport !== undefined
+        ? { botToken: accountTransport }
+        : ((_d = options.credentials) !== null && _d !== void 0 ? _d : credentialsFromEnv(options.envPrefix));
+    const envKeys = slackEnvKeys(options.envPrefix);
+    const onAppMention = (_e = options.onAppMention) !== null && _e !== void 0 ? _e : defaultOnAppMention;
+    const onDirectMessage = (_f = options.onDirectMessage) !== null && _f !== void 0 ? _f : defaultOnDirectMessage;
+    const onChannelPost = (_g = options.onChannelPost) !== null && _g !== void 0 ? _g : defaultOnChannelPost;
+    const engagement = (_h = options.engagement) !== null && _h !== void 0 ? _h : {};
+    const mentionsEnabled = engagement.mentions !== false;
+    const directMessagesEnabled = engagement.directMessages !== false;
+    const channelPosts = engagement.channelPosts;
+    if (channelPosts !== undefined) {
+        const entries = channelPosts.allow.filter((entry) => entry.trim() !== "");
+        if (entries.length === 0) {
+            throw new Error("slackChannel engagement.channelPosts.allow must list at least one channel (id or #name); there is no wildcard watch.");
+        }
+    }
+    const eventIds = createEventIdDedupe();
+    const toolApprovals = options.toolApprovals === true;
+    const interactivity = options.interactivity === true;
+    const routeInteractive = toolApprovals || interactivity;
+    const runtime = {
+        log: createSlackLogger(options.logger),
+    };
+    const getLog = () => runtime.log;
+    const events = {};
+    if (options.deliverDefaults !== false) {
+        Object.assign(events, buildDefaultEvents({
+            credentials,
+            // cursorAccount: never edit posts — setStatus for thinking, one
+            // final postMessage for the reply (proxy pins agent username/icon).
+            streaming: cursorAccount ? false : options.streaming,
+            thinkingSteps: options.thinkingSteps,
+            suggestedPrompts: options.suggestedPrompts,
+            suggestedPromptsTitle: options.suggestedPromptsTitle,
+            getLog,
+        }));
+    }
+    if (toolApprovals) {
+        Object.assign(events, buildToolApprovalEvents({ credentials, getLog }));
+    }
+    Object.assign(events, options.events);
+    let socketHandle = null;
+    let channelWatch;
+    function inboundDeps(args) {
+        return Object.assign({ send: args.send, waitUntil: args.waitUntil, onAppMention,
+            onDirectMessage,
+            credentials,
+            eventIds, host: args.host, log: getLog(), mentionsEnabled,
+            directMessagesEnabled }, (channelWatch === undefined ? {} : { channelWatch }));
+    }
+    const definition = defineChannel({
+        auth: [allowAll()],
+        state: emptySlackChannelState(),
+        routes: [],
+        meta: Object.assign(Object.assign({ kind: "slack" }, (cursorAccount ? { slackCursorAccount: true } : {})), (channelPosts === undefined
+            ? {}
+            : { slackChannelPosts: [...channelPosts.allow] })),
+        receive(input_1, _a) {
+            return __awaiter(this, arguments, void 0, function* (input, { send }) {
+                var _b;
+                const target = (_b = input.target) !== null && _b !== void 0 ? _b : {};
+                const channelId = typeof target.channelId === "string" ? target.channelId : "";
+                if (channelId === "") {
+                    throw new Error("slackChannel().receive requires target.channelId (Slack channel id).");
+                }
+                const threadTs = typeof target.threadTs === "string" ? target.threadTs : "";
+                if (threadTs === "") {
+                    throw new Error("slackChannel().receive requires target.threadTs (Slack thread ts).");
+                }
+                const teamId = typeof target.teamId === "string" ? target.teamId : undefined;
+                getLog().info("receive handoff", {
+                    channel: channelId,
+                    thread_ts: threadTs,
+                    team: teamId,
+                });
+                return send(input.message, {
+                    auth: input.auth,
+                    continuationToken: slackContinuationKey(channelId, threadTs),
+                    state: emptySlackChannelState({
+                        channelId,
+                        threadTs,
+                        teamId: teamId !== null && teamId !== void 0 ? teamId : null,
+                    }),
+                });
+            });
+        },
+        events,
+        onStart(args) {
+            return __awaiter(this, void 0, void 0, function* () {
+                var _a, _b, _c;
+                runtime.log = createSlackLogger((_a = args.logger) !== null && _a !== void 0 ? _a : options.logger);
+                if (cursorAccount) {
+                    // Inbound arrives through the serve host's Cursor Slack relay
+                    // (`/v0/slack-events`), not Socket Mode; outbound goes through the
+                    // bound API transport. Nothing to start here.
+                    getLog().info("channel start", { transport: "cursor-account" });
+                    return;
+                }
+                getLog().info("channel start", { transport: "socket" });
+                const appToken = yield tryResolveAppToken(credentials);
+                const botToken = yield tryResolveBotToken(credentials);
+                if (appToken === undefined || botToken === undefined) {
+                    getLog().info("channel idle", {
+                        reason: "missing credentials",
+                        need: `${envKeys.bot} and ${envKeys.app}`,
+                    });
+                    return;
+                }
+                if (channelPosts !== undefined) {
+                    const allowlist = new SlackChannelAllowlist(channelPosts.allow);
+                    let botUserId;
+                    try {
+                        const { WebClient } = yield import("@slack/web-api");
+                        const client = new WebClient(botToken);
+                        const identity = yield client.auth.test();
+                        botUserId =
+                            typeof identity.user_id === "string" ? identity.user_id : undefined;
+                        const names = allowlist.unresolvedNames();
+                        if (names.length > 0) {
+                            allowlist.applyResolvedNames(yield resolveChannelNames(client, names, getLog()));
+                        }
+                    }
+                    catch (error) {
+                        getLog().error("channel watch setup degraded", {
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                    }
+                    channelWatch = createChannelPostWatcher({
+                        options: channelPosts,
+                        allowlist,
+                        getBotUserId: () => botUserId,
+                        log: getLog(),
+                        dispatch: (message, eventId) => {
+                            args.waitUntil(dispatchInboundMessage(Object.assign({ kind: "channel_post", message, handler: onChannelPost, send: args.send, credentials, host: args.host, log: getLog() }, (eventId === undefined ? {} : { eventId }))));
+                        },
+                    });
+                    getLog().info("channel watch enabled", {
+                        channels: channelPosts.allow.join(","),
+                        posts: (_b = channelPosts.posts) !== null && _b !== void 0 ? _b : "top-level",
+                        debounce_ms: (_c = channelPosts.debounceMs) !== null && _c !== void 0 ? _c : 0,
+                    });
+                }
+                const socketOptions = {
+                    appToken,
+                    logger: (line) => getLog().write(line),
+                    onEvent: (payload) => {
+                        dispatchInboundFromEventBody(payload, inboundDeps({
+                            send: args.send,
+                            waitUntil: args.waitUntil,
+                            host: args.host,
+                        }));
+                    },
+                };
+                if (routeInteractive) {
+                    socketOptions.onInteractive = (payload) => __awaiter(this, void 0, void 0, function* () {
+                        yield dispatchInteractiveFromPayload(payload, {
+                            credentials,
+                            getSession: args.getSession,
+                            resolveApproval: args.resolveApproval,
+                            waitUntil: args.waitUntil,
+                            log: getLog(),
+                        });
+                    });
+                }
+                try {
+                    socketHandle = yield startSlackSocketMode(socketOptions);
+                }
+                catch (error) {
+                    // Bad Vault tokens / revoked apps: Socket Mode fails once with
+                    // invalid_auth and does not reconnect. Treat as idle so one bad
+                    // Slack pack does not blow up server start with a stack dump.
+                    const message = error instanceof Error ? error.message : String(error);
+                    if (message.includes("invalid_auth") ||
+                        message.includes("not_authed")) {
+                        getLog().info("channel idle", {
+                            reason: "invalid credentials",
+                            need: `${envKeys.bot} and ${envKeys.app}`,
+                        });
+                        return;
+                    }
+                    throw error;
+                }
+            });
+        },
+        onStop: () => __awaiter(this, void 0, void 0, function* () {
+            getLog().info("channel stop");
+            channelWatch === null || channelWatch === void 0 ? void 0 : channelWatch.stop();
+            channelWatch = undefined;
+            yield socketHandle === null || socketHandle === void 0 ? void 0 : socketHandle.stop();
+            socketHandle = null;
+        }),
+    });
+    if (accountTransport !== undefined) {
+        // Serve-time seam: the host discovers cursor-account channels through
+        // this registry, binds the outbound transport, and dispatches relayed
+        // inbound envelopes through the pack's normal path.
+        registerSlackCursorAccountRuntime(definition, {
+            options,
+            credentials,
+            transport: accountTransport,
+            eventIds,
+            onAppMention,
+            onDirectMessage,
+            getLog,
+        });
+    }
+    return definition;
+}

package/dist/channels/slack/socket-mode.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Slack Socket Mode via `@slack/socket-mode`.
+ *
+ * Thin wrapper: ACK envelopes immediately, then forward Events API
+ * payloads to the channel pack. Reconnect is handled by the SDK.
+ */
+export interface SlackSocketModeOptions {
+    appToken: string;
+    /** Events API payloads (`type: events_api` envelope body). */
+    onEvent: (payload: unknown) => void | Promise<void>;
+    /**
+     * Interactive payloads (`type: interactive` — Block Kit actions).
+     * When omitted, interactive envelopes are ACKed and ignored.
+     */
+    onInteractive?: (payload: unknown) => void | Promise<void>;
+    logger?: (line: string) => void;
+}
+export interface SlackSocketModeHandle {
+    stop(): void | Promise<void>;
+}
+/**
+ * Start a Socket Mode connection. Call `stop()` to tear down.
+ * Resolves once the first WebSocket session is connected.
+ */
+export declare function startSlackSocketMode(options: SlackSocketModeOptions): Promise<SlackSocketModeHandle>;
+//# sourceMappingURL=socket-mode.d.ts.map

package/dist/channels/slack/socket-mode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"socket-mode.d.ts","sourceRoot":"","sources":["../../../src/channels/slack/socket-mode.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,MAAM,WAAW,sBAAsB;IACrC,QAAQ,EAAE,MAAM,CAAC;IACjB,8DAA8D;IAC9D,OAAO,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACpD;;;OAGG;IACH,aAAa,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3D,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CACjC;AAED,MAAM,WAAW,qBAAqB;IACpC,IAAI,IAAI,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9B;AA+DD;;;GAGG;AACH,wBAAsB,oBAAoB,CACxC,OAAO,EAAE,sBAAsB,GAC9B,OAAO,CAAC,qBAAqB,CAAC,CA6DhC"}