toolroll 0.5.0

package/dist/slack-api.js

@@ -0,0 +1,229 @@
+import { ChatDeliveryError } from "./chat-delivery-state.js";
+import { chmodSync, readFileSync, renameSync, rmSync, writeFileSync, } from "node:fs";
+import { join } from "node:path";
+import { randomBytes } from "node:crypto";
+import { slackHash } from "./slack-state.js";
+export class SlackError extends ChatDeliveryError {
+    constructor(code, retryMs = 5_000, uncertain = false) {
+        super(code, retryMs, uncertain);
+        this.message =
+            {
+                invalid_auth: "Slack access expired. Disconnect and reconnect with the current tokens.",
+                not_authed: "Slack access expired. Reconnect the app.",
+                token_revoked: "Slack access was revoked. Reconnect the app.",
+                token_expired: "Slack access expired. Reconnect the app.",
+                account_inactive: "This Slack account is no longer active.",
+                missing_scope: "The Slack app needs additional permissions. Reinstall it with the supplied manifest.",
+                no_permission: "Slack refused access to this conversation. Check the app permissions.",
+                ratelimited: "Slack asked us to wait. Saved replies will retry.",
+                channel_not_found: "The Slack conversation is unavailable. Pair your account again.",
+                message_not_found: "The original Slack message was removed. Open the saved chat to recover it.",
+                already_complete: "Waiting to confirm the uploaded file’s receipt.",
+            }[code] ?? code;
+    }
+}
+const errors = new Set([
+    "invalid_auth",
+    "not_authed",
+    "token_revoked",
+    "token_expired",
+    "account_inactive",
+    "missing_scope",
+    "no_permission",
+    "channel_not_found",
+    "message_not_found",
+    "ratelimited",
+    "file_not_found",
+    "already_complete",
+    "not_in_channel",
+]);
+export function slackApi(token, fetcher = fetch) {
+    return async (method, args = {}) => {
+        if (!/^[a-zA-Z]+(?:\.[a-zA-Z]+){1,2}$/.test(method))
+            throw new SlackError("Invalid Slack method");
+        let response;
+        try {
+            response = await fetcher(`https://slack.com/api/${method}`, {
+                method: "POST",
+                redirect: "error",
+                headers: {
+                    Authorization: `Bearer ${token}`,
+                    "Content-Type": "application/json; charset=utf-8",
+                },
+                body: JSON.stringify(args),
+                signal: AbortSignal.timeout(15_000),
+            });
+        }
+        catch {
+            throw new SlackError("Slack did not confirm delivery", 15_000, true);
+        }
+        if (response.status === 429) {
+            const seconds = Number(response.headers.get("retry-after"));
+            throw new SlackError("ratelimited", Number.isFinite(seconds) && seconds > 0
+                ? Math.ceil(seconds) * 1000
+                : 60_000);
+        }
+        if (!response.ok)
+            throw new SlackError("Slack is unavailable", 15_000, true);
+        let body;
+        try {
+            body = (await response.json());
+        }
+        catch {
+            throw new SlackError("Slack returned an incomplete receipt", 15_000, true);
+        }
+        if (body.ok !== true)
+            throw new SlackError(errors.has(String(body.error))
+                ? String(body.error)
+                : "Slack could not complete the request", 5_000, body.error === "internal_error" || body.error === "fatal_error");
+        return body;
+    };
+}
+export const slackCredentialFile = (dir) => join(dir, "slack-connection.json");
+export function loadSlackCredentials(dir) {
+    try {
+        const value = JSON.parse(readFileSync(slackCredentialFile(dir), "utf8"));
+        return /^xapp-\S+$/.test(value.appToken) &&
+            /^xoxb-\S+$/.test(value.botToken) &&
+            [value.team, value.app, value.bot, value.installation].every((v) => typeof v === "string" && v.length > 0)
+            ? value
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function saveSlackCredentials(dir, value) {
+    const target = slackCredentialFile(dir), temp = `${target}.${randomBytes(8).toString("hex")}.tmp`;
+    try {
+        writeFileSync(temp, JSON.stringify(value) + "\n", {
+            mode: 0o600,
+            flag: "wx",
+        });
+        chmodSync(temp, 0o600);
+        renameSync(temp, target);
+    }
+    finally {
+        rmSync(temp, { force: true });
+    }
+}
+export function clearSlackCredentials(dir) {
+    rmSync(slackCredentialFile(dir), { force: true });
+}
+export async function checkSlackCredentials(appToken, botToken, fetcher = fetch) {
+    if (!/^xapp-\S{10,}$/.test(appToken) || !/^xoxb-\S{10,}$/.test(botToken))
+        throw new SlackError("Enter the app token and bot token from your Slack app");
+    const api = slackApi(botToken, fetcher), auth = await api("auth.test");
+    const bot = await api("bots.info", { bot: auth.bot_id });
+    const detail = object(bot.bot);
+    if (!slackId(auth.team_id, "T") ||
+        !slackId(auth.user_id, "UW") ||
+        !slackId(detail.app_id, "A"))
+        throw new SlackError("Slack did not return a workspace and bot identity");
+    await slackApi(appToken, fetcher)("apps.connections.open");
+    return {
+        appToken,
+        botToken,
+        team: String(auth.team_id),
+        app: String(detail.app_id),
+        bot: String(auth.user_id),
+        workspace: typeof auth.team === "string" ? auth.team : "Slack",
+        installation: slackHash(`${auth.team_id}:${detail.app_id}:${auth.user_id}`),
+    };
+}
+export function object(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
+export function slackId(value, prefix) {
+    return (typeof value === "string" &&
+        new RegExp(`^[${prefix}][A-Z0-9]{2,80}$`).test(value));
+}
+export function slackTs(value) {
+    return typeof value === "string" && /^\d{10,16}\.\d{6}$/.test(value);
+}
+export async function slackMember(api, identity, member, channel) {
+    const user = object((await api("users.info", { user: member })).user);
+    if (user.id !== member ||
+        user.team_id !== identity.team ||
+        user.deleted === true ||
+        user.is_bot === true ||
+        user.is_app_user === true)
+        return false;
+    const conversation = object((await api("conversations.info", { channel })).channel);
+    return (conversation.id === channel &&
+        conversation.is_im === true &&
+        conversation.user === member &&
+        conversation.is_ext_shared !== true);
+}
+export async function uploadSlackBytes(url, bytes, fetcher = fetch) {
+    const target = new URL(url);
+    if (target.protocol !== "https:" ||
+        target.hostname !== "files.slack.com" ||
+        target.username ||
+        target.password ||
+        target.port)
+        throw new SlackError("Slack returned an invalid upload address");
+    try {
+        const response = await fetcher(url, {
+            method: "POST",
+            redirect: "error",
+            headers: { "Content-Type": "application/octet-stream" },
+            body: Buffer.from(bytes),
+            signal: AbortSignal.timeout(30_000),
+        });
+        if (!response.ok)
+            throw new Error();
+    }
+    catch {
+        throw new SlackError("Slack did not confirm the file upload", 15_000, true);
+    }
+}
+/** DM scopes plus channel history for rooms that follow a team conversation. */
+export const SLACK_MANIFEST = {
+    display_information: {
+        name: "Toolroll",
+        description: "Manage your projects and review results in a private chat",
+        background_color: "#142b2b",
+    },
+    features: {
+        bot_user: { display_name: "Toolroll", always_online: false },
+        app_home: {
+            home_tab_enabled: false,
+            messages_tab_enabled: true,
+            messages_tab_read_only_enabled: false,
+        },
+    },
+    oauth_config: {
+        scopes: {
+            bot: [
+                "chat:write",
+                "im:history",
+                "im:read",
+                "channels:history",
+                "channels:read",
+                "groups:history",
+                "groups:read",
+                "users:read",
+                "files:read",
+                "files:write",
+            ],
+        },
+    },
+    settings: {
+        event_subscriptions: {
+            bot_events: [
+                "message.im",
+                "message.channels",
+                "message.groups",
+                "app_uninstalled",
+                "tokens_revoked",
+                "user_change",
+            ],
+        },
+        interactivity: { is_enabled: true },
+        socket_mode_enabled: true,
+        token_rotation_enabled: false,
+    },
+};

package/dist/slack-chat.d.ts

@@ -0,0 +1,28 @@
+import { type DoorOptions } from "./mate-doors.js";
+import { SlackState, type SlackIdentity, type SlackBinding, type SlackEvent } from "./slack-state.js";
+import { uploadSlackBytes, type SlackApi } from "./slack-api.js";
+import { type Store } from "./store.js";
+import type { SubscriptionMateRunner } from "./subscription-chat.js";
+export type SlackChatOptions = {
+    store: Store;
+    identity: SlackIdentity;
+    api: SlackApi;
+    owner: string;
+    readProjects: () => Promise<readonly string[]>;
+    evidenceRoot: string;
+    current: () => boolean;
+    origin: () => string | null;
+    subscriptionRunner?: SubscriptionMateRunner;
+    held?: DoorOptions["held"];
+    canNotify?: () => boolean;
+    clock?: () => Date;
+    upload?: typeof uploadSlackBytes;
+};
+/** Synchronous receipt before ACK. Never stores response_url, raw tokens, or a pairing code. */
+export declare function receiveSlack(state: SlackState, identity: SlackIdentity, type: string, raw: unknown, now: Date): boolean;
+export declare const processSlackEvent: (options: SlackChatOptions) => Promise<boolean>;
+export declare const applySlackAction: (options: SlackChatOptions, event: SlackEvent, binding: SlackBinding, repos: readonly string[]) => void;
+export declare const planSlackNotifications: (options: SlackChatOptions) => Promise<void>;
+export declare const planSlackRooms: (options: SlackChatOptions) => Promise<void>;
+export declare function slackBlocks(text: string, buttons?: Record<string, unknown>[]): Record<string, unknown>[];
+export declare function deliverSlackPart(options: SlackChatOptions): Promise<boolean>;

package/dist/slack-chat.js

@@ -0,0 +1,413 @@
+import { chatFlowButtons } from "./chat-flow.js";
+import { chatQuestionButtons } from "./teammate-question.js";
+import { channelInbox } from "./chat-inbox.js";
+import { roomCommand } from "./chat-rooms.js";
+import { processChatEvent, applyChatAction, planChatNotifications, channelAccess, planRoomMessages, } from "./chat-delivery.js";
+/** Slack is a transport for the same saved assistant and confirmation doors. */
+import { proposalPreview, proposalLink, proposalOutcomeText, armedCardText, armedYesLabel, } from "./chat-channel.js";
+import { MATE_MESSAGE_MAX_CHARS } from "./mate.js";
+import {} from "./mate-doors.js";
+import { SlackState, slackHash, } from "./slack-state.js";
+import { object, slackId, slackTs, slackMember, SlackError, uploadSlackBytes, } from "./slack-api.js";
+import { resultImageFileName, safeResultImageCaption, verifyResultImage, } from "./chat-evidence.js";
+import {} from "./store.js";
+const nowOf = (options) => options.clock?.() ?? new Date();
+const split = (text, size = 2800) => {
+    const parts = [];
+    for (let at = 0; at < text.length;) {
+        let end = Math.min(at + size, text.length);
+        if (end < text.length && /[\uD800-\uDBFF]/.test(text[end - 1]))
+            end--;
+        parts.push(text.slice(at, end));
+        at = end;
+    }
+    return parts.length ? parts : ["No reply was recorded."];
+};
+/** Synchronous receipt before ACK. Never stores response_url, raw tokens, or a pairing code. */
+export function receiveSlack(state, identity, type, raw, now) {
+    const body = object(raw);
+    if (body.api_app_id !== identity.app)
+        return false;
+    const team = type === "events_api" ? body.team_id : object(body.team).id;
+    if (team !== identity.team || body.is_ext_shared_channel === true)
+        return false;
+    const event = type === "events_api" ? object(body.event) : body;
+    if (type === "events_api" &&
+        (event.type === "app_uninstalled" || event.type === "tokens_revoked")) {
+        state.revoke(identity.installation, now);
+        return true;
+    }
+    if (type === "events_api" && event.type === "user_change") {
+        const user = object(event.user), binding = typeof user.id === "string" ? state.bindingFor(identity.installation, user.id) : null;
+        if (binding !== null && user.deleted === true)
+            state.revokeBinding(binding, now);
+        return true;
+    }
+    let member, channel, ts, thread, id, payload, kind;
+    if (type === "events_api" && event.type === "message") {
+        if (event.subtype !== undefined ||
+            event.bot_id !== undefined ||
+            !["im", "channel", "group"].includes(String(event.channel_type)) ||
+            typeof event.text !== "string")
+            return false;
+        if (typeof body.event_id !== "string" || body.event_id.length > 120)
+            return false;
+        member = event.user;
+        channel = event.channel;
+        ts = event.ts;
+        thread = event.thread_ts ?? event.ts;
+        const match = /^pair ([a-f0-9]{32})$/.exec(event.text.trim());
+        kind = match ? "pair" : "message";
+        payload = match
+            ? { hash: slackHash(match[1]) }
+            : {
+                text: event.text.slice(0, MATE_MESSAGE_MAX_CHARS + 1),
+                originalLength: event.text.length,
+            };
+        id = slackHash(`${identity.installation}:event:${body.event_id}`);
+    }
+    else if (type === "interactive" && body.type === "block_actions") {
+        const actions = Array.isArray(body.actions) ? body.actions : [];
+        if (actions.length !== 1)
+            return false;
+        const action = object(actions[0]), container = object(body.container);
+        if (
+        // toolroll_* since the rename; standing_orders_* buttons on older messages still work.
+        !/^(?:toolroll|standing_orders)_(confirm|dismiss|yes|cancel|flow_approve|flow_edit|flow_send_back|question_choice|question_words)$/.test(String(action.action_id)) ||
+            typeof action.value !== "string" ||
+            !/^[a-f0-9]{32}$/.test(action.value) ||
+            !slackTs(action.action_ts) ||
+            container.type !== "message")
+            return false;
+        member = object(body.user).id;
+        channel = container.channel_id;
+        ts = container.message_ts;
+        thread = object(body.message).thread_ts ?? ts;
+        kind = "action";
+        payload = { token: action.value };
+        id = slackHash(`${identity.installation}:action:${member}:${ts}:${action.value}:${action.action_ts}`);
+    }
+    else
+        return false;
+    if (!slackId(member, "UW") ||
+        !slackId(channel, "DCG") ||
+        !slackTs(ts) ||
+        !slackTs(thread) ||
+        member === identity.bot)
+        return false;
+    // A channel or private group is a room: accepted only while it follows a
+    // conversation, or for the `/team` words that make it follow one.
+    const isRoom = !slackId(channel, "D");
+    // v89: a channel that feeds a flow takes anyone's message (as a card, with no say over anything); "flow 12" connects one.
+    const inbox = isRoom && kind === "message" ? channelInbox(state.store, "slack", identity.installation, String(channel), String(payload.text ?? "")) : { watched: false, command: false };
+    const roomish = isRoom && (state.room(identity.installation, String(channel)) !== null || (kind === "message" && roomCommand(String(payload.text ?? "")) !== null) || inbox.watched || inbox.command);
+    if (isRoom && !roomish)
+        return false;
+    const binding = state.bindingFor(identity.installation, member);
+    const open = inbox.watched && !inbox.command;
+    if (kind !== "pair" && !open &&
+        (!binding ||
+            !state.live(binding) ||
+            (binding.channel !== channel && !roomish)))
+        return false;
+    if (kind === "pair" && (binding || isRoom))
+        return false;
+    return state.enqueue({
+        id,
+        installation: identity.installation,
+        binding: kind === "pair" || binding === null ? null : binding.id,
+        kind,
+        channel,
+        member,
+        ts,
+        thread,
+        payload: JSON.stringify(payload),
+        created: now.toISOString(),
+    });
+}
+const delivery = (options) => ({
+    ...options,
+    state: new SlackState(options.store),
+    label: "Slack",
+    member: (member, channel) => slackMember(options.api, options.identity, member, channel),
+});
+export const processSlackEvent = (options) => processChatEvent(delivery(options));
+export const applySlackAction = (options, event, binding, repos) => applyChatAction(delivery(options), event, binding, repos);
+export const planSlackNotifications = (options) => planChatNotifications(delivery(options));
+export const planSlackRooms = (options) => planRoomMessages(delivery(options));
+const access = (options, binding, ceiling) => channelAccess(delivery(options), binding, ceiling);
+export function slackBlocks(text, buttons = []) {
+    const lines = text.split("\n"), title = lines[0] ?? "Toolroll";
+    const blocks = [];
+    if (title.length <= 150 && lines.length > 1) {
+        blocks.push({
+            type: "header",
+            text: { type: "plain_text", text: title, emoji: true },
+        });
+        text = lines.slice(1).join("\n").trim();
+    }
+    for (const part of split(text))
+        blocks.push({
+            type: "section",
+            text: { type: "plain_text", text: part, emoji: true },
+        });
+    if (buttons.length)
+        blocks.push({ type: "actions", elements: buttons });
+    return blocks;
+}
+function linkButton(origin, link) {
+    if (!origin ||
+        !link ||
+        !link.path.startsWith("/") ||
+        link.path.startsWith("//"))
+        return [];
+    try {
+        const url = new URL(origin);
+        if (url.protocol !== "https:" ||
+            url.username ||
+            url.password ||
+            url.search ||
+            url.hash)
+            return [];
+        return [
+            {
+                type: "button",
+                text: { type: "plain_text", text: link.label },
+                url: `${url.origin}${link.path}`,
+                action_id: "toolroll_link",
+            },
+        ];
+    }
+    catch {
+        return [];
+    }
+}
+export async function deliverSlackPart(options) {
+    const state = new SlackState(options.store), { store, identity } = options, now = nowOf(options);
+    if (!state.owns(identity.installation, options.owner, now) ||
+        !options.current())
+        return false;
+    const row = state.db
+        .prepare("SELECT p.* FROM slack_part p JOIN slack_event e ON e.id=p.event WHERE e.installation=? AND p.state='pending' AND (e.kind!='notice' OR ?=1) AND (p.next_at IS NULL OR p.next_at<=?) ORDER BY p.id LIMIT 1")
+        .get(identity.installation, options.canNotify?.() === false ? 0 : 1, now.toISOString());
+    if (!row)
+        return false;
+    const event = state.event(row.event), binding = event.binding === null ? null : state.bindingById(event.binding);
+    if (!binding) {
+        state.db
+            .prepare("UPDATE slack_part SET state='dropped',problem='Chat access changed' WHERE id=?")
+            .run(row.id);
+        return true;
+    }
+    if (new Date(row.created).getTime() + 86_400_000 < now.getTime()) {
+        state.db
+            .prepare("UPDATE slack_part SET state='dropped',problem='Delivery expired; open the saved chat to recover it' WHERE id=?")
+            .run(row.id);
+        return true;
+    }
+    try {
+        const session = event.session === null ? null : store.getMateSession(event.session);
+        const repos = await access(options, binding, session?.ceilingDigest);
+        if (event.kind === "notice" && options.canNotify?.() === false)
+            return false;
+        const content = JSON.parse(row.payload);
+        const destination = content.channel ?? binding.channel;
+        let text = content.text, buttons = [];
+        if (content.task &&
+            !repos.includes(store.lookupRef(content.task)?.repo ?? ""))
+            throw new SlackError("Connected projects changed");
+        if (content.image) {
+            const verified = verifyResultImage(store, options.evidenceRoot, repos, content.image);
+            if (!verified.ok) {
+                text = `Screenshot not sent\n${verified.problem}. Open the saved result to review it.`;
+            }
+            else {
+                let file = row.file;
+                if (!row.uploaded) {
+                    const allocated = await options.api("files.getUploadURLExternal", {
+                        filename: resultImageFileName(content.image.taskId, content.image.run, content.image.artifact, verified.format),
+                        length: verified.bytes.length,
+                    });
+                    if (!slackId(allocated.file_id, "F") ||
+                        typeof allocated.upload_url !== "string")
+                        throw new SlackError("Slack did not identify the upload");
+                    file = allocated.file_id;
+                    state.db
+                        .prepare("UPDATE slack_part SET file=? WHERE id=?")
+                        .run(file, row.id);
+                    await access(options, binding, session?.ceilingDigest);
+                    const fresh = verifyResultImage(store, options.evidenceRoot, repos, content.image);
+                    if (!fresh.ok)
+                        throw new SlackError("Screenshot evidence changed before upload");
+                    await (options.upload ?? uploadSlackBytes)(allocated.upload_url, fresh.bytes);
+                    state.db
+                        .prepare("UPDATE slack_part SET uploaded=1 WHERE id=?")
+                        .run(row.id);
+                }
+                await access(options, binding, session?.ceilingDigest);
+                if (!verifyResultImage(store, options.evidenceRoot, repos, content.image)
+                    .ok)
+                    throw new SlackError("Screenshot evidence changed before sharing");
+                // A lost completion response is reconciled against Slack's file receipt.
+                if (row.uncertain && file) {
+                    const remote = object((await options.api("files.info", { file })).file), shares = object(object(remote.shares).private);
+                    const receipts = Array.isArray(shares[destination])
+                        ? shares[destination]
+                        : [];
+                    const found = receipts
+                        .map(object)
+                        .find((receipt) => receipt.thread_ts === event.thread && slackTs(receipt.ts));
+                    if (found) {
+                        state.db
+                            .prepare("UPDATE slack_part SET state='sent',message=?,problem=NULL WHERE id=?")
+                            .run(String(found.ts), row.id);
+                        return true;
+                    }
+                }
+                const completed = await options.api("files.completeUploadExternal", {
+                    files: [
+                        {
+                            id: file,
+                            title: safeResultImageCaption(content.text, content.image.taskId, content.image.run),
+                        },
+                    ],
+                    channel_id: destination,
+                    thread_ts: event.thread,
+                    initial_comment: safeResultImageCaption(content.text, content.image.taskId, content.image.run),
+                });
+                if (!Array.isArray(completed.files) ||
+                    !completed.files.some((value) => object(value).id === file))
+                    throw new SlackError("Slack did not confirm the file identity", 15_000, true);
+                state.db
+                    .prepare("UPDATE slack_part SET state='sent',problem=NULL WHERE id=?")
+                    .run(row.id);
+                return true;
+            }
+        }
+        if (content.proposal) {
+            const proposal = store.getMateProposal(content.proposal);
+            if (!proposal)
+                text = "This proposal is unavailable.";
+            else if (proposal.state !== "pending")
+                text = proposalOutcomeText(proposal);
+            else {
+                const preview = proposalPreview(store, proposal, repos, "slack");
+                text =
+                    content.phase === "armed"
+                        ? armedCardText(proposal, preview.text)
+                        : preview.text.replace("\n\nConfirm or Dismiss below. Nothing changes until you confirm.", "");
+                if (preview.buttons && preview.text.length <= 10_000) {
+                    const tokens = state.db
+                        .prepare("SELECT token,phase FROM slack_action WHERE part=? AND consumed IS NULL AND expires>? ORDER BY rowid")
+                        .all(row.id, now.toISOString());
+                    buttons = tokens.map((action) => ({
+                        type: "button",
+                        text: {
+                            type: "plain_text",
+                            text: action.phase === "yes"
+                                ? armedYesLabel(proposal)
+                                : action.phase === "cancel"
+                                    ? "Cancel"
+                                    : action.phase === "dismiss"
+                                        ? "Dismiss"
+                                        : "Confirm",
+                        },
+                        action_id: `toolroll_${action.phase}`,
+                        value: String(action.token),
+                        ...(action.phase === "confirm"
+                            ? { style: "primary" }
+                            : action.phase === "yes"
+                                ? { style: "danger" }
+                                : {}),
+                    }));
+                    if (!buttons.length)
+                        text = "This confirmation expired. Ask for a fresh proposal.";
+                }
+                else {
+                    const link = proposalLink(store, proposal, repos) ?? {
+                        label: "Review action",
+                        path: `/chat`,
+                    };
+                    buttons = linkButton(options.origin(), link);
+                    if (!buttons.length)
+                        text +=
+                            "\n\nOpen Toolroll on your computer to review this action.";
+                    if (text.length > 10_000)
+                        text =
+                            "Review the full action in Toolroll before confirming.";
+                }
+            }
+        }
+        else
+            buttons = [
+                // A flow decision (v88): Approve / Edit / Send back, then the link.
+                ...(content.flow
+                    ? chatFlowButtons(state, row.id, now).map((one) => ({
+                        type: "button",
+                        text: { type: "plain_text", text: one.label },
+                        action_id: `toolroll_flow_${one.action.replace("-", "_")}`,
+                        value: one.token,
+                        ...(one.action === "approve" ? { style: "primary" } : {}),
+                    }))
+                    : []),
+                // A teammate's question (v93): its options, then "Answer in words".
+                ...(content.question
+                    ? chatQuestionButtons(state, row.id, now).map((one) => ({
+                        type: "button",
+                        text: { type: "plain_text", text: one.label },
+                        action_id: one.words ? "toolroll_question_words" : "toolroll_question_choice",
+                        value: one.token,
+                    }))
+                    : []),
+                ...linkButton(options.origin(), content.link),
+            ];
+        const target = content.edit ?? row.message;
+        const args = {
+            channel: destination,
+            text: text
+                .replaceAll("&", "&amp;")
+                .replaceAll("<", "&lt;")
+                .replaceAll(">", "&gt;"),
+            blocks: slackBlocks(text, buttons),
+            mrkdwn: false,
+            parse: "none",
+            unfurl_links: false,
+            unfurl_media: false,
+        };
+        const answer = target
+            ? await options.api("chat.update", { ...args, ts: target })
+            : await options.api("chat.postMessage", {
+                ...args,
+                thread_ts: event.kind === "notice" && event.thread === ""
+                    ? undefined
+                    : event.thread,
+            });
+        if (!slackTs(answer.ts) || (target && answer.ts !== target))
+            throw new SlackError("Slack did not confirm the message identity", 15_000, true);
+        state.db
+            .prepare("UPDATE slack_part SET state='sent',message=?,attempts=attempts+1,problem=NULL,next_at=NULL WHERE id=?")
+            .run(answer.ts, row.id);
+        state.db
+            .prepare("UPDATE slack_runtime SET problem=NULL WHERE installation=? AND owner=?")
+            .run(identity.installation, options.owner);
+        return true;
+    }
+    catch (error) {
+        const problem = error instanceof SlackError
+            ? error
+            : new SlackError("Slack delivery is waiting to retry", 15_000, true);
+        state.db
+            .prepare("UPDATE slack_runtime SET problem=? WHERE installation=? AND owner=?")
+            .run(problem.message, identity.installation, options.owner);
+        const until = new Date(nowOf(options).getTime() +
+            Math.max(problem.retryMs, [5000, 15000, 60000, 300000][Math.min(row.attempts, 3)])).toISOString();
+        state.db
+            .prepare("UPDATE slack_part SET attempts=attempts+1,uncertain=uncertain+?,next_at=?,problem=? WHERE id=?")
+            .run(problem.uncertain ? 1 : 0, until, problem.message, row.id);
+        if (problem.code === "ratelimited")
+            state.db
+                .prepare("UPDATE slack_runtime SET retry_at=? WHERE installation=?")
+                .run(until, identity.installation);
+        return true;
+    }
+}

package/dist/slack-settings.d.ts

@@ -0,0 +1,7 @@
+import type { Store } from "./store.js";
+export declare function slackSettingsHtml(store: Store, dir: string, csrf: string, options?: {
+    code?: string;
+    problem?: string;
+    now?: Date;
+    who?: string;
+}): string;