@cursor/bdk 0.2.1

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

@@ -0,0 +1,40 @@
+/**
+ * Slack channel doctor — verify env, Socket Mode app token, auth.test, and
+ * (when watched channels are supplied) that the bot token's workspace can
+ * actually see, join, and read those channels.
+ */
+import { callSlackApi } from "./api.js";
+import type { SlackCredentials } from "./types.js";
+export interface SlackDoctorCheck {
+    id: string;
+    ok: boolean;
+    message: string;
+}
+export interface SlackDoctorResult {
+    ok: boolean;
+    checks: SlackDoctorCheck[];
+    envKeys: {
+        bot: string;
+        app: string;
+    };
+    /**
+     * Things a bot token cannot prove. Event subscriptions are app-level
+     * config, so a fully green doctor can still be a silent agent.
+     */
+    notes?: string[];
+}
+export interface SlackDoctorOptions {
+    credentials?: SlackCredentials;
+    /** Per-agent env prefix (e.g. `MY_AGENT`). */
+    envPrefix?: string;
+    /**
+     * Watched channel ids (`engagement.channelPosts.allow`). Each is checked
+     * for visibility, bot membership, and history scope.
+     */
+    channels?: readonly string[];
+    /** Test seams. */
+    callImpl?: typeof callSlackApi;
+    fetchImpl?: typeof fetch;
+}
+export declare function runSlackDoctor(options?: SlackDoctorOptions): Promise<SlackDoctorResult>;
+//# sourceMappingURL=doctor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"doctor.d.ts","sourceRoot":"","sources":["../../../src/channels/slack/doctor.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,YAAY,EAAoC,MAAM,UAAU,CAAC;AAE1E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEnD,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,OAAO,CAAC;IACZ,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,iBAAiB;IAChC,EAAE,EAAE,OAAO,CAAC;IACZ,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,OAAO,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC;IACtC;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;CAClB;AAED,MAAM,WAAW,kBAAkB;IACjC,WAAW,CAAC,EAAE,gBAAgB,CAAC;IAC/B,8CAA8C;IAC9C,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;OAGG;IACH,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7B,kBAAkB;IAClB,QAAQ,CAAC,EAAE,OAAO,YAAY,CAAC;IAC/B,SAAS,CAAC,EAAE,OAAO,KAAK,CAAC;CAC1B;AA2ID,wBAAsB,cAAc,CAAC,OAAO,GAAE,kBAAuB,GAAG,OAAO,CAAC,iBAAiB,CAAC,CA+JjG"}

package/dist/channels/slack/doctor.js

@@ -0,0 +1,291 @@
+/**
+ * Slack channel doctor — verify env, Socket Mode app token, auth.test, and
+ * (when watched channels are supplied) that the bot token's workspace can
+ * actually see, join, and read those channels.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { callSlackApi, resolveAppToken, resolveBotToken } from "./api.js";
+import { credentialsFromEnv, slackEnvKeys } from "./credentials.js";
+/**
+ * Socket Mode only delivers bot events the app subscribes to. Missing
+ * subscriptions produce total silence with valid tokens, and cannot be read
+ * back from a bot token.
+ */
+const REQUIRED_BOT_EVENTS = {
+    app_mention: "@mentions of the bot",
+    "message.im": "direct messages",
+    "message.channels": "public channel posts",
+    "message.groups": "private channel posts",
+    reaction_added: "reaction handlers (onReactionAdded)",
+};
+function eventSubscriptionNote() {
+    const lines = Object.entries(REQUIRED_BOT_EVENTS).map(([event, purpose]) => `    ${event} — ${purpose}`);
+    return [
+        "A bot token cannot read Event Subscriptions. If every check above passes",
+        "but the bot is silent, verify these bot events are subscribed on the app",
+        "(Slack app config -> Event Subscriptions -> Subscribe to bot events):",
+        ...lines,
+    ].join("\n");
+}
+function asRecord(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        return undefined;
+    }
+    return value;
+}
+function errorOf(response) {
+    return typeof response.error === "string" ? response.error : "unknown";
+}
+/**
+ * Visibility, membership, and history-scope checks for one watched channel.
+ * `channel_not_found` here is the classic wrong-workspace bot token: the
+ * token authenticates fine, it just belongs to a different installation.
+ */
+function checkChannel(args) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { call, botToken, channelId } = args;
+        const checks = [];
+        let info;
+        try {
+            info = yield call({
+                botToken,
+                operation: "conversations.info",
+                body: { channel: channelId },
+            });
+        }
+        catch (error) {
+            checks.push({
+                id: `channel_visible:${channelId}`,
+                ok: false,
+                message: `conversations.info threw: ${error instanceof Error ? error.message : String(error)}`,
+            });
+            return checks;
+        }
+        if (info.ok !== true) {
+            const error = errorOf(info);
+            checks.push({
+                id: `channel_visible:${channelId}`,
+                ok: false,
+                message: error === "channel_not_found"
+                    ? `${channelId} not found by this bot token — the token is probably installed on a different workspace, or the channel id is wrong`
+                    : `conversations.info failed: ${error}`,
+            });
+            return checks;
+        }
+        const channel = asRecord(info.channel);
+        const name = typeof (channel === null || channel === void 0 ? void 0 : channel.name) === "string" ? channel.name : "?";
+        checks.push({
+            id: `channel_visible:${channelId}`,
+            ok: true,
+            message: `${channelId} visible (#${name})`,
+        });
+        const isMember = (channel === null || channel === void 0 ? void 0 : channel.is_member) === true;
+        checks.push({
+            id: `channel_member:${channelId}`,
+            ok: isMember,
+            message: isMember
+                ? `bot is a member of ${channelId}`
+                : `bot is NOT a member of ${channelId} — invite it to the channel`,
+        });
+        let history;
+        try {
+            history = yield call({
+                botToken,
+                operation: "conversations.history",
+                body: { channel: channelId, limit: 1 },
+            });
+        }
+        catch (error) {
+            checks.push({
+                id: `channel_history:${channelId}`,
+                ok: false,
+                message: `conversations.history threw: ${error instanceof Error ? error.message : String(error)}`,
+            });
+            return checks;
+        }
+        if (history.ok === true) {
+            checks.push({
+                id: `channel_history:${channelId}`,
+                ok: true,
+                message: `conversations.history ok for ${channelId}`,
+            });
+            return checks;
+        }
+        const error = errorOf(history);
+        const needed = typeof history.needed === "string" ? history.needed : undefined;
+        checks.push({
+            id: `channel_history:${channelId}`,
+            ok: false,
+            message: error === "missing_scope"
+                ? `conversations.history missing scope${needed === undefined ? "" : ` ${needed}`} — add it and reinstall the app`
+                : `conversations.history failed: ${error}`,
+        });
+        return checks;
+    });
+}
+export function runSlackDoctor() {
+    return __awaiter(this, arguments, void 0, function* (options = {}) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        const credentials = (_a = options.credentials) !== null && _a !== void 0 ? _a : credentialsFromEnv(options.envPrefix);
+        const envKeys = slackEnvKeys(options.envPrefix);
+        const checks = [];
+        const call = (_b = options.callImpl) !== null && _b !== void 0 ? _b : callSlackApi;
+        const fetchImpl = (_c = options.fetchImpl) !== null && _c !== void 0 ? _c : fetch;
+        let appTokenRaw;
+        try {
+            appTokenRaw = yield resolveAppToken(credentials);
+        }
+        catch (_k) {
+            appTokenRaw = undefined;
+        }
+        const hasApp = appTokenRaw !== undefined && appTokenRaw !== "";
+        checks.push({
+            id: "app_token",
+            ok: hasApp,
+            message: hasApp
+                ? `${envKeys.app} present`
+                : `${envKeys.app} is missing (xapp-… with connections:write)`,
+        });
+        if (hasApp && appTokenRaw !== undefined) {
+            try {
+                const response = yield fetchImpl("https://slack.com/api/apps.connections.open", {
+                    method: "POST",
+                    headers: {
+                        authorization: `Bearer ${appTokenRaw}`,
+                        "content-type": "application/x-www-form-urlencoded",
+                    },
+                    body: "",
+                });
+                const data = (yield response.json());
+                if (data.ok === true) {
+                    checks.push({
+                        id: "connections_open",
+                        ok: true,
+                        message: "apps.connections.open ok (Socket Mode reachable)",
+                    });
+                }
+                else {
+                    checks.push({
+                        id: "connections_open",
+                        ok: false,
+                        message: `apps.connections.open failed: ${String((_d = data.error) !== null && _d !== void 0 ? _d : "unknown")}`,
+                    });
+                }
+            }
+            catch (error) {
+                checks.push({
+                    id: "connections_open",
+                    ok: false,
+                    message: `apps.connections.open threw: ${error instanceof Error ? error.message : String(error)}`,
+                });
+            }
+        }
+        let botToken;
+        try {
+            botToken = yield resolveBotToken(credentials);
+        }
+        catch (_l) {
+            botToken = undefined;
+        }
+        const hasToken = botToken !== undefined && botToken !== "";
+        checks.push({
+            id: "bot_token",
+            ok: hasToken,
+            message: hasToken ? `${envKeys.bot} present` : `${envKeys.bot} is missing`,
+        });
+        let authOk = false;
+        let botUserId = "";
+        if (hasToken) {
+            try {
+                const auth = yield call({
+                    botToken,
+                    operation: "auth.test",
+                    body: {},
+                });
+                if (auth.ok === true) {
+                    authOk = true;
+                    botUserId = typeof auth.user_id === "string" ? auth.user_id : "";
+                    checks.push({
+                        id: "auth_test",
+                        ok: true,
+                        message: `auth.test ok (team=${String((_e = auth.team) !== null && _e !== void 0 ? _e : "?")}` +
+                            `, team_id=${String((_f = auth.team_id) !== null && _f !== void 0 ? _f : "?")}` +
+                            `, user=${String((_g = auth.user) !== null && _g !== void 0 ? _g : "?")})`,
+                    });
+                }
+                else {
+                    checks.push({
+                        id: "auth_test",
+                        ok: false,
+                        message: `auth.test failed: ${String((_h = auth.error) !== null && _h !== void 0 ? _h : "unknown")}`,
+                    });
+                }
+            }
+            catch (error) {
+                checks.push({
+                    id: "auth_test",
+                    ok: false,
+                    message: `auth.test threw: ${error instanceof Error ? error.message : String(error)}`,
+                });
+            }
+        }
+        // The external-sender policy (`blockExternals`, on by default) classifies a
+        // sender as external whenever `users.info` fails — so a token that cannot
+        // look up users silently drops EVERY inbound event while all other checks
+        // stay green. Probe with the bot's own user id from auth.test.
+        if (authOk && botToken !== undefined && botUserId !== "") {
+            let info;
+            let threw;
+            try {
+                info = yield call({
+                    botToken,
+                    operation: "users.info",
+                    body: { user: botUserId },
+                });
+            }
+            catch (error) {
+                threw = error instanceof Error ? error.message : String(error);
+            }
+            if ((info === null || info === void 0 ? void 0 : info.ok) === true) {
+                checks.push({
+                    id: "users_read",
+                    ok: true,
+                    message: "users.info ok (users:read granted; external-sender policy can classify senders)",
+                });
+            }
+            else {
+                const error = threw !== null && threw !== void 0 ? threw : (info === undefined ? "unknown" : errorOf(info));
+                const hint = error === "missing_scope"
+                    ? "add the users:read scope and reinstall the app"
+                    : error === "user_not_found"
+                        ? "the token cannot see its own workspace's users — probably a token from a different installation"
+                        : "fix the token";
+                checks.push({
+                    id: "users_read",
+                    ok: false,
+                    message: `users.info failed: ${error} — ${hint}. The external-sender policy fails open to "external" on users.info errors, so every inbound event is silently dropped.`,
+                });
+            }
+        }
+        const channels = (_j = options.channels) !== null && _j !== void 0 ? _j : [];
+        if (authOk && botToken !== undefined && channels.length > 0) {
+            for (const channelId of channels) {
+                checks.push(...(yield checkChannel({ call, botToken, channelId })));
+            }
+        }
+        return {
+            ok: checks.every(check => check.ok),
+            checks,
+            envKeys,
+            notes: [eventSubscriptionNote()],
+        };
+    });
+}

package/dist/channels/slack/eval-directive.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Built-in Slack `eval` directive — run playground evals from a mention/DM
+ * without per-agent custom handlers (parity with CLI / playground runs).
+ *
+ * Examples (after stripping @mentions):
+ *   eval
+ *   eval triage/open-incidents smoke
+ *   eval --tag oncall
+ *   eval list
+ *   eval status
+ *   eval help
+ */
+import type { EvalRunSnapshot, HostEvalsApi } from "../../evals.js";
+import type { SlackBinding } from "./types.js";
+export type SlackEvalDirective = {
+    kind: "help";
+} | {
+    kind: "list";
+} | {
+    kind: "status";
+} | {
+    kind: "cancel";
+    runId: string;
+} | {
+    kind: "run";
+    filterIds?: string[];
+    tags?: string[];
+};
+/**
+ * Normalize inbound Slack text for directive parsing: strip leading
+ * `<@U…>` mentions and leading `@U…` markdown mentions.
+ */
+export declare function normalizeSlackEvalDirectiveBody(text: string): string;
+/**
+ * Parse a Slack eval directive. Returns null when the message is not an
+ * eval command (falls through to the normal agent handler).
+ */
+export declare function parseSlackEvalDirective(text: string): SlackEvalDirective | null;
+/** True when either raw Slack text or markdown form is an eval directive. */
+export declare function isSlackEvalDirective(text: string, markdown: string): boolean;
+export declare function formatSlackEvalHelp(): string;
+export declare function formatSlackEvalList(evals: Array<{
+    id: string;
+    description?: string;
+    tags?: string[];
+}>): string;
+export declare function formatSlackEvalRunSummary(run: EvalRunSnapshot): string;
+/**
+ * Handle a parsed Slack eval directive against {@link HostEvalsApi}.
+ * Posts results in-thread; does not start an agent turn.
+ */
+export declare function handleSlackEvalDirective(args: {
+    directive: SlackEvalDirective;
+    evals: HostEvalsApi;
+    binding: SlackBinding;
+    /** Override poll interval (tests). */
+    pollMs?: number;
+}): Promise<void>;
+//# sourceMappingURL=eval-directive.d.ts.map

package/dist/channels/slack/eval-directive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eval-directive.d.ts","sourceRoot":"","sources":["../../../src/channels/slack/eval-directive.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAIpE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAK/C,MAAM,MAAM,kBAAkB,GAC1B;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAChB;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAChB;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,GAClB;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GACjC;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AAE3D;;;GAGG;AACH,wBAAgB,+BAA+B,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAMpE;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,kBAAkB,GAAG,IAAI,CAyE/E;AAED,6EAA6E;AAC7E,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAE5E;AAED,wBAAgB,mBAAmB,IAAI,MAAM,CAW5C;AAED,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,KAAK,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;CACjB,CAAC,GACD,MAAM,CAaR;AAED,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,eAAe,GAAG,MAAM,CA0BtE;AAyBD;;;GAGG;AACH,wBAAsB,wBAAwB,CAAC,IAAI,EAAE;IACnD,SAAS,EAAE,kBAAkB,CAAC;IAC9B,KAAK,EAAE,YAAY,CAAC;IACpB,OAAO,EAAE,YAAY,CAAC;IACtB,sCAAsC;IACtC,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,GAAG,OAAO,CAAC,IAAI,CAAC,CAqFhB"}

package/dist/channels/slack/eval-directive.js

@@ -0,0 +1,269 @@
+/**
+ * Built-in Slack `eval` directive — run playground evals from a mention/DM
+ * without per-agent custom handlers (parity with CLI / playground runs).
+ *
+ * Examples (after stripping @mentions):
+ *   eval
+ *   eval triage/open-incidents smoke
+ *   eval --tag oncall
+ *   eval list
+ *   eval status
+ *   eval help
+ */
+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 { EvalRunConflictError, EvalRunEmptyError } from "../../internal/eval-run-store.js";
+import { sleep } from "../../internal/sleep.js";
+import { stripLeadingSlackMentions } from "./stop.js";
+const EVAL_POLL_MS = 2000;
+const TYPING_STATUS_MAX = 50;
+/**
+ * Normalize inbound Slack text for directive parsing: strip leading
+ * `<@U…>` mentions and leading `@U…` markdown mentions.
+ */
+export function normalizeSlackEvalDirectiveBody(text) {
+    let body = stripLeadingSlackMentions(text);
+    while (/^@[A-Za-z0-9._-]+\s+/.test(body)) {
+        body = body.replace(/^@[A-Za-z0-9._-]+\s+/, "").trim();
+    }
+    return body;
+}
+/**
+ * Parse a Slack eval directive. Returns null when the message is not an
+ * eval command (falls through to the normal agent handler).
+ */
+export function parseSlackEvalDirective(text) {
+    var _a, _b, _c;
+    const body = normalizeSlackEvalDirectiveBody(text);
+    if (body.length === 0) {
+        return null;
+    }
+    const tokens = body.split(/\s+/).filter(t => t.length > 0);
+    if (tokens.length === 0 || !/^eval$/i.test((_a = tokens[0]) !== null && _a !== void 0 ? _a : "")) {
+        return null;
+    }
+    const rest = tokens.slice(1);
+    if (rest.length === 0) {
+        return { kind: "run" };
+    }
+    const head = ((_b = rest[0]) !== null && _b !== void 0 ? _b : "").toLowerCase();
+    if (rest.length === 1 && (head === "help" || head === "-h" || head === "--help")) {
+        return { kind: "help" };
+    }
+    if (rest.length === 1 && (head === "list" || head === "ls")) {
+        return { kind: "list" };
+    }
+    if (rest.length === 1 && head === "status") {
+        return { kind: "status" };
+    }
+    if (head === "cancel") {
+        const runId = rest[1];
+        if (rest.length !== 2 || runId === undefined || runId.length === 0) {
+            return { kind: "help" };
+        }
+        return { kind: "cancel", runId };
+    }
+    const filterIds = [];
+    const tags = [];
+    for (let i = 0; i < rest.length; i++) {
+        const tok = (_c = rest[i]) !== null && _c !== void 0 ? _c : "";
+        if (tok === "--tag" || tok === "-t") {
+            const value = rest[i + 1];
+            if (value === undefined || value.length === 0) {
+                return { kind: "help" };
+            }
+            tags.push(value);
+            i += 1;
+            continue;
+        }
+        if (tok.startsWith("--tag=")) {
+            const value = tok.slice("--tag=".length);
+            if (value.length === 0) {
+                return { kind: "help" };
+            }
+            tags.push(value);
+            continue;
+        }
+        if (tok.startsWith("-t=") && tok.length > 3) {
+            tags.push(tok.slice(3));
+            continue;
+        }
+        if (tok.startsWith("-")) {
+            // Unknown flag — surface help rather than treating as an eval id.
+            return { kind: "help" };
+        }
+        filterIds.push(tok);
+    }
+    const run = { kind: "run" };
+    if (filterIds.length > 0) {
+        run.filterIds = filterIds;
+    }
+    if (tags.length > 0) {
+        run.tags = tags;
+    }
+    return run;
+}
+/** True when either raw Slack text or markdown form is an eval directive. */
+export function isSlackEvalDirective(text, markdown) {
+    return parseSlackEvalDirective(text) !== null || parseSlackEvalDirective(markdown) !== null;
+}
+export function formatSlackEvalHelp() {
+    return [
+        "*Eval commands* (same batches as the playground / `agent-sdk eval --prod`):",
+        "• `eval` — run all evals",
+        "• `eval <id> [id…]` — run specific eval ids",
+        "• `eval --tag <tag>` — run evals with a tag (`-t` also works)",
+        "• `eval list` — list available evals",
+        "• `eval status` — show the active or latest eval run",
+        "• `eval cancel <evalId>` — cancel a running eval batch",
+        "• `eval help` — this message",
+    ].join("\n");
+}
+export function formatSlackEvalList(evals) {
+    if (evals.length === 0) {
+        return "No evals found under `evals/`.";
+    }
+    const lines = [`*${evals.length} eval(s):*`];
+    for (const item of evals) {
+        const tags = item.tags === undefined || item.tags.length === 0 ? "" : ` _[${item.tags.join(", ")}]_`;
+        const desc = item.description === undefined || item.description === "" ? "" : ` — ${item.description}`;
+        lines.push(`• \`${item.id}\`${tags}${desc}`);
+    }
+    return lines.join("\n");
+}
+export function formatSlackEvalRunSummary(run) {
+    const { summary } = run;
+    const statusLabel = run.status === "completed" ? "completed" : run.status === "failed" ? "failed" : "running";
+    const lines = [
+        `*Eval run* \`${run.runId}\` — *${statusLabel}*`,
+        `• ${summary.passed} passed, ${summary.failed} failed, ${summary.total} total` +
+            (summary.done < summary.total ? ` (${summary.done}/${summary.total} done)` : ""),
+    ];
+    if (run.error !== undefined && run.error !== "") {
+        lines.push(`• error: ${run.error}`);
+    }
+    for (const c of run.cases) {
+        const mark = c.status !== "done"
+            ? c.status === "running"
+                ? "RUN "
+                : "….  "
+            : c.ok === true
+                ? "PASS"
+                : "FAIL";
+        const dur = c.durationMs === undefined ? "" : ` (${(c.durationMs / 1000).toFixed(1)}s)`;
+        const err = c.ok === false && c.error !== undefined && c.error !== "" ? ` — ${c.error}` : "";
+        lines.push(`\`${mark}\` \`${c.id}\`${dur}${err}`);
+    }
+    return lines.join("\n");
+}
+function truncateTyping(status) {
+    if (status.length <= TYPING_STATUS_MAX) {
+        return status;
+    }
+    return `${status.slice(0, TYPING_STATUS_MAX - 1)}…`;
+}
+function safeTyping(binding, status) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            yield binding.thread.startTyping(truncateTyping(status));
+        }
+        catch (_a) {
+            // best-effort status
+        }
+    });
+}
+function safePost(binding, text) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            yield binding.thread.post(text);
+        }
+        catch (_a) {
+            // best-effort reply
+        }
+    });
+}
+/**
+ * Handle a parsed Slack eval directive against {@link HostEvalsApi}.
+ * Posts results in-thread; does not start an agent turn.
+ */
+export function handleSlackEvalDirective(args) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        const { directive, evals, binding } = args;
+        const pollMs = (_a = args.pollMs) !== null && _a !== void 0 ? _a : EVAL_POLL_MS;
+        if (directive.kind === "help") {
+            yield safePost(binding, formatSlackEvalHelp());
+            return;
+        }
+        if (directive.kind === "list") {
+            const listed = yield evals.list();
+            yield safePost(binding, formatSlackEvalList(listed.evals));
+            return;
+        }
+        if (directive.kind === "status") {
+            const { runs, activeRunId } = yield evals.listRunsWithActive();
+            const run = (_b = (activeRunId === undefined ? undefined : yield evals.get(activeRunId))) !== null && _b !== void 0 ? _b : runs[0];
+            if (run === undefined) {
+                yield safePost(binding, "No eval runs yet. Try `eval list` then `eval`.");
+                return;
+            }
+            yield safePost(binding, formatSlackEvalRunSummary(run));
+            return;
+        }
+        if (directive.kind === "cancel") {
+            try {
+                const run = yield evals.cancel(directive.runId);
+                yield safePost(binding, `Cancelled Eval ID \`${run.runId}\`.\n${formatSlackEvalRunSummary(run)}`);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                yield safePost(binding, `Failed to cancel eval: ${message}`);
+            }
+            return;
+        }
+        yield safeTyping(binding, "Starting evals…");
+        let run;
+        try {
+            run = yield evals.start({
+                filterIds: directive.filterIds,
+                tags: directive.tags,
+            });
+        }
+        catch (error) {
+            if (error instanceof EvalRunConflictError) {
+                const active = yield evals.get(error.activeRunId);
+                yield safePost(binding, active === undefined
+                    ? `An eval run is already in progress (\`${error.activeRunId}\`).`
+                    : `An eval run is already in progress:\n${formatSlackEvalRunSummary(active)}`);
+                return;
+            }
+            if (error instanceof EvalRunEmptyError) {
+                yield safePost(binding, "No matching evals. Try `eval list` or `eval help`.");
+                return;
+            }
+            const message = error instanceof Error ? error.message : String(error);
+            yield safePost(binding, `Failed to start evals: ${message}`);
+            return;
+        }
+        yield safePost(binding, `Started Eval ID \`${run.runId}\` (${run.summary.total} case(s)). Cancel with \`eval cancel ${run.runId}\`.`);
+        while (run.status === "running") {
+            yield safeTyping(binding, `Evals ${run.summary.done}/${run.summary.total}…`);
+            yield sleep(pollMs);
+            const next = yield evals.get(run.runId);
+            if (next === undefined) {
+                yield safePost(binding, `Eval run \`${run.runId}\` disappeared before completion.`);
+                return;
+            }
+            run = next;
+        }
+        yield safePost(binding, formatSlackEvalRunSummary(run));
+        yield safeTyping(binding, "Evals done.");
+    });
+}

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

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

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

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