@cursor/bdk 0.2.1

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

@@ -0,0 +1,10 @@
+/**
+ * Slack deep links for threads / messages.
+ */
+/** Build a web permalink that opens a Slack thread in the browser. */
+export declare function slackThreadPermalink(args: {
+    channelId: string;
+    threadTs: string;
+    teamId?: string;
+}): string | null;
+//# sourceMappingURL=links.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"links.d.ts","sourceRoot":"","sources":["../../../src/channels/slack/links.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,sEAAsE;AACtE,wBAAgB,oBAAoB,CAAC,IAAI,EAAE;IACzC,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,GAAG,MAAM,GAAG,IAAI,CAahB"}

package/dist/channels/slack/links.js

@@ -0,0 +1,19 @@
+/**
+ * Slack deep links for threads / messages.
+ */
+/** Build a web permalink that opens a Slack thread in the browser. */
+export function slackThreadPermalink(args) {
+    var _a;
+    const channelId = args.channelId.trim();
+    const threadTs = args.threadTs.trim();
+    if (channelId === "" || threadTs === "") {
+        return null;
+    }
+    const teamId = (_a = args.teamId) === null || _a === void 0 ? void 0 : _a.trim();
+    if (teamId !== undefined && teamId !== "" && teamId !== "unknown") {
+        // Client deep link opens the thread pane in the right workspace.
+        return `https://app.slack.com/client/${encodeURIComponent(teamId)}/${encodeURIComponent(channelId)}/thread/${encodeURIComponent(channelId)}-${encodeURIComponent(threadTs)}`;
+    }
+    const pTs = `p${threadTs.replace(".", "")}`;
+    return `https://app.slack.com/archives/${encodeURIComponent(channelId)}/${pTs}?thread_ts=${encodeURIComponent(threadTs)}`;
+}

package/dist/channels/slack/live-delivery.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Live-reply delivery for Slack `chat.startStream` / append / stop.
+ *
+ * Cursor-account channels do not use this path — they reply with a single
+ * final `chat.postMessage` and put thinking on `assistant.threads.setStatus`
+ * (no message edits).
+ *
+ * Assistant-pane threads only render stream APIs. Start lazily with the
+ * first real markdown/chunks plus recipient ids — empty startStream is
+ * rejected or never attaches.
+ *
+ * Every call speaks `chunks`. Slack pins a stream's mode at start: text
+ * opened as bare `markdown_text` rejects later `task_update` appends with
+ * `streaming_mode_mismatch`, so assistant text goes out as `markdown_text`
+ * chunks and tool steps can land in the same message.
+ */
+import type { ChannelEventContext } from "../../types.js";
+import type { SlackLog } from "./log.js";
+import { type StreamTaskChunk } from "./stream.js";
+import type { SlackBotToken, SlackChannelState } from "./types.js";
+type SlackChannel = ChannelEventContext<SlackChannelState>;
+export interface LiveDeliveryDeps {
+    botToken: SlackBotToken | undefined;
+    getLog: () => SlackLog;
+}
+type OpenArgs = {
+    channel: SlackChannel;
+    channelId: string;
+    threadTs?: string;
+    sessionId: string;
+    markdown_text?: string;
+    chunks?: StreamTaskChunk[];
+};
+type StreamArgs = {
+    channel: SlackChannel;
+    channelId: string;
+    sessionId: string;
+};
+/**
+ * How the default handlers deliver an in-progress reply. Methods write live
+ * delivery state (`streamTs`, `streamChannelId`, `lastPostedText`,
+ * `streamBlockText`, `streamingUnavailable`) on `channel.state` directly.
+ */
+export interface LiveDeliveryStrategy {
+    readonly inlineToolSteps: boolean;
+    /** Open the live message with the first real markdown or task chunks. */
+    open(args: OpenArgs): Promise<boolean>;
+    append(args: StreamArgs & {
+        text: string;
+    }): Promise<void>;
+    appendChunks(args: StreamArgs & {
+        chunks: StreamTaskChunk[];
+    }): Promise<boolean>;
+    /**
+     * Flush the final reply text. `delivered` is false only when the caller must
+     * post the full reply as a fresh message (finalize failed on partial text).
+     */
+    finalize(args: StreamArgs & {
+        text: string;
+    }): Promise<{
+        delivered: boolean;
+    }>;
+    finalizeEmpty(args: {
+        channel: SlackChannel;
+    }): Promise<void>;
+    cleanupOrphan(args: {
+        channel: SlackChannel;
+    }): Promise<void>;
+    fail(args: StreamArgs & {
+        errorText: string;
+    }): Promise<{
+        delivered: boolean;
+    }>;
+}
+export declare function createStreamDeliveryStrategy(deps: LiveDeliveryDeps): LiveDeliveryStrategy;
+export {};
+//# sourceMappingURL=live-delivery.d.ts.map

package/dist/channels/slack/live-delivery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"live-delivery.d.ts","sourceRoot":"","sources":["../../../src/channels/slack/live-delivery.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAI1D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AACzC,OAAO,EAIL,KAAK,eAAe,EACrB,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAEnE,KAAK,YAAY,GAAG,mBAAmB,CAAC,iBAAiB,CAAC,CAAC;AAE3D,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,aAAa,GAAG,SAAS,CAAC;IACpC,MAAM,EAAE,MAAM,QAAQ,CAAC;CACxB;AAED,KAAK,QAAQ,GAAG;IACd,OAAO,EAAE,YAAY,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,MAAM,CAAC,EAAE,eAAe,EAAE,CAAC;CAC5B,CAAC;AAEF,KAAK,UAAU,GAAG;IAChB,OAAO,EAAE,YAAY,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC;IAClC,yEAAyE;IACzE,IAAI,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACvC,MAAM,CAAC,IAAI,EAAE,UAAU,GAAG;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3D,YAAY,CAAC,IAAI,EAAE,UAAU,GAAG;QAAE,MAAM,EAAE,eAAe,EAAE,CAAA;KAAE,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACjF;;;OAGG;IACH,QAAQ,CAAC,IAAI,EAAE,UAAU,GAAG;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC;QAAE,SAAS,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;IAC/E,aAAa,CAAC,IAAI,EAAE;QAAE,OAAO,EAAE,YAAY,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9D,aAAa,CAAC,IAAI,EAAE;QAAE,OAAO,EAAE,YAAY,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9D,IAAI,CAAC,IAAI,EAAE,UAAU,GAAG;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC;QAAE,SAAS,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;CACjF;AAmBD,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,gBAAgB,GAAG,oBAAoB,CA6YzF"}

package/dist/channels/slack/live-delivery.js

@@ -0,0 +1,399 @@
+/**
+ * Live-reply delivery for Slack `chat.startStream` / append / stop.
+ *
+ * Cursor-account channels do not use this path — they reply with a single
+ * final `chat.postMessage` and put thinking on `assistant.threads.setStatus`
+ * (no message edits).
+ *
+ * Assistant-pane threads only render stream APIs. Start lazily with the
+ * first real markdown/chunks plus recipient ids — empty startStream is
+ * rejected or never attaches.
+ *
+ * Every call speaks `chunks`. Slack pins a stream's mode at start: text
+ * opened as bare `markdown_text` rejects later `task_update` appends with
+ * `streaming_mode_mismatch`, so assistant text goes out as `markdown_text`
+ * chunks and tool steps can land in the same message.
+ */
+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 { markHostedFirstVisibleReply } from "../../internal/hosted-execution-latency.js";
+import { appendChatStream, postMessage, startChatStream, stopChatStream } from "./api.js";
+import { highlightCodeFences } from "./code-fences.js";
+import { SLACK_MARKDOWN_TEXT_MAX_LEN } from "./constants.js";
+import { computeStreamAppend, markdownChunk, } from "./stream.js";
+function streamRecipients(channel) {
+    const user = channel.state.triggeringUserId;
+    const team = channel.state.teamId;
+    return {
+        recipient_user_id: user === null || user === "" ? undefined : user,
+        recipient_team_id: team === null || team === "" ? undefined : team,
+    };
+}
+function activeStreamTs(channel) {
+    const ts = channel.state.streamTs;
+    return ts === null || ts === "" ? null : ts;
+}
+export function createStreamDeliveryStrategy(deps) {
+    const { botToken, getLog } = deps;
+    const open = (_a) => __awaiter(this, [_a], void 0, function* ({ channel, channelId, threadTs, sessionId, markdown_text, chunks, }) {
+        if (activeStreamTs(channel) !== null) {
+            return true;
+        }
+        const openingText = markdown_text !== null && markdown_text !== void 0 ? markdown_text : "";
+        const opening = [];
+        if (openingText !== "") {
+            opening.push(markdownChunk(highlightCodeFences(openingText)));
+        }
+        opening.push(...(chunks !== null && chunks !== void 0 ? chunks : []));
+        if (opening.length === 0) {
+            return false;
+        }
+        const log = getLog();
+        const started = yield startChatStream(Object.assign({ botToken, channel: channelId, thread_ts: threadTs, chunks: opening }, streamRecipients(channel)));
+        if (!started.ok) {
+            log.warn("chat.startStream unavailable", {
+                error: started.error,
+                channel: channelId,
+                thread_ts: threadTs,
+                session: sessionId,
+            });
+            if (started.unsupported === true) {
+                channel.state.streamingUnavailable = true;
+            }
+            return false;
+        }
+        channel.state.streamTs = started.ts;
+        channel.state.streamChannelId = started.channel;
+        channel.state.streamFull = false;
+        channel.state.streamAppendedChunks = 0;
+        channel.state.lastPostedText = openingText;
+        channel.state.streamBlockText = openingText;
+        log.info("chat.startStream ok", {
+            channel: started.channel,
+            stream_ts: started.ts,
+            session: sessionId,
+        });
+        markHostedFirstVisibleReply({
+            outcome: "progress_update",
+            deliverySurface: "slack",
+        });
+        return true;
+    });
+    const ensureOpen = (args) => __awaiter(this, void 0, void 0, function* () {
+        const existing = activeStreamTs(args.channel);
+        if (existing !== null) {
+            return existing;
+        }
+        if (args.channelId === "") {
+            return null;
+        }
+        if (args.channel.state.threadTs === null || args.channel.state.threadTs === "") {
+            return null;
+        }
+        const opened = yield open({
+            channel: args.channel,
+            channelId: args.channelId,
+            threadTs: args.channel.state.threadTs,
+            sessionId: args.sessionId,
+            markdown_text: args.markdown_text,
+            chunks: args.chunks,
+        });
+        return opened ? activeStreamTs(args.channel) : null;
+    });
+    /**
+     * What to append for the new cumulative text, as Slack should see it: the
+     * block text on both sides goes through the same fence rewrite, so the
+     * delta lines up with what the stream already holds.
+     */
+    const streamDelta = (channel, text) => { var _a; return computeStreamAppend(highlightCodeFences((_a = channel.state.streamBlockText) !== null && _a !== void 0 ? _a : ""), highlightCodeFences(text)); };
+    /**
+     * The reply does not extend what the stream already holds, so there is no
+     * delta to append and the text on Slack is not the reply.
+     */
+    const rewound = (channel, text) => { var _a; return streamDelta(channel, text) === "" &&
+        !highlightCodeFences(text).startsWith(highlightCodeFences((_a = channel.state.streamBlockText) !== null && _a !== void 0 ? _a : "")); };
+    const countAppended = (channel, chunks) => {
+        var _a;
+        channel.state.streamAppendedChunks = ((_a = channel.state.streamAppendedChunks) !== null && _a !== void 0 ? _a : 0) + chunks;
+    };
+    const stopWithSuffix = (args) => __awaiter(this, void 0, void 0, function* () {
+        const appendText = streamDelta(args.channel, args.text);
+        const stopped = yield stopChatStream({
+            botToken,
+            channel: args.channelId,
+            ts: args.ts,
+            chunks: appendText === "" ? undefined : [markdownChunk(appendText)],
+        });
+        args.channel.state.streamTs = null;
+        if (stopped.ok) {
+            args.channel.state.lastPostedText = args.text;
+            args.channel.state.lastBotMessageTs = args.ts;
+            return { ok: true };
+        }
+        if (stopped.unsupported === true) {
+            args.channel.state.streamingUnavailable = true;
+        }
+        return { ok: false, error: stopped.error };
+    });
+    const closeOrphan = (channel) => __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const orphanTs = activeStreamTs(channel);
+        const channelId = (_a = channel.state.streamChannelId) !== null && _a !== void 0 ? _a : channel.state.channelId;
+        if (orphanTs === null || channelId === null || channelId === "") {
+            return;
+        }
+        yield stopChatStream({ botToken, channel: channelId, ts: orphanTs });
+        channel.state.streamTs = null;
+    });
+    /**
+     * `msg_too_long` means the message is full: every further append would
+     * fail the same way, so appends stop until `finalize` continues the reply
+     * in a new message.
+     */
+    const noteAppendFailure = (channel, result) => {
+        if (result.unsupported === true) {
+            channel.state.streamingUnavailable = true;
+        }
+        if (result.error === "msg_too_long") {
+            channel.state.streamFull = true;
+        }
+    };
+    /**
+     * The open stream cannot carry the rest of the reply — it is full, or the
+     * reply no longer extends what it holds. Close it as it stands so it stops
+     * spinning and post the remainder as a new thread message.
+     */
+    const continueInNewMessage = (args) => __awaiter(this, void 0, void 0, function* () {
+        const { channel, channelId, ts, remainder, reason, sessionId } = args;
+        const log = getLog();
+        yield stopChatStream({ botToken, channel: channelId, ts });
+        channel.state.streamTs = null;
+        if (remainder === "") {
+            return true;
+        }
+        if (channel.state.threadTs === null || channel.state.threadTs === "") {
+            return true;
+        }
+        try {
+            const posted = yield postMessage({
+                botToken,
+                channel: channelId,
+                text: remainder,
+                threadTs: channel.state.threadTs,
+                plainText: remainder.length >= SLACK_MARKDOWN_TEXT_MAX_LEN,
+            });
+            channel.state.lastBotMessageTs = posted.ts;
+            log.info("reply continued in a new message", {
+                reason,
+                channel: channelId,
+                stream_ts: ts,
+                session: sessionId,
+                continued_chars: remainder.length,
+            });
+            markHostedFirstVisibleReply({
+                outcome: "final_post",
+                deliverySurface: "slack",
+            });
+            return true;
+        }
+        catch (error) {
+            log.warn("stream continuation failed", {
+                reason,
+                error: error instanceof Error ? error.message : String(error),
+                channel: channelId,
+                stream_ts: ts,
+                session: sessionId,
+            });
+            return false;
+        }
+    });
+    return {
+        inlineToolSteps: true,
+        open,
+        append(_a) {
+            return __awaiter(this, arguments, void 0, function* ({ channel, channelId, text, sessionId }) {
+                if (channel.state.streamFull === true) {
+                    return;
+                }
+                const ts = yield ensureOpen({
+                    channel,
+                    channelId,
+                    sessionId,
+                    markdown_text: text,
+                });
+                if (ts === null) {
+                    return;
+                }
+                const appendText = streamDelta(channel, text);
+                if (appendText === "") {
+                    return;
+                }
+                const result = yield appendChatStream({
+                    botToken,
+                    channel: channelId,
+                    ts,
+                    chunks: [markdownChunk(appendText)],
+                });
+                if (!result.ok) {
+                    getLog().warn("appendStream failed", {
+                        error: result.error,
+                        channel: channelId,
+                        stream_ts: ts,
+                        session: sessionId,
+                    });
+                    noteAppendFailure(channel, result);
+                    return;
+                }
+                countAppended(channel, 1);
+                channel.state.lastPostedText = text;
+                channel.state.streamBlockText = text;
+            });
+        },
+        appendChunks(_a) {
+            return __awaiter(this, arguments, void 0, function* ({ channel, channelId, chunks, sessionId }) {
+                if (channel.state.streamFull === true) {
+                    return false;
+                }
+                const hadStream = activeStreamTs(channel) !== null;
+                const ts = yield ensureOpen({
+                    channel,
+                    channelId,
+                    sessionId,
+                    chunks,
+                });
+                if (ts === null) {
+                    return false;
+                }
+                if (!hadStream) {
+                    return true;
+                }
+                const result = yield appendChatStream({
+                    botToken,
+                    channel: channelId,
+                    ts,
+                    chunks,
+                });
+                if (!result.ok) {
+                    getLog().warn("appendStream chunks failed", {
+                        error: result.error,
+                        channel: channelId,
+                        stream_ts: ts,
+                        session: sessionId,
+                        chunks: chunks.length,
+                    });
+                    noteAppendFailure(channel, result);
+                    return false;
+                }
+                countAppended(channel, chunks.length);
+                return true;
+            });
+        },
+        finalize(_a) {
+            return __awaiter(this, arguments, void 0, function* ({ channel, channelId, text, sessionId }) {
+                var _b;
+                const log = getLog();
+                const ts = yield ensureOpen({
+                    channel,
+                    channelId,
+                    sessionId,
+                    markdown_text: text,
+                });
+                if (ts === null) {
+                    return { delivered: false };
+                }
+                // Measured before the stop attempt mutates stream state.
+                const remainder = streamDelta(channel, text);
+                // Nothing to append and the stream does not hold the reply: closing it
+                // here would leave the answer nowhere and report it as delivered.
+                if (rewound(channel, text)) {
+                    const posted = yield continueInNewMessage({
+                        channel,
+                        channelId,
+                        ts,
+                        remainder: text,
+                        reason: "rewound",
+                        sessionId,
+                    });
+                    if (posted) {
+                        channel.state.lastPostedText = text;
+                    }
+                    return { delivered: posted };
+                }
+                const stopped = channel.state.streamFull === true
+                    ? { ok: false, error: "msg_too_long" }
+                    : yield stopWithSuffix({ channel, channelId, ts, text });
+                if (stopped.ok) {
+                    log.info("reply delivered via stream", {
+                        channel: channelId,
+                        stream_ts: ts,
+                        session: sessionId,
+                        chars: text.length,
+                        appends: (_b = channel.state.streamAppendedChunks) !== null && _b !== void 0 ? _b : 0,
+                    });
+                    return { delivered: true };
+                }
+                if (stopped.error === "msg_too_long") {
+                    yield continueInNewMessage({
+                        channel,
+                        channelId,
+                        ts,
+                        remainder,
+                        reason: "msg_too_long",
+                        sessionId,
+                    });
+                    channel.state.lastPostedText = text;
+                    return { delivered: true };
+                }
+                log.warn("chat.stopStream failed; falling back to postMessage", {
+                    error: stopped.error,
+                    channel: channelId,
+                    stream_ts: ts,
+                    session: sessionId,
+                });
+                const alreadyStreamed = typeof channel.state.lastPostedText === "string" && channel.state.lastPostedText.length > 0;
+                return { delivered: alreadyStreamed };
+            });
+        },
+        finalizeEmpty(_a) {
+            return __awaiter(this, arguments, void 0, function* ({ channel }) {
+                yield closeOrphan(channel);
+            });
+        },
+        cleanupOrphan(_a) {
+            return __awaiter(this, arguments, void 0, function* ({ channel }) {
+                yield closeOrphan(channel);
+            });
+        },
+        fail(_a) {
+            return __awaiter(this, arguments, void 0, function* ({ channel, channelId, errorText, sessionId }) {
+                const ts = yield ensureOpen({
+                    channel,
+                    channelId,
+                    sessionId,
+                    markdown_text: errorText,
+                });
+                if (ts === null) {
+                    return { delivered: false };
+                }
+                const stopped = yield stopWithSuffix({
+                    channel,
+                    channelId,
+                    ts,
+                    text: errorText,
+                });
+                if (stopped.ok) {
+                    return { delivered: true };
+                }
+                const alreadyStreamed = typeof channel.state.lastPostedText === "string" && channel.state.lastPostedText.length > 0;
+                return { delivered: alreadyStreamed };
+            });
+        },
+    };
+}

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

@@ -0,0 +1,25 @@
+/**
+ * Shared logging for the Slack channel pack.
+ *
+ * Uses the same `(line: string) => void` contract as ServeOptions.logger.
+ * Lines always start with `[agent-sdk/slack]` so Socket Mode docs and greps
+ * keep working. Optional key=value fields carry correlation ids.
+ */
+export type SlackLogWrite = (line: string) => void;
+export type SlackLogLevel = "debug" | "info" | "warn" | "error";
+export type SlackLogFields = Record<string, string | number | boolean | null | undefined>;
+export interface SlackLog {
+    /** Raw sink used by Socket Mode (already-prefixed lines ok). */
+    write: SlackLogWrite;
+    debug: (message: string, fields?: SlackLogFields) => void;
+    info: (message: string, fields?: SlackLogFields) => void;
+    warn: (message: string, fields?: SlackLogFields) => void;
+    error: (message: string, fields?: SlackLogFields) => void;
+}
+/** Format `key=value` pairs; omit null/undefined. */
+export declare function formatSlackLogFields(fields?: SlackLogFields): string;
+export declare function formatSlackLogLine(level: SlackLogLevel, message: string, fields?: SlackLogFields): string;
+export declare function createSlackLogger(write?: SlackLogWrite): SlackLog;
+/** Default logger when none is injected (console). */
+export declare const defaultSlackLog: SlackLog;
+//# sourceMappingURL=log.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"log.d.ts","sourceRoot":"","sources":["../../../src/channels/slack/log.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,MAAM,MAAM,aAAa,GAAG,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;AAEnD,MAAM,MAAM,aAAa,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;AAEhE,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,SAAS,CAAC,CAAC;AAE1F,MAAM,WAAW,QAAQ;IACvB,gEAAgE;IAChE,KAAK,EAAE,aAAa,CAAC;IACrB,KAAK,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,cAAc,KAAK,IAAI,CAAC;IAC1D,IAAI,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,cAAc,KAAK,IAAI,CAAC;IACzD,IAAI,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,cAAc,KAAK,IAAI,CAAC;IACzD,KAAK,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,cAAc,KAAK,IAAI,CAAC;CAC3D;AAED,qDAAqD;AACrD,wBAAgB,oBAAoB,CAAC,MAAM,CAAC,EAAE,cAAc,GAAG,MAAM,CAcpE;AAED,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,aAAa,EACpB,OAAO,EAAE,MAAM,EACf,MAAM,CAAC,EAAE,cAAc,GACtB,MAAM,CAGR;AAED,wBAAgB,iBAAiB,CAAC,KAAK,GAAE,aAAyC,GAAG,QAAQ,CAe5F;AAED,sDAAsD;AACtD,eAAO,MAAM,eAAe,EAAE,QAA8B,CAAC"}

package/dist/channels/slack/log.js

@@ -0,0 +1,44 @@
+/**
+ * Shared logging for the Slack channel pack.
+ *
+ * Uses the same `(line: string) => void` contract as ServeOptions.logger.
+ * Lines always start with `[agent-sdk/slack]` so Socket Mode docs and greps
+ * keep working. Optional key=value fields carry correlation ids.
+ */
+import { SLACK_LOG_PREFIX } from "../../internal/distribution.js";
+/** Format `key=value` pairs; omit null/undefined. */
+export function formatSlackLogFields(fields) {
+    if (fields === undefined) {
+        return "";
+    }
+    const parts = [];
+    for (const [key, value] of Object.entries(fields)) {
+        if (value === undefined || value === null) {
+            continue;
+        }
+        const rendered = typeof value === "string" && /[\s=]/.test(value) ? JSON.stringify(value) : String(value);
+        parts.push(`${key}=${rendered}`);
+    }
+    return parts.length === 0 ? "" : ` ${parts.join(" ")}`;
+}
+export function formatSlackLogLine(level, message, fields) {
+    const levelTag = level === "info" ? "" : `${level} `;
+    return `${SLACK_LOG_PREFIX} ${levelTag}${message}${formatSlackLogFields(fields)}`;
+}
+export function createSlackLogger(write = line => console.log(line)) {
+    const emit = (level, message, fields) => {
+        write(formatSlackLogLine(level, message, fields));
+    };
+    return {
+        write(line) {
+            // Preserve Socket Mode messages that already include the prefix.
+            write(line.startsWith(SLACK_LOG_PREFIX) ? line : `${SLACK_LOG_PREFIX} ${line}`);
+        },
+        debug: (message, fields) => emit("debug", message, fields),
+        info: (message, fields) => emit("info", message, fields),
+        warn: (message, fields) => emit("warn", message, fields),
+        error: (message, fields) => emit("error", message, fields),
+    };
+}
+/** Default logger when none is injected (console). */
+export const defaultSlackLog = createSlackLogger();

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

@@ -0,0 +1,80 @@
+/**
+ * Generate Slack app manifests (dev + prod) for Cursor-managed provision.
+ *
+ * Always Socket Mode. No Events Request URL. Humans do not paste these
+ * at api.slack.com; `slack create` sends them through the dashboard wizard.
+ *
+ * Mirrored by backend/server/src/agentServe/agentServeSlackManifest.ts (the
+ * backend cannot import this published package); keep the twins in lockstep.
+ */
+import type { SlackManifestOptions } from "./types.js";
+/**
+ * Dashboard tab root: Slack's app-settings banner, and the only OAuth
+ * redirect URI we register. AAA request-approval (`oauth_authorize_url`)
+ * 400s with redirect_uri mismatch unless a URI is registered. This is
+ * not an install callback. `apps.managedInstall` still installs.
+ */
+export declare const SLACK_EXTERNAL_APP_MANAGEMENT_URL = "https://cursor.com/dashboard/deployed-agents";
+export interface SlackAppManifest {
+    display_information: {
+        name: string;
+        description?: string;
+    };
+    features: {
+        bot_user: {
+            display_name: string;
+            always_online: boolean;
+        };
+        agent_view?: {
+            agent_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[];
+        };
+        redirect_urls?: 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;
+        managed_app_settings?: {
+            is_install_from_slack_disabled: boolean;
+            external_app_management_url: string;
+        };
+    };
+}
+/**
+ * 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;
+};
+/** Manifest filenames written under `.slack/`. */
+export declare function slackManifestFileEntries(pair: {
+    dev: SlackAppManifest;
+    prod: SlackAppManifest;
+}, env?: "dev" | "prod" | "both"): ReadonlyArray<{
+    name: "manifest.dev.json" | "manifest.prod.json";
+    contents: string;
+}>;
+//# 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;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEvD;;;;;GAKG;AACH,eAAO,MAAM,iCAAiC,iDAAiD,CAAC;AAEhG,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,UAAU,CAAC,EAAE;YACX,iBAAiB,EAAE,MAAM,CAAC;YAC1B,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;QACF,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;KAC1B,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;QACxB,oBAAoB,CAAC,EAAE;YACrB,8BAA8B,EAAE,OAAO,CAAC;YACxC,2BAA2B,EAAE,MAAM,CAAC;SACrC,CAAC;KACH,CAAC;CACH;AA8DD;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,oBAAoB,GAAG,gBAAgB,CA0ElF;AAED,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,IAAI,CAAC,oBAAoB,EAAE,KAAK,CAAC,GAAG;IAClF,GAAG,EAAE,gBAAgB,CAAC;IACtB,IAAI,EAAE,gBAAgB,CAAC;CACxB,CAKA;AAED,kDAAkD;AAClD,wBAAgB,wBAAwB,CACtC,IAAI,EAAE;IAAE,GAAG,EAAE,gBAAgB,CAAC;IAAC,IAAI,EAAE,gBAAgB,CAAA;CAAE,EACvD,GAAG,GAAE,KAAK,GAAG,MAAM,GAAG,MAAe,GACpC,aAAa,CAAC;IACf,IAAI,EAAE,mBAAmB,GAAG,oBAAoB,CAAC;IACjD,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC,CAkBD"}