@cursor/july 0.1.1

package/dist/channels/slack/api.js

@@ -0,0 +1,437 @@
+/**
+ * Slack Web API helpers used by the channel pack (`@slack/web-api`).
+ */
+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 { ErrorCode, WebClient } from "@slack/web-api";
+import { SLACK_DEFAULT_LOADING_MESSAGES, SLACK_LOADING_MESSAGE_MAX_LEN, SLACK_STATUS_MAX_LEN, SLACK_TITLE_MAX_LEN, SLACK_UNSUPPORTED_ERRORS, } from "./constants.js";
+import { tryResolveAppToken, tryResolveBotToken } from "./credentials.js";
+import { defaultSlackLog } from "./log.js";
+/** Whether a bot token slot holds an API transport instead of a token. */
+export function isSlackApiTransport(token) {
+    return (typeof token === "object" &&
+        token !== null &&
+        token.kind === "api-transport");
+}
+export function resolveBotToken(credentials) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const token = yield tryResolveBotToken(credentials);
+        if (token === undefined) {
+            throw new Error("SLACK_BOT_TOKEN is required (set credentials.botToken, envPrefix, or the env var).");
+        }
+        return token;
+    });
+}
+/** Resolve the Socket Mode app-level token (`xapp-…`). */
+export function resolveAppToken(credentials) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const token = yield tryResolveAppToken(credentials);
+        if (token === undefined) {
+            throw new Error("SLACK_APP_TOKEN is required for Socket Mode (set credentials.appToken, envPrefix, or the env var).");
+        }
+        return token;
+    });
+}
+/** Channel-local continuation key: `<slackChannelId>:<threadTs>`. */
+export function slackContinuationKey(channelId, threadTs) {
+    return `${channelId}:${threadTs}`;
+}
+function isPlatformError(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        error.code === ErrorCode.PlatformError &&
+        "data" in error);
+}
+function createWebClient(botToken) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return new WebClient(yield resolveBotToken({ botToken }));
+    });
+}
+/**
+ * Call a Slack Web API method. Platform errors (`ok: false`) are returned as
+ * the response body (not thrown) so callers can soft-fail cleanly. When the
+ * bot token slot holds a {@link SlackApiTransport} (e.g. the Cursor account
+ * proxy), the call is executed by the transport instead of `@slack/web-api`.
+ */
+export function callSlackApi(args) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (isSlackApiTransport(args.botToken)) {
+            return args.botToken.call(args.operation, args.body);
+        }
+        const client = yield createWebClient(args.botToken);
+        try {
+            const result = yield client.apiCall(args.operation, args.body);
+            return result;
+        }
+        catch (error) {
+            if (isPlatformError(error)) {
+                return error.data;
+            }
+            throw error;
+        }
+    });
+}
+/**
+ * Soft-fail wrapper: never throws for Slack API errors. Network/throw
+ * errors become `{ ok: false, error }`. Unsupported feature errors set
+ * `unsupported: true`.
+ */
+export function callSlackApiSoft(args) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const response = yield callSlackApi(args);
+            if (response.ok === true) {
+                return Object.assign({ ok: true }, response);
+            }
+            const error = typeof response.error === "string" ? response.error : "unknown_error";
+            return Object.assign({ ok: false, error }, (SLACK_UNSUPPORTED_ERRORS.has(error) ? { unsupported: true } : {}));
+        }
+        catch (error) {
+            return {
+                ok: false,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    });
+}
+export function truncateTypingStatus(status, max) {
+    const limit = max !== null && max !== void 0 ? max : SLACK_STATUS_MAX_LEN;
+    const trimmed = status.trim().replace(/\s+/g, " ");
+    if (trimmed.length <= limit) {
+        return trimmed;
+    }
+    return `${trimmed.slice(0, limit - 1)}…`;
+}
+function truncateLoadingMessages(messages) {
+    return messages
+        .map((message) => truncateTypingStatus(message, SLACK_LOADING_MESSAGE_MAX_LEN))
+        .filter((message) => message.length > 0)
+        .slice(0, 5);
+}
+export function truncateTitle(title, max) {
+    const limit = max !== null && max !== void 0 ? max : SLACK_TITLE_MAX_LEN;
+    const trimmed = title.trim().replace(/\s+/g, " ");
+    if (trimmed.length <= limit) {
+        return trimmed;
+    }
+    return `${trimmed.slice(0, limit - 1)}…`;
+}
+// ---------------------------------------------------------------------------
+// Assistant / stream helpers
+// ---------------------------------------------------------------------------
+export function setThreadStatus(args) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (args.channelId === "" || args.threadTs === "") {
+            return { ok: false, error: "missing_channel_or_thread" };
+        }
+        const status = truncateTypingStatus(args.status);
+        const loadingRaw = args.loadingMessages !== undefined && args.loadingMessages.length > 0
+            ? args.loadingMessages
+            : status.length > 0
+                ? [
+                    status,
+                    ...SLACK_DEFAULT_LOADING_MESSAGES.filter((m) => m !== status),
+                ]
+                : [...SLACK_DEFAULT_LOADING_MESSAGES];
+        const loading_messages = truncateLoadingMessages(loadingRaw);
+        return callSlackApiSoft({
+            botToken: args.botToken,
+            operation: "assistant.threads.setStatus",
+            body: Object.assign({ channel_id: args.channelId, thread_ts: args.threadTs, status }, (loading_messages.length > 0 ? { loading_messages } : {})),
+        });
+    });
+}
+export function setThreadTitle(args) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return callSlackApiSoft({
+            botToken: args.botToken,
+            operation: "assistant.threads.setTitle",
+            body: {
+                channel_id: args.channelId,
+                thread_ts: args.threadTs,
+                title: truncateTitle(args.title),
+            },
+        });
+    });
+}
+export function setSuggestedPrompts(args) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const body = {
+            channel_id: args.channelId,
+            thread_ts: args.threadTs,
+            prompts: args.prompts.map((p) => ({
+                title: p.title,
+                message: p.message,
+            })),
+        };
+        if (args.title !== undefined && args.title !== "") {
+            body.title = args.title;
+        }
+        return callSlackApiSoft({
+            botToken: args.botToken,
+            operation: "assistant.threads.setSuggestedPrompts",
+            body,
+        });
+    });
+}
+export function startChatStream(args) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const body = {
+            channel: args.channel,
+        };
+        if (args.thread_ts !== undefined && args.thread_ts !== "") {
+            body.thread_ts = args.thread_ts;
+        }
+        if (args.markdown_text !== undefined) {
+            body.markdown_text = args.markdown_text;
+        }
+        const result = yield callSlackApiSoft({
+            botToken: args.botToken,
+            operation: "chat.startStream",
+            body,
+        });
+        if (!result.ok) {
+            return result;
+        }
+        const ts = typeof result.ts === "string" ? result.ts : "";
+        const channel = typeof result.channel === "string" ? result.channel : args.channel;
+        if (ts === "") {
+            return { ok: false, error: "missing_ts" };
+        }
+        return { ok: true, ts, channel };
+    });
+}
+export function appendChatStream(args) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const body = {
+            channel: args.channel,
+            ts: args.ts,
+        };
+        if (args.markdown_text !== undefined) {
+            body.markdown_text = args.markdown_text;
+        }
+        if (args.chunks !== undefined && args.chunks.length > 0) {
+            body.chunks = args.chunks;
+        }
+        return callSlackApiSoft({
+            botToken: args.botToken,
+            operation: "chat.appendStream",
+            body,
+        });
+    });
+}
+export function stopChatStream(args) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const body = {
+            channel: args.channel,
+            ts: args.ts,
+        };
+        if (args.markdown_text !== undefined) {
+            body.markdown_text = args.markdown_text;
+        }
+        if (args.blocks !== undefined && args.blocks.length > 0) {
+            body.blocks = args.blocks;
+        }
+        return callSlackApiSoft({
+            botToken: args.botToken,
+            operation: "chat.stopStream",
+            body,
+        });
+    });
+}
+export function postMessage(args) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        // Slack treats markdown_text as mutually exclusive with text and blocks
+        // (error: markdown_text_conflict). Prefer markdown when we have no
+        // blocks; with Block Kit, use text as body/fallback.
+        const base = {
+            channel: args.channel,
+            unfurl_links: false,
+            unfurl_media: false,
+        };
+        if (args.threadTs !== undefined && args.threadTs !== "") {
+            base.thread_ts = args.threadTs;
+        }
+        const hasBlocks = args.blocks !== undefined && args.blocks.length > 0;
+        let response;
+        if (hasBlocks) {
+            response = yield callSlackApi({
+                botToken: args.botToken,
+                operation: "chat.postMessage",
+                body: Object.assign(Object.assign({}, base), { text: args.text, blocks: args.blocks }),
+            });
+        }
+        else {
+            response = yield callSlackApi({
+                botToken: args.botToken,
+                operation: "chat.postMessage",
+                body: Object.assign(Object.assign({}, base), { markdown_text: args.text }),
+            });
+            // Older workspaces / scopes may not accept markdown_text — retry with text.
+            if (response.ok !== true &&
+                (response.error === "markdown_text_conflict" ||
+                    response.error === "invalid_arguments" ||
+                    response.error === "invalid_blocks" ||
+                    SLACK_UNSUPPORTED_ERRORS.has(String((_a = response.error) !== null && _a !== void 0 ? _a : "")))) {
+                response = yield callSlackApi({
+                    botToken: args.botToken,
+                    operation: "chat.postMessage",
+                    body: Object.assign(Object.assign({}, base), { text: args.text }),
+                });
+            }
+        }
+        if (response.ok !== true) {
+            throw new Error(`Slack chat.postMessage failed: ${String((_b = response.error) !== null && _b !== void 0 ? _b : "unknown_error")}`);
+        }
+        const ts = typeof response.ts === "string" ? response.ts : "";
+        return { ts };
+    });
+}
+/** Replace an existing message (e.g. strip Approve/Deny after a decision). */
+export function updateMessage(args) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const base = {
+            channel: args.channel,
+            ts: args.ts,
+        };
+        if (args.blocks !== undefined) {
+            // Blocks force the legacy text path (same as postMessage).
+            return callSlackApiSoft({
+                botToken: args.botToken,
+                operation: "chat.update",
+                body: Object.assign(Object.assign({}, base), { text: args.text, blocks: args.blocks }),
+            });
+        }
+        let result = yield callSlackApiSoft({
+            botToken: args.botToken,
+            operation: "chat.update",
+            body: Object.assign(Object.assign({}, base), { markdown_text: args.text }),
+        });
+        // Older workspaces / scopes may not accept markdown_text — retry with text.
+        if (!result.ok &&
+            (result.error === "markdown_text_conflict" ||
+                result.error === "invalid_arguments" ||
+                result.error === "invalid_blocks" ||
+                SLACK_UNSUPPORTED_ERRORS.has(String((_a = result.error) !== null && _a !== void 0 ? _a : "")))) {
+            result = yield callSlackApiSoft({
+                botToken: args.botToken,
+                operation: "chat.update",
+                body: Object.assign(Object.assign({}, base), { text: args.text }),
+            });
+        }
+        return result;
+    });
+}
+/**
+ * Delete a message (`chat.delete`). Soft-fails — used best-effort to remove an
+ * orphaned skeleton before falling back to a fresh post, so a failed delete
+ * never blocks delivery of the reply.
+ */
+export function deleteMessage(args) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (args.channel === "" || args.ts === "") {
+            return { ok: false, error: "missing_channel_or_ts" };
+        }
+        return callSlackApiSoft({
+            botToken: args.botToken,
+            operation: "chat.delete",
+            body: {
+                channel: args.channel,
+                ts: args.ts,
+            },
+        });
+    });
+}
+export function buildSlackBinding(args) {
+    var _a;
+    let threadTs = args.threadTs;
+    const log = (_a = args.log) !== null && _a !== void 0 ? _a : defaultSlackLog;
+    const thread = {
+        post(text, options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                const result = yield postMessage(Object.assign({ botToken: args.botToken, channel: args.channelId, text,
+                    threadTs }, ((options === null || options === void 0 ? void 0 : options.blocks) === undefined ? {} : { blocks: options.blocks })));
+                if (result.ts !== "" && threadTs === "") {
+                    threadTs = result.ts;
+                    (_a = args.onThreadTsChanged) === null || _a === void 0 ? void 0 : _a.call(args, result.ts);
+                }
+                log.info("postMessage ok", {
+                    channel: args.channelId,
+                    thread_ts: threadTs,
+                    message_ts: result.ts,
+                });
+                return { ts: result.ts };
+            });
+        },
+        startTyping(status, loadingMessages) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (args.channelId === "" || threadTs === "") {
+                    return;
+                }
+                const result = yield setThreadStatus(Object.assign({ botToken: args.botToken, channelId: args.channelId, threadTs,
+                    status }, (loadingMessages === undefined ? {} : { loadingMessages })));
+                if (!result.ok) {
+                    log.warn("assistant.threads.setStatus not-ok", {
+                        error: result.error,
+                        channel: args.channelId,
+                        thread_ts: threadTs,
+                    });
+                }
+            });
+        },
+        setTitle(title) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (args.channelId === "" || threadTs === "") {
+                    return;
+                }
+                const result = yield setThreadTitle({
+                    botToken: args.botToken,
+                    channelId: args.channelId,
+                    threadTs,
+                    title,
+                });
+                if (!result.ok) {
+                    log.warn("assistant.threads.setTitle not-ok", {
+                        error: result.error,
+                        channel: args.channelId,
+                        thread_ts: threadTs,
+                    });
+                }
+            });
+        },
+        setSuggestedPrompts(prompts, title) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (args.channelId === "" || threadTs === "" || prompts.length === 0) {
+                    return;
+                }
+                const result = yield setSuggestedPrompts(Object.assign({ botToken: args.botToken, channelId: args.channelId, threadTs,
+                    prompts }, (title === undefined ? {} : { title })));
+                if (!result.ok) {
+                    log.warn("assistant.threads.setSuggestedPrompts not-ok", {
+                        error: result.error,
+                        channel: args.channelId,
+                        thread_ts: threadTs,
+                    });
+                }
+            });
+        },
+    };
+    return {
+        thread,
+        slack: Object.assign({ channelId: args.channelId, get threadTs() {
+                return threadTs;
+            } }, (args.teamId === undefined ? {} : { teamId: args.teamId })),
+        host: args.host,
+    };
+}

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

@@ -0,0 +1,32 @@
+/**
+ * Slack Block Kit cards for human-in-the-loop tool approvals.
+ */
+import type { ApprovalDecision } from "../../types.js";
+export declare const SLACK_APPROVE_ACTION_ID = "agent_serve_approve";
+export declare const SLACK_DENY_ACTION_ID = "agent_serve_deny";
+export interface SlackApprovalActionValue {
+    sessionId: string;
+    callId: string;
+}
+export declare function encodeApprovalActionValue(payload: SlackApprovalActionValue): string;
+export declare function parseApprovalActionValue(raw: string): SlackApprovalActionValue | null;
+export declare function decisionFromActionId(actionId: string): ApprovalDecision | null;
+/** Strip likely secrets before args are shown in Slack cards. */
+export declare function redactSensitiveValues(value: unknown): unknown;
+/**
+ * Full redacted JSON for Slack display. Never silently truncates without
+ * noting that execution still uses the complete args.
+ */
+export declare function formatArgsForSlackDisplay(value: unknown): string;
+export declare function buildApprovalBlocks(args: {
+    sessionId: string;
+    callId: string;
+    toolName: string;
+    args?: unknown;
+}): unknown[];
+export declare function buildResolvedApprovalBlocks(args: {
+    toolName: string;
+    decision: ApprovalDecision;
+    byUserId?: string;
+}): unknown[];
+//# sourceMappingURL=approvals.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"approvals.d.ts","sourceRoot":"","sources":["../../../src/channels/slack/approvals.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAEvD,eAAO,MAAM,uBAAuB,wBAAwB,CAAC;AAC7D,eAAO,MAAM,oBAAoB,qBAAqB,CAAC;AAEvD,MAAM,WAAW,wBAAwB;IACvC,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,wBAAwB,GAChC,MAAM,CAER;AAED,wBAAgB,wBAAwB,CACtC,GAAG,EAAE,MAAM,GACV,wBAAwB,GAAG,IAAI,CAoBjC;AAED,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,MAAM,GACf,gBAAgB,GAAG,IAAI,CAQzB;AAMD,iEAAiE;AACjE,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAmB7D;AASD;;;GAGG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAgBhE;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE;IACxC,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB,GAAG,OAAO,EAAE,CA4DZ;AAED,wBAAgB,2BAA2B,CAAC,IAAI,EAAE;IAChD,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,GAAG,OAAO,EAAE,CAeZ"}

package/dist/channels/slack/approvals.js

@@ -0,0 +1,157 @@
+/**
+ * Slack Block Kit cards for human-in-the-loop tool approvals.
+ */
+export const SLACK_APPROVE_ACTION_ID = "agent_serve_approve";
+export const SLACK_DENY_ACTION_ID = "agent_serve_deny";
+export function encodeApprovalActionValue(payload) {
+    return JSON.stringify(payload);
+}
+export function parseApprovalActionValue(raw) {
+    try {
+        const value = JSON.parse(raw);
+        if (typeof value !== "object" ||
+            value === null ||
+            typeof value.sessionId !== "string" ||
+            typeof value.callId !== "string") {
+            return null;
+        }
+        const sessionId = value.sessionId;
+        const callId = value.callId;
+        if (sessionId === "" || callId === "") {
+            return null;
+        }
+        return { sessionId, callId };
+    }
+    catch (_a) {
+        return null;
+    }
+}
+export function decisionFromActionId(actionId) {
+    if (actionId === SLACK_APPROVE_ACTION_ID) {
+        return "approve";
+    }
+    if (actionId === SLACK_DENY_ACTION_ID) {
+        return "deny";
+    }
+    return null;
+}
+const REDACTED = "[REDACTED]";
+const SENSITIVE_KEY = /(?:pass(?:word|wd)?|secret|token|api[_-]?key|authorization|credential|private[_-]?key|access[_-]?key)/i;
+/** Strip likely secrets before args are shown in Slack cards. */
+export function redactSensitiveValues(value) {
+    if (value === null || value === undefined) {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => redactSensitiveValues(item));
+    }
+    if (typeof value === "object") {
+        const out = {};
+        for (const [key, nested] of Object.entries(value)) {
+            out[key] = SENSITIVE_KEY.test(key)
+                ? REDACTED
+                : redactSensitiveValues(nested);
+        }
+        return out;
+    }
+    return value;
+}
+const SLACK_FIELD_MRDKWN_MAX = 2000;
+const SLACK_ARGS_LABEL = "*Args (redacted)*\n```";
+/** Max arg body that fits a section `fields` mrkdwn entry (2000 chars incl. label + fences). */
+const SLACK_ARGS_DISPLAY_MAX = SLACK_FIELD_MRDKWN_MAX - SLACK_ARGS_LABEL.length - "```".length - 1;
+/**
+ * Full redacted JSON for Slack display. Never silently truncates without
+ * noting that execution still uses the complete args.
+ */
+export function formatArgsForSlackDisplay(value) {
+    if (value === undefined || value === null) {
+        return "";
+    }
+    const redacted = redactSensitiveValues(value);
+    const text = typeof redacted === "string" ? redacted : JSON.stringify(redacted, null, 2);
+    if (text.length <= SLACK_ARGS_DISPLAY_MAX) {
+        return text;
+    }
+    const suffix = `\n(${text.length} chars total; execution uses full args)`;
+    const bodyBudget = Math.max(0, SLACK_ARGS_DISPLAY_MAX - suffix.length - 1);
+    const out = `${text.slice(0, bodyBudget)}…${suffix}`;
+    return out.length <= SLACK_ARGS_DISPLAY_MAX
+        ? out
+        : out.slice(0, SLACK_ARGS_DISPLAY_MAX);
+}
+export function buildApprovalBlocks(args) {
+    const value = encodeApprovalActionValue({
+        sessionId: args.sessionId,
+        callId: args.callId,
+    });
+    const argsText = formatArgsForSlackDisplay(args.args);
+    const fields = [
+        {
+            type: "mrkdwn",
+            text: `*Tool*\n\`${args.toolName}\``,
+        },
+    ];
+    if (argsText !== "") {
+        fields.push({
+            type: "mrkdwn",
+            text: `*Args (redacted)*\n\`\`\`${argsText}\`\`\``,
+        });
+    }
+    return [
+        {
+            type: "header",
+            text: {
+                type: "plain_text",
+                text: "Approval required",
+                emoji: true,
+            },
+        },
+        {
+            type: "section",
+            text: {
+                type: "mrkdwn",
+                text: "A tool call is parked until someone in this thread approves or denies it.",
+            },
+        },
+        {
+            type: "section",
+            fields,
+        },
+        {
+            type: "actions",
+            block_id: `approval_${args.callId}`.slice(0, 255),
+            elements: [
+                {
+                    type: "button",
+                    action_id: SLACK_APPROVE_ACTION_ID,
+                    text: { type: "plain_text", text: "Approve", emoji: true },
+                    style: "primary",
+                    value,
+                },
+                {
+                    type: "button",
+                    action_id: SLACK_DENY_ACTION_ID,
+                    text: { type: "plain_text", text: "Deny", emoji: true },
+                    style: "danger",
+                    value,
+                },
+            ],
+        },
+    ];
+}
+export function buildResolvedApprovalBlocks(args) {
+    const verb = args.decision === "approve" ? "Approved" : "Denied";
+    const by = args.byUserId === undefined || args.byUserId === ""
+        ? ""
+        : ` by <@${args.byUserId}>`;
+    return [
+        {
+            type: "section",
+            text: {
+                type: "mrkdwn",
+                text: `*${verb}*${by} — \`${args.toolName}\``,
+            },
+        },
+    ];
+}

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

@@ -0,0 +1,23 @@
+/**
+ * Assistant thread UX: titles and suggested prompts.
+ */
+import { type SlackLog } from "./log.js";
+import type { SlackBotToken, SlackSuggestedPrompt } from "./types.js";
+export declare function firstNonEmptyLine(text: string): string | undefined;
+export declare function firstLineTitle(text: string): string;
+export declare function maybeSetThreadTitle(args: {
+    botToken: SlackBotToken | undefined;
+    channelId: string;
+    threadTs: string;
+    title: string;
+    log?: SlackLog;
+}): Promise<boolean>;
+export declare function maybeSetSuggestedPrompts(args: {
+    botToken: SlackBotToken | undefined;
+    channelId: string;
+    threadTs: string;
+    prompts: SlackSuggestedPrompt[];
+    title?: string;
+    log?: SlackLog;
+}): Promise<boolean>;
+//# sourceMappingURL=assistant.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"assistant.d.ts","sourceRoot":"","sources":["../../../src/channels/slack/assistant.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EAAmB,KAAK,QAAQ,EAAE,MAAM,UAAU,CAAC;AAC1D,OAAO,KAAK,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEtE,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAQlE;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEnD;AAED,wBAAsB,mBAAmB,CAAC,IAAI,EAAE;IAC9C,QAAQ,EAAE,aAAa,GAAG,SAAS,CAAC;IACpC,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,QAAQ,CAAC;CAChB,GAAG,OAAO,CAAC,OAAO,CAAC,CAiBnB;AAED,wBAAsB,wBAAwB,CAAC,IAAI,EAAE;IACnD,QAAQ,EAAE,aAAa,GAAG,SAAS,CAAC;IACpC,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,oBAAoB,EAAE,CAAC;IAChC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,GAAG,CAAC,EAAE,QAAQ,CAAC;CAChB,GAAG,OAAO,CAAC,OAAO,CAAC,CAqBnB"}