@cursor/july 0.1.1

package/dist/channels/slack/dispatch.js

@@ -0,0 +1,185 @@
+/**
+ * Shared inbound dispatch for Slack Events API bodies and Socket Mode.
+ */
+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 { SessionBusyError } from "../../internal/session-engine.js";
+import { buildSlackBinding, slackContinuationKey } from "./api.js";
+import { firstLineTitle, maybeSetThreadTitle } from "./assistant.js";
+import { formatSlackContextBlock, parseAppMentionEvent, parseChannelMessageEvent, parseDirectMessageEvent, } from "./inbound.js";
+import { defaultSlackLog } from "./log.js";
+const BUSY_REPLY = "I'm still working on your previous message in this thread — I'll reply when that finishes. Send another message after that.";
+/** Blank per-session adapter state. */
+export function emptySlackChannelState(patch = {}) {
+    return Object.assign({ channelId: null, threadTs: null, teamId: null, triggeringUserId: null, pendingToolCallMessage: null, lastReasoningTypingAtMs: null, lastReasoningTypingStatus: null, streamTs: null, streamChannelId: null, lastPostedText: null, streamingUnavailable: false, approvalMessageByCallId: {} }, patch);
+}
+export function dispatchInboundMessage(args) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d, _e, _f;
+        var _g, _h, _j, _k, _l, _m, _o;
+        const { message, kind } = args;
+        const log = (_g = args.log) !== null && _g !== void 0 ? _g : defaultSlackLog;
+        const binding = buildSlackBinding(Object.assign({ botToken: (_a = args.credentials) === null || _a === void 0 ? void 0 : _a.botToken, channelId: message.channelId, threadTs: message.threadTs, host: args.host, log }, (message.teamId === undefined ? {} : { teamId: message.teamId })));
+        log.info("inbound", {
+            kind,
+            event_id: args.eventId,
+            channel: message.channelId,
+            thread_ts: message.threadTs,
+            message_ts: message.ts,
+            user: (_b = message.author) === null || _b === void 0 ? void 0 : _b.userId,
+            team: message.teamId,
+        });
+        if (message.ts === message.threadTs) {
+            yield maybeSetThreadTitle({
+                botToken: (_c = args.credentials) === null || _c === void 0 ? void 0 : _c.botToken,
+                channelId: message.channelId,
+                threadTs: message.threadTs,
+                title: firstLineTitle(message.markdown),
+                log,
+            });
+        }
+        let decision;
+        try {
+            decision = yield args.handler(binding, message);
+        }
+        catch (error) {
+            log.error(`${kind} handler failed`, {
+                error: error instanceof Error ? error.message : String(error),
+                channel: message.channelId,
+                thread_ts: message.threadTs,
+                event_id: args.eventId,
+            });
+            return;
+        }
+        if (decision === null || decision === undefined) {
+            log.info("inbound skipped (handler returned null)", {
+                kind,
+                channel: message.channelId,
+                thread_ts: message.threadTs,
+                event_id: args.eventId,
+            });
+            return;
+        }
+        const userText = (_h = decision.message) !== null && _h !== void 0 ? _h : message.markdown;
+        const prompt = [
+            formatSlackContextBlock(Object.assign(Object.assign({ userId: (_j = (_d = message.author) === null || _d === void 0 ? void 0 : _d.userId) !== null && _j !== void 0 ? _j : "", channelId: message.channelId, threadTs: message.threadTs }, (((_e = message.author) === null || _e === void 0 ? void 0 : _e.userName) === undefined
+                ? {}
+                : { userName: message.author.userName })), (message.teamId === undefined ? {} : { teamId: message.teamId }))),
+            ...((_k = decision.context) !== null && _k !== void 0 ? _k : []),
+            "",
+            userText,
+        ]
+            .filter((part) => part.length > 0)
+            .join("\n");
+        const continuation = slackContinuationKey(message.channelId, message.threadTs);
+        try {
+            const session = yield args.send(prompt, {
+                auth: decision.auth,
+                continuationToken: continuation,
+                state: emptySlackChannelState({
+                    channelId: message.channelId,
+                    threadTs: message.threadTs,
+                    teamId: (_l = message.teamId) !== null && _l !== void 0 ? _l : null,
+                    triggeringUserId: (_m = (_f = message.author) === null || _f === void 0 ? void 0 : _f.userId) !== null && _m !== void 0 ? _m : null,
+                }),
+                title: (_o = decision.title) !== null && _o !== void 0 ? _o : `slack:${message.channelId}:${message.threadTs}`,
+                workspaceDir: decision.workspaceDir,
+                workspaceFiles: decision.workspaceFiles,
+                cloud: decision.cloud,
+                sdkAgentId: decision.sdkAgentId,
+            });
+            log.info("session start", {
+                kind,
+                session: session.id,
+                is_new: session.isNew,
+                continuation,
+                channel: message.channelId,
+                thread_ts: message.threadTs,
+                event_id: args.eventId,
+            });
+        }
+        catch (error) {
+            if (error instanceof SessionBusyError) {
+                log.info("session busy; notifying thread", {
+                    kind,
+                    channel: message.channelId,
+                    thread_ts: message.threadTs,
+                    continuation,
+                    event_id: args.eventId,
+                });
+                try {
+                    yield binding.thread.post(BUSY_REPLY);
+                }
+                catch (postError) {
+                    log.error(`busy reply failed: ${postError instanceof Error ? postError.message : String(postError)}`, {
+                        channel: message.channelId,
+                        thread_ts: message.threadTs,
+                        event_id: args.eventId,
+                    });
+                }
+                return;
+            }
+            log.error(`${kind} delivery failed: ${error instanceof Error ? error.message : String(error)}`, {
+                channel: message.channelId,
+                thread_ts: message.threadTs,
+                continuation,
+                event_id: args.eventId,
+            });
+        }
+    });
+}
+/**
+ * Parse an Events API body (or Socket Mode `events_api` payload) and dispatch
+ * app_mention / DM handlers. Deduplicates by `event_id` when present. Returns
+ * true when a handler was scheduled.
+ */
+export function dispatchInboundFromEventBody(body, deps) {
+    var _a;
+    const log = (_a = deps.log) !== null && _a !== void 0 ? _a : defaultSlackLog;
+    let eventId;
+    if (body !== null && typeof body === "object" && !Array.isArray(body)) {
+        const root = body;
+        if (typeof root.event_id === "string" && root.event_id.length > 0) {
+            eventId = root.event_id;
+            if (!deps.eventIds.tryHandle(root.event_id)) {
+                log.debug("inbound dedupe drop", { event_id: eventId });
+                return false;
+            }
+        }
+    }
+    const mention = parseAppMentionEvent(body);
+    if (mention !== null) {
+        if (deps.mentionsEnabled === false) {
+            log.debug("inbound ignored (mentions disabled)", { event_id: eventId });
+            return false;
+        }
+        deps.waitUntil(dispatchInboundMessage(Object.assign({ kind: "app_mention", message: mention, handler: deps.onAppMention, send: deps.send, credentials: deps.credentials, host: deps.host, log }, (eventId === undefined ? {} : { eventId }))));
+        return true;
+    }
+    const dm = parseDirectMessageEvent(body);
+    if (dm !== null) {
+        if (deps.directMessagesEnabled === false) {
+            log.debug("inbound ignored (direct messages disabled)", {
+                event_id: eventId,
+            });
+            return false;
+        }
+        deps.waitUntil(dispatchInboundMessage(Object.assign({ kind: "direct_message", message: dm, handler: deps.onDirectMessage, send: deps.send, credentials: deps.credentials, host: deps.host, log }, (eventId === undefined ? {} : { eventId }))));
+        return true;
+    }
+    if (deps.channelWatch !== undefined) {
+        const channelEvent = parseChannelMessageEvent(body);
+        if (channelEvent !== null) {
+            return deps.channelWatch.handle(channelEvent, eventId);
+        }
+    }
+    log.debug("inbound ignored (unhandled event shape)", { event_id: eventId });
+    return false;
+}

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

@@ -0,0 +1,24 @@
+/**
+ * Slack channel doctor — verify env, Socket Mode app token, auth.test.
+ */
+import type { SlackCredentials } from "./types.js";
+export interface SlackDoctorCheck {
+    id: string;
+    ok: boolean;
+    message: string;
+}
+export interface SlackDoctorResult {
+    ok: boolean;
+    checks: SlackDoctorCheck[];
+    envKeys: {
+        bot: string;
+        app: string;
+    };
+}
+export interface SlackDoctorOptions {
+    credentials?: SlackCredentials;
+    /** Per-agent env prefix (e.g. `MY_AGENT`). */
+    envPrefix?: string;
+}
+export declare function runSlackDoctor(options?: SlackDoctorOptions): Promise<SlackDoctorResult>;
+//# sourceMappingURL=doctor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"doctor.d.ts","sourceRoot":"","sources":["../../../src/channels/slack/doctor.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEnD,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,OAAO,CAAC;IACZ,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,iBAAiB;IAChC,EAAE,EAAE,OAAO,CAAC;IACZ,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,OAAO,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC;CACvC;AAED,MAAM,WAAW,kBAAkB;IACjC,WAAW,CAAC,EAAE,gBAAgB,CAAC;IAC/B,8CAA8C;IAC9C,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,wBAAsB,cAAc,CAClC,OAAO,GAAE,kBAAuB,GAC/B,OAAO,CAAC,iBAAiB,CAAC,CA0G5B"}

package/dist/channels/slack/doctor.js

@@ -0,0 +1,115 @@
+/**
+ * Slack channel doctor — verify env, Socket Mode app token, auth.test.
+ */
+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 { callSlackApi, resolveAppToken, resolveBotToken } from "./api.js";
+import { credentialsFromEnv, slackEnvKeys } from "./credentials.js";
+export function runSlackDoctor() {
+    return __awaiter(this, arguments, void 0, function* (options = {}) {
+        var _a, _b, _c, _d, _e;
+        const credentials = (_a = options.credentials) !== null && _a !== void 0 ? _a : credentialsFromEnv(options.envPrefix);
+        const envKeys = slackEnvKeys(options.envPrefix);
+        const checks = [];
+        let appTokenRaw;
+        try {
+            appTokenRaw = yield resolveAppToken(credentials);
+        }
+        catch (_f) {
+            appTokenRaw = undefined;
+        }
+        const hasApp = appTokenRaw !== undefined && appTokenRaw !== "";
+        checks.push({
+            id: "app_token",
+            ok: hasApp,
+            message: hasApp
+                ? `${envKeys.app} present`
+                : `${envKeys.app} is missing (xapp-… with connections:write)`,
+        });
+        if (hasApp && appTokenRaw !== undefined) {
+            try {
+                const response = yield fetch("https://slack.com/api/apps.connections.open", {
+                    method: "POST",
+                    headers: {
+                        authorization: `Bearer ${appTokenRaw}`,
+                        "content-type": "application/x-www-form-urlencoded",
+                    },
+                    body: "",
+                });
+                const data = (yield response.json());
+                if (data.ok === true) {
+                    checks.push({
+                        id: "connections_open",
+                        ok: true,
+                        message: "apps.connections.open ok (Socket Mode reachable)",
+                    });
+                }
+                else {
+                    checks.push({
+                        id: "connections_open",
+                        ok: false,
+                        message: `apps.connections.open failed: ${String((_b = data.error) !== null && _b !== void 0 ? _b : "unknown")}`,
+                    });
+                }
+            }
+            catch (error) {
+                checks.push({
+                    id: "connections_open",
+                    ok: false,
+                    message: `apps.connections.open threw: ${error instanceof Error ? error.message : String(error)}`,
+                });
+            }
+        }
+        let botToken;
+        try {
+            botToken = yield resolveBotToken(credentials);
+        }
+        catch (_g) {
+            botToken = undefined;
+        }
+        const hasToken = botToken !== undefined && botToken !== "";
+        checks.push({
+            id: "bot_token",
+            ok: hasToken,
+            message: hasToken ? `${envKeys.bot} present` : `${envKeys.bot} is missing`,
+        });
+        if (hasToken) {
+            try {
+                const auth = yield callSlackApi({
+                    botToken,
+                    operation: "auth.test",
+                    body: {},
+                });
+                if (auth.ok === true) {
+                    checks.push({
+                        id: "auth_test",
+                        ok: true,
+                        message: `auth.test ok (team=${String((_c = auth.team) !== null && _c !== void 0 ? _c : "?")}, user=${String((_d = auth.user) !== null && _d !== void 0 ? _d : "?")})`,
+                    });
+                }
+                else {
+                    checks.push({
+                        id: "auth_test",
+                        ok: false,
+                        message: `auth.test failed: ${String((_e = auth.error) !== null && _e !== void 0 ? _e : "unknown")}`,
+                    });
+                }
+            }
+            catch (error) {
+                checks.push({
+                    id: "auth_test",
+                    ok: false,
+                    message: `auth.test threw: ${error instanceof Error ? error.message : String(error)}`,
+                });
+            }
+        }
+        return { ok: checks.every((check) => check.ok), checks, envKeys };
+    });
+}

package/dist/channels/slack/event-id-dedupe.d.ts

@@ -0,0 +1,10 @@
+/**
+ * FIFO-capped event_id dedupe for Slack Events API / Socket Mode.
+ * One instance per channel mount — not process-global.
+ */
+export interface EventIdDedupe {
+    /** Returns true the first time an id is seen; false if already seen. */
+    tryHandle(eventId: string): boolean;
+}
+export declare function createEventIdDedupe(cap?: number): EventIdDedupe;
+//# sourceMappingURL=event-id-dedupe.d.ts.map

package/dist/channels/slack/event-id-dedupe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-id-dedupe.d.ts","sourceRoot":"","sources":["../../../src/channels/slack/event-id-dedupe.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,MAAM,WAAW,aAAa;IAC5B,wEAAwE;IACxE,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC;CACrC;AAED,wBAAgB,mBAAmB,CAAC,GAAG,GAAE,MAAoB,GAAG,aAAa,CAiB5E"}

package/dist/channels/slack/event-id-dedupe.js

@@ -0,0 +1,23 @@
+/**
+ * FIFO-capped event_id dedupe for Slack Events API / Socket Mode.
+ * One instance per channel mount — not process-global.
+ */
+const DEFAULT_CAP = 2000;
+export function createEventIdDedupe(cap = DEFAULT_CAP) {
+    const handled = new Set();
+    return {
+        tryHandle(eventId) {
+            if (handled.has(eventId)) {
+                return false;
+            }
+            handled.add(eventId);
+            if (handled.size > cap) {
+                const first = handled.values().next().value;
+                if (first !== undefined) {
+                    handled.delete(first);
+                }
+            }
+            return true;
+        },
+    };
+}

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

@@ -0,0 +1,41 @@
+/**
+ * Parse Slack Events API payloads into structured inbound messages.
+ */
+import type { SlackMessage } from "./types.js";
+/** Strip common Slack mention tokens for a cleaner model prompt. */
+export declare function slackTextToMarkdown(text: string): string;
+export declare function parseAppMentionEvent(body: unknown): SlackMessage | null;
+/**
+ * Parse DM / IM messages. More generous than a strict channel_type check:
+ * accepts `channel_type === "im"` or channel ids starting with `D`, and
+ * treats threaded follow-ups (`thread_ts` present) as continuations.
+ */
+export declare function parseDirectMessageEvent(body: unknown): SlackMessage | null;
+/** Parsed `message.channels` / `message.groups` event for channel watch. */
+export type SlackChannelMessageEvent = {
+    kind: "post";
+    message: SlackMessage;
+} | {
+    kind: "edited";
+    message: SlackMessage;
+} | {
+    kind: "deleted";
+    channelId: string;
+    ts: string;
+};
+/**
+ * Parse channel / private-channel message events for the opt-in channel
+ * watch. Accepts `channel_type === "channel" | "group"` (or `C…`/`G…`
+ * channel ids when the type is absent). Bot-authored messages are dropped
+ * (loop safety); edits and deletions are surfaced so a debounce window can
+ * update or cancel a pending dispatch.
+ */
+export declare function parseChannelMessageEvent(body: unknown): SlackChannelMessageEvent | null;
+export declare function formatSlackContextBlock(args: {
+    userId: string;
+    userName?: string;
+    channelId: string;
+    threadTs: string;
+    teamId?: string;
+}): string;
+//# sourceMappingURL=inbound.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"inbound.d.ts","sourceRoot":"","sources":["../../../src/channels/slack/inbound.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAe,YAAY,EAAE,MAAM,YAAY,CAAC;AAe5D,oEAAoE;AACpE,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CASxD;AA4CD,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,OAAO,GAAG,YAAY,GAAG,IAAI,CAevE;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,OAAO,GAAG,YAAY,GAAG,IAAI,CA8B1E;AAED,4EAA4E;AAC5E,MAAM,MAAM,wBAAwB,GAChC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,YAAY,CAAA;CAAE,GACvC;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,OAAO,EAAE,YAAY,CAAA;CAAE,GACzC;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC;AAEvD;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,OAAO,GACZ,wBAAwB,GAAG,IAAI,CAwDjC;AAED,wBAAgB,uBAAuB,CAAC,IAAI,EAAE;IAC5C,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,GAAG,MAAM,CAYT"}

package/dist/channels/slack/inbound.js

@@ -0,0 +1,166 @@
+/**
+ * Parse Slack Events API payloads into structured inbound messages.
+ */
+function asRecord(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    return value;
+}
+function asString(value) {
+    return typeof value === "string" ? value : undefined;
+}
+/** Strip common Slack mention tokens for a cleaner model prompt. */
+export function slackTextToMarkdown(text) {
+    return text
+        .replace(/<@([A-Z0-9]+)>/g, "@$1")
+        .replace(/<#([A-Z0-9]+)(?:\|([^>]*))?>/g, (_m, _id, name) => name ? `#${name}` : "#channel")
+        .replace(/<([^|>]+)\|([^>]+)>/g, "$2")
+        .replace(/<([^>]+)>/g, "$1")
+        .trim();
+}
+function parseAuthor(event) {
+    const userId = asString(event.user);
+    if (userId === undefined || userId === "") {
+        return undefined;
+    }
+    const botId = asString(event.bot_id);
+    const userName = asString(event.username);
+    return Object.assign(Object.assign({ userId }, (userName === undefined ? {} : { userName })), { isBot: botId !== undefined && botId.length > 0 });
+}
+function buildSlackMessage(event, teamId) {
+    var _a, _b;
+    const channelId = asString(event.channel);
+    const ts = asString(event.ts);
+    if (channelId === undefined ||
+        channelId === "" ||
+        ts === undefined ||
+        ts === "") {
+        return null;
+    }
+    const text = (_a = asString(event.text)) !== null && _a !== void 0 ? _a : "";
+    const threadTs = (_b = asString(event.thread_ts)) !== null && _b !== void 0 ? _b : ts;
+    const author = parseAuthor(event);
+    return Object.assign(Object.assign({ text, markdown: slackTextToMarkdown(text), ts,
+        threadTs,
+        channelId }, (teamId === undefined ? {} : { teamId })), (author === undefined ? {} : { author }));
+}
+export function parseAppMentionEvent(body) {
+    const root = asRecord(body);
+    if (root === null || root.type !== "event_callback") {
+        return null;
+    }
+    const event = asRecord(root.event);
+    if (event === null || event.type !== "app_mention") {
+        return null;
+    }
+    // Drop bot-authored mentions (mirrors DM filtering) to avoid loops.
+    const botId = asString(event.bot_id);
+    if (botId !== undefined && botId.length > 0) {
+        return null;
+    }
+    return buildSlackMessage(event, asString(root.team_id));
+}
+/**
+ * Parse DM / IM messages. More generous than a strict channel_type check:
+ * accepts `channel_type === "im"` or channel ids starting with `D`, and
+ * treats threaded follow-ups (`thread_ts` present) as continuations.
+ */
+export function parseDirectMessageEvent(body) {
+    var _a;
+    const root = asRecord(body);
+    if (root === null || root.type !== "event_callback") {
+        return null;
+    }
+    const event = asRecord(root.event);
+    if (event === null || event.type !== "message") {
+        return null;
+    }
+    const channelId = (_a = asString(event.channel)) !== null && _a !== void 0 ? _a : "";
+    const channelType = asString(event.channel_type);
+    const isIm = channelType === "im" ||
+        (channelId.startsWith("D") &&
+            channelType !== "channel" &&
+            channelType !== "group");
+    if (!isIm) {
+        return null;
+    }
+    const subtype = asString(event.subtype);
+    if (subtype !== undefined && subtype.length > 0 && subtype !== "file_share") {
+        return null;
+    }
+    const botId = asString(event.bot_id);
+    if (botId !== undefined && botId.length > 0) {
+        return null;
+    }
+    return buildSlackMessage(event, asString(root.team_id));
+}
+/**
+ * Parse channel / private-channel message events for the opt-in channel
+ * watch. Accepts `channel_type === "channel" | "group"` (or `C…`/`G…`
+ * channel ids when the type is absent). Bot-authored messages are dropped
+ * (loop safety); edits and deletions are surfaced so a debounce window can
+ * update or cancel a pending dispatch.
+ */
+export function parseChannelMessageEvent(body) {
+    var _a, _b, _c;
+    const root = asRecord(body);
+    if (root === null || root.type !== "event_callback") {
+        return null;
+    }
+    const event = asRecord(root.event);
+    if (event === null || event.type !== "message") {
+        return null;
+    }
+    const channelId = (_a = asString(event.channel)) !== null && _a !== void 0 ? _a : "";
+    const channelType = asString(event.channel_type);
+    const isChannel = channelType === "channel" ||
+        channelType === "group" ||
+        (channelType === undefined &&
+            (channelId.startsWith("C") || channelId.startsWith("G")));
+    if (!isChannel || channelId === "") {
+        return null;
+    }
+    const teamId = asString(root.team_id);
+    const subtype = (_b = asString(event.subtype)) !== null && _b !== void 0 ? _b : "";
+    if (subtype === "message_deleted") {
+        const deletedTs = (_c = asString(event.deleted_ts)) !== null && _c !== void 0 ? _c : "";
+        return deletedTs === ""
+            ? null
+            : { kind: "deleted", channelId, ts: deletedTs };
+    }
+    if (subtype === "message_changed") {
+        const nested = asRecord(event.message);
+        if (nested === null) {
+            return null;
+        }
+        const botId = asString(nested.bot_id);
+        if (botId !== undefined && botId.length > 0) {
+            return null;
+        }
+        const message = buildSlackMessage(Object.assign(Object.assign({}, nested), { channel: channelId }), teamId);
+        return message === null ? null : { kind: "edited", message };
+    }
+    if (subtype !== "" && subtype !== "file_share") {
+        return null;
+    }
+    const botId = asString(event.bot_id);
+    if (botId !== undefined && botId.length > 0) {
+        return null;
+    }
+    const message = buildSlackMessage(event, teamId);
+    return message === null ? null : { kind: "post", message };
+}
+export function formatSlackContextBlock(args) {
+    const lines = ["<slack_context>", `user_id: ${args.userId}`];
+    if (args.userName !== undefined) {
+        lines.push(`user_name: ${args.userName}`);
+    }
+    lines.push(`channel_id: ${args.channelId}`);
+    lines.push(`thread_ts: ${args.threadTs}`);
+    if (args.teamId !== undefined) {
+        lines.push(`team_id: ${args.teamId}`);
+    }
+    lines.push("</slack_context>");
+    return lines.join("\n");
+}

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

@@ -0,0 +1,45 @@
+/**
+ * Slack platform channel pack for agent-serve.
+ *
+ * ```ts
+ * import { slackChannel } from "@anysphere/agent-serve/channels/slack";
+ *
+ * // Single agent: SLACK_BOT_TOKEN + SLACK_APP_TOKEN
+ * export default slackChannel();
+ *
+ * // Multi-agent serve: one Slack app per agent
+ * export default slackChannel({ envPrefix: "MY_AGENT" });
+ * // → MY_AGENT_SLACK_BOT_TOKEN + MY_AGENT_SLACK_APP_TOKEN
+ *
+ * // No Slack app at all: ride the signed-in Cursor account's Slack
+ * // connection (`@Cursor <agent name> …` routes here; replies post as
+ * // this agent through the Cursor Slack app)
+ * export default slackChannel({ cursorAccount: true });
+ * ```
+ */
+export * from "./api.js";
+export * from "./approvals.js";
+export * from "./assistant.js";
+export * from "./auth.js";
+export * from "./channel-watch.js";
+export * from "./constants.js";
+export * from "./credentials.js";
+export * from "./cursor-account.js";
+export * from "./defaults.js";
+export * from "./dispatch.js";
+export * from "./doctor.js";
+export * from "./event-id-dedupe.js";
+export * from "./inbound.js";
+export * from "./init.js";
+export * from "./interactive.js";
+export * from "./links.js";
+export * from "./log.js";
+export * from "./manifest.js";
+export * from "./pr-ref.js";
+export * from "./setup.js";
+export * from "./slack-channel.js";
+export * from "./socket-mode.js";
+export * from "./stream.js";
+export * from "./tool-approval-events.js";
+export * from "./types.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/channels/slack/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,cAAc,UAAU,CAAC;AACzB,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,WAAW,CAAC;AAC1B,cAAc,oBAAoB,CAAC;AACnC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,kBAAkB,CAAC;AACjC,cAAc,qBAAqB,CAAC;AACpC,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,sBAAsB,CAAC;AACrC,cAAc,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC;AAC1B,cAAc,kBAAkB,CAAC;AACjC,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,aAAa,CAAC;AAC5B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,YAAY,CAAC"}

package/dist/channels/slack/index.js

@@ -0,0 +1,44 @@
+/**
+ * Slack platform channel pack for agent-serve.
+ *
+ * ```ts
+ * import { slackChannel } from "@anysphere/agent-serve/channels/slack";
+ *
+ * // Single agent: SLACK_BOT_TOKEN + SLACK_APP_TOKEN
+ * export default slackChannel();
+ *
+ * // Multi-agent serve: one Slack app per agent
+ * export default slackChannel({ envPrefix: "MY_AGENT" });
+ * // → MY_AGENT_SLACK_BOT_TOKEN + MY_AGENT_SLACK_APP_TOKEN
+ *
+ * // No Slack app at all: ride the signed-in Cursor account's Slack
+ * // connection (`@Cursor <agent name> …` routes here; replies post as
+ * // this agent through the Cursor Slack app)
+ * export default slackChannel({ cursorAccount: true });
+ * ```
+ */
+export * from "./api.js";
+export * from "./approvals.js";
+export * from "./assistant.js";
+export * from "./auth.js";
+export * from "./channel-watch.js";
+export * from "./constants.js";
+export * from "./credentials.js";
+export * from "./cursor-account.js";
+export * from "./defaults.js";
+export * from "./dispatch.js";
+export * from "./doctor.js";
+export * from "./event-id-dedupe.js";
+export * from "./inbound.js";
+export * from "./init.js";
+export * from "./interactive.js";
+export * from "./links.js";
+export * from "./log.js";
+export * from "./manifest.js";
+export * from "./pr-ref.js";
+export * from "./setup.js";
+export * from "./slack-channel.js";
+export * from "./socket-mode.js";
+export * from "./stream.js";
+export * from "./tool-approval-events.js";
+export * from "./types.js";