allaboard 0.5.0 → 0.6.0

package/dist/core/flows/words.js

@@ -1,11 +1,21 @@
+/**
+ * A word of the daemon's own: what each does, and where it is answered. Typed in the channel (or
+ * in a thread that holds no session) it is answered by a normal post in the channel; typed
+ * inside a session's thread it is answered for the owner alone under the owner's message, or by
+ * a mark on it, so nothing rings a phone; `!stop` is answered by a post that stays in the
+ * thread, and `!open` shows its files there.
+ */
+import { ChatError } from "../../chat/seam.js";
+import { errorName } from "../../values.js";
 import { helpText, WORD } from "../commands.js";
 import { guideText } from "../guide.js";
 import { BypassUnavailable } from "../sessions/errors.js";
 import * as texts from "../texts.js";
 import { fill, named } from "../texts.js";
 import { channelStatus } from "./status.js";
+import { logger } from "./talk.js";
 export function wordFlow(deps, talk, others) {
-    const { chat, agent, sessions, names } = deps;
+    const { chat, agent, sessions, state, names } = deps;
     const status = channelStatus(deps, talk);
     // The words this agent and this chat cannot serve: each is refused when typed, and `!help`
     // does not list it.
@@ -16,10 +26,35 @@ export function wordFlow(deps, talk, others) {
         unserved.add(WORD.resume);
     if (!chat.capabilities.fileUpload)
         unserved.add(WORD.open);
+    if (!chat.capabilities.threadTags) {
+        unserved.add(WORD.tag);
+        unserved.add(WORD.untag);
+    }
+    if (!chat.capabilities.threadDelete)
+        unserved.add(WORD["delete-thread"]);
     // A daemon built without a way to update itself offers no `!allaboard`.
     const allaboard = others.allaboard;
     if (allaboard === undefined)
         unserved.add(WORD.allaboard);
+    /**
+     * The agent's own tag for the session, once the chat shows the change. A thread whose session
+     * has no id yet has nothing to tag, and an agent that declares no `sessionTags` keeps none; a
+     * failure leaves the chat's change standing and is told to the owner alone.
+     */
+    async function mirrorTag(ref, session, tag) {
+        if (!agent.capabilities.sessionTags || agent.tagSession === undefined)
+            return;
+        const id = state.thread(ref.channel, ref.thread)?.sessionId;
+        if (id === null || id === undefined)
+            return;
+        try {
+            await agent.tagSession(session.directory, id, tag);
+        }
+        catch (error) {
+            logger.warning(`could not tag the agent's session of ${ref.channel}/${ref.thread}: ${errorName(error)}`);
+            await talk.tell(ref, named(texts.TAG_AGENT_FAILED, names));
+        }
+    }
     return async (ref, message, command, { session, outside }) => {
         const { channel, thread } = ref;
         const where = session === null ? null : thread;
@@ -50,6 +85,8 @@ export function wordFlow(deps, talk, others) {
                     backgroundTasks: have.backgroundTasks,
                     sessionListing: have.sessionListing,
                     fileUpload: chat.capabilities.fileUpload,
+                    threadTags: chat.capabilities.threadTags,
+                    threadDelete: chat.capabilities.threadDelete,
                     updates: allaboard !== undefined,
                 };
                 await talk.say(channel, where, guideText(names, offered), { ownerOnly: quiet });
@@ -139,6 +176,48 @@ export function wordFlow(deps, talk, others) {
                     await chat.openFile(ref, session.directory, command.target);
                 }
                 return;
+            case "tag":
+            case "untag": {
+                if (session === null) {
+                    await talk.inChannel(channel, texts.TAG_TOP_LEVEL);
+                    return;
+                }
+                if (!chat.capabilities.threadTags || chat.tagThread === undefined) {
+                    await talk.tell(ref, named(texts.TAG_UNAVAILABLE, names));
+                    return;
+                }
+                const tag = command.kind === "tag" ? command.name : null;
+                // The chat first, since it is what the owner sees. Its refusal is the chat's, not the
+                // agent's, which the reply to any other failure of a word would name.
+                try {
+                    await chat.tagThread(ref, tag);
+                }
+                catch (error) {
+                    if (!(error instanceof ChatError))
+                        throw error;
+                    await talk.tell(ref, fill(named(texts.TAG_FAILED, names), { error: error.name }));
+                    return;
+                }
+                await mirrorTag(ref, session, tag);
+                await talk.acknowledge(ref, message);
+                return;
+            }
+            case "delete-thread":
+                if (session === null) {
+                    await talk.inChannel(channel, texts.DELETE_THREAD_TOP_LEVEL);
+                }
+                else if (!chat.capabilities.threadDelete || chat.deleteThread === undefined) {
+                    await talk.tell(ref, named(texts.DELETE_THREAD_UNAVAILABLE, names));
+                }
+                else if (session.inUse) {
+                    // Refused before the owner is asked; the delete checks again on their yes, since the
+                    // thread may have started working meanwhile.
+                    await talk.tell(ref, texts.DELETE_THREAD_BUSY);
+                }
+                else {
+                    await chat.deleteThread(ref);
+                }
+                return;
             case "allaboard":
                 if (allaboard === undefined) {
                     await showHelp("");

package/dist/core/guide.js

@@ -43,6 +43,8 @@ export function guideText(names, offered) {
         sessions,
         ...(offered.fileUpload ? [say(texts.GUIDE_FILES)] : []),
         ...(offered.bypass ? [say(texts.GUIDE_BYPASS)] : []),
+        ...(offered.threadTags ? [say(texts.GUIDE_TAGS)] : []),
+        ...(offered.threadDelete ? [say(texts.GUIDE_DELETE)] : []),
         ...(offered.updates ? [texts.GUIDE_UPDATES] : []),
         texts.GUIDE_END,
     ];

package/dist/core/port/cleanup.js

@@ -0,0 +1 @@
+export {};

package/dist/core/port.js

@@ -1,3 +1,4 @@
+export { TAG_NAME } from "./commands.js";
 export { ConfigError } from "./config.js";
 export { changedIn } from "./files/changed.js";
 export { Listings } from "./files/listing.js";

package/dist/core/sessions/directory.js

@@ -4,6 +4,7 @@ import { opendir, stat } from "node:fs/promises";
 import { isAbsolute, sep } from "node:path";
 import { shellQuote } from "../../text.js";
 import { errorCode } from "../../values.js";
+import { untrustedRepositories } from "../files/listing.js";
 import { ABSENT, expandUser, resolvePath } from "../paths.js";
 import * as texts from "../texts.js";
 import { DirectoryMissing, DirectoryUnreadable, DirectoryUntrusted } from "./errors.js";
@@ -22,6 +23,18 @@ export function trustedBy(agent) {
 export function repositoryBy(agent) {
     return async (folder) => agent.capabilities.folderTrust ? agent.trustedRepository(folder) : null;
 }
+/**
+ * What tells the owner which repositories below `folder` still need `agent`'s trust before the
+ * footer and `!open` read them (issue #247), each with the shell line that asks for it at its
+ * key; nothing for an agent that keeps no record of trust. Rejects as the lookups do.
+ */
+export async function untrustedNotice(agent, folder, names, escapeMarkup) {
+    const template = agent.words.trust;
+    if (!agent.capabilities.folderTrust || template === null)
+        return [];
+    const found = await untrustedRepositories(folder, repositoryBy(agent), (directory) => agent.untrustedRepository(directory));
+    return untrustedLines(template, found.map((repository) => repository.key), names, escapeMarkup);
+}
 /**
  * Rejects with the `DirectoryUnavailable` that keeps a session from starting in `directory`,
  * the first found in the order the owner can act on: missing, unreadable, untrusted.
@@ -52,7 +65,10 @@ export async function checkDirectory(directory, trusted, names) {
 function under(path, root) {
     return path === root || path.startsWith(root.endsWith(sep) ? root : root + sep);
 }
-/** The real directory `raw` names, if it exists under `root`; guards against a typo only. */
+/**
+ * The real directory `raw` names when it exists under `root`, or why it does not; guards
+ * against a typo only.
+ */
 export function resolveDirectory(raw, root) {
     // A relative path is read under the root: the daemon's own working directory means nothing
     // to the owner (launchd starts it in `/`).
@@ -60,14 +76,18 @@ export function resolveDirectory(raw, root) {
     try {
         // Joined as text: the disk follows a link before a `..`.
         const path = resolvePath(isAbsolute(written) ? written : `${root}/${written}`);
-        if (!statSync(path).isDirectory() || !under(path, root))
-            return null;
+        if (!under(path, root))
+            return { refused: "outside" };
+        if (!statSync(path).isDirectory())
+            return { refused: "file" };
         // The kernel is asked too, since a session runs in the folder it reaches: whatever the
         // reading above made of the spelling, that folder lies under the root or is refused.
-        return under(realpathSync.native(path), realpathSync.native(root)) ? path : null;
+        return under(realpathSync.native(path), realpathSync.native(root))
+            ? { directory: path }
+            : { refused: "outside" };
     }
     catch {
-        return null; // it names nothing, or goes through a loop of links
+        return { refused: "missing" }; // it names nothing, or goes through a loop of links
     }
 }
 /**
@@ -80,7 +100,26 @@ export function terminalLine(template, directory, sessionId, escapeMarkup) {
         directory: shellQuote(directory),
         session: sessionId,
     });
-    // A code span cannot hold a backtick: such a command is plain text, escaped.
-    const shown = command.includes("`") ? escapeMarkup(command) : `\`${command}\``;
-    return texts.fill(texts.STATUS_TERMINAL, { command: shown });
+    return texts.fill(texts.STATUS_TERMINAL, { command: commandShown(command, escapeMarkup) });
+}
+/** The repositories `untrustedLines` names at most; the rest are counted. */
+export const UNTRUSTED_ROWS = 10;
+/**
+ * What tells the owner which of `roots` still need the agent's trust, each with the shell line
+ * that asks for it there (the agent's `words.trust`, `template`); empty with no root.
+ */
+export function untrustedLines(template, roots, names, escapeMarkup) {
+    if (roots.length === 0)
+        return [];
+    const lines = roots
+        .slice(0, UNTRUSTED_ROWS)
+        .map((root) => commandShown(texts.fill(template, { directory: shellQuote(root) }), escapeMarkup));
+    if (roots.length > UNTRUSTED_ROWS) {
+        lines.push(texts.fill(texts.UNTRUSTED_MORE, { count: roots.length - UNTRUSTED_ROWS }));
+    }
+    return [texts.named(texts.UNTRUSTED_REPOSITORIES, names), ...lines];
+}
+/** A shell line as a code span, which cannot hold a backtick: such a line is plain text, escaped. */
+function commandShown(command, escapeMarkup) {
+    return command.includes("`") ? escapeMarkup(command) : `\`${command}\``;
 }

package/dist/core/sessions/manager.js

@@ -105,7 +105,10 @@ export class SessionManager {
             session = null;
         }
         if (session === null) {
-            const built = new ThreadSession(channelId, threadId, directory, this.deps, { predecessor });
+            const built = new ThreadSession(channelId, threadId, directory, this.deps, {
+                predecessor,
+                stopped: () => this.closed,
+            });
             built.draining = this.draining;
             built.startsBlocked = this.startsBlocked;
             built.onClosed = () => this.evictIfCurrent(key, built);
@@ -195,23 +198,40 @@ export class SessionManager {
      * thread is held for a delete the stop would cut short.
      */
     async release(channelId, threadId) {
+        if (!this.hold(channelId, threadId))
+            return false;
+        await this.closeHeld(channelId, threadId);
+        return true;
+    }
+    /**
+     * The first half of `release`, in one synchronous step: holds the thread unless the manager is
+     * closed, the thread is held already or its session is in use, and says whether it did. A
+     * caller that gets true owns the hold, and ends it with `free`; one that gets false took none,
+     * and so never ends another's.
+     */
+    hold(channelId, threadId) {
         if (this.closed)
             return false;
         const key = keyOf(channelId, threadId);
+        if (this.heldThreads.has(key))
+            return false;
         const session = this.sessions.get(key);
-        const inUse = session !== undefined && !session.closed && (session.waitingForOwner || !session.idle);
-        if (inUse)
+        if (session !== undefined && !session.closed && session.inUse)
             return false;
         // (sync) Held before the first await: a message that arrives while the session closes, or
         // while the thread's messages are deleted, must not build a session in it.
         this.heldThreads.add(key);
-        if (session !== undefined) {
-            if (!session.closed)
-                await session.close(texts.ENDED_IDLE);
-            await session.doneClosing.wait();
-        }
         return true;
     }
+    /** The second half of `release`: closes the thread's session, if any, once `hold` took it. */
+    async closeHeld(channelId, threadId) {
+        const session = this.sessions.get(keyOf(channelId, threadId));
+        if (session === undefined)
+            return;
+        if (!session.closed)
+            await session.close(texts.ENDED_IDLE);
+        await session.doneClosing.wait();
+    }
     /** Whether the thread is being deleted: it still has its entry, and takes no session. */
     held(channelId, threadId) {
         return this.heldThreads.has(keyOf(channelId, threadId));
@@ -226,15 +246,10 @@ export class SessionManager {
      * same as `ThreadSession.stop`'s own null, since the held thread already got `Not sent.`.
      */
     async stopChannel(channelId) {
-        let stopped = false;
-        let heldOnly = false;
-        for (const session of this.sessionsOf(channelId)) {
-            const result = await session.stop();
-            if (result)
-                stopped = true;
-            else if (result === null)
-                heldOnly = true;
-        }
+        // Together: a stop that closes a process takes seconds, and the sessions share nothing.
+        const results = await Promise.all(this.sessionsOf(channelId).map((session) => session.stop()));
+        const stopped = results.some((result) => result);
+        const heldOnly = results.some((result) => result === null);
         if (stopped)
             return true;
         return heldOnly ? null : false;

package/dist/core/sessions/quote.js

@@ -0,0 +1,57 @@
+/**
+ * A text quoted inside a reference, line by line. A line past `QUOTE_WIDTH` is
+ * wrapped first, after whitespace where there is some, else at a grapheme boundary, so that every
+ * piece carries its own quote mark: the chat splits a message past its limit at line breaks, and a
+ * line it had to cut itself would leave an unquoted chunk.
+ */
+/** The longest line of a quote, well under any chat's message limit. */
+export const QUOTE_WIDTH = 1000;
+// Segments lazily: a hard cut reads graphemes only up to the width, whatever the line's length.
+const graphemes = new Intl.Segmenter();
+/** Where a hard cut of `rest` falls: the last grapheme boundary within `width`, else the first. */
+function graphemeCut(rest, width) {
+    let end = 0;
+    for (const { segment } of graphemes.segment(rest)) {
+        if (end > 0 && end + segment.length > width)
+            break;
+        end += segment.length;
+    }
+    return end;
+}
+/**
+ * `line` cut into pieces of at most `width` characters, each cut after the last whitespace of a
+ * piece, which stays at the end of it so that the pieces joined give the line back. A piece with
+ * no whitespace is cut hard at a grapheme boundary, never inside a surrogate pair, a ZWJ sequence
+ * or a combining sequence (a single grapheme longer than `width` goes whole).
+ */
+export function wrapped(line, width) {
+    const pieces = [];
+    let rest = line;
+    while (rest.length > width) {
+        let end = 0;
+        for (let at = width - 1; at > 0; at -= 1) {
+            if (/\s/.test(rest.charAt(at))) {
+                end = at + 1;
+                break;
+            }
+        }
+        if (end === 0)
+            end = graphemeCut(rest, width);
+        pieces.push(rest.slice(0, end));
+        rest = rest.slice(end);
+    }
+    if (rest !== "" || pieces.length === 0)
+        pieces.push(rest);
+    return pieces;
+}
+/**
+ * `text` with each line, and each piece of a long one, escaped by `escaped` and marked `> `. The
+ * pieces are cut before they are escaped, so an escape is never split.
+ */
+export function quoted(text, escaped) {
+    return text
+        .split(/\r?\n/)
+        .flatMap((line) => wrapped(line, QUOTE_WIDTH))
+        .map((piece) => `> ${escaped(piece)}`.trimEnd())
+        .join("\n");
+}