@cursor/bdk 0.2.8 → 0.2.10

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

@@ -14,15 +14,6 @@
  * `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";
@@ -42,21 +33,27 @@ function activeStreamTs(channel) {
 }
 export function createStreamDeliveryStrategy(deps) {
     const { botToken, getLog } = deps;
-    const open = (_a) => __awaiter(this, [_a], void 0, function* ({ channel, channelId, threadTs, sessionId, markdown_text, chunks, }) {
+    const open = async ({ 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 openingText = markdown_text ?? "";
         const opening = [];
         if (openingText !== "") {
             opening.push(markdownChunk(highlightCodeFences(openingText)));
         }
-        opening.push(...(chunks !== null && chunks !== void 0 ? chunks : []));
+        opening.push(...(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)));
+        const started = await startChatStream({
+            botToken,
+            channel: channelId,
+            thread_ts: threadTs,
+            chunks: opening,
+            ...streamRecipients(channel),
+        });
         if (!started.ok) {
             log.warn("chat.startStream unavailable", {
                 error: started.error,
@@ -85,8 +82,8 @@ export function createStreamDeliveryStrategy(deps) {
             deliverySurface: "slack",
         });
         return true;
-    });
-    const ensureOpen = (args) => __awaiter(this, void 0, void 0, function* () {
+    };
+    const ensureOpen = async (args) => {
         const existing = activeStreamTs(args.channel);
         if (existing !== null) {
             return existing;
@@ -97,7 +94,7 @@ export function createStreamDeliveryStrategy(deps) {
         if (args.channel.state.threadTs === null || args.channel.state.threadTs === "") {
             return null;
         }
-        const opened = yield open({
+        const opened = await open({
             channel: args.channel,
             channelId: args.channelId,
             threadTs: args.channel.state.threadTs,
@@ -106,26 +103,25 @@ export function createStreamDeliveryStrategy(deps) {
             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)); };
+    const streamDelta = (channel, text) => computeStreamAppend(highlightCodeFences(channel.state.streamBlockText ?? ""), 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 rewound = (channel, text) => streamDelta(channel, text) === "" &&
+        !highlightCodeFences(text).startsWith(highlightCodeFences(channel.state.streamBlockText ?? ""));
     const countAppended = (channel, chunks) => {
-        var _a;
-        channel.state.streamAppendedChunks = ((_a = channel.state.streamAppendedChunks) !== null && _a !== void 0 ? _a : 0) + chunks;
+        channel.state.streamAppendedChunks = (channel.state.streamAppendedChunks ?? 0) + chunks;
     };
-    const stopWithSuffix = (args) => __awaiter(this, void 0, void 0, function* () {
+    const stopWithSuffix = async (args) => {
         const appendText = streamDelta(args.channel, args.text);
-        const stopped = yield stopChatStream({
+        const stopped = await stopChatStream({
             botToken,
             channel: args.channelId,
             ts: args.ts,
@@ -141,17 +137,16 @@ export function createStreamDeliveryStrategy(deps) {
             args.channel.state.streamingUnavailable = true;
         }
         return { ok: false, error: stopped.error };
-    });
-    const closeOrphan = (channel) => __awaiter(this, void 0, void 0, function* () {
-        var _a;
+    };
+    const closeOrphan = async (channel) => {
         const orphanTs = activeStreamTs(channel);
-        const channelId = (_a = channel.state.streamChannelId) !== null && _a !== void 0 ? _a : channel.state.channelId;
+        const channelId = channel.state.streamChannelId ?? channel.state.channelId;
         if (orphanTs === null || channelId === null || channelId === "") {
             return;
         }
-        yield stopChatStream({ botToken, channel: channelId, ts: orphanTs });
+        await 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
@@ -170,10 +165,10 @@ export function createStreamDeliveryStrategy(deps) {
      * 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 continueInNewMessage = async (args) => {
         const { channel, channelId, ts, remainder, reason, sessionId } = args;
         const log = getLog();
-        yield stopChatStream({ botToken, channel: channelId, ts });
+        await stopChatStream({ botToken, channel: channelId, ts });
         channel.state.streamTs = null;
         if (remainder === "") {
             return true;
@@ -182,7 +177,7 @@ export function createStreamDeliveryStrategy(deps) {
             return true;
         }
         try {
-            const posted = yield postMessage({
+            const posted = await postMessage({
                 botToken,
                 channel: channelId,
                 text: remainder,
@@ -213,187 +208,174 @@ export function createStreamDeliveryStrategy(deps) {
             });
             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;
+        async append({ channel, channelId, text, sessionId }) {
+            if (channel.state.streamFull === true) {
+                return;
+            }
+            const ts = await ensureOpen({
+                channel,
+                channelId,
+                sessionId,
+                markdown_text: 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,
+            if (ts === null) {
+                return;
+            }
+            const appendText = streamDelta(channel, text);
+            if (appendText === "") {
+                return;
+            }
+            const result = await appendChatStream({
+                botToken,
+                channel: channelId,
+                ts,
+                chunks: [markdownChunk(appendText)],
+            });
+            if (!result.ok) {
+                getLog().warn("appendStream failed", {
+                    error: result.error,
                     channel: channelId,
-                    ts,
-                    chunks,
+                    stream_ts: ts,
+                    session: sessionId,
                 });
-                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);
+                noteAppendFailure(channel, result);
+                return;
+            }
+            countAppended(channel, 1);
+            channel.state.lastPostedText = text;
+            channel.state.streamBlockText = text;
+        },
+        async appendChunks({ channel, channelId, chunks, sessionId }) {
+            if (channel.state.streamFull === true) {
+                return false;
+            }
+            const hadStream = activeStreamTs(channel) !== null;
+            const ts = await ensureOpen({
+                channel,
+                channelId,
+                sessionId,
+                chunks,
+            });
+            if (ts === null) {
+                return false;
+            }
+            if (!hadStream) {
                 return true;
+            }
+            const result = await appendChatStream({
+                botToken,
+                channel: channelId,
+                ts,
+                chunks,
             });
-        },
-        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,
+            if (!result.ok) {
+                getLog().warn("appendStream chunks failed", {
+                    error: result.error,
                     channel: channelId,
                     stream_ts: ts,
                     session: sessionId,
+                    chunks: chunks.length,
                 });
-                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);
-            });
+                noteAppendFailure(channel, result);
+                return false;
+            }
+            countAppended(channel, chunks.length);
+            return true;
         },
-        cleanupOrphan(_a) {
-            return __awaiter(this, arguments, void 0, function* ({ channel }) {
-                yield closeOrphan(channel);
+        async finalize({ channel, channelId, text, sessionId }) {
+            const log = getLog();
+            const ts = await ensureOpen({
+                channel,
+                channelId,
+                sessionId,
+                markdown_text: text,
             });
-        },
-        fail(_a) {
-            return __awaiter(this, arguments, void 0, function* ({ channel, channelId, errorText, sessionId }) {
-                const ts = yield ensureOpen({
+            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 = await continueInNewMessage({
                     channel,
                     channelId,
+                    ts,
+                    remainder: text,
+                    reason: "rewound",
                     sessionId,
-                    markdown_text: errorText,
                 });
-                if (ts === null) {
-                    return { delivered: false };
+                if (posted) {
+                    channel.state.lastPostedText = text;
                 }
-                const stopped = yield stopWithSuffix({
+                return { delivered: posted };
+            }
+            const stopped = channel.state.streamFull === true
+                ? { ok: false, error: "msg_too_long" }
+                : await 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: channel.state.streamAppendedChunks ?? 0,
+                });
+                return { delivered: true };
+            }
+            if (stopped.error === "msg_too_long") {
+                await continueInNewMessage({
                     channel,
                     channelId,
                     ts,
-                    text: errorText,
+                    remainder,
+                    reason: "msg_too_long",
+                    sessionId,
                 });
-                if (stopped.ok) {
-                    return { delivered: true };
-                }
-                const alreadyStreamed = typeof channel.state.lastPostedText === "string" && channel.state.lastPostedText.length > 0;
-                return { delivered: alreadyStreamed };
+                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 };
+        },
+        async finalizeEmpty({ channel }) {
+            await closeOrphan(channel);
+        },
+        async cleanupOrphan({ channel }) {
+            await closeOrphan(channel);
+        },
+        async fail({ channel, channelId, errorText, sessionId }) {
+            const ts = await ensureOpen({
+                channel,
+                channelId,
+                sessionId,
+                markdown_text: errorText,
             });
+            if (ts === null) {
+                return { delivered: false };
+            }
+            const stopped = await 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/manifest.d.ts.map

@@ -1 +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,CA2ElF;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"}
+{"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;AAiFD;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,oBAAoB,GAAG,gBAAgB,CAsElF;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"}

package/dist/channels/slack/manifest.js

@@ -14,28 +14,47 @@
  * not an install callback. `apps.managedInstall` still installs.
  */
 export const SLACK_EXTERNAL_APP_MANAGEMENT_URL = "https://cursor.com/dashboard/deployed-agents";
+/**
+ * Every scope any Slack channel feature can use, requested by every app: a
+ * feature never needs a manifest option or a re-provision (a new scope
+ * forces a reinstall), and the same agent runs over Socket Mode locally
+ * and over the Events API on Cursor-managed v2. Nothing that workspace
+ * policies commonly refuse (`chat:write.public`, `channels:join`) is here.
+ */
 const BOT_SCOPES = [
     "app_mentions:read",
     "assistant:write",
     "channels:history",
+    // Resolve and verify watched channels (`#name` allowlists, `slack doctor`).
+    "channels:read",
     "chat:write",
     "files:read",
     "files:write",
     "groups:history",
+    "groups:read",
     "im:history",
     "im:read",
     "im:write",
     "mpim:history",
+    // `reaction_added` wakes (`onReactionAdded`).
+    "reactions:read",
     // Emoji acknowledgements (e.g. an agent reacting 👀 when it locks onto
     // a watched-channel post before investigating).
     "reactions:write",
+    // Resolve user groups and people by email in agent tools.
+    "usergroups:read",
     "users:read",
+    "users:read.email",
 ];
+/** Every event the channel dispatches on. */
 const BOT_EVENTS = [
     "app_mention",
     "message.im",
     // agent_view DMs: Slack no longer fires assistant_thread_started.
     "app_home_opened",
+    "message.channels",
+    "message.groups",
+    "reaction_added",
 ];
 /** Slack's display_information.description bound. */
 const MAX_DESCRIPTION_LENGTH = 140;
@@ -71,22 +90,18 @@ function toBotDisplayName(name, env) {
  * Build a Slack app manifest suitable for Create from Manifest.
  */
 export function buildSlackManifest(options) {
-    var _a, _b, _c;
     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 description = (_b = options.description) !== null && _b !== void 0 ? _b : defaultDescription(options.name);
-    const agentDescription = (_c = options.agentDescription) !== null && _c !== void 0 ? _c : description;
+    const botName = options.botDisplayName ?? toBotDisplayName(options.name, env);
+    const description = options.description ?? defaultDescription(options.name);
+    const agentDescription = options.agentDescription ?? description;
     const includeAgentView = options.assistant !== false;
     const botScopes = includeAgentView
         ? [...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: {
@@ -116,29 +131,35 @@ export function buildSlackManifest(options) {
             },
             redirect_urls: options.managedByCursor === false ? undefined : [SLACK_EXTERNAL_APP_MANAGEMENT_URL],
         },
-        settings: Object.assign({ event_subscriptions: {
-                bot_events: botEvents,
-            }, interactivity: {
-                is_enabled: options.interactivity === true,
-            }, 
+        settings: {
+            event_subscriptions: {
+                bot_events: [...BOT_EVENTS],
+            },
+            interactivity: {
+                is_enabled: true,
+            },
             // Benny installs org-wide in the Cursor FE & ADM workspace.
-            org_deploy_enabled: benny, 
+            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 }, (options.managedByCursor === false
-            ? {}
-            : {
-                managed_app_settings: {
-                    is_install_from_slack_disabled: true,
-                    external_app_management_url: SLACK_EXTERNAL_APP_MANAGEMENT_URL,
-                },
-            })),
+            socket_mode_enabled: true,
+            token_rotation_enabled: false,
+            is_mcp_enabled: false,
+            ...(options.managedByCursor === false
+                ? {}
+                : {
+                    managed_app_settings: {
+                        is_install_from_slack_disabled: true,
+                        external_app_management_url: SLACK_EXTERNAL_APP_MANAGEMENT_URL,
+                    },
+                }),
+        },
     };
 }
 export function buildSlackManifestPair(options) {
     return {
-        dev: buildSlackManifest(Object.assign(Object.assign({}, options), { env: "dev" })),
-        prod: buildSlackManifest(Object.assign(Object.assign({}, options), { env: "prod" })),
+        dev: buildSlackManifest({ ...options, env: "dev" }),
+        prod: buildSlackManifest({ ...options, env: "prod" }),
     };
 }
 /** Manifest filenames written under `.slack/`. */

package/dist/channels/slack/message-body.js

@@ -46,14 +46,14 @@ export function slackApiMessageBody(message) {
             continue;
         }
         const blockText = asRecord(rec.text);
-        const blockTextValue = asString(blockText === null || blockText === void 0 ? void 0 : blockText.text);
+        const blockTextValue = asString(blockText?.text);
         if (blockTextValue !== undefined && blockTextValue.trim() !== "") {
             parts.push(blockTextValue);
         }
         const fields = Array.isArray(rec.fields) ? rec.fields : [];
         for (const field of fields) {
             const fieldRec = asRecord(field);
-            const fieldText = asString(fieldRec === null || fieldRec === void 0 ? void 0 : fieldRec.text);
+            const fieldText = asString(fieldRec?.text);
             if (fieldText !== undefined && fieldText.trim() !== "") {
                 parts.push(fieldText);
             }