allaboard 0.0.0-stage → 0.4.0

package/dist/core/flows/setup.js

@@ -0,0 +1,130 @@
+import { errorName } from "../../values.js";
+import { SessionClosed, SessionGone } from "../sessions/errors.js";
+import { choiceOf, DEFAULT, DEFAULT_CHOICE, summaryOf } from "../setup.js";
+import * as texts from "../texts.js";
+import { fill } from "../texts.js";
+import { askOwner } from "./ask-owner.js";
+import { isCancelled, logger } from "./talk.js";
+/** The one line that replaces the controls once the owner pressed Start. */
+export function summaryLine(models, choice) {
+    const data = summaryOf(models, choice);
+    return fill(texts.SETUP_SUMMARY, {
+        model: data.model,
+        effort: data.effort ?? texts.SETUP_EFFORT_DEFAULT,
+        bypass: data.bypass ? "on" : "off",
+    });
+}
+/**
+ * The effort levels a setup offers by themselves: the agent's own, for an agent that lists no
+ * models. An agent that lists models offers none here, even when its list came back empty:
+ * each model names the levels it takes.
+ */
+export function effortsOffered(deps) {
+    const { capabilities } = deps.agent;
+    return capabilities.models ? [] : capabilities.effortLevels;
+}
+/** Whether the agent has a mode that skips permission requests, which a setup then offers. */
+export function bypassOffered(deps) {
+    return deps.agent.capabilities.permissionModes.bypass !== null;
+}
+/**
+ * The owner's choice from the controls they left, held to what the request offered: a model the
+ * agent did not list reads as its default, an effort the model (or, for an agent with no model
+ * list, the agent) does not take reads as `Default`, and bypass reads as off when none was
+ * offered.
+ */
+export function chosen(deps, models, selection) {
+    const choice = choiceOf(models, selection);
+    const efforts = effortsOffered(deps);
+    const effort = efforts.length === 0
+        ? choice.effort
+        : efforts.includes(selection.effort)
+            ? selection.effort
+            : DEFAULT;
+    return { ...choice, effort, bypass: choice.bypass && bypassOffered(deps) };
+}
+export function setupFlow(deps, talk) {
+    /**
+     * Ask for the session's model, effort and bypass before its first prompt, and apply the
+     * answer to the live session. The session to send the message on, or null when it was not
+     * sent, either way telling the owner `Not sent.` already. The session is connected first: the
+     * agent's own model list is what the request offers, and a folder that cannot start fails
+     * here, before the owner picks anything.
+     */
+    async function beforeSending(ref, asked) {
+        const { sessions, state } = deps;
+        let session = asked;
+        try {
+            // First what an earlier, unsent Start left: the session it changed is dropped, so the
+            // connect below reads the folder's own mode again.
+            await session.forgetSetup();
+            await session.ensureConnected();
+        }
+        catch (error) {
+            if (!(error instanceof SessionClosed))
+                throw error;
+            // Closed during the downloads before this: the retry of the submit never sees this
+            // step, so the thread's fresh session is looked up here, as it does.
+            const fresh = sessions.get(ref.channel, ref.thread);
+            if (fresh === null)
+                throw new SessionGone(deps.names);
+            session = fresh;
+            await session.ensureConnected();
+        }
+        const live = session;
+        const models = live.models;
+        // Ticked when the connect above runs in bypass (a folder whose own settings start the agent
+        // so): it is what would run, and unticking is the explicit off.
+        const ticked = live.bypass;
+        // Apply the choice, then turn the message into its summary line: all of it while the hold
+        // is still open, so a stop that lands anywhere in here still cancels.
+        const settle = async (answer, shownAt, pending) => {
+            // A hold's Continue carries no choice: one answered with a setup's id applies nothing.
+            if (answer === true)
+                throw new TypeError("a setup was answered with no choice");
+            const choice = answer;
+            await live.applySetup(choice);
+            // The message stays as a record of what was set: no longer a request, not deleted.
+            try {
+                state.removeRequest(ref.channel, ref.thread, shownAt);
+            }
+            catch (error) {
+                logger.warning(`could not clear a setup message from state.json in ${ref.channel}/${ref.thread}: ${errorName(error)}`);
+            }
+            // Nothing to edit: deleted, or the daemon is gone.
+            if (pending.cancelled || talk.stopped)
+                return;
+            try {
+                await talk.thread(ref).rewrite(shownAt, summaryLine(models, choice));
+            }
+            catch (error) {
+                if (isCancelled(error))
+                    throw error;
+                logger.warning(`could not update a setup message in ${ref.channel}: ${errorName(error)}`);
+            }
+        };
+        const answer = await askOwner(deps, talk, ref, live, {
+            kind: "setup",
+            title: texts.SETUP_FALLBACK,
+            request: (requestId) => ({
+                type: "setup",
+                requestId,
+                models,
+                efforts: effortsOffered(deps),
+                bypassOffered: bypassOffered(deps),
+                selection: { ...DEFAULT_CHOICE, bypass: ticked },
+            }),
+            settle,
+            context: models,
+        });
+        if (answer === null) {
+            // A stop or drain that came while Start was applied. Not once the daemon is gone: the
+            // state it would rewrite is the next start's.
+            if (!talk.stopped)
+                await live.forgetSetup();
+            return null;
+        }
+        return live;
+    }
+    return { beforeSending };
+}

package/dist/core/flows/status.js

@@ -0,0 +1,98 @@
+import { errorName } from "../../values.js";
+import { oneLine, TITLE_LIMIT } from "../reply/words.js";
+import * as texts from "../texts.js";
+import { fill } from "../texts.js";
+import { isCancelled, logger } from "./talk.js";
+/** How long ago, in one unit, as a channel's `!status` says it of an idle session. */
+export function ago(seconds) {
+    const whole = Math.trunc(seconds);
+    if (whole < 60)
+        return "just now";
+    if (whole < 3600)
+        return `${Math.floor(whole / 60)}m ago`;
+    if (whole < 86400)
+        return `${Math.floor(whole / 3600)}h ago`;
+    return `${Math.floor(whole / 86400)}d ago`;
+}
+export function channelStatus(deps, talk) {
+    const { state, sessions } = deps;
+    async function row(channel, channelDirectory, session, known) {
+        const stored = state.thread(channel, session.threadId);
+        const info = stored === null ? undefined : known.get(String(stored.sessionId));
+        const title = info === undefined ? "" : oneLine(info.title, TITLE_LIMIT);
+        const linked = await talk.referenceLink({ channel, thread: session.threadId }, title);
+        let activity;
+        if (session.waitingForOwner) {
+            activity = texts.STATUS_CHANNEL_WAITING;
+        }
+        else if (session.busy || session.runningKinds) {
+            // A session with only a background task running is not idle either.
+            activity = texts.STATUS_CHANNEL_BUSY;
+        }
+        else {
+            activity = texts.STATUS_CHANNEL_IDLE;
+            if (info?.lastModified) {
+                // In milliseconds, and by now the time of the session's last message (dated below).
+                const since = ago(deps.now() - info.lastModified / 1000);
+                activity += fill(texts.STATUS_CHANNEL_SINCE, { ago: since });
+            }
+        }
+        let line = fill(texts.STATUS_CHANNEL_ROW, { link: linked, activity });
+        if (session.runningKinds) {
+            line += ` · ${fill(texts.RUNNING, { counts: session.runningKinds })}`;
+        }
+        if (session.bypass)
+            line += texts.STATUS_CHANNEL_BYPASS;
+        if (session.directory !== channelDirectory) {
+            line += fill(texts.STATUS_CHANNEL_FOLDER, { directory: session.directory });
+        }
+        return line;
+    }
+    return async (channel) => {
+        const record = state.channel(channel);
+        if (record === null) {
+            await talk.unbound(channel);
+            return;
+        }
+        const lines = [fill(texts.STATUS_CHANNEL_HEADER, { directory: record.directory })];
+        const live = sessions.sessionsOf(channel);
+        if (live.length === 0) {
+            lines.push(texts.STATUS_CHANNEL_EMPTY);
+        }
+        else {
+            // What tells one thread from another (issue #76): the title the agent gave its session,
+            // as the Home tab and a restart's notice name it, and the time of its last message. Not
+            // the time of its file, which the listing gives: Claude Code writes entries with no
+            // timestamp to a transcript when it connects the session again, so a session idle for 16
+            // minutes read `just now` (seen 2026-10-07). Only the sessions the answer shows are
+            // dated, since dating reads their files.
+            const shown = new Set();
+            for (const session of live) {
+                const stored = state.thread(channel, session.threadId);
+                if (stored?.sessionId)
+                    shown.add(stored.sessionId);
+            }
+            const known = new Map();
+            for (const directory of new Set(live.map((session) => session.directory))) {
+                try {
+                    const listed = await sessions.sessionsIn(directory);
+                    const dated = await sessions.dated(directory, listed.filter((session) => shown.has(session.id)));
+                    for (const session of dated)
+                        known.set(session.id, session);
+                }
+                catch (error) {
+                    if (isCancelled(error))
+                        throw error;
+                    logger.warning(`could not list a folder's sessions: ${errorName(error)}`);
+                }
+            }
+            lines.push(...(await Promise.all(live.map((session) => row(channel, record.directory, session, known)))));
+        }
+        await talk.say(channel, null, lines.join("\n"));
+        const waits = await talk.restartWaits(channel);
+        if (waits) {
+            // A notice of its own: the rows are written for a notice, and the status above is a reference.
+            await talk.inChannel(channel, [texts.RESTART_WAITS_HEADER, waits].join("\n"));
+        }
+    };
+}

package/dist/core/flows/talk.js

@@ -0,0 +1,207 @@
+import { getLogger } from "../../log.js";
+import { errorName } from "../../values.js";
+import { oneLine, TITLE_LIMIT } from "../reply/words.js";
+import { DirectoryUnavailable, SessionClosed, SessionGone, StartsBlocked, } from "../sessions/errors.js";
+import { Cancelled } from "../sessions/tasks.js";
+import * as texts from "../texts.js";
+import { fill, named } from "../texts.js";
+export const logger = getLogger("allaboard.core.flows");
+// Rows of threads a stop waits for in one notice: a row holds a link and a title of
+// `TITLE_LIMIT`, and the whole must fit one notice of any chat.
+export const RESTART_WAIT_ROWS = 8;
+/** Whether a wait was cancelled: a task's signal aborted. */
+export function isCancelled(error) {
+    return error instanceof Cancelled;
+}
+export class Talk {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    /**
+     * Whether the daemon has stopped. A flow that finds it so ends silently: its work goes on at
+     * its next await after the stop.
+     */
+    get stopped() {
+        return this.deps.stopped.aborted;
+    }
+    /** The thread as its live session holds it, so that what is posted there counts as written. */
+    thread(ref) {
+        return this.deps.sessions.chatOf(ref.channel, ref.thread);
+    }
+    /**
+     * A line for the owner alone, under their message in the thread: a refusal that answers what
+     * they just did. With `stays` it is a message of the thread instead. Never throws.
+     */
+    async tell(ref, text, options = {}) {
+        if (this.stopped)
+            return;
+        await this.thread(ref).tell(text, options);
+    }
+    /**
+     * A reference the owner reads (`!help`, `!guide`, `!status`), at full size: in the thread, or
+     * in the channel when `thread` is null.
+     */
+    async say(channel, thread, markdown, options = {}) {
+        if (this.stopped)
+            return;
+        if (thread === null)
+            await this.deps.chat.channel(channel).say(markdown);
+        else
+            await this.thread({ channel, thread }).say(markdown, options);
+    }
+    /**
+     * Answer in the channel itself: where a word typed in the channel, or a pick from a list
+     * posted there, is answered.
+     */
+    async inChannel(channel, text) {
+        await this.postInChannel(channel, text);
+    }
+    /**
+     * `inChannel`, resolving with the message posted: for an answer the daemon rewrites later.
+     * Null when the chat cannot say which message it is, or the daemon has stopped.
+     */
+    async postInChannel(channel, text) {
+        if (this.stopped)
+            return null;
+        return this.deps.chat.channel(channel).notice(text);
+    }
+    /** The mark that a word took effect, on the owner's own message, where the chat has one. */
+    async acknowledge(ref, message) {
+        if (this.stopped || !this.deps.chat.capabilities.reactions)
+            return;
+        await this.thread(ref).acknowledge(message);
+    }
+    /**
+     * A failure after the checks reaches the owner as a line of its own, never as silence: by
+     * `report`, or as a message of the thread, the one push of a turn that failed.
+     */
+    async replyOnFailure(ref, work, report) {
+        const told = report ?? ((text) => this.tell(ref, text, { stays: true }));
+        // Never throws: nobody is left to tell about a failure of the report itself.
+        const guarded = async (text) => {
+            try {
+                await told(text);
+            }
+            catch (error) {
+                if (isCancelled(error))
+                    throw error;
+                logger.warning(`could not report a failure in ${ref.channel}/${ref.thread}: ${errorName(error)}`);
+            }
+        };
+        try {
+            await work();
+        }
+        catch (error) {
+            if (isCancelled(error))
+                throw error;
+            if (error instanceof DirectoryUnavailable ||
+                error instanceof SessionClosed ||
+                error instanceof SessionGone ||
+                error instanceof StartsBlocked) {
+                await guarded(error.message);
+                return;
+            }
+            logger.error(`a request failed in ${ref.channel}/${ref.thread}: ${errorName(error)}`);
+            await guarded(fill(named(texts.ERROR_REPLY, this.deps.names), { error: errorName(error) }));
+        }
+    }
+    /**
+     * Tells the channel it is not bound to a folder, in the words of an agent that keeps a record
+     * of trust or of one that does not.
+     */
+    unbound(channel) {
+        const { agent, names, allowedRoot } = this.deps;
+        const text = agent.capabilities.folderTrust ? named(texts.UNBOUND, names) : texts.UNBOUND_ANY;
+        return this.inChannel(channel, fill(text, { root: allowedRoot }));
+    }
+    /** The request's message has done its job: removed from the chat and from what repair reads. */
+    async removeRequest(ref, message) {
+        if (message === null || this.stopped)
+            return;
+        await this.thread(ref).withdraw(message);
+        try {
+            // Spoken for either way, as the session's own removal does. A no-op for a message this
+            // thread never recorded.
+            this.deps.state.removeRequest(ref.channel, ref.thread, message);
+        }
+        catch (error) {
+            logger.warning(`could not clear a removed request from state.json in ${ref.channel}: ${errorName(error)}`);
+        }
+    }
+    /** A link to a thread inside a reference, labelled with the session's title. */
+    async referenceLink(ref, title = "") {
+        const label = this.deps.chat.escape(title, "reference") || texts.STATUS_CHANNEL_SESSION;
+        const link = await this.thread(ref).link(label, "reference");
+        return link ?? fill(texts.STATUS_CHANNEL_LINK_FALLBACK, { thread_ts: ref.thread });
+    }
+    /** A link to a thread inside a notice; `label` is already escaped for one. */
+    async noticeLink(ref, label) {
+        const link = await this.thread(ref).link(label, "notice");
+        return link ?? fill(texts.STATUS_CHANNEL_LINK_FALLBACK, { thread_ts: ref.thread });
+    }
+    /**
+     * The threads a stop still waits for, one row each: its channel, a link to it labelled with
+     * its session's title, and what holds the restart there. Then the word that ends the wait,
+     * when it ends any of them. Empty when nothing holds it. With `only`, the threads of that
+     * channel are named and the others counted: the answer is a message the channel's members
+     * read. At most `RESTART_WAIT_ROWS` rows. Never throws: a title or a link that cannot be read
+     * falls back to a plain label.
+     */
+    async restartWaits(only = null) {
+        const { sessions, state, chat } = this.deps;
+        const every = sessions.restartHolds();
+        const named_ = every.filter(([session]) => only === null || session.channelId === only);
+        if (every.length === 0)
+            return "";
+        const shown = named_.slice(0, RESTART_WAIT_ROWS);
+        const known = new Map();
+        for (const directory of new Set(shown.map(([session]) => session.directory))) {
+            try {
+                for (const listed of await sessions.sessionsIn(directory)) {
+                    known.set(listed.id, listed.title);
+                }
+            }
+            catch (error) {
+                if (isCancelled(error))
+                    throw error;
+                logger.warning(`could not list a folder's sessions: ${errorName(error)}`);
+            }
+        }
+        const row = async (session, hold) => {
+            const stored = state.thread(session.channelId, session.threadId);
+            const title = stored === null ? "" : (known.get(String(stored.sessionId)) ?? "");
+            const label = chat.escape(oneLine(title, TITLE_LIMIT), "notice") || texts.RESTART_WAIT_SESSION;
+            const link = await this.noticeLink({ channel: session.channelId, thread: session.threadId }, label);
+            return fill(texts.RESTART_WAIT_ROW, {
+                channel: chat.channelName(session.channelId, "notice"),
+                link,
+                hold,
+            });
+        };
+        const lines = await Promise.all(shown.map(([session, hold]) => row(session, hold)));
+        if (named_.length > shown.length) {
+            lines.push(fill(texts.RESTART_WAITS_MORE, { count: named_.length - shown.length }));
+        }
+        if (every.length > named_.length) {
+            lines.push(fill(texts.RESTART_WAITS_ELSEWHERE, { count: every.length - named_.length }));
+        }
+        if (every.some(([, hold]) => hold !== texts.RESTART_HOLD_REPORT)) {
+            // A thread that only waits for a task's report ends by itself: `!stop` stops nothing
+            // there, so the line is left out when no other thread holds the stop.
+            lines.push(texts.RESTART_WAIT_STOP);
+        }
+        return lines.join("\n");
+    }
+    /**
+     * Tell the owner their message was not taken because the daemon is stopping, and which
+     * threads the stop waits for: only they can answer or `!stop` those.
+     */
+    async refuseRestarting(ref) {
+        const waits = await this.restartWaits();
+        let text = texts.RESTARTING;
+        if (waits)
+            text = [text, texts.RESTART_WAITS_FOR, waits].join("\n");
+        await this.tell(ref, text);
+    }
+}