toolroll 0.5.0

package/dist/discord-api.d.ts

@@ -0,0 +1,20 @@
+import { ChatDeliveryError, type ChatIdentity } from "./chat-delivery-state.js";
+import { chatObject as object } from "./chat-delivery.js";
+export { object };
+export declare const discordId: (v: unknown) => v is string;
+export type DiscordCredentials = ChatIdentity & {
+    botToken: string;
+};
+export type DiscordApi = (method: "GET" | "POST" | "PATCH", path: string, body?: Record<string, unknown>, file?: {
+    bytes: Uint8Array;
+    name: string;
+}) => Promise<Record<string, unknown>>;
+export declare class DiscordError extends ChatDeliveryError {
+}
+export declare function discordApi(token: string, fetcher?: typeof fetch): DiscordApi;
+export declare const discordCredentialFile: (dir: string) => string;
+export declare function loadDiscordCredentials(dir: string): DiscordCredentials | null;
+export declare function saveDiscordCredentials(dir: string, value: DiscordCredentials): void;
+export declare function clearDiscordCredentials(dir: string): void;
+export declare function checkDiscordCredentials(botToken: string, fetcher?: typeof fetch): Promise<DiscordCredentials>;
+export declare function discordMember(api: DiscordApi, member: string, channel: string): Promise<boolean>;

package/dist/discord-api.js

@@ -0,0 +1,138 @@
+/** Discord REST requests and private installation credentials. */
+import { chmodSync, readFileSync, renameSync, rmSync, writeFileSync, } from "node:fs";
+import { join } from "node:path";
+import { randomBytes } from "node:crypto";
+import { ChatDeliveryError, chatHash, } from "./chat-delivery-state.js";
+import { chatObject as object } from "./chat-delivery.js";
+export { object };
+export const discordId = (v) => typeof v === "string" && /^[1-9][0-9]{16,19}$/.test(v);
+export class DiscordError extends ChatDeliveryError {
+}
+export function discordApi(token, fetcher = fetch) {
+    return async (method, path, body, file) => {
+        // Only relative API routes; never send the bot credential to supplied URLs.
+        if (!/^\/(?:users\/@me|users\/[0-9]+|oauth2\/applications\/@me|channels\/[0-9]+(?:\/messages(?:\/[0-9]+)?(?:\?limit=100)?)?|interactions\/[0-9]+\/[A-Za-z0-9._-]+\/callback)$/.test(path))
+            throw new DiscordError("Invalid Discord request");
+        let response;
+        const headers = { Authorization: `Bot ${token}` };
+        let payload;
+        if (file) {
+            const form = new FormData();
+            form.set("payload_json", JSON.stringify(body ?? {}));
+            form.set("files[0]", new Blob([Buffer.from(file.bytes)]), file.name);
+            payload = form;
+        }
+        else if (body) {
+            headers["Content-Type"] = "application/json";
+            payload = JSON.stringify(body);
+        }
+        try {
+            response = await fetcher(`https://discord.com/api/v10${path}`, {
+                method,
+                headers,
+                ...(payload ? { body: payload } : {}),
+                redirect: "error",
+                signal: AbortSignal.timeout(15_000),
+            });
+        }
+        catch {
+            throw new DiscordError("Discord did not confirm delivery", 15_000, true);
+        }
+        let raw;
+        try {
+            raw = response.status === 204 ? {} : await response.json();
+        }
+        catch {
+            throw new DiscordError("Discord returned an incomplete receipt", 15_000, true);
+        }
+        const data = object(raw);
+        if (response.status === 429) {
+            const seconds = Number(data.retry_after ?? response.headers.get("retry-after"));
+            throw new DiscordError("ratelimited", Number.isFinite(seconds) && seconds > 0
+                ? Math.ceil(seconds * 1000)
+                : 60_000);
+        }
+        if (!response.ok) {
+            const message = response.status === 401
+                ? "Discord access expired. Disconnect and reconnect with the current bot token."
+                : response.status === 403
+                    ? "Discord refused access. Check the app and direct-message permissions."
+                    : response.status === 404
+                        ? "The Discord message or conversation is unavailable. Open the saved chat."
+                        : response.status === 413
+                            ? "Discord refused this file size. Open the saved result to view the evidence."
+                            : "Discord could not complete the request";
+            throw new DiscordError(message, response.status >= 500 ? 15_000 : 60_000, response.status >= 500);
+        }
+        return Array.isArray(raw) ? { items: raw } : data;
+    };
+}
+export const discordCredentialFile = (dir) => join(dir, "discord-connection.json");
+export function loadDiscordCredentials(dir) {
+    try {
+        const v = JSON.parse(readFileSync(discordCredentialFile(dir), "utf8"));
+        return validToken(v.botToken) &&
+            discordId(v.app) &&
+            discordId(v.bot) &&
+            typeof v.workspace === "string" &&
+            v.installation === chatHash(`discord:${v.app}:${v.bot}`)
+            ? v
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+const validToken = (token) => typeof token === "string" && /^[A-Za-z0-9._-]{30,300}$/.test(token);
+export function saveDiscordCredentials(dir, value) {
+    const target = discordCredentialFile(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 clearDiscordCredentials(dir) {
+    rmSync(discordCredentialFile(dir), { force: true });
+}
+export async function checkDiscordCredentials(botToken, fetcher = fetch) {
+    if (!validToken(botToken))
+        throw new DiscordError("Enter the bot token from your Discord application");
+    const api = discordApi(botToken, fetcher), user = await api("GET", "/users/@me"), app = await api("GET", "/oauth2/applications/@me");
+    if (!discordId(user.id) ||
+        user.bot !== true ||
+        !discordId(app.id) ||
+        (app.bot !== undefined && object(app.bot).id !== user.id))
+        throw new DiscordError("Discord did not confirm the app and bot identity");
+    if (typeof app.interactions_endpoint_url === "string" &&
+        app.interactions_endpoint_url)
+        throw new DiscordError("Clear the app’s Interactions Endpoint URL in Discord so buttons can reach this installation.");
+    return {
+        botToken,
+        app: app.id,
+        bot: user.id,
+        workspace: typeof app.name === "string" ? app.name : "Toolroll",
+        installation: chatHash(`discord:${app.id}:${user.id}`),
+    };
+}
+export async function discordMember(api, member, channel) {
+    if (!discordId(member) || !discordId(channel))
+        return false;
+    const user = await api("GET", `/users/${member}`), dm = await api("GET", `/channels/${channel}`);
+    const recipients = Array.isArray(dm.recipients)
+        ? dm.recipients.map(object)
+        : [];
+    return (user.id === member &&
+        user.bot !== true &&
+        user.system !== true &&
+        dm.id === channel &&
+        dm.type === 1 &&
+        recipients.length === 1 &&
+        recipients[0]?.id === member);
+}

package/dist/discord-chat.d.ts

@@ -0,0 +1,16 @@
+import { ChatState, type ChatIdentity } from "./chat-delivery-state.js";
+import { type ChatDeliveryOptions } from "./chat-delivery.js";
+import { type DiscordApi } from "./discord-api.js";
+export type DiscordChatOptions = Omit<ChatDeliveryOptions, "state" | "label" | "member" | "partSize" | "maxProposal"> & {
+    api: DiscordApi;
+};
+export declare const discordDelivery: (options: DiscordChatOptions) => ChatDeliveryOptions;
+export declare const processDiscordEvent: (options: DiscordChatOptions) => Promise<boolean>;
+export declare const planDiscordRooms: (options: DiscordChatOptions) => Promise<void>;
+export declare const planDiscordNotifications: (options: DiscordChatOptions) => Promise<void>;
+/** Save only normalized input. Interaction credentials and pairing codes never enter SQLite. */
+export declare function receiveDiscord(state: ChatState, identity: ChatIdentity, type: string, raw: unknown, now: Date): boolean;
+/** Escape Discord's presentation syntax; allowed_mentions also prevents actual pings. */
+export declare const discordPlain: (text: string) => string;
+export declare function discordCard(text: string, buttons?: Record<string, unknown>[]): Record<string, unknown>;
+export declare function deliverDiscordPart(options: DiscordChatOptions): Promise<boolean>;

package/dist/discord-chat.js

@@ -0,0 +1,381 @@
+/** Discord messages and buttons transport the shared assistant's saved actions. */
+import { chatQuestionButtons } from "./teammate-question.js";
+import { chatFlowButtons } from "./chat-flow.js";
+import { channelInbox } from "./chat-inbox.js";
+import { roomCommand } from "./chat-rooms.js";
+import { ChatState, ChatDeliveryError, chatHash, } from "./chat-delivery-state.js";
+import { processChatEvent, planChatNotifications, channelAccess, chatObject as object, planRoomMessages, } from "./chat-delivery.js";
+import { chatResultHref } from "./chat-controls.js";
+import { MATE_MESSAGE_MAX_CHARS } from "./mate.js";
+import { proposalPreview, proposalLink, proposalOutcomeText, armedCardText, armedYesLabel, } from "./chat-channel.js";
+import { resultImageFileName, safeResultImageCaption, verifyResultImage, } from "./chat-evidence.js";
+import { discordId, discordMember, DiscordError, } from "./discord-api.js";
+export const discordDelivery = (options) => ({
+    ...options,
+    state: new ChatState(options.store, "discord"),
+    label: "Discord",
+    member: (member, channel) => discordMember(options.api, member, channel),
+    partSize: 1800,
+    maxProposal: 3400,
+});
+export const processDiscordEvent = (options) => processChatEvent(discordDelivery(options));
+export const planDiscordRooms = (options) => planRoomMessages(discordDelivery(options));
+export const planDiscordNotifications = (options) => planChatNotifications(discordDelivery(options));
+/** Save only normalized input. Interaction credentials and pairing codes never enter SQLite. */
+export function receiveDiscord(state, identity, type, raw, now) {
+    const body = object(raw);
+    if (body.webhook_id !== undefined)
+        return false;
+    // A guild channel is a room: accepted only while it follows a conversation,
+    // or for the `/team` words that make it follow one.
+    const isRoom = body.guild_id !== undefined;
+    let member, channel, id, ts, thread, kind, payload;
+    if (type === "MESSAGE_CREATE") {
+        const author = object(body.author), ref = object(body.message_reference);
+        if (author.bot === true ||
+            author.system === true ||
+            ![0, 19].includes(Number(body.type)) ||
+            typeof body.content !== "string" ||
+            (!isRoom && ref.guild_id !== undefined))
+            return false;
+        member = author.id;
+        channel = body.channel_id;
+        id = body.id;
+        ts = body.id;
+        thread = ref.message_id ?? body.id;
+        if (ref.channel_id !== undefined && ref.channel_id !== channel)
+            return false;
+        const pair = /^pair ([a-f0-9]{32})$/.exec(body.content.trim());
+        kind = pair ? "pair" : "message";
+        payload = pair
+            ? { hash: chatHash(pair[1]) }
+            : {
+                text: body.content.slice(0, MATE_MESSAGE_MAX_CHARS + 1),
+                originalLength: body.content.length,
+                ...(Array.isArray(body.attachments) && body.attachments.length
+                    ? {
+                        unsupported: "Incoming files are not supported yet. Describe the request in a message; saved result screenshots can still be sent here.",
+                    }
+                    : {}),
+            };
+    }
+    else if (type === "INTERACTION_CREATE") {
+        const data = object(body.data), message = object(body.message);
+        if (body.type !== 3 ||
+            body.application_id !== identity.app ||
+            (isRoom ? object(body.channel).type !== 0 : object(body.channel).type !== 1) ||
+            object(message.author).id !== identity.bot ||
+            message.channel_id !== body.channel_id ||
+            !/^so_[a-f0-9]{32}$/.test(String(data.custom_id)))
+            return false;
+        member = isRoom ? object(object(body.member).user).id : object(body.user).id;
+        channel = body.channel_id;
+        id = body.id;
+        ts = message.id;
+        thread = message.id;
+        kind = "action";
+        payload = { token: String(data.custom_id).slice(3) };
+    }
+    else
+        return false;
+    if (!discordId(member) ||
+        !discordId(channel) ||
+        !discordId(id) ||
+        !discordId(ts) ||
+        !discordId(thread) ||
+        member === identity.bot)
+        return false;
+    // 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, "discord", 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"
+        ? !!binding || isRoom
+        : !open && (!binding ||
+            !state.live(binding) ||
+            (binding.channel !== channel && !roomish)))
+        return false;
+    return state.enqueue({
+        id: chatHash(`${identity.installation}:${kind === "action" ? "interaction" : "message"}:${id}`),
+        installation: identity.installation,
+        binding: kind === "pair" || binding === null ? null : binding.id,
+        kind,
+        channel,
+        member,
+        ts,
+        thread,
+        payload: JSON.stringify(payload),
+        created: now.toISOString(),
+    });
+}
+function link(origin, target) {
+    if (!origin ||
+        !target ||
+        !target.path.startsWith("/") ||
+        target.path.startsWith("//"))
+        return [];
+    try {
+        const url = new URL(origin);
+        if (url.protocol !== "https:" ||
+            url.username ||
+            url.password ||
+            url.search ||
+            url.hash)
+            return [];
+        return [
+            {
+                type: 2,
+                style: 5,
+                label: target.label.slice(0, 80),
+                url: url.origin + target.path,
+            },
+        ];
+    }
+    catch {
+        return [];
+    }
+}
+/** Escape Discord's presentation syntax; allowed_mentions also prevents actual pings. */
+export const discordPlain = (text) => text.replace(/([\\`*_~|>#\[\]])/g, "\\$1").replace(/@/g, "@\u200b");
+export function discordCard(text, buttons = []) {
+    const lines = text.split("\n"), first = lines[0] ?? "Toolroll", title = discordPlain(first).length <= 256 &&
+        first.length <= 150 &&
+        lines.length > 1
+        ? first
+        : "Toolroll", detail = title === first ? lines.slice(1).join("\n").trim() : text;
+    // Long answers were split before this point; approval controls only appear when full terms fit.
+    return {
+        content: "",
+        embeds: [
+            {
+                title: discordPlain(title),
+                description: discordPlain(detail || title).slice(0, 4096),
+                color: 0x297b70,
+            },
+        ],
+        // A row holds at most 5 buttons (a question's 4 options and "Answer in words", then the link, need two).
+        components: Array.from({ length: Math.min(5, Math.ceil(buttons.length / 5)) }, (_, row) => ({ type: 1, components: buttons.slice(row * 5, row * 5 + 5) })),
+        allowed_mentions: { parse: [], replied_user: false },
+    };
+}
+export async function deliverDiscordPart(options) {
+    const shared = discordDelivery(options), state = shared.state, { store, identity } = options, now = options.clock?.() ?? new Date();
+    if (!options.current() ||
+        !state.owns(identity.installation, options.owner, now))
+        return false;
+    const row = state
+        .prepare("SELECT p.* FROM chat_part p JOIN chat_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 ||
+        new Date(row.created).getTime() + 86_400_000 < now.getTime()) {
+        state
+            .prepare("UPDATE chat_part SET state='dropped',problem='Delivery expired or access changed; open the saved chat' WHERE id=?")
+            .run(row.id);
+        return true;
+    }
+    try {
+        const session = event.session === null ? null : store.getMateSession(event.session), repos = await channelAccess(shared, binding, session?.ceilingDigest);
+        if (event.kind === "notice" && options.canNotify?.() === false)
+            return false;
+        const content = JSON.parse(row.payload);
+        const destination = content.channel ?? binding.channel;
+        if (content.task &&
+            !repos.includes(store.lookupRef(content.task)?.repo ?? ""))
+            throw new DiscordError("Connected projects changed");
+        let text = content.text, buttons = [], file;
+        if (content.image) {
+            const image = verifyResultImage(store, options.evidenceRoot, repos, content.image);
+            if (!image.ok)
+                text = `Screenshot not sent\n${image.problem}. Open the saved result to review it.`;
+            else if (image.bytes.length > 10 * 1024 * 1024)
+                text =
+                    "Screenshot exceeds Discord’s upload limit. Open the saved result to review it.";
+            else {
+                file = {
+                    bytes: image.bytes,
+                    name: resultImageFileName(content.image.taskId, content.image.run, content.image.artifact, image.format),
+                };
+                text = safeResultImageCaption(content.text, content.image.taskId, content.image.run);
+            }
+            buttons = link(options.origin(), {
+                label: "Open result",
+                path: chatResultHref(content.image.taskId, content.image.run, "checks"),
+            });
+        }
+        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, "discord");
+                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 <= 3400 &&
+                    discordPlain(text).length <= 3900) {
+                    buttons = state
+                        .prepare("SELECT token,phase FROM chat_action WHERE part=? AND consumed IS NULL AND expires>? ORDER BY rowid")
+                        .all(row.id, now.toISOString())
+                        .map((action) => ({
+                        type: 2,
+                        style: action.phase === "yes" ? 4 : action.phase === "confirm" ? 1 : 2,
+                        label: action.phase === "yes"
+                            ? armedYesLabel(proposal)
+                            : action.phase === "cancel"
+                                ? "Cancel"
+                                : action.phase === "dismiss"
+                                    ? "Dismiss"
+                                    : "Confirm",
+                        custom_id: `so_${action.token}`,
+                    }));
+                    if (!buttons.length)
+                        text = "This confirmation expired. Ask for a fresh proposal.";
+                }
+                else {
+                    buttons = link(options.origin(), proposalLink(store, proposal, repos) ?? {
+                        label: "Review action",
+                        path: "/chat",
+                    });
+                    text = "Review the full action in Toolroll before confirming.";
+                    if (!buttons.length)
+                        text += " Open Toolroll on your computer.";
+                }
+            }
+        }
+        else if (!content.image)
+            buttons = [
+                // A flow decision (v88): Approve / Edit / Send back, then the link.
+                ...(content.flow
+                    ? chatFlowButtons(state, row.id, now).map((one) => ({
+                        type: 2,
+                        style: one.action === "approve" ? 3 : 2,
+                        label: one.label,
+                        custom_id: `so_${one.token}`,
+                    }))
+                    : []),
+                // A teammate's question (v93): its options, then "Answer in words".
+                ...(content.question
+                    ? chatQuestionButtons(state, row.id, now).map((one) => ({
+                        type: 2,
+                        style: one.words ? 1 : 2,
+                        label: one.label.slice(0, 80),
+                        custom_id: `so_${one.token}`,
+                    }))
+                    : []),
+                ...link(options.origin(), content.link),
+            ];
+        let target = content.edit ?? row.message;
+        if (target && content.image && row.uploaded) {
+            if (!file)
+                text =
+                    "Screenshot delivered earlier. The saved evidence has since changed; open the result to review its current state.";
+            file = undefined;
+        }
+        const nonce = chatHash(`discord:part:${row.id}:${event.id}`).slice(0, 24);
+        // Recent Discord nonce receipts reconcile uncertain sends, including attachments.
+        if (row.uncertain && !target) {
+            const recent = await options.api("GET", `/channels/${destination}/messages?limit=100`);
+            const found = (Array.isArray(recent.items) ? recent.items : [])
+                .map(object)
+                .find((m) => m.nonce === nonce &&
+                object(m.author).id === identity.bot &&
+                m.channel_id === destination &&
+                discordId(m.id));
+            if (found) {
+                // Record the recovered placement, then repaint current terms/progress.
+                // A notification or proposal may have changed while delivery was uncertain.
+                target = String(found.id);
+                if (content.image) {
+                    const attachments = Array.isArray(found.attachments)
+                        ? found.attachments.map(object)
+                        : [];
+                    if (file &&
+                        !attachments.some((a) => a.filename === file.name &&
+                            Number(a.size) === file.bytes.length))
+                        throw new DiscordError("Discord’s earlier file receipt does not match the saved evidence", 60_000);
+                    if (!file && attachments.length)
+                        text =
+                            "Screenshot delivered earlier. The saved evidence has since changed; open the result to review its current state.";
+                    // Preserve the original remote attachment; never upload it again on an edit.
+                    file = undefined;
+                }
+                state
+                    .prepare("UPDATE chat_part SET message=?,uploaded=? WHERE id=?")
+                    .run(target, content.image &&
+                    Array.isArray(found.attachments) &&
+                    found.attachments.length
+                    ? 1
+                    : 0, row.id);
+            }
+        }
+        await channelAccess(shared, binding, session?.ceilingDigest);
+        if (file && content.image) {
+            const fresh = verifyResultImage(store, options.evidenceRoot, repos, content.image);
+            if (!fresh.ok)
+                throw new DiscordError("Screenshot evidence changed before upload");
+            file.bytes = fresh.bytes;
+        }
+        const args = discordCard(text, buttons);
+        if (file)
+            args.attachments = [
+                { id: 0, filename: file.name, description: text.slice(0, 1024) },
+            ];
+        if (!target) {
+            args.nonce = nonce;
+            args.enforce_nonce = true;
+            if (discordId(event.thread))
+                args.message_reference = {
+                    message_id: event.thread,
+                    channel_id: destination,
+                    fail_if_not_exists: false,
+                };
+        }
+        const answer = await options.api(target ? "PATCH" : "POST", `/channels/${destination}/messages${target ? `/${target}` : ""}`, args, file);
+        if (!discordId(answer.id) ||
+            answer.channel_id !== destination ||
+            (target && answer.id !== target) ||
+            object(answer.author).id !== identity.bot ||
+            (file &&
+                (!Array.isArray(answer.attachments) ||
+                    !answer.attachments.some((v) => object(v).filename === file.name &&
+                        Number(object(v).size) === file.bytes.length))))
+            throw new DiscordError("Discord did not confirm the message and file identity", 15_000, true);
+        state
+            .prepare("UPDATE chat_part SET state='sent',message=?,attempts=attempts+1,problem=NULL,next_at=NULL WHERE id=?")
+            .run(answer.id, row.id);
+        state
+            .prepare("UPDATE chat_runtime SET problem=NULL WHERE installation=? AND owner=?")
+            .run(identity.installation, options.owner);
+        return true;
+    }
+    catch (error) {
+        const problem = error instanceof ChatDeliveryError
+            ? error
+            : new DiscordError("Discord delivery is waiting to retry", 15_000, true);
+        const until = new Date((options.clock?.() ?? new Date()).getTime() +
+            Math.max(problem.retryMs, [5000, 15000, 60000, 300000][Math.min(row.attempts, 3)])).toISOString();
+        state
+            .prepare("UPDATE chat_part SET attempts=attempts+1,uncertain=uncertain+?,next_at=?,problem=? WHERE id=?")
+            .run(problem.uncertain ? 1 : 0, until, problem.message, row.id);
+        state
+            .prepare("UPDATE chat_runtime SET problem=? WHERE installation=? AND owner=?")
+            .run(problem.code === "ratelimited"
+            ? "Discord asked us to wait. Saved replies will retry."
+            : problem.message, identity.installation, options.owner);
+        if (problem.code === "ratelimited")
+            state
+                .prepare("UPDATE chat_runtime SET retry_at=? WHERE installation=?")
+                .run(until, identity.installation);
+        return true;
+    }
+}

package/dist/discord-settings.d.ts

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

package/dist/discord-settings.js

@@ -0,0 +1,75 @@
+import { loadPrimary } from "./webhooks.js";
+import { loadDiscordCredentials } from "./discord-api.js";
+import { ChatState } from "./chat-delivery-state.js";
+const escape = (text) => text
+    .replaceAll("&", "&")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;")
+    .replaceAll("'", "&#39;");
+export function discordSettingsHtml(store, dir, csrf, options = {}) {
+    const credentials = loadDiscordCredentials(dir), state = new ChatState(store, "discord"), bindings = credentials ? state.bindings(credentials.installation).filter(one => state.live(one)) : [], binding = options.who === undefined ? null : bindings.find(one => one.approver === options.who) ?? null, others = bindings.length - (binding === null ? 0 : 1);
+    const runtime = credentials
+        ? state.db
+            .prepare("SELECT connected,problem,lease_until FROM discord_runtime WHERE installation=?")
+            .get(credentials.installation)
+        : null;
+    const now = options.now ?? new Date(), live = runtime &&
+        typeof runtime.lease_until === "string" &&
+        runtime.lease_until > now.toISOString() &&
+        runtime.connected;
+    const hidden = `<input type="hidden" name="csrf" value="${escape(csrf)}">`;
+    const password = '<label>Your Toolroll password<input style="min-height:44px" type="password" name="password" autocomplete="current-password" required></label>';
+    const post = (action, content) => `<form method="post" action="/settings/discord/${action}" class="card">${hidden}${content}</form>`;
+    let content = "";
+    if (!credentials) {
+        content =
+            "<p>Manage projects and review results in a private Discord conversation.</p>" +
+                '<details open><summary>Create your Discord app</summary><ol><li><a href="https://discord.com/developers/applications" target="_blank" rel="noopener noreferrer">Create an application</a>, then copy its token from the Bot page.</li><li>Keep the Interactions Endpoint URL empty and privileged intents off.</li><li>Under Installation, enable Guild Install with the bot scope and no server permissions. Use its install link to add it to your server, then open a direct message to the bot.</li></ol></details>' +
+                post("connect", '<label>Bot token<input style="min-height:44px" type="password" name="bot-token" autocomplete="off" required></label>' +
+                    password +
+                    '<p class="meta">The token stays on this installation. Next, pair your own Discord account.</p><button type="submit">Connect Discord</button>');
+    }
+    else {
+        content = `<p><strong>${escape(credentials.workspace)}</strong> · ${live ? "Connected" : "Waiting for connection"}</p>`;
+        if (runtime?.problem)
+            content += `<p role="status">${escape(String(runtime.problem))}</p>`;
+        if (!live && !runtime?.problem)
+            content +=
+                "<p>Keep the Toolroll worker running to receive Discord messages.</p>";
+        if (options.code) {
+            content +=
+                "<h2>Pair your account</h2><p>Send this in a direct message to your Toolroll Discord app. It expires in 10 minutes.</p>" +
+                    `<label>Pairing message<input type="text" readonly value="pair ${escape(options.code)}" autocomplete="off" style="width:100%;max-width:100%;font-size:14px;min-height:44px"></label>` +
+                    '<a class="button-link" style="min-height:44px;white-space:nowrap" href="/settings/discord">Check connection</a>';
+        }
+        else if (binding && state.live(binding)) {
+            const pending = Number(state.db
+                .prepare("SELECT count(*) n FROM discord_part p JOIN discord_event e ON e.id=p.event WHERE e.binding=? AND p.state='pending'")
+                .get(binding.id)?.n ?? 0);
+            const failed = Number(state.db
+                .prepare("SELECT count(*) n FROM discord_part p JOIN discord_event e ON e.id=p.event WHERE e.binding=? AND p.state='dropped'")
+                .get(binding.id)?.n ?? 0);
+            content +=
+                `<p>Your Discord account is paired.${others ? ` ${others} teammate${others === 1 ? " is" : "s are"} paired too.` : ""}${pending ? ` ${pending} replies waiting to send.` : ""}${failed ? ` ${failed} replies could not be delivered. Open the saved chat to recover them.` : ""}</p>` +
+                    "<p>Try “What needs my attention?” or “Show the evidence for the latest result.”</p>" +
+                    '<p><a href="/chat">Open saved chat</a></p>' +
+                    (loadPrimary(process.env, dir) === "discord"
+                        ? "<p>Task updates are sent here.</p>"
+                        : post("alerts", '<button type="submit">Send task updates here</button>'));
+        }
+        else {
+            content += post("pair", "<h2>Pair your account</h2><p>Your paired Discord account can read your connected projects and confirm proposed changes. Password approvals still open in Toolroll." +
+                (others ? ` ${others} teammate${others === 1 ? " is" : "s are"} already paired.` : "") + "</p>" +
+                password +
+                '<button type="submit">Create pairing code</button>');
+        }
+        if (binding && state.live(binding) && !options.code)
+            content += post("unpair", password + '<p class="meta">Unpairing ends every open button in your chat. Teammates are unaffected.</p><button type="submit">Unpair my account</button>');
+        content +=
+            "<details><summary>Connection settings</summary>" +
+                post("disconnect", password + '<button type="submit">Disconnect Discord</button>') +
+                "</details>";
+    }
+    return `<section style="max-width:42rem;overflow-wrap:anywhere"><p><a href="/settings">Settings</a></p><h1>Discord</h1>${options.problem ? `<p class="problem" role="alert">${escape(options.problem)}</p>` : ""}${content}<details><summary>Access and setup</summary><p>Private messages and replies use your Toolroll permissions. Shared channels are not supported. Secure review links use this installation’s configured HTTPS console address.</p><p>The worker connects out to Discord. It does not need a public webhook or a Tailscale account.</p></details></section>`;
+}

package/dist/discord.d.ts

@@ -0,0 +1,10 @@
+import { type DiscordChatOptions } from "./discord-chat.js";
+export declare function discordReadyMatches(raw: unknown, identity: {
+    app: string;
+    bot: string;
+}): boolean;
+export declare function followDiscord(options: Omit<DiscordChatOptions, "identity" | "api" | "owner" | "current"> & {
+    dir: string;
+    signal: AbortSignal;
+    notifications: () => boolean;
+}): Promise<void>;