@timqi/pier 0.0.1

package/dist/channels/receipts.js

@@ -0,0 +1,104 @@
+// Reaction receipts: the whole lifecycle, storage included.
+//
+// A 👀 goes on an inbound message and comes off when its turn settles. Both
+// halves live in Telegram, not in Pier, so anything ending the process between
+// them leaves the emoji on a user's message with nobody left to clear it —
+// and so does a message whose session never started a turn at all. Making the
+// pending set durable is what closes the loop: an adapter clears every receipt
+// it finds at startup (nothing in memory can be its own yet), and sweeps its
+// own stragglers on a timer.
+import { pierDb } from "../db.js";
+const toReceipt = (row) => ({
+    conversationId: row.conversation_id,
+    chatId: row.chat_id,
+    // SQLite hands back whatever affinity it stored; the column is TEXT, but
+    // coercing keeps a numeric-looking id from arriving as a number.
+    messageId: String(row.message_id),
+});
+export class ReceiptLedger {
+    platform;
+    db;
+    constructor(platform, db = pierDb()) {
+        this.platform = platform;
+        this.db = db;
+    }
+    /** Re-marking the same message replaces the row rather than duplicating it. */
+    add(receipt) {
+        this.db.prepare(`
+      INSERT INTO receipts(platform, conversation_id, chat_id, message_id, created_at)
+      VALUES (?, ?, ?, ?, ?)
+      ON CONFLICT(platform, chat_id, message_id) DO UPDATE SET
+        conversation_id = excluded.conversation_id, created_at = excluded.created_at
+    `).run(this.platform, receipt.conversationId, receipt.chatId, receipt.messageId, Date.now());
+    }
+    /** Claim a conversation's receipts: returned once, then gone. */
+    take(conversationId) {
+        const rows = this.db.prepare(`
+      SELECT conversation_id, chat_id, message_id FROM receipts
+      WHERE platform = ? AND conversation_id = ?
+    `).all(this.platform, conversationId);
+        this.db.prepare("DELETE FROM receipts WHERE platform = ? AND conversation_id = ?")
+            .run(this.platform, conversationId);
+        return rows.map(toReceipt);
+    }
+    /** Claim receipts older than `ageMs`; `0` claims everything (startup sweep). */
+    takeStale(ageMs, now = Date.now()) {
+        const cutoff = now - ageMs;
+        const rows = this.db.prepare(`
+      SELECT conversation_id, chat_id, message_id FROM receipts
+      WHERE platform = ? AND created_at <= ?
+    `).all(this.platform, cutoff);
+        this.db.prepare("DELETE FROM receipts WHERE platform = ? AND created_at <= ?")
+            .run(this.platform, cutoff);
+        return rows.map(toReceipt);
+    }
+}
+/**
+ * Marks messages as being worked on and unmarks them when their turn settles.
+ * Lives next to the ledger because the ordering rule spans both: a receipt is
+ * booked synchronously (so an instant turn cannot clear an unbooked one) while
+ * the platform call is in flight, and the clear must wait for that call to land
+ * or the reaction stays up forever.
+ */
+export class Receipts {
+    api;
+    ledger;
+    log;
+    emoji;
+    staleMs;
+    /** In-flight `setReaction` per marked message. Only this process's own. */
+    applying = new Map();
+    constructor(api, ledger, log, emoji, 
+    /** After this, a receipt's turn is assumed never to settle. */
+    staleMs) {
+        this.api = api;
+        this.ledger = ledger;
+        this.log = log;
+        this.emoji = emoji;
+        this.staleMs = staleMs;
+    }
+    mark(conversationId, chatId, messageId) {
+        this.applying.set(`${chatId}:${messageId}`, this.api.setReaction(chatId, messageId, this.emoji)
+            .catch((err) => this.log(`reaction failed: ${String(err)}`)));
+        this.ledger.add({ conversationId, chatId, messageId });
+    }
+    /** The turn this conversation was running has ended. */
+    settle(conversationId) {
+        return this.clear(this.ledger.take(conversationId));
+    }
+    /**
+     * Everything on the books at startup is orphaned — nothing in memory can be
+     * ours yet — and past `staleMs` a receipt's turn is never going to settle.
+     */
+    sweep(all = false) {
+        return this.clear(this.ledger.takeStale(all ? 0 : this.staleMs));
+    }
+    async clear(receipts) {
+        for (const { chatId, messageId } of receipts) {
+            const key = `${chatId}:${messageId}`;
+            await this.applying.get(key);
+            this.applying.delete(key);
+            await this.api.setReaction(chatId, messageId, null).catch(() => { });
+        }
+    }
+}

package/dist/channels/routes.js

@@ -0,0 +1,110 @@
+// Console → Channels HTTP surface. One document per platform: credentials,
+// global defaults, bound users and discovered chats travel together, so the
+// UI never has to stitch two half-configs.
+import { isThinkingLevel } from "../core/types.js";
+import { defaultChannelConfig, isChannelPlatform, } from "./types.js";
+/** Stable mask: recomputable at write time, so "unchanged" is detectable. */
+const maskToken = (token) => token ? `${"•".repeat(8)}${token.slice(-4)}` : "";
+const asBool = (v) => v === true;
+const asString = (v) => (typeof v === "string" ? v.trim() : "");
+const asThinking = (v) => (isThinkingLevel(v) ? v : null);
+/** A model is a provider/id pair or nothing; a half-filled one is nothing. */
+function asModel(v) {
+    const ref = v;
+    if (!ref || typeof ref !== "object")
+        return null;
+    const provider = asString(ref.provider);
+    const id = asString(ref.id);
+    return provider && id ? { provider, id } : null;
+}
+/**
+ * Apply the client's edits on top of what the store knows. Iterating the
+ * stored list, not the payload, is what makes the save non-destructive: chats
+ * are discovered, so one that appeared while the operator had the page open
+ * must survive their save instead of being deleted by a stale client list.
+ */
+function parseChats(raw, known) {
+    if (!Array.isArray(raw))
+        return known;
+    const edits = new Map();
+    for (const item of raw) {
+        const id = asString(item?.id);
+        if (id)
+            edits.set(id, item);
+    }
+    return known.map((base) => {
+        const edit = edits.get(base.id);
+        if (!edit)
+            return base;
+        return {
+            ...base,
+            enabled: asBool(edit.enabled),
+            requireMention: asBool(edit.requireMention),
+            requireBind: asBool(edit.requireBind),
+            topicMode: asBool(edit.topicMode),
+            cwd: asString(edit.cwd),
+            model: asModel(edit.model),
+            thinking: asThinking(edit.thinking),
+        };
+    });
+}
+export function registerChannelRoutes(app, store, runtime) {
+    app.get("/api/channels/:platform", (c) => {
+        const platform = c.req.param("platform");
+        if (!isChannelPlatform(platform))
+            return c.json({ error: "unknown platform" }, 404);
+        const config = store.get(platform);
+        // Never hand a token back: the client only needs to know one is set.
+        return c.json({
+            ...config,
+            token: maskToken(config.token),
+            appToken: maskToken(config.appToken),
+            supported: platform === "telegram" || platform === "slack",
+        });
+    });
+    app.put("/api/channels/:platform", async (c) => {
+        const platform = c.req.param("platform");
+        if (!isChannelPlatform(platform))
+            return c.json({ error: "unknown platform" }, 404);
+        const body = (await c.req.json().catch(() => null));
+        if (!body || typeof body !== "object")
+            return c.json({ error: "invalid body" }, 400);
+        const current = store.get(platform);
+        // A token that comes back masked is the stored one, untouched.
+        const kept = (incoming, stored) => !incoming || incoming === maskToken(stored) ? stored : incoming;
+        const next = {
+            ...defaultChannelConfig(),
+            enabled: asBool(body.enabled),
+            token: kept(asString(body.token), current.token),
+            appToken: kept(asString(body.appToken), current.appToken),
+            // Absent means "on": a client that predates the field must not silently
+            // switch off a capability the operator never touched.
+            agentTool: body.agentTool === undefined ? current.agentTool : asBool(body.agentTool),
+            requireMention: asBool(body.requireMention),
+            requireBind: asBool(body.requireBind),
+            topicMode: asBool(body.topicMode),
+            cwd: asString(body.cwd),
+            model: asModel(body.model),
+            thinking: asThinking(body.thinking),
+            users: current.users,
+            chats: parseChats(body.chats, current.chats),
+            bindCode: current.bindCode,
+        };
+        store.save(platform, next);
+        await runtime.reload();
+        return c.json({ ok: true });
+    });
+    app.post("/api/channels/:platform/bind-code", (c) => {
+        const platform = c.req.param("platform");
+        if (!isChannelPlatform(platform))
+            return c.json({ error: "unknown platform" }, 404);
+        return c.json(store.issueBindCode(platform));
+    });
+    app.delete("/api/channels/:platform/users/:id", (c) => {
+        const platform = c.req.param("platform");
+        if (!isChannelPlatform(platform))
+            return c.json({ error: "unknown platform" }, 404);
+        store.unbind(platform, c.req.param("id"));
+        return c.json({ ok: true });
+    });
+}

package/dist/channels/runtime.js

@@ -0,0 +1,76 @@
+// Channel lifecycle: which adapters are running, and where their sessions
+// live. Keeps main.ts wiring-only and gives the Console one call to apply a
+// config change. Lark is configurable but has no adapter yet.
+import { logger } from "../log.js";
+import { SlackChannel } from "./slack.js";
+import { TelegramChannel } from "./telegram.js";
+/** Platforms with an adapter, and what each needs before it can start. */
+const ADAPTERS = [
+    { platform: "telegram", needsAppToken: false, build: (deps) => new TelegramChannel(deps) },
+    { platform: "slack", needsAppToken: true, build: (deps) => new SlackChannel(deps) },
+];
+// Lifecycle news, which is not what the injected sink below is for: that one
+// is a warning sink the adapters share, and "slack started" is not a warning.
+const log = logger("channels");
+export class ChannelRuntime {
+    store;
+    router;
+    control;
+    log;
+    live = new Map();
+    constructor(store, router, control, log = (m) => logger("channels").warn(m)) {
+        this.store = store;
+        this.router = router;
+        this.control = control;
+        this.log = log;
+    }
+    /** (Re)start every platform whose config says it should run. Idempotent. */
+    async reload() {
+        for (const adapter of ADAPTERS)
+            await this.restart(adapter);
+    }
+    async restart(adapter) {
+        const { platform, needsAppToken, build } = adapter;
+        const existing = this.live.get(platform);
+        if (existing) {
+            this.live.delete(platform);
+            // Never fatal — the config still has to be applied — but a socket that
+            // refuses to close is exactly what makes the next start behave oddly.
+            await existing.stop().catch((err) => this.log(`${platform} did not stop cleanly: ${String(err)}`));
+        }
+        const config = this.store.get(platform);
+        if (!config.enabled || !config.token)
+            return;
+        if (needsAppToken && !config.appToken) {
+            // Named, not silent: "enabled but nothing happens" is otherwise
+            // indistinguishable from a broken adapter.
+            this.log(`${platform}: enabled but no app token, not starting`);
+            return;
+        }
+        const channel = build({
+            store: this.store,
+            log: (m) => this.log(`${platform}: ${m}`),
+            // The runtime owns the router, so channel control (stop, the settings
+            // panel) is wired here instead of widening the Channel seam.
+            control: this.control,
+        });
+        try {
+            await channel.start((msg) => {
+                void this.router.dispatch(msg).catch((err) => this.log(`dispatch failed: ${String(err)}`));
+            });
+        }
+        catch (err) {
+            this.log(`${platform} failed to start: ${String(err)}`);
+            return;
+        }
+        this.router.registerChannel(channel);
+        this.live.set(platform, channel);
+        log.info(`${platform} started`);
+    }
+    async stop() {
+        for (const channel of this.live.values()) {
+            await channel.stop().catch((err) => this.log(`${channel.id} did not stop cleanly: ${String(err)}`));
+        }
+        this.live.clear();
+    }
+}

package/dist/channels/slack-api.js

@@ -0,0 +1,296 @@
+// Thin Slack client: HTTP shapes and the Socket Mode transport, no policy.
+// The one file in channels/ that talks to slack.com, so the adapter stays
+// testable against `SlackClient`.
+//
+// Socket Mode, not the Events API over HTTP: Pier is one local process and must
+// not require a public inbound URL. It needs two credentials — an app-level
+// token (`xapp-`) opens the socket, the bot token (`xoxb-`) signs every Web API
+// call — which is why ChannelConfig carries `appToken` beside `token`.
+//
+// No SDK: `apps.connections.open` plus Node's built-in WebSocket is the whole
+// protocol, and @slack/socket-mode would pull a dependency tree to wrap it.
+const BASE = "https://slack.com/api";
+/**
+ * Did Slack refuse the payload because of the *block* itself? The `markdown`
+ * block is recent, so a workspace that predates it answers with one of these —
+ * the signal to re-render the turn as legacy mrkdwn rather than to lose it.
+ *
+ * Slack has no capability API to ask up front, so the only detection is a
+ * failed send. That makes the test's *narrowness* the whole safety property:
+ * the caller latches the answer for the process, so anything matched here
+ * degrades every later message too. `invalid_arguments` is deliberately NOT
+ * matched even though avibe lists it — avibe retries per message, where a
+ * broad match costs one fallback; latching turns the same breadth into a
+ * permanent downgrade triggered by an unrelated bad argument (a malformed
+ * `thread_ts` would silently cost the whole process its rendering). A wrong
+ * call should surface as an error, not as a quieter renderer.
+ */
+export const isBlockRejection = (err) => /invalid_blocks|unsupported_block_type/.test(String(err));
+/**
+ * A connection that dies younger than this was a failed attempt, however it
+ * ended: Slack answers "too many connections" by accepting the socket and
+ * closing it straight away, which is not an error the loop would otherwise see.
+ */
+const MIN_CONNECTION_MS = 5000;
+const RECONNECT_FLOOR_MS = 1000;
+const RECONNECT_MAX_MS = 30_000;
+export class SlackApi {
+    token;
+    appToken;
+    log;
+    openSocket;
+    socketRunning = false;
+    constructor(token, appToken, log = () => { }, 
+    /** Injected in tests; production opens a real WebSocket. */
+    openSocket = (url) => new WebSocket(url)) {
+        this.token = token;
+        this.appToken = appToken;
+        this.log = log;
+        this.openSocket = openSocket;
+    }
+    /**
+     * Slack accepts a JSON body only on *write* methods. A read method
+     * (`users.info`, `conversations.info|history|replies`) silently ignores it and
+     * then reports the missing parameter — `users.info` answers `user_not_found`,
+     * which reads like "no such person" rather than "you sent the id in a place I
+     * do not look". So reads go form-encoded. This was worth four broken calls.
+     */
+    async read(method, params) {
+        const form = new URLSearchParams();
+        for (const [key, value] of Object.entries(params)) {
+            if (value !== undefined)
+                form.set(key, String(value));
+        }
+        return this.call(method, form);
+    }
+    async call(method, payload, token = this.token, retry = true) {
+        const form = payload instanceof URLSearchParams;
+        const res = await fetch(`${BASE}/${method}`, {
+            method: "POST",
+            headers: {
+                "content-type": form
+                    ? "application/x-www-form-urlencoded; charset=utf-8"
+                    : "application/json; charset=utf-8",
+                authorization: `Bearer ${token}`,
+            },
+            body: form ? payload.toString() : JSON.stringify(payload),
+            signal: AbortSignal.timeout(30_000),
+        });
+        // Slack answers a flood (a long turn split into chunks hits ~1 msg/s per
+        // channel) with the exact wait in a header. Obeying it once turns a dropped
+        // reply into a late one; a second 429 is a real problem and throws.
+        if (res.status === 429 && retry) {
+            const after = Number(res.headers.get("retry-after") ?? "1");
+            if (Number.isFinite(after) && after <= 60) {
+                await new Promise((r) => setTimeout(r, (after + 1) * 1000));
+                return this.call(method, payload, token, false);
+            }
+        }
+        const body = (await res.json().catch(() => null));
+        if (!body)
+            throw new Error(`slack ${method}: ${res.status} with no JSON body`);
+        if (!body.ok)
+            throw new Error(`slack ${method}: ${body.error ?? res.status}`);
+        return body;
+    }
+    async authTest() {
+        const body = await this.call("auth.test", {});
+        return { userId: body.user_id ?? "" };
+    }
+    // --- Socket Mode -----------------------------------------------------------
+    /**
+     * Reconnecting is part of the protocol, not the adapter's problem: Slack
+     * cycles a connection every few hours with `disconnect: refresh_requested`,
+     * so the loop reopens until `close()` clears the flag.
+     */
+    async connect(onEnvelope) {
+        this.socketRunning = true;
+        let socket;
+        const run = async () => {
+            let backoff = RECONNECT_FLOOR_MS;
+            while (this.socketRunning) {
+                // Set once the socket exists, so a slow `apps.connections.open` cannot
+                // make a connection that died instantly look like a healthy one.
+                let connectedAt = 0;
+                try {
+                    const open = await this.call("apps.connections.open", {}, this.appToken);
+                    if (!open.url)
+                        throw new Error("apps.connections.open returned no url");
+                    // stop() may have landed while that call was in flight. Opening now
+                    // would leave a live socket nobody holds a reference to.
+                    if (!this.socketRunning)
+                        return;
+                    socket = this.openSocket(open.url);
+                    connectedAt = Date.now();
+                    // Resolves on close, never rejects: a dropped socket is normal and
+                    // the loop's job is to reopen it, not to treat it as an error.
+                    await new Promise((resolve) => {
+                        const ws = socket;
+                        ws.onmessage = (ev) => {
+                            let env;
+                            try {
+                                env = JSON.parse(String(ev.data));
+                            }
+                            catch {
+                                // Validate at the boundary: log and drop, never half-handle.
+                                this.log(`unparseable socket frame dropped`);
+                                return;
+                            }
+                            // Ack first and always. Handling happens after, because a turn
+                            // outlives the deadline and Slack redelivers what it never saw
+                            // acknowledged.
+                            if (env.envelope_id) {
+                                try {
+                                    ws.send(JSON.stringify({ envelope_id: env.envelope_id }));
+                                }
+                                catch (err) {
+                                    this.log(`ack failed: ${String(err)}`);
+                                }
+                            }
+                            if (env.type === "hello")
+                                return;
+                            if (env.type === "disconnect") {
+                                // Expected: Slack recycles connections. Closing resolves the
+                                // promise below and the loop reopens.
+                                this.log(`socket disconnect (${env.reason ?? "no reason"}), reconnecting`);
+                                ws.close();
+                                return;
+                            }
+                            onEnvelope(env);
+                        };
+                        ws.onerror = () => {
+                            // `onclose` always follows, and carries the useful detail.
+                        };
+                        ws.onclose = () => resolve();
+                    });
+                }
+                catch (err) {
+                    this.log(`socket connect failed: ${String(err)}`);
+                }
+                if (!this.socketRunning)
+                    return;
+                // The anti-spin floor. A socket that lived a while was healthy, so the
+                // next attempt starts from the floor again; one that died young — or
+                // threw — backs off, because reopening instantly would hammer
+                // apps.connections.open in a tight loop.
+                if (connectedAt && Date.now() - connectedAt >= MIN_CONNECTION_MS) {
+                    backoff = RECONNECT_FLOOR_MS;
+                }
+                await new Promise((r) => setTimeout(r, backoff));
+                backoff = Math.min(backoff * 2, RECONNECT_MAX_MS);
+            }
+        };
+        void run();
+        return {
+            close: async () => {
+                this.socketRunning = false;
+                try {
+                    socket?.close();
+                }
+                catch {
+                    // Already closing; nothing to recover.
+                }
+            },
+        };
+    }
+    // --- messages --------------------------------------------------------------
+    async postMessage(payload) {
+        const body = await this.call("chat.postMessage", {
+            unfurl_links: false,
+            unfurl_media: false,
+            ...payload,
+        });
+        return { ts: body.ts ?? "" };
+    }
+    async updateMessage(payload) {
+        // chat.update takes no thread_ts; sending it is an invalid_arguments error.
+        const { thread_ts: _thread, ...rest } = payload;
+        await this.call("chat.update", rest);
+    }
+    async deleteMessage(channel, ts) {
+        await this.call("chat.delete", { channel, ts });
+    }
+    async setBlocks(channel, ts, text, blocks) {
+        await this.call("chat.update", { channel, ts, text, blocks });
+    }
+    async addReaction(channel, ts, name) {
+        try {
+            await this.call("reactions.add", { channel, timestamp: ts, name });
+        }
+        catch (err) {
+            // The reaction is already where we want it; that is a success.
+            if (!String(err).includes("already_reacted"))
+                throw err;
+        }
+    }
+    async removeReaction(channel, ts, name) {
+        try {
+            await this.call("reactions.remove", { channel, timestamp: ts, name });
+        }
+        catch (err) {
+            if (!String(err).includes("no_reaction"))
+                throw err;
+        }
+    }
+    async openView(triggerId, view) {
+        await this.call("views.open", { trigger_id: triggerId, view });
+    }
+    async channelInfo(channel) {
+        const body = await this.read("conversations.info", { channel });
+        return {
+            name: body.channel?.name,
+            isIm: !!(body.channel?.is_im || body.channel?.is_mpim),
+        };
+    }
+    async userName(userId) {
+        const body = await this.read("users.info", { user: userId });
+        return body.user?.real_name || body.user?.name || userId;
+    }
+    async page(method, params) {
+        const body = await this.read(method, params);
+        // An empty cursor means "no more"; Slack sends `""` rather than omitting it.
+        const next = body.response_metadata?.next_cursor;
+        return { messages: body.messages ?? [], nextCursor: next || undefined };
+    }
+    history(channel, query) {
+        return this.page("conversations.history", {
+            channel,
+            oldest: query.oldest,
+            latest: query.latest,
+            limit: query.limit ?? 200,
+            cursor: query.cursor,
+            inclusive: true,
+        });
+    }
+    replies(channel, ts, query) {
+        return this.page("conversations.replies", {
+            channel,
+            ts,
+            // Slack drops the boundary message unless asked; the caller wants it and
+            // filters for itself, the same as `history` above.
+            oldest: query.oldest,
+            inclusive: true,
+            limit: query.limit ?? 200,
+            cursor: query.cursor,
+        });
+    }
+    /**
+     * Slack file URLs are private: they need the bot token as a bearer header and
+     * answer HTML (a login page) rather than an error when it is missing.
+     */
+    async downloadFile(file) {
+        const url = file.url_private_download ?? file.url_private;
+        if (!url)
+            throw new Error("slack file has no private url");
+        const res = await fetch(url, {
+            headers: { authorization: `Bearer ${this.token}` },
+            signal: AbortSignal.timeout(60_000),
+        });
+        if (!res.ok)
+            throw new Error(`slack file download: ${res.status}`);
+        const mimeType = res.headers.get("content-type")?.split(";")[0] ?? file.mimetype ?? "image/png";
+        if (!mimeType.startsWith("image/"))
+            throw new Error(`slack file is ${mimeType}, not an image`);
+        return { data: Buffer.from(await res.arrayBuffer()).toString("base64"), mimeType };
+    }
+}

package/dist/channels/slack-directory.js

@@ -0,0 +1,77 @@
+// Who and where, cached: user display names and channel kind/name.
+//
+// Every inbound message needs the sender's name, and every transcript the tool
+// returns needs one per speaker — so without a cache this is one `users.info`
+// per message and per read. Neither answer changes in practice, so the cache is
+// process-lifetime and shared: the adapter and the agent-facing tool ask the
+// same instance, which is why a repeated `read_thread` costs no lookups at all.
+//
+// Failures are logged and fall back to the id, never swallowed: without
+// `users:read` this fails for every message, and the only symptom used to be an
+// agent telling the human "Slack does not expose your display name" — a scope
+// problem wearing a product problem's clothes.
+export class SlackDirectory {
+    log;
+    channels = new Map();
+    users = new Map();
+    constructor(log) {
+        this.log = log;
+    }
+    /**
+     * Kind and display name together, because one `conversations.info` answers
+     * both. The event usually settles the kind for free (`channel_type`), and a
+     * `D`-prefixed id is always a DM — but only the lookup knows the name.
+     */
+    async channel(api, channel, event) {
+        const cached = this.channels.get(channel);
+        if (cached)
+            return cached;
+        const fromEvent = event?.channel_type
+            ? event.channel_type === "im" || event.channel_type === "mpim" ? "dm" : "group"
+            : channel.startsWith("D")
+                ? "dm"
+                : undefined;
+        // A DM's name comes from its member, not from the channel, so a DM settled
+        // by the event needs no lookup at all.
+        if (fromEvent === "dm") {
+            const facts = { kind: fromEvent };
+            this.channels.set(channel, facts);
+            return facts;
+        }
+        const info = await api.channelInfo(channel).catch((err) => {
+            this.log(`conversations.info failed for ${channel}: ${String(err)}`);
+            return undefined;
+        });
+        // Uncached on failure, so the next message retries rather than pinning a
+        // guess for the life of the process.
+        if (!info)
+            return { kind: fromEvent ?? "group" };
+        const facts = {
+            kind: info.isIm ? "dm" : "group",
+            name: info.name ? `#${info.name}` : undefined,
+        };
+        this.channels.set(channel, facts);
+        return facts;
+    }
+    /** Display name for a user id; the id itself when Slack will not say. */
+    async user(api, userId) {
+        const hit = this.users.get(userId);
+        if (hit !== undefined)
+            return hit;
+        const name = await api.userName(userId).catch((err) => {
+            this.log(`users.info failed for ${userId} (is users:read granted?): ${String(err)}`);
+            return userId;
+        });
+        this.users.set(userId, name);
+        return name;
+    }
+    /** Names for every speaker in a transcript, in one pass. */
+    async names(api, userIds) {
+        const out = new Map();
+        for (const id of userIds) {
+            if (!out.has(id))
+                out.set(id, await this.user(api, id));
+        }
+        return out;
+    }
+}