@cursor/july 0.1.1

package/dist/channels/slack/assistant.js

@@ -0,0 +1,67 @@
+/**
+ * Assistant thread UX: titles and suggested prompts.
+ */
+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 { setSuggestedPrompts, setThreadTitle, truncateTitle } from "./api.js";
+import { defaultSlackLog } from "./log.js";
+export function firstNonEmptyLine(text) {
+    for (const line of text.split(/\r?\n/u)) {
+        const trimmed = line.trim();
+        if (trimmed.length > 0) {
+            return trimmed;
+        }
+    }
+    return undefined;
+}
+export function firstLineTitle(text) {
+    var _a;
+    return truncateTitle((_a = firstNonEmptyLine(text)) !== null && _a !== void 0 ? _a : "Conversation");
+}
+export function maybeSetThreadTitle(args) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const log = (_a = args.log) !== null && _a !== void 0 ? _a : defaultSlackLog;
+        const result = yield setThreadTitle({
+            botToken: args.botToken,
+            channelId: args.channelId,
+            threadTs: args.threadTs,
+            title: args.title,
+        });
+        if (!result.ok) {
+            log.warn("setTitle not-ok", {
+                error: result.error,
+                channel: args.channelId,
+                thread_ts: args.threadTs,
+            });
+            return false;
+        }
+        return true;
+    });
+}
+export function maybeSetSuggestedPrompts(args) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const log = (_a = args.log) !== null && _a !== void 0 ? _a : defaultSlackLog;
+        if (args.prompts.length === 0) {
+            return false;
+        }
+        const result = yield setSuggestedPrompts(Object.assign({ botToken: args.botToken, channelId: args.channelId, threadTs: args.threadTs, prompts: args.prompts }, (args.title === undefined ? {} : { title: args.title })));
+        if (!result.ok) {
+            log.warn("setSuggestedPrompts not-ok", {
+                error: result.error,
+                channel: args.channelId,
+                thread_ts: args.threadTs,
+            });
+            return false;
+        }
+        return true;
+    });
+}

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

@@ -0,0 +1,40 @@
+/**
+ * Slack auth helpers — AuthContext builders for thread-scoped sessions.
+ */
+import type { AuthContext } from "../../types.js";
+import type { SlackBinding, SlackMessage } from "./types.js";
+/**
+ * Build a thread-scoped principal so any participant in the same Slack
+ * thread can continue the session. The triggering user is preserved in
+ * attributes for message context.
+ */
+export declare function buildSlackAuthContext(args: {
+    channelId: string;
+    threadTs: string;
+    teamId?: string;
+    userId?: string;
+    userName?: string;
+    isBot?: boolean;
+    /**
+     * Engagement surface that started the session (e.g. `"channel_post"` for
+     * the opt-in channel watch). Recorded as an attribute; the principal stays
+     * thread-scoped so an @mention in the same thread continues the session.
+     */
+    engagement?: string;
+}): AuthContext;
+/**
+ * Auth for a Slack user clicking an interactive Approve/Deny button.
+ * Uses the clicker's identity for {@link SessionEngine.resolveApproval},
+ * not the stored session principal (which would bypass ownership checks).
+ */
+export declare function buildSlackInteractiveApprovalAuth(args: {
+    sessionAuth: AuthContext;
+    channelId: string;
+    threadTs: string;
+    teamId?: string;
+    clickingUserId: string;
+}): AuthContext;
+export declare function defaultSlackAuth(message: SlackMessage, ctx: SlackBinding, options?: {
+    engagement?: string;
+}): AuthContext | null;
+//# sourceMappingURL=auth.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../../src/channels/slack/auth.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE7D;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE;IAC1C,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,GAAG,WAAW,CA4Bd;AAED;;;;GAIG;AACH,wBAAgB,iCAAiC,CAAC,IAAI,EAAE;IACtD,WAAW,EAAE,WAAW,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,cAAc,EAAE,MAAM,CAAC;CACxB,GAAG,WAAW,CAqBd;AAED,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,YAAY,EACrB,GAAG,EAAE,YAAY,EACjB,OAAO,CAAC,EAAE;IAAE,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,GAChC,WAAW,GAAG,IAAI,CAiBpB"}

package/dist/channels/slack/auth.js

@@ -0,0 +1,71 @@
+/**
+ * Slack auth helpers — AuthContext builders for thread-scoped sessions.
+ */
+import { samePrincipal } from "../../internal/auth.js";
+/**
+ * Build a thread-scoped principal so any participant in the same Slack
+ * thread can continue the session. The triggering user is preserved in
+ * attributes for message context.
+ */
+export function buildSlackAuthContext(args) {
+    var _a;
+    const team = (_a = args.teamId) !== null && _a !== void 0 ? _a : "unknown";
+    const principalId = `slack:${team}:${args.channelId}:${args.threadTs}`;
+    const attributes = {
+        channel_id: args.channelId,
+        thread_ts: args.threadTs,
+    };
+    if (args.teamId !== undefined) {
+        attributes.team_id = args.teamId;
+    }
+    if (args.userId !== undefined) {
+        attributes.user_id = args.userId;
+    }
+    if (args.userName !== undefined) {
+        attributes.user_name = args.userName;
+    }
+    if (args.isBot === true) {
+        attributes.author_type = "bot";
+    }
+    if (args.engagement !== undefined) {
+        attributes.engagement = args.engagement;
+    }
+    return {
+        authenticator: "slack",
+        principalId,
+        principalType: "user",
+        attributes,
+    };
+}
+/**
+ * Auth for a Slack user clicking an interactive Approve/Deny button.
+ * Uses the clicker's identity for {@link SessionEngine.resolveApproval},
+ * not the stored session principal (which would bypass ownership checks).
+ */
+export function buildSlackInteractiveApprovalAuth(args) {
+    const clickerAuth = buildSlackAuthContext({
+        channelId: args.channelId,
+        threadTs: args.threadTs,
+        teamId: args.teamId,
+        userId: args.clickingUserId,
+    });
+    if (samePrincipal(args.sessionAuth, clickerAuth)) {
+        return clickerAuth;
+    }
+    const userSuffix = `:${args.clickingUserId}`;
+    if (args.clickingUserId !== "" &&
+        args.sessionAuth.principalId.endsWith(userSuffix)) {
+        return Object.assign(Object.assign({}, clickerAuth), { principalId: args.sessionAuth.principalId });
+    }
+    return clickerAuth;
+}
+export function defaultSlackAuth(message, ctx, options) {
+    if (message.author === undefined) {
+        return null;
+    }
+    return buildSlackAuthContext(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ channelId: ctx.slack.channelId, threadTs: ctx.slack.threadTs }, (message.teamId === undefined ? {} : { teamId: message.teamId })), { userId: message.author.userId }), (message.author.userName === undefined
+        ? {}
+        : { userName: message.author.userName })), { isBot: message.author.isBot }), ((options === null || options === void 0 ? void 0 : options.engagement) === undefined
+        ? {}
+        : { engagement: options.engagement })));
+}

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

@@ -0,0 +1,46 @@
+/**
+ * Opt-in channel watch: dispatch on posts in allowlisted channels.
+ *
+ * Filtering rules (the anti-slop guarantees):
+ * - Only explicitly allowlisted channels are watched — no wildcard.
+ * - Top-level posts only by default; thread replies never dispatch unless
+ *   `posts: "all"` is configured.
+ * - Posts that @mention the bot are skipped here (the `app_mention` path
+ *   owns them), and bot-authored posts are dropped upstream in parsing.
+ * - An optional debounce window lets rapid edits settle: edits update the
+ *   pending text, deleting the post cancels the dispatch.
+ */
+import type { WebClient } from "@slack/web-api";
+import type { SlackChannelMessageEvent } from "./inbound.js";
+import { type SlackLog } from "./log.js";
+import type { SlackChannelPostsOptions, SlackMessage } from "./types.js";
+/** Allowlist over channel ids and `#names` (names resolve lazily). */
+export declare class SlackChannelAllowlist {
+    private readonly ids;
+    private readonly names;
+    constructor(entries: readonly string[]);
+    matches(channelId: string): boolean;
+    unresolvedNames(): string[];
+    /** Fold resolved `name → id` pairs into the id set. */
+    applyResolvedNames(resolved: ReadonlyMap<string, string>): void;
+}
+/**
+ * Resolve channel `#names` to ids via `conversations.list`. Best-effort:
+ * returns whatever resolved; the caller logs names that stayed unresolved.
+ */
+export declare function resolveChannelNames(client: WebClient, names: readonly string[], log?: SlackLog): Promise<Map<string, string>>;
+export interface ChannelPostWatcher {
+    /** Handle a parsed channel message event. Returns true when consumed. */
+    handle(event: SlackChannelMessageEvent, eventId?: string): boolean;
+    /** Cancel pending debounced dispatches. */
+    stop(): void;
+}
+export declare function createChannelPostWatcher(args: {
+    options: SlackChannelPostsOptions;
+    allowlist: SlackChannelAllowlist;
+    /** Bot user id (from `auth.test`) so bot mentions route via app_mention. */
+    getBotUserId: () => string | undefined;
+    dispatch: (message: SlackMessage, eventId?: string) => void;
+    log?: SlackLog;
+}): ChannelPostWatcher;
+//# sourceMappingURL=channel-watch.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"channel-watch.d.ts","sourceRoot":"","sources":["../../../src/channels/slack/channel-watch.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,cAAc,CAAC;AAC7D,OAAO,EAAmB,KAAK,QAAQ,EAAE,MAAM,UAAU,CAAC;AAC1D,OAAO,KAAK,EAAE,wBAAwB,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAIzE,sEAAsE;AACtE,qBAAa,qBAAqB;IAChC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAqB;IACzC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAqB;IAE3C,YAAY,OAAO,EAAE,SAAS,MAAM,EAAE,EAerC;IAED,OAAO,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAElC;IAED,eAAe,IAAI,MAAM,EAAE,CAE1B;IAED,uDAAuD;IACvD,kBAAkB,CAAC,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAO9D;CACF;AAED;;;GAGG;AACH,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,SAAS,EACjB,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,GAAG,GAAE,QAA0B,GAC9B,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAiC9B;AAED,MAAM,WAAW,kBAAkB;IACjC,yEAAyE;IACzE,MAAM,CAAC,KAAK,EAAE,wBAAwB,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IACnE,2CAA2C;IAC3C,IAAI,IAAI,IAAI,CAAC;CACd;AAED,wBAAgB,wBAAwB,CAAC,IAAI,EAAE;IAC7C,OAAO,EAAE,wBAAwB,CAAC;IAClC,SAAS,EAAE,qBAAqB,CAAC;IACjC,4EAA4E;IAC5E,YAAY,EAAE,MAAM,MAAM,GAAG,SAAS,CAAC;IACvC,QAAQ,EAAE,CAAC,OAAO,EAAE,YAAY,EAAE,OAAO,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IAC5D,GAAG,CAAC,EAAE,QAAQ,CAAC;CAChB,GAAG,kBAAkB,CAoGrB"}

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

@@ -0,0 +1,180 @@
+/**
+ * Opt-in channel watch: dispatch on posts in allowlisted channels.
+ *
+ * Filtering rules (the anti-slop guarantees):
+ * - Only explicitly allowlisted channels are watched — no wildcard.
+ * - Top-level posts only by default; thread replies never dispatch unless
+ *   `posts: "all"` is configured.
+ * - Posts that @mention the bot are skipped here (the `app_mention` path
+ *   owns them), and bot-authored posts are dropped upstream in parsing.
+ * - An optional debounce window lets rapid edits settle: edits update the
+ *   pending text, deleting the post cancels the dispatch.
+ */
+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 { defaultSlackLog } from "./log.js";
+const CHANNEL_ID_PATTERN = /^[CG][A-Z0-9]+$/;
+/** Allowlist over channel ids and `#names` (names resolve lazily). */
+export class SlackChannelAllowlist {
+    constructor(entries) {
+        this.ids = new Set();
+        this.names = new Set();
+        for (const raw of entries) {
+            const entry = raw.trim();
+            if (entry === "") {
+                continue;
+            }
+            if (entry.startsWith("#")) {
+                this.names.add(entry.slice(1).toLowerCase());
+            }
+            else if (CHANNEL_ID_PATTERN.test(entry)) {
+                this.ids.add(entry);
+            }
+            else {
+                // Bare name without "#" — treat as a name for forgiving authoring.
+                this.names.add(entry.toLowerCase());
+            }
+        }
+    }
+    matches(channelId) {
+        return this.ids.has(channelId);
+    }
+    unresolvedNames() {
+        return [...this.names];
+    }
+    /** Fold resolved `name → id` pairs into the id set. */
+    applyResolvedNames(resolved) {
+        for (const name of this.names) {
+            const id = resolved.get(name);
+            if (id !== undefined) {
+                this.ids.add(id);
+            }
+        }
+    }
+}
+/**
+ * Resolve channel `#names` to ids via `conversations.list`. Best-effort:
+ * returns whatever resolved; the caller logs names that stayed unresolved.
+ */
+export function resolveChannelNames(client_1, names_1) {
+    return __awaiter(this, arguments, void 0, function* (client, names, log = defaultSlackLog) {
+        var _a, _b;
+        var _c;
+        const wanted = new Set(names.map((name) => name.toLowerCase()));
+        const resolved = new Map();
+        if (wanted.size === 0) {
+            return resolved;
+        }
+        let cursor;
+        for (let page = 0; page < 20 && resolved.size < wanted.size; page += 1) {
+            const response = yield client.conversations.list(Object.assign({ types: "public_channel,private_channel", exclude_archived: true, limit: 200 }, (cursor === undefined ? {} : { cursor })));
+            for (const channel of (_c = response.channels) !== null && _c !== void 0 ? _c : []) {
+                const name = (_a = channel.name) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+                if (name !== undefined && wanted.has(name) && channel.id !== undefined) {
+                    resolved.set(name, channel.id);
+                }
+            }
+            cursor = ((_b = response.response_metadata) === null || _b === void 0 ? void 0 : _b.next_cursor) || undefined;
+            if (cursor === undefined) {
+                break;
+            }
+        }
+        for (const name of wanted) {
+            if (!resolved.has(name)) {
+                log.error("channel watch: could not resolve channel name", {
+                    name: `#${name}`,
+                });
+            }
+        }
+        return resolved;
+    });
+}
+export function createChannelPostWatcher(args) {
+    var _a, _b;
+    const log = (_a = args.log) !== null && _a !== void 0 ? _a : defaultSlackLog;
+    const includeReplies = args.options.posts === "all";
+    const debounceMs = (_b = args.options.debounceMs) !== null && _b !== void 0 ? _b : 0;
+    const pending = new Map();
+    const pendingKey = (channelId, ts) => `${channelId}:${ts}`;
+    function skip(reason, message) {
+        log.debug(`channel watch skip (${reason})`, {
+            channel: message.channelId,
+            message_ts: message.ts,
+            thread_ts: message.threadTs,
+        });
+        return true;
+    }
+    function fire(message, eventId) {
+        log.info("channel watch dispatch", {
+            channel: message.channelId,
+            message_ts: message.ts,
+            thread_ts: message.threadTs,
+            event_id: eventId,
+        });
+        args.dispatch(message, eventId);
+    }
+    return {
+        handle(event, eventId) {
+            if (event.kind === "deleted") {
+                const key = pendingKey(event.channelId, event.ts);
+                const entry = pending.get(key);
+                if (entry !== undefined) {
+                    clearTimeout(entry.timer);
+                    pending.delete(key);
+                    log.info("channel watch cancel (post deleted)", {
+                        channel: event.channelId,
+                        message_ts: event.ts,
+                    });
+                }
+                return true;
+            }
+            const message = event.message;
+            if (!args.allowlist.matches(message.channelId)) {
+                return skip("channel not allowlisted", message);
+            }
+            if (event.kind === "edited") {
+                const entry = pending.get(pendingKey(message.channelId, message.ts));
+                if (entry !== undefined) {
+                    entry.message = Object.assign(Object.assign({}, entry.message), message);
+                }
+                // Edits never (re-)dispatch on their own.
+                return true;
+            }
+            if (!includeReplies && message.ts !== message.threadTs) {
+                return skip("thread reply (posts: top-level)", message);
+            }
+            const botUserId = args.getBotUserId();
+            if (botUserId !== undefined && message.text.includes(`<@${botUserId}>`)) {
+                return skip("bot mention (app_mention path owns it)", message);
+            }
+            if (debounceMs <= 0) {
+                fire(message, eventId);
+                return true;
+            }
+            const key = pendingKey(message.channelId, message.ts);
+            const existing = pending.get(key);
+            if (existing !== undefined) {
+                clearTimeout(existing.timer);
+            }
+            const entry = Object.assign({ timer: setTimeout(() => {
+                    pending.delete(key);
+                    fire(entry.message, entry.eventId);
+                }, debounceMs), message }, (eventId === undefined ? {} : { eventId }));
+            pending.set(key, entry);
+            return true;
+        },
+        stop() {
+            for (const entry of pending.values()) {
+                clearTimeout(entry.timer);
+            }
+            pending.clear();
+        },
+    };
+}

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

@@ -0,0 +1,17 @@
+/** Defaults for the Slack channel pack. */
+export declare const SLACK_CHANNEL_ID = "slack";
+export declare const SLACK_TYPING_MIN_GROWTH = 4;
+export declare const SLACK_TYPING_MIN_INTERVAL_MS = 5000;
+/**
+ * Slack `assistant.threads.setStatus` limits each `loading_messages[]`
+ * entry to under 51 characters. `status` is often mirrored into that array,
+ * so keep both at 50.
+ */
+export declare const SLACK_STATUS_MAX_LEN = 50;
+export declare const SLACK_LOADING_MESSAGE_MAX_LEN = 50;
+export declare const SLACK_TITLE_MAX_LEN = 80;
+/** Rotating assistant status lines (Slack `loading_messages`). */
+export declare const SLACK_DEFAULT_LOADING_MESSAGES: readonly ["Thinking…", "Working on it…", "Almost there…"];
+/** Slack API errors that mean a feature is unavailable for this app. */
+export declare const SLACK_UNSUPPORTED_ERRORS: Set<string>;
+//# sourceMappingURL=constants.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/channels/slack/constants.ts"],"names":[],"mappings":"AAAA,2CAA2C;AAE3C,eAAO,MAAM,gBAAgB,UAAU,CAAC;AACxC,eAAO,MAAM,uBAAuB,IAAI,CAAC;AACzC,eAAO,MAAM,4BAA4B,OAAQ,CAAC;AAClD;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,KAAK,CAAC;AACvC,eAAO,MAAM,6BAA6B,KAAK,CAAC;AAChD,eAAO,MAAM,mBAAmB,KAAK,CAAC;AAEtC,kEAAkE;AAClE,eAAO,MAAM,8BAA8B,YACzC,WAAW,EACX,gBAAgB,EAChB,eAAe,CACP,CAAC;AAEX,wEAAwE;AACxE,eAAO,MAAM,wBAAwB,EAAE,GAAG,CAAC,MAAM,CAO/C,CAAC"}

package/dist/channels/slack/constants.js

@@ -0,0 +1,27 @@
+/** Defaults for the Slack channel pack. */
+export const SLACK_CHANNEL_ID = "slack";
+export const SLACK_TYPING_MIN_GROWTH = 4;
+export const SLACK_TYPING_MIN_INTERVAL_MS = 5000;
+/**
+ * Slack `assistant.threads.setStatus` limits each `loading_messages[]`
+ * entry to under 51 characters. `status` is often mirrored into that array,
+ * so keep both at 50.
+ */
+export const SLACK_STATUS_MAX_LEN = 50;
+export const SLACK_LOADING_MESSAGE_MAX_LEN = 50;
+export const SLACK_TITLE_MAX_LEN = 80;
+/** Rotating assistant status lines (Slack `loading_messages`). */
+export const SLACK_DEFAULT_LOADING_MESSAGES = [
+    "Thinking…",
+    "Working on it…",
+    "Almost there…",
+];
+/** Slack API errors that mean a feature is unavailable for this app. */
+export const SLACK_UNSUPPORTED_ERRORS = new Set([
+    "method_not_found",
+    "not_allowed",
+    "missing_scope",
+    "not_enabled",
+    "feature_not_enabled",
+    "unknown_method",
+]);

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

@@ -0,0 +1,35 @@
+/**
+ * Per-agent Slack credential resolution.
+ *
+ * Multi-agent serve needs one Slack app (and token pair) per agent. Use
+ * `envPrefix: "MY_AGENT"` so the pack reads `MY_AGENT_SLACK_BOT_TOKEN` /
+ * `MY_AGENT_SLACK_APP_TOKEN` instead of the shared globals.
+ */
+import type { SlackCredentials } from "./types.js";
+/** Normalize an agent directory / display name into an env prefix. */
+export declare function envPrefixFromName(name: string): string;
+/** Env var names for a Slack token pair. */
+export declare function slackEnvKeys(prefix?: string): {
+    bot: string;
+    app: string;
+};
+/**
+ * Credentials that read `{PREFIX}_SLACK_BOT_TOKEN` / `{PREFIX}_SLACK_APP_TOKEN`
+ * (or the unprefixed globals when `prefix` is omitted). Resolvers return `""`
+ * when unset so multi-agent serve does not fall through to a shared token.
+ */
+export declare function credentialsFromEnv(prefix?: string): SlackCredentials;
+/**
+ * Resolve a bot token string without throwing. When `credentials.botToken`
+ * is set (string or resolver), only that value is used — no global fallback
+ * — so a per-agent prefix cannot accidentally bind every mounted agent to
+ * one app. When omitted, falls back to `SLACK_BOT_TOKEN`. API transports
+ * resolve to `undefined` (they execute calls without a local token).
+ */
+export declare function tryResolveBotToken(credentials: SlackCredentials | undefined): Promise<string | undefined>;
+/**
+ * Resolve an app-level token without throwing. Same per-agent rules as
+ * {@link tryResolveBotToken}.
+ */
+export declare function tryResolveAppToken(credentials: SlackCredentials | undefined): Promise<string | undefined>;
+//# sourceMappingURL=credentials.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"credentials.d.ts","sourceRoot":"","sources":["../../../src/channels/slack/credentials.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAiB,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAElE,sEAAsE;AACtE,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAMtD;AAED,4CAA4C;AAC5C,wBAAgB,YAAY,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG;IAC7C,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;CACb,CASA;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,gBAAgB,CAMpE;AAiBD;;;;;;GAMG;AACH,wBAAsB,kBAAkB,CACtC,WAAW,EAAE,gBAAgB,GAAG,SAAS,GACxC,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAK7B;AAED;;;GAGG;AACH,wBAAsB,kBAAkB,CACtC,WAAW,EAAE,gBAAgB,GAAG,SAAS,GACxC,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAK7B"}

package/dist/channels/slack/credentials.js

@@ -0,0 +1,88 @@
+/**
+ * Per-agent Slack credential resolution.
+ *
+ * Multi-agent serve needs one Slack app (and token pair) per agent. Use
+ * `envPrefix: "MY_AGENT"` so the pack reads `MY_AGENT_SLACK_BOT_TOKEN` /
+ * `MY_AGENT_SLACK_APP_TOKEN` instead of the shared globals.
+ */
+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());
+    });
+};
+/** Normalize an agent directory / display name into an env prefix. */
+export function envPrefixFromName(name) {
+    return name
+        .trim()
+        .replace(/[^A-Za-z0-9]+/g, "_")
+        .replace(/^_+|_+$/g, "")
+        .toUpperCase();
+}
+/** Env var names for a Slack token pair. */
+export function slackEnvKeys(prefix) {
+    if (prefix === undefined || prefix.trim() === "") {
+        return { bot: "SLACK_BOT_TOKEN", app: "SLACK_APP_TOKEN" };
+    }
+    const normalized = envPrefixFromName(prefix);
+    return {
+        bot: `${normalized}_SLACK_BOT_TOKEN`,
+        app: `${normalized}_SLACK_APP_TOKEN`,
+    };
+}
+/**
+ * Credentials that read `{PREFIX}_SLACK_BOT_TOKEN` / `{PREFIX}_SLACK_APP_TOKEN`
+ * (or the unprefixed globals when `prefix` is omitted). Resolvers return `""`
+ * when unset so multi-agent serve does not fall through to a shared token.
+ */
+export function credentialsFromEnv(prefix) {
+    const keys = slackEnvKeys(prefix);
+    return {
+        botToken: () => { var _a; var _b; return (_b = (_a = process.env[keys.bot]) === null || _a === void 0 ? void 0 : _a.trim()) !== null && _b !== void 0 ? _b : ""; },
+        appToken: () => { var _a; var _b; return (_b = (_a = process.env[keys.app]) === null || _a === void 0 ? void 0 : _a.trim()) !== null && _b !== void 0 ? _b : ""; },
+    };
+}
+function readExplicitToken(explicit) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (explicit === undefined) {
+            return undefined;
+        }
+        const value = typeof explicit === "function" ? yield explicit() : explicit;
+        // API transports (objects) carry no raw token to resolve.
+        if (typeof value !== "string") {
+            return undefined;
+        }
+        const trimmed = value.trim();
+        return trimmed === "" ? undefined : trimmed;
+    });
+}
+/**
+ * Resolve a bot token string without throwing. When `credentials.botToken`
+ * is set (string or resolver), only that value is used — no global fallback
+ * — so a per-agent prefix cannot accidentally bind every mounted agent to
+ * one app. When omitted, falls back to `SLACK_BOT_TOKEN`. API transports
+ * resolve to `undefined` (they execute calls without a local token).
+ */
+export function tryResolveBotToken(credentials) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if ((credentials === null || credentials === void 0 ? void 0 : credentials.botToken) !== undefined) {
+            return readExplicitToken(credentials.botToken);
+        }
+        return readExplicitToken(process.env.SLACK_BOT_TOKEN);
+    });
+}
+/**
+ * Resolve an app-level token without throwing. Same per-agent rules as
+ * {@link tryResolveBotToken}.
+ */
+export function tryResolveAppToken(credentials) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if ((credentials === null || credentials === void 0 ? void 0 : credentials.appToken) !== undefined) {
+            return readExplicitToken(credentials.appToken);
+        }
+        return readExplicitToken(process.env.SLACK_APP_TOKEN);
+    });
+}

package/dist/channels/slack/cursor-account.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Cursor-account mode for the Slack channel pack: instead of a dedicated
+ * Slack app (Socket Mode + `xoxb`/`xapp` tokens), the channel rides the
+ * signed-in Cursor account's Slack connection. Inbound events are relayed
+ * by the serve host from `/v0/slack-events` (see
+ * `internal/cursor-slack-relay.ts`); outbound Web API calls run through a
+ * {@link SlackApiTransport} bound to the backend proxy.
+ *
+ * This file is the seam between the channel definition (authored at
+ * `defineChannel` time) and the serve-time relay: `slackChannel()` registers
+ * a runtime ref here, and the server discovers it, binds the transport, and
+ * dispatches relayed envelopes through the pack's normal inbound path.
+ */
+import type { HostContext, SendMessageFn } from "../../types.js";
+import type { EventIdDedupe } from "./event-id-dedupe.js";
+import type { SlackLog } from "./log.js";
+import type { SlackApiTransport, SlackChannelOptions, SlackCredentials, SlackMessageHandler } from "./types.js";
+/**
+ * Transport placeholder created at `slackChannel()` definition time and
+ * bound to the real backend proxy caller when the serve host starts its
+ * relay. Calls before binding soft-fail Slack-style.
+ */
+export interface PendingSlackApiTransport extends SlackApiTransport {
+    bind(impl: SlackApiTransport["call"]): void;
+}
+export declare function createPendingSlackApiTransport(): PendingSlackApiTransport;
+/**
+ * One routed Slack event from `/v0/slack-events` (mirror of the backend's
+ * SlackAgentEventEnvelope, minus server-only fields).
+ */
+export interface CursorSlackEnvelope {
+    eventName: string;
+    slackTeamId: string;
+    channelId: string;
+    channelType?: string;
+    threadTs: string;
+    messageTs: string;
+    slackUserId?: string;
+    text: string;
+    agentName: string;
+    consumerId: string;
+    /**
+     * How the backend routed the event: leading agent name or owned thread.
+     */
+    matchedBy: "name" | "thread";
+    eventId?: string;
+    receivedAtMs: number;
+}
+/** Serve-time runtime handle for one cursor-account Slack channel. */
+export interface SlackCursorAccountRuntime {
+    options: SlackChannelOptions;
+    /** The channel's live credentials (botToken slot holds the transport). */
+    credentials: SlackCredentials;
+    transport: PendingSlackApiTransport;
+    eventIds: EventIdDedupe;
+    onAppMention: SlackMessageHandler;
+    onDirectMessage: SlackMessageHandler;
+    getLog: () => SlackLog;
+}
+export declare function registerSlackCursorAccountRuntime(definition: object, runtime: SlackCursorAccountRuntime): void;
+/**
+ * Recover the cursor-account runtime for a channel definition, if it was
+ * created via `slackChannel({ cursorAccount: true })`.
+ */
+export declare function getSlackCursorAccountRuntime(definition: object): SlackCursorAccountRuntime | undefined;
+/**
+ * Dispatch one relayed envelope through the pack's normal inbound path
+ * (same handlers, session continuation, and reply delivery as Socket Mode).
+ */
+export declare function dispatchCursorSlackEnvelope(args: {
+    runtime: SlackCursorAccountRuntime;
+    envelope: CursorSlackEnvelope;
+    send: SendMessageFn;
+    host: HostContext;
+}): Promise<void>;
+//# sourceMappingURL=cursor-account.d.ts.map