allaboard 0.0.0-stage → 0.4.0

package/dist/chat/slack/delete.js

@@ -0,0 +1,278 @@
+/**
+ * Deleting from Slack what the Home tab's edit mode names: a session's whole thread, or what
+ * sits in a channel outside every thread (the commands typed there and the bot's own messages).
+ *
+ * `chat.delete` with a bot token "may delete only messages posted by that bot", and with a user
+ * token the messages that user can delete (docs.slack.dev/reference/methods/chat.delete, read
+ * 2026-10-05). A session's thread is started by the owner, so its root and the owner's replies
+ * need the owner's own user token (`SLACK_USER_TOKEN`, user scope `chat:write`): the bot's
+ * messages are deleted with the bot token, every other one with the owner's. Without that token
+ * there is no deleter, and the page offers no delete.
+ *
+ * The replies go first and the root last: the reference does not say what a root deleted under
+ * its replies leaves behind. `chat.delete` is Tier 3 (50+ per minute); both clients retry a rate
+ * limit after the time Slack asks for, which is what a delete's time is made of (measured
+ * 2026-10-05 on a free workspace: 20 to 40 seconds a thread, with a rate limit met every few
+ * calls), so threads are deleted one at a time. A delete that stops half way leaves the thread
+ * in `state.json`, so asking again continues with the messages that are left. The Claude Code
+ * session is not touched: its transcript stays, and `!resume` lists it again once no thread
+ * holds it.
+ *
+ * Cleaning up a channel reads its history (`conversations.history`, Tier 3, cursor pagination,
+ * read 2026-10-05) and deletes the messages that are no thread and belong to no thread: "Detect
+ * a threaded message by looking for a `thread_ts` value in the message object", and a parent
+ * keeps it "even if all its replies have been deleted" (docs.slack.dev/messaging/retrieving-
+ * messages, read 2026-10-05). In a channel bound to a folder every message the owner sends
+ * outside a thread is a prompt or a word for the daemon, so one with no reply is a leftover
+ * whoever wrote it: the owner's and the bot's both go. What stays: a thread that has a reply, a
+ * message with a `subtype` (Slack's own lines), anyone else's message, and a message
+ * `state.json` holds as a thread whose first reply has not come yet. A message that carries
+ * `thread_ts` is deleted only after `conversations.replies` on it, with `limit=1`, returned its
+ * root with no `reply_count` (a root nobody replied to has none, measured 2026-10-01): the
+ * reference does not say what a parent's count reads in the channel's history once its replies
+ * are gone, and a thread taken for a leftover would lose its root.
+ */
+import { fill, Mutex, named } from "../../core/port.js";
+import { getLogger } from "../../log.js";
+import { isRecord } from "../../values.js";
+import { describe } from "./reply/errors.js";
+import * as slackTexts from "./texts.js";
+export const logger = getLogger("allaboard.chat.slack.delete");
+/** How many messages one `conversations.replies` page is asked for. */
+export const PAGE = 200;
+export const MESSAGE_NOT_FOUND = "message_not_found";
+export const CANT_DELETE = "cant_delete_message";
+export const THREAD_NOT_FOUND = "thread_not_found";
+/** The messages of a `conversations.*` answer, `[]` for an answer with none. */
+function messagesOf(answer) {
+    const messages = isRecord(answer) ? answer.messages : undefined;
+    return Array.isArray(messages) ? messages.filter(isRecord) : [];
+}
+/** The cursor of the next page; null on the last one. */
+function nextCursor(answer) {
+    const metadata = isRecord(answer) ? answer.response_metadata : undefined;
+    const cursor = isRecord(metadata) ? metadata.next_cursor : undefined;
+    return typeof cursor === "string" && cursor !== "" ? cursor : null;
+}
+/** A message's `ts`; a message without one is a failure. */
+function tsOf(message) {
+    if (message.ts === undefined)
+        throw new Error("a message without a ts");
+    return String(message.ts);
+}
+/** Deletes the threads the Home tab's Delete names, and cleans the channels it names. */
+export class ThreadDeleter {
+    #bot;
+    #owner;
+    #botUserId;
+    #ownerUserId;
+    #state;
+    #names;
+    #release;
+    #free;
+    // One thread at a time: two deletes at once would share Slack's rate limit, and each would
+    // use up its retries on the other's calls.
+    #oneAtATime = new Mutex();
+    constructor(bot, owner, options) {
+        this.#bot = bot;
+        this.#owner = owner;
+        this.#botUserId = options.botUserId;
+        this.#ownerUserId = options.ownerUserId;
+        this.#state = options.state;
+        this.#names = options.names;
+        this.#release = options.release;
+        this.#free = options.free;
+    }
+    /**
+     * Delete every message of a thread that holds a session and forget the thread. Returns null
+     * once the thread is gone (or was not one of the daemon's), else the line that says why it is
+     * still there. Never throws.
+     */
+    async delete(channelId, threadTs) {
+        if (this.#state.thread(channelId, threadTs) === null) {
+            return null; // not a thread of the daemon's: nothing a click may delete
+        }
+        return this.#oneAtATime.run(() => this.#delete(channelId, threadTs));
+    }
+    async #delete(channelId, threadTs) {
+        if (this.#state.thread(channelId, threadTs) === null) {
+            return null; // deleted while this call waited its turn
+        }
+        try {
+            // From here until `free`, the thread is held: a message sent in it while its messages go
+            // finds no session, and none is rebuilt from the entry `state.json` still has
+            // (`SessionManager.release`).
+            if (!(await this.#release(channelId, threadTs)))
+                return slackTexts.HOME_DELETE_BUSY;
+            const refused = await this.#empty(channelId, threadTs);
+            if (refused > 0) {
+                // The root stays while a reply does, so the thread can still be opened.
+                return fill(named(slackTexts.HOME_DELETE_REFUSED, this.#names()), { count: refused });
+            }
+            this.#state.removeThread(channelId, threadTs);
+        }
+        catch (error) {
+            logger.warning(`could not delete ${channelId}/${threadTs}: ${describe(error)}`);
+            return fill(slackTexts.HOME_DELETE_FAILED, { error: describe(error) });
+        }
+        finally {
+            this.#free(channelId, threadTs);
+        }
+        logger.info(`deleted thread ${channelId}/${threadTs}`);
+        return null;
+    }
+    /**
+     * Delete the thread's replies, then its root. The thread is read again after each pass, so a
+     * message that arrived meanwhile goes too, and the root goes only once a read shows no reply
+     * left: a delete never leaves replies under a deleted root. Returns how many messages Slack
+     * refused to delete; the root stays when it is not zero.
+     */
+    async #empty(channelId, threadTs) {
+        const handled = new Set();
+        const refused = new Set();
+        let messages;
+        for (;;) {
+            messages = await this.#messages(channelId, threadTs);
+            const replies = [...messages].filter(([ts]) => ts !== threadTs && !handled.has(ts));
+            if (replies.length === 0)
+                break;
+            for (const [ts, author] of replies) {
+                handled.add(ts);
+                if (!(await this.#remove(channelId, ts, author)))
+                    refused.add(ts);
+            }
+        }
+        const root = refused.size > 0 ? undefined : messages.get(threadTs);
+        if (root !== undefined && !(await this.#remove(channelId, threadTs, root))) {
+            refused.add(threadTs);
+        }
+        return refused.size;
+    }
+    /**
+     * Delete one message with its author's token; anyone else's is tried with the owner's, which
+     * deletes what the owner may delete in Slack. False when Slack refuses this very message
+     * (`cant_delete_message`): the caller goes on and counts it. A message already gone is
+     * deleted; any other failure throws.
+     */
+    async #remove(channelId, ts, author) {
+        const client = author === this.#botUserId ? this.#bot : this.#owner;
+        try {
+            await client.chat.delete({ channel: channelId, ts });
+        }
+        catch (error) {
+            if (describe(error) === CANT_DELETE)
+                return false;
+            if (describe(error) !== MESSAGE_NOT_FOUND)
+                throw error;
+        }
+        return true;
+    }
+    /**
+     * Delete what sits in a bound channel outside every thread: the owner's messages and the
+     * bot's that have no reply. Returns null when done (or for a channel that is not bound), else
+     * the line that says why it stopped. Never throws.
+     */
+    async clean(channelId) {
+        if (!this.#state.channels().includes(channelId)) {
+            return null; // not a channel of the daemon's: nothing a click may clean
+        }
+        return this.#oneAtATime.run(async () => {
+            let loose = new Map();
+            let refused = 0;
+            try {
+                loose = await this.#loose(channelId);
+                for (const [ts, author] of loose) {
+                    if (!(await this.#remove(channelId, ts, author)))
+                        refused += 1;
+                }
+            }
+            catch (error) {
+                logger.warning(`could not clean up ${channelId}: ${describe(error)}`);
+                return fill(slackTexts.HOME_CLEAN_FAILED, { error: describe(error) });
+            }
+            logger.info(`cleaned up ${channelId}: ${loose.size} messages, ${refused} refused`);
+            return refused > 0
+                ? fill(named(slackTexts.HOME_CLEAN_REFUSED, this.#names()), { count: refused })
+                : null;
+        });
+    }
+    /** The channel's messages a clean-up deletes, `ts` to author, read page by page. */
+    async #loose(channelId) {
+        const found = new Map();
+        let cursor = null;
+        for (;;) {
+            const page = await this.#bot.conversations.history({
+                channel: channelId,
+                limit: PAGE,
+                ...(cursor === null ? {} : { cursor }),
+            });
+            for (const message of messagesOf(page)) {
+                const ts = tsOf(message);
+                const author = String(message.user || "");
+                const threaded = message.thread_ts;
+                if (message.subtype || (threaded && String(threaded) !== ts)) {
+                    continue; // Slack's own line; or a thread's reply shown in the channel
+                }
+                if (author !== this.#botUserId && author !== this.#ownerUserId)
+                    continue;
+                if (this.#state.thread(channelId, ts) !== null) {
+                    continue; // a thread of the daemon's with no reply yet
+                }
+                if (threaded && (await this.#hasReplies(channelId, ts)))
+                    continue; // a thread
+                found.set(ts, author);
+            }
+            cursor = nextCursor(page);
+            if (cursor === null)
+                return found;
+        }
+    }
+    /**
+     * Whether a message that carries `thread_ts` still has a reply, asked of the thread itself.
+     * True as well for one that is gone meanwhile: there is nothing to delete.
+     */
+    async #hasReplies(channelId, ts) {
+        let answer;
+        try {
+            answer = await this.#bot.conversations.replies({ channel: channelId, ts, limit: 1 });
+        }
+        catch (error) {
+            if (describe(error) === THREAD_NOT_FOUND)
+                return true;
+            throw error;
+        }
+        const messages = messagesOf(answer);
+        const root = messages.find((message) => String(message.ts) === ts);
+        // No root in the answer is no proof of an empty thread: keep the message.
+        return root === undefined || Boolean(root.reply_count) || messages.length > 1;
+    }
+    /**
+     * Every message of the thread, its `ts` to its author's user id, read page by page (cursor
+     * pagination, `response_metadata.next_cursor`). Empty when the root is gone.
+     */
+    async #messages(channelId, threadTs) {
+        const found = new Map();
+        let cursor = null;
+        for (;;) {
+            let page;
+            try {
+                page = await this.#bot.conversations.replies({
+                    channel: channelId,
+                    ts: threadTs,
+                    limit: PAGE,
+                    ...(cursor === null ? {} : { cursor }),
+                });
+            }
+            catch (error) {
+                if (describe(error) === THREAD_NOT_FOUND)
+                    return found;
+                throw error;
+            }
+            for (const message of messagesOf(page))
+                found.set(tsOf(message), String(message.user || ""));
+            cursor = nextCursor(page);
+            if (cursor === null)
+                return found;
+        }
+    }
+}

package/dist/chat/slack/footer.js

@@ -0,0 +1,43 @@
+/** The footer as one line of Slack mrkdwn. */
+import { basename } from "node:path";
+import { footerFields, valueWithDetail, } from "../../core/port.js";
+import { mrkdwnEscape } from "./reply/escape.js";
+// The footer's fields that come before the folder.
+const SESSION = ["model", "effort"];
+/** A field as the footer writes it: the label in bold (`*ctx* 15%`, the owner's choice). */
+function short(field) {
+    const { key, value } = field;
+    switch (key) {
+        case "model":
+        case "changes":
+            return value;
+        case "effort":
+            return `*effort* ${valueWithDetail(field)}`;
+        case "branch":
+            return mrkdwnEscape(value);
+        case "tokens":
+            return `${value} *tok*`;
+        case "context":
+            return `*ctx* ${value}`;
+        case "session_limit":
+            return `*5h* ${value}`;
+        case "week_limit":
+            return `*7d* ${value}`;
+    }
+}
+/**
+ * One line: bypass, model and effort, the channel's folder, then branch, changes, tokens,
+ * context and limits (the owner's order).
+ */
+export function formatFooter(data, now) {
+    const fields = footerFields(data, now);
+    const parts = data.bypass ? ["⚡ bypass"] : [];
+    parts.push(...fields.filter((f) => SESSION.includes(f.key)).map((f) => short(f)));
+    // Its name alone, the project's: the whole path is on `!status`'s Directory line.
+    const name = data.folder === null ? "" : basename(data.folder);
+    if (name) {
+        parts.push(mrkdwnEscape(name));
+    }
+    parts.push(...fields.filter((f) => !SESSION.includes(f.key)).map((f) => short(f)));
+    return parts.join(" · ");
+}

package/dist/chat/slack/hold.js

@@ -0,0 +1,37 @@
+import { texts } from "../../core/port.js";
+import * as slackTexts from "./texts.js";
+/** The same-folder hold's question as Slack blocks. */
+export const HOLD_CONTINUE = "hold_continue";
+export const HOLD_CANCEL = "hold_cancel";
+/**
+ * The question in the thread: a `mrkdwn` section (`link` in mrkdwn's own `<url|label>` form, same
+ * as approvals and the resume picker use for their own buttons) plus Continue and Cancel. Only
+ * Continue is `primary`: one button of a set, and never `danger` for an answer that destroys
+ * nothing (button element reference, docs.slack.dev, read 2026-10-07).
+ */
+export function holdBlocks(holdId, link) {
+    return [
+        {
+            type: "section",
+            text: { type: "mrkdwn", text: texts.fill(texts.HOLD_QUESTION, { link }) },
+        },
+        {
+            type: "actions",
+            elements: [
+                {
+                    type: "button",
+                    action_id: HOLD_CONTINUE,
+                    value: holdId,
+                    style: "primary",
+                    text: { type: "plain_text", text: slackTexts.HOLD_CONTINUE_BUTTON },
+                },
+                {
+                    type: "button",
+                    action_id: HOLD_CANCEL,
+                    value: holdId,
+                    text: { type: "plain_text", text: slackTexts.HOLD_CANCEL_BUTTON },
+                },
+            ],
+        },
+    ];
+}