allaboard 0.0.0-stage → 0.4.0

package/dist/chat/slack/repair.js

@@ -0,0 +1,123 @@
+import { getLogger } from "../../log.js";
+import { isRecord, records } from "../../values.js";
+import { contextBlock, RUNNING_LIST_ID } from "./reply/blocks.js";
+import { describe, gone, NOT_STREAMING } from "./reply/errors.js";
+export const logger = getLogger("allaboard.chat.slack.repair");
+// What a card left running becomes: it never ended, and will not.
+const RUNNING_CARD = ["pending", "in_progress"];
+// Slack's own cap: the read-back count is Slack's (streamed markdown reads back as several
+// blocks), not the sink's, which keeps a margin under it for what it writes itself.
+export const SLACK_BLOCKS = 50;
+/**
+ * Stop the reply's message, then rewrite it: its blocks as Slack keeps them, every card left
+ * running closed as an error (a stopped message would show it so anyway, until it is updated:
+ * measured 2026-09-28), the list of what still runs taken off (found by its `block_id`), plus the
+ * line that says it stopped. Kept within Slack's 50 blocks: at
+ * the cap the line goes into the last context block (the footer), or is left out if there is
+ * none; a block that holds content is never replaced. A failed read or a message already gone
+ * is logged and left alone: never replaced with a shorter form that would lose its content.
+ * `note` is the line that says it stopped. Never rejects. False when the message is there and
+ * was not rewritten (a failed read, a failed rewrite), so the caller can ask again; a stop that
+ * failed is not a reason to, since Slack ends a stream itself and the rewrite says the rest. A
+ * message Slack no longer has (`GONE`) counts as ended, and one that already carries `note` in
+ * a context block is left as it is: a rewrite whose answer was lost may have landed.
+ */
+export async function endReply(slack, limiter, place, messageTs, note) {
+    const { channel: channelId, threadTs } = place;
+    // Whether the stream may have been open: a stop that was refused for another reason is not
+    // known to have found it over.
+    let streamed = true;
+    try {
+        await slack.chat.stopStream({ channel: channelId, ts: messageTs });
+    }
+    catch (error) {
+        // the stream is over already when it is: nothing to stop
+        if (describe(error) === NOT_STREAMING) {
+            streamed = false;
+        }
+        else {
+            logger.warning(`could not stop a crashed reply's stream in ${channelId}/${threadTs}: ${describe(error)}`);
+        }
+    }
+    let answer;
+    try {
+        answer = await slack.conversations.replies({ channel: channelId, ts: messageTs, limit: 1 });
+    }
+    catch (error) {
+        logger.warning(`could not read a crashed reply's message in ${channelId}/${threadTs}: ${describe(error)}`);
+        return gone(error);
+    }
+    const messages = records(isRecord(answer) ? answer.messages : undefined);
+    const message = messages.find((found) => String(found.ts) === messageTs);
+    if (message === undefined) {
+        logger.info(`a crashed reply's message is gone in ${channelId}/${threadTs}`);
+        return true;
+    }
+    if (saysStopped(records(message.blocks), note))
+        return true;
+    // The list of what still runs is no card of the reply's own work: it goes, where the card of a
+    // call that never ended is closed as an error.
+    const read = records(message.blocks);
+    const isList = (block) => block.block_id === RUNNING_LIST_ID || block.task_id === RUNNING_LIST_ID;
+    const kept = read.filter((block) => !isList(block));
+    const callRunning = kept.some((block) => block.type === "task_card" && RUNNING_CARD.includes(String(block.status)));
+    // A message kept open only by the list holds a finished answer (its stream is over and no call
+    // of it runs): the app did not stop before it, so no note says so.
+    const onlyList = kept.length < read.length && !streamed && !callRunning;
+    let blocks = kept.map((block) => block.type === "task_card" && RUNNING_CARD.includes(String(block.status))
+        ? { ...block, status: "error" }
+        : block);
+    if (!onlyList) {
+        if (blocks.length < SLACK_BLOCKS)
+            blocks.push({ ...contextBlock(note) });
+        else
+            blocks = sayStoppedInTheFooter(blocks, note);
+    }
+    try {
+        await limiter.acquire();
+        await slack.chat.update({
+            channel: channelId,
+            ts: messageTs,
+            text: onlyList && typeof message.text === "string" ? message.text : note,
+            // Blocks as Slack read them back, sent back as they are: opaque to the library's types.
+            blocks: blocks,
+        });
+    }
+    catch (error) {
+        logger.warning(`could not rewrite a crashed reply in ${channelId}/${threadTs}: ${describe(error)}`);
+        return gone(error);
+    }
+    return true;
+}
+/** Whether a context block's text already ends with `note`: where this file writes it. */
+function saysStopped(blocks, note) {
+    return blocks.some((block) => {
+        if (block.type !== "context")
+            return false;
+        const first = records(block.elements)[0];
+        return typeof first?.text === "string" && first.text.endsWith(note);
+    });
+}
+/**
+ * The blocks with the stopped line added to the text of the footer: the context block that ends
+ * the message under a divider. A message that rests has no footer, and a context block that is
+ * not one (a line of the daemon's own) is not rewritten: the blocks are then unchanged, and the
+ * edit's own `text` says the stop.
+ */
+function sayStoppedInTheFooter(blocks, note) {
+    const index = blocks.length - 1;
+    if (blocks[index]?.type !== "context" || blocks[index - 1]?.type !== "divider")
+        return blocks;
+    const last = blocks[index];
+    if (last === undefined)
+        return blocks;
+    const elements = records(last.elements);
+    const first = elements[0];
+    if (first === undefined || (first.type !== "mrkdwn" && first.type !== "plain_text")) {
+        return blocks;
+    }
+    const text = typeof first.text === "string" ? first.text : "";
+    const joined = `${text} · ${note}`.replace(/^[ ·]+/, "");
+    const rewritten = { ...last, elements: [{ ...first, text: joined }, ...elements.slice(1)] };
+    return blocks.map((block, i) => (i === index ? rewritten : block));
+}

package/dist/chat/slack/reply/blocks.js

@@ -0,0 +1,372 @@
+/**
+ * The blocks and the stream chunks a reply is written with, and the limits they are held to.
+ *
+ * The shapes are the ones the recordings read back; the pinned
+ * `@slack/types` 3.2.0 declares them as `MarkdownBlock`, `ContextBlock`, `DividerBlock`,
+ * `TaskCardBlock`, `ContainerBlock`, `RichTextBlock` and the chunks of `AnyChunk`.
+ */
+import { NESTED, STOPPED, shownPreview } from "../../../core/port.js";
+import { RECORD_MARK } from "../texts.js";
+import { at, lastNewline, len, take } from "./chars.js";
+import { shownAsWritten } from "./escape.js";
+import { markdownBlocks } from "./markdown.js";
+// A message holds at most 12,000 characters and 50 blocks or task cards (measured 2026-09-28),
+// a text counting the blocks Slack makes of it (`markdownStarts`);
+// the margins keep a preview that arrives after its card, and the footer, inside them. A stream
+// and a post count the text of a collapsed container toward that cap; `chat.update` does not
+// (measured 2026-10-06, slack-sdk 3.44.1: 50 containers of 10,000 characters taken, nothing ever
+// refused). A message written by update therefore counts a container as its block only: at most
+// BLOCKS_LIMIT containers of MESSAGE_LIMIT characters, 495,000, which is what was measured in the
+// shape of a call with no card (45 of 11,000, taken).
+export const MESSAGE_LIMIT = 11_000;
+export const BLOCKS_LIMIT = 45;
+export const FALLBACK_LIMIT = 3_000;
+// What a message's `text` says: the banner of a notification, short, since a `chat.update` whose
+// `text` is long fails `msg_too_long` (measured 2026-09-28).
+export const BANNER_LIMIT = 300;
+// A task card's details and output are text of a rich text element; a context block's text
+// holds at most 3,000 characters.
+export const CARD_TEXT_LIMIT = 2_900;
+export const CARD_TITLE_LIMIT = 150;
+// The list of what still runs: its card's id (a tool call's id never has this form), and how many
+// lines it draws before `+N more`. With the footer it stays inside the margins MESSAGE_LIMIT
+// leaves: 6 lines of 80 characters, a title of 150, 3 blocks of the 5 spare.
+export const RUNNING_LIST_ID = "running-list";
+export const RUNNING_LIST_LINES = 6;
+export const CARD_TEXT_FIELDS = ["title", "details", "output"];
+// A stream keeps the details and the output of every `task_update` of a card, each added to what
+// the card holds; an update that carries neither leaves them, and its title replaces the title
+// (measured 2026-10-01 and 2026-10-08).
+export const CARD_APPENDED = ["details", "output"];
+// What a card costs a streamed message besides its characters: the card, each of the two texts
+// it holds, and each line of them. Slack stores a card's text as rich text, a line an element,
+// and its cap follows what it stores. Replayed over the 15 streams of 2026-10-01 (slack-sdk
+// 3.44.1), text and cards counted this way came to 13,514 at most in an accepted append and to
+// 13,801 at least in a refused one; MESSAGE_LIMIT sits under both.
+export const CARD_COST = 100;
+export const CARD_FIELD_COST = 150;
+export const CARD_LINE_COST = 50;
+// What stands where a preview arrived too late for its message.
+export const PREVIEW_CUT = "Preview left out: it did not fit this message.";
+export const TERMINAL = ["complete", "error"];
+// A container's title and subtitle (Block Kit reference).
+const CONTAINER_TITLE_LIMIT = 150;
+export function contextBlock(text) {
+    return { type: "context", elements: [{ type: "mrkdwn", text }] };
+}
+// The `block_id` of a line about the work, with the place of its text in the reply: a context
+// block as the count of a run of calls is, told apart from one and from the footer by its id.
+export const ASIDE_ID = "aside-";
+/** A line about the work (a task's end), small and grey. `at` is unique within the message. */
+export function asideBlock(text, at) {
+    return { ...contextBlock(text), block_id: `${ASIDE_ID}${at}` };
+}
+/**
+ * A `plain_text` text object. `emoji` false says `:name:` in `text` is not to be turned into an
+ * emoji (text object reference, read 2026-10-06); left out when null.
+ */
+export function plainTextObject(text, emoji = null) {
+    const shown = { type: "plain_text", text };
+    if (emoji !== null)
+        shown.emoji = emoji;
+    return shown;
+}
+// A text object's limit, as a context block's mrkdwn element holds one (Block Kit reference).
+export const CONTEXT_LIMIT = 3000;
+/** A daemon notice fitted into one context element: cut with `…` past its limit. */
+export function noticeText(text) {
+    const end = at(text, CONTEXT_LIMIT);
+    return end >= text.length ? text : `${take(text, CONTEXT_LIMIT - 1)}…`;
+}
+/**
+ * A preview's lines of words as one context element's text: each indented under its card and
+ * shown as written, the whole cut with `…` past the element's limit. A record has no card: its
+ * title leads, marked, with the lines under it.
+ */
+export function plainLines(body, title = null) {
+    const lines = body.split("\n").map((line) => NESTED + shownAsWritten(line));
+    if (title !== null)
+        lines.unshift(RECORD_MARK + shownAsWritten(title));
+    return noticeText(lines.join("\n"));
+}
+// Invisible, so a block that holds only this one shows no text of its own; never pasted as a
+// literal character in source, always by its code.
+export const ZERO_WIDTH_SPACE = String.fromCodePoint(0x200b);
+/**
+ * A new file's first lines as code blocks, split where a block would pass its limit. A fence
+ * inside the file must not close the block early: every run of three or more backticks is
+ * broken up, as `shownAsWritten` breaks every one.
+ */
+export function previewBlocks(body) {
+    const broken = body.replace(/`{3,}/g, (run) => run.split("").join(ZERO_WIDTH_SPACE));
+    return split(broken)
+        .filter((chunk) => chunk !== "")
+        .map((chunk) => ({ type: "markdown", text: `\`\`\`\n${chunk}\n\`\`\`` }));
+}
+/**
+ * A preview's body, collapsed: a full-width container per MESSAGE_LIMIT piece of it, closed
+ * until the owner opens it. A call with no card is titled with its line, in code style as a tool
+ * line is (`asCode`), and says the preview's sentence under it; under a card, which is the
+ * call's line, the title is the sentence alone. The body sits in the message itself, so it opens
+ * after a restart too.
+ */
+export function previewContainers(title, body, options = {}) {
+    const { subtitle = "", language = "diff", asCode = false } = options;
+    const shown = take(title, CONTAINER_TITLE_LIMIT);
+    return split(body)
+        .filter((chunk) => chunk !== "")
+        .map((chunk) => {
+        const block = {
+            type: "container",
+            title: { type: "plain_text", text: shown },
+            width: "full",
+            is_collapsible: true,
+            default_collapsed: true,
+            // A `markdown` block is not allowed in a container: rich text is, and its text is
+            // literal, so no fence to break. Slack desktop colours `diff`; mobile colours nothing.
+            child_blocks: [
+                {
+                    type: "rich_text",
+                    elements: [
+                        {
+                            type: "rich_text_preformatted",
+                            ...(language ? { language } : {}),
+                            elements: [{ type: "text", text: chunk }],
+                        },
+                    ],
+                },
+            ],
+        };
+        // The plain title is the fallback of a client that does not draw the rich one.
+        if (asCode) {
+            block.rich_text_title = {
+                type: "rich_text",
+                elements: [
+                    {
+                        type: "rich_text_section",
+                        elements: [{ type: "text", text: shown, style: { code: true } }],
+                    },
+                ],
+            };
+        }
+        if (subtitle) {
+            block.subtitle = { type: "plain_text", text: take(subtitle, CONTAINER_TITLE_LIMIT) };
+        }
+        return block;
+    });
+}
+export function blockText(block) {
+    switch (block.type) {
+        case "markdown":
+            return block.text;
+        case "container":
+            return block.child_blocks
+                .flatMap((child) => child.elements.flatMap((pre) => pre.elements.map((e) => e.text)))
+                .join("");
+        case "context":
+            return block.elements.map((element) => element.text).join("");
+        default:
+            return "";
+    }
+}
+/**
+ * What a refused write sent, for the log, never its content: the characters of text, the blocks,
+ * and how many of them are task cards.
+ */
+export function blocksSizes(blocks) {
+    const cards = blocks.filter((block) => block.type === "task_card").length;
+    const text = blocks.reduce((sum, block) => sum + len(blockText(block)), 0);
+    return [text, blocks.length, cards];
+}
+/**
+ * A message's text with no block: what a refused final write is retried with. Slack caps a
+ * text-only message at 4,000 characters (chat.update reference, 2026-09-25).
+ */
+export function plainText(blocks) {
+    let body = blocks
+        .flatMap((block) => (block.type === "markdown" ? [block.text] : []))
+        .join("\n\n");
+    const end = at(body, FALLBACK_LIMIT);
+    if (end < body.length)
+        body = `${body.slice(0, end)}…`;
+    return body || "…";
+}
+/** Cut a body into messages of at most MESSAGE_LIMIT characters, at line breaks if possible. */
+export function split(body) {
+    const chunks = [];
+    let rest = body;
+    for (;;) {
+        // The index that ends MESSAGE_LIMIT characters: the end of the text when it has no more.
+        const end = at(rest, MESSAGE_LIMIT);
+        if (end >= rest.length)
+            break;
+        const cut = lastNewline(rest, end);
+        if (cut <= 0) {
+            chunks.push(rest.slice(0, end));
+            rest = rest.slice(end);
+        }
+        else {
+            chunks.push(rest.slice(0, cut));
+            rest = rest.slice(cut + 1);
+        }
+    }
+    chunks.push(rest);
+    return chunks;
+}
+/**
+ * What a tool's card says, in the terminal's words: the title, the state, what it is doing now
+ * while it runs, and its output when it failed, was stopped, or has a preview's sentence. A
+ * running call, a task and a stopped call keep the words their tool line had.
+ */
+export function cardFields(update) {
+    const view = shownPreview(update);
+    let title = view ? view.title : update.title;
+    if (update.calls) {
+        // How much a subagent has done: its latest call alone does not say.
+        title += ` · ${update.calls} call${update.calls === 1 ? "" : "s"}`;
+    }
+    const fields = { title: take(title, CARD_TITLE_LIMIT), status: update.status };
+    const output = update.output;
+    if (view) {
+        if (view.summary)
+            fields.output = take(view.summary, CARD_TEXT_LIMIT);
+    }
+    else if (output && (update.status === "error" || output === STOPPED)) {
+        fields.output = take(output, CARD_TEXT_LIMIT);
+    }
+    else if (update.status === "in_progress" && update.details) {
+        fields.details = take(update.details, CARD_TEXT_LIMIT);
+    }
+    return fields;
+}
+/**
+ * What a tool's card says, as a `task_update` chunk. A stream is sent `cardAddition` of it: the
+ * card is updated in place by its id, and its details and output only grow.
+ */
+export function cardChunk(update) {
+    return { type: "task_update", id: update.id, ...cardFields(update) };
+}
+/**
+ * What to add to the text a card holds so that it ends with `wanted`: the lines of `wanted` past
+ * those the card already ends with, a line break first. Empty when it lacks nothing. Ten equal
+ * lines followed by an eleventh read as nothing new.
+ */
+export function lacking(held, wanted) {
+    if (!held)
+        return wanted;
+    const has = held.split("\n");
+    const wants = wanted.split("\n");
+    let shared = 0;
+    for (let n = Math.min(has.length, wants.length); n > 0; n -= 1) {
+        const tail = has.slice(-n);
+        if (tail.every((line, i) => line === wants[i])) {
+            shared = n;
+            break;
+        }
+    }
+    return wants
+        .slice(shared)
+        .map((line) => `\n${line}`)
+        .join("");
+}
+function newlines(text) {
+    let count = 0;
+    for (let i = text.indexOf("\n"); i !== -1; i = text.indexOf("\n", i + 1))
+        count += 1;
+    return count;
+}
+/**
+ * The chunk that brings a stream's card to `chunk`, what the card holds after it, and what it
+ * costs the message. `sent` is the card's last chunk (undefined for a new card) and `held` the
+ * details and the output Slack keeps for it. A card already in the message leaves out the
+ * details that do not fit `room`, and keeps those it holds; its output, which says how the call
+ * ended, is sent whatever the room.
+ */
+export function cardAddition(chunk, sent, held, room) {
+    const told = {
+        type: chunk.type,
+        id: chunk.id,
+        title: chunk.title,
+        status: chunk.status,
+    };
+    // A title that alternates between long and short (a run's card: the call that runs, then the
+    // counts) is charged once for its longest, not again each time it grows back.
+    const after = { ...held };
+    const longest = held.title ?? (sent === undefined ? 0 : len(sent.title));
+    let cost = sent === undefined ? CARD_COST + len(chunk.title) : Math.max(0, len(chunk.title) - longest);
+    after.title = Math.max(longest, len(chunk.title));
+    for (const key of CARD_APPENDED) {
+        const wanted = chunk[key];
+        if (wanted === undefined)
+            continue; // nothing to say: the card keeps what it holds
+        const has = held[key];
+        const more = lacking(has ?? "", wanted);
+        if (!more)
+            continue;
+        let price = len(more) + CARD_LINE_COST * (newlines(more) + (has === undefined ? 1 : 0));
+        if (has === undefined)
+            price += CARD_FIELD_COST;
+        if (key === "details" && sent !== undefined && room !== null && cost + price > room)
+            continue;
+        told[key] = more;
+        after[key] = (has ?? "") + more;
+        cost += price;
+    }
+    return [told, after, cost];
+}
+export function richText(text) {
+    return {
+        type: "rich_text",
+        elements: [{ type: "rich_text_section", elements: [{ type: "text", text }] }],
+    };
+}
+/**
+ * The `task_card` block of a tool, for a message that is no longer a stream (recorded shape:
+ * `details` and `output` are rich text).
+ */
+export function cardBlock(update) {
+    const fields = cardFields(update);
+    const block = {
+        type: "task_card",
+        task_id: update.id,
+        title: fields.title,
+        status: fields.status,
+    };
+    for (const key of CARD_APPENDED) {
+        const value = fields[key];
+        if (value !== undefined)
+            block[key] = richText(value);
+    }
+    return block;
+}
+/**
+ * The card of the list of what still runs: one `task_card` that keeps its `block_id` for its whole
+ * life, since Slack leaves a card with a fixed id open across an edit (measured 2026-10-12,
+ * desktop). Past `RUNNING_LIST_LINES` lines the rest is told as `+N more`.
+ */
+export function runningListBlock(running) {
+    const lines = running.lines.length > RUNNING_LIST_LINES
+        ? [
+            ...running.lines.slice(0, RUNNING_LIST_LINES),
+            `+${running.lines.length - RUNNING_LIST_LINES} more`,
+        ]
+        : running.lines;
+    const block = {
+        type: "task_card",
+        block_id: RUNNING_LIST_ID,
+        task_id: RUNNING_LIST_ID,
+        title: take(running.title, CARD_TITLE_LIMIT),
+        status: "in_progress",
+    };
+    if (lines.length > 0)
+        block.details = richText(take(lines.join("\n"), CARD_TEXT_LIMIT));
+    return block;
+}
+/** Whether the block is the list of what still runs. */
+export function isRunningList(block) {
+    return block.type === "task_card" && block.block_id === RUNNING_LIST_ID;
+}
+/** The blocks of a message as Slack counts them. */
+export function blocksCount(blocks) {
+    return blocks.reduce((sum, block) => sum + (block.type === "markdown" ? markdownBlocks(block.text) : 1), 0);
+}

package/dist/chat/slack/reply/chars.js

@@ -0,0 +1,59 @@
+/**
+ * Text counted and trimmed in code points, which is what the limits of a reply were measured
+ * against.
+ *
+ * Python's `len` and its slices count code points; a JavaScript string counts UTF-16 units, two
+ * for an emoji or any other character past U+FFFF (the red and green squares of every diff
+ * preview are such). The rule the reply's code follows:
+ *
+ * - an offset into a text (a cursor, what a stream was sent up to, a block's start) is a UTF-16
+ *   index, and offsets are only ever added to `.length` values and to each other;
+ * - a size held against a limit (`MESSAGE_LIMIT`, a card's cost, a title's 150 characters) is
+ *   `len`, in code points;
+ * - a cut "after N characters" goes through `at` or `take`, which turn the count into the index
+ *   that ends that many code points, so a cut never lands inside a surrogate pair.
+ */
+import { isHigh, isLow, len } from "../../../text.js";
+export { len };
+/** The UTF-16 index that ends the first `count` code points of `text`: where `text[:count]` cuts. */
+export function at(text, count) {
+    if (count <= 0)
+        return 0;
+    // A text has at most as many code points as units: nothing to scan when it is that short.
+    if (count >= text.length)
+        return text.length;
+    let index = 0;
+    for (let taken = 0; taken < count && index < text.length; taken += 1) {
+        index +=
+            isHigh(text.charCodeAt(index)) && index + 1 < text.length && isLow(text.charCodeAt(index + 1))
+                ? 2
+                : 1;
+    }
+    return index;
+}
+/** Python's `text[:count]`. */
+export function take(text, count) {
+    return text.slice(0, at(text, count));
+}
+/** Python's `text.lstrip("\n")`. */
+export function lstripNewlines(text) {
+    let start = 0;
+    while (text.charCodeAt(start) === 0x0a)
+        start += 1;
+    return text.slice(start);
+}
+/** Python's `text.rstrip("\n")`. */
+export function rstripNewlines(text) {
+    let end = text.length;
+    while (end > 0 && text.charCodeAt(end - 1) === 0x0a)
+        end -= 1;
+    return text.slice(0, end);
+}
+/** Python's `text.strip("\n")`. */
+export function stripNewlines(text) {
+    return rstripNewlines(lstripNewlines(text));
+}
+/** Python's `text.rfind("\n", 0, end)`, `end` a UTF-16 index: -1 when there is none. */
+export function lastNewline(text, end) {
+    return end <= 0 ? -1 : text.lastIndexOf("\n", end - 1);
+}