allaboard 0.0.0-stage → 0.5.0

package/dist/log.js

@@ -0,0 +1,37 @@
+/**
+ * The daemon's log: lines on standard error, which the service writes to the log file. A line
+ * carries ids, counts and error names, never the text of a prompt or of a reply.
+ */
+const ORDER = ["DEBUG", "INFO", "WARNING", "ERROR"];
+let threshold = "INFO";
+let write = (line) => {
+    process.stderr.write(`${line}\n`);
+};
+/** The lowest level that is written; `INFO` until set. */
+export function setLevel(level) {
+    threshold = level;
+}
+/** Where the lines go, for a test that reads them; returns the writer it replaced. */
+export function setWriter(writer) {
+    const previous = write;
+    write = writer;
+    return previous;
+}
+function two(value) {
+    return String(value).padStart(2, "0");
+}
+/** `2026-10-10 09:05:03,042`, local time. */
+export function timestamp(at) {
+    const day = `${at.getFullYear()}-${two(at.getMonth() + 1)}-${two(at.getDate())}`;
+    const time = `${two(at.getHours())}:${two(at.getMinutes())}:${two(at.getSeconds())}`;
+    return `${day} ${time},${String(at.getMilliseconds()).padStart(3, "0")}`;
+}
+/** A logger whose lines read `<time> <LEVEL> <name>: <message>`. */
+export function getLogger(name) {
+    const at = (level) => (message) => {
+        if (ORDER.indexOf(level) < ORDER.indexOf(threshold))
+            return;
+        write(`${timestamp(new Date())} ${level} ${name}: ${message}`);
+    };
+    return { debug: at("DEBUG"), info: at("INFO"), warning: at("WARNING"), error: at("ERROR") };
+}

package/dist/main.js

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+/**
+ * `allaboard`: the file `bin` in `package.json` names, and the one the LaunchAgent runs. It checks
+ * the Node, then loads the daemon (`daemon.ts`).
+ *
+ * It has no static import, and the modules it loads before it knows the Node is new enough
+ * (`node-version.ts`, `version.ts`, `log.ts`) name `node:fs` and each other only. An ES module
+ * graph is linked whole before any module runs: a named import that an old Node lacks, such as
+ * `parseEnv` of `node:util` on Node 18, would end the process with a `SyntaxError` at link time,
+ * before a guard anywhere in the graph could run (measured on 2026-10-17, Node 18.19.0). The
+ * daemon's own graph is loaded only after the check. `test/node-version.test.ts` holds both
+ * rules.
+ *
+ * The file is the process's entry whenever it loads, a symlink in `node_modules/.bin` included, so
+ * nothing here depends on `import.meta.main`, which an older Node lacks (it is `@since v22.18.0`).
+ */
+const { nodeRefusal } = await import("./node-version.js");
+const refusal = nodeRefusal(process.versions.node);
+if (refusal === null) {
+    const { start } = await import("./daemon.js");
+    await start();
+}
+else {
+    const { getLogger } = await import("./log.js");
+    getLogger("allaboard.main").error(refusal);
+    // A status, not `process.exit`: a write to a pipe can still be pending on macOS.
+    process.exitCode = 1;
+}
+export {};

package/dist/node-version.js

@@ -0,0 +1,40 @@
+/**
+ * The oldest Node that runs allaboard, and the sentence that refuses an older one. The entry reads
+ * it before it loads the daemon (`main.ts`). `test/node-version.test.ts` holds `MINIMUM_NODE` to
+ * `engines.node` in `package.json`. This file and what it imports are loaded on every Node, so
+ * they name `node:fs` and each other only.
+ */
+import { SETUP_SECTIONS, setupGuide } from "./version.js";
+// The floor `undici` 8 declares (`engines.node`). No Node API the source uses is newer than Node
+// 20.12 (`util.parseEnv`); the dependencies set it. `@slack/socket-mode` takes `undici` 7 or 8 as a
+// peer, and the lockfile, which the tests run, holds 8. On a lower Node 22 whether npm installs 7
+// or 8 depends on the user's npm (measured on 2026-10-17: npm 10.5.1 installs 8, which fails to
+// load on 22.0.0), so the floor follows the version the tests run, not one npm happens to pick.
+export const MINIMUM_NODE = "22.19.0";
+/** `major.minor.patch` as three numbers; null for a text that does not start with them. */
+function parts(version) {
+    const match = /^(\d+)\.(\d+)\.(\d+)/.exec(version);
+    if (match === null)
+        return null;
+    return [Number(match[1]), Number(match[2]), Number(match[3])];
+}
+/**
+ * The refusal for a Node whose `process.versions.node` is `found`, or null when it is at least
+ * `MINIMUM_NODE`. Compared number by number (22.9.0 is below 22.19.0); a pre-release suffix is
+ * ignored, and a text that holds no version is not refused, since nothing says it is too old.
+ */
+export function nodeRefusal(found) {
+    const have = parts(found);
+    const need = parts(MINIMUM_NODE);
+    if (have === null)
+        return null;
+    for (const [index, wanted] of need.entries()) {
+        const actual = have[index];
+        if (actual > wanted)
+            return null;
+        if (actual < wanted) {
+            return `allaboard needs Node ${MINIMUM_NODE} or later and this is Node ${found}; to run it on a newer Node without changing this one, see ${setupGuide(SETUP_SECTIONS.nodeOfItsOwn)}`;
+        }
+    }
+    return null;
+}

package/dist/registry.js

@@ -0,0 +1,12 @@
+/**
+ * The agents and the chats the daemon can run, by the name `ALLABOARD_AGENT` and `ALLABOARD_CHAT`
+ * select them with. The one file outside the two modules that names them: `main` takes each
+ * module from here, and a test passes its own registry through `run`'s options.
+ */
+import { claudeAgent } from "./agent/claude/module.js";
+import { slackChat } from "./chat/slack/module.js";
+export const REGISTRY = {
+    agents: { claude: claudeAgent() },
+    chats: { slack: slackChat() },
+    defaults: { agent: "claude", chat: "slack" },
+};

package/dist/semver.js

@@ -0,0 +1,53 @@
+/**
+ * Semantic Versioning 2.0.0 as npm publishes it: whether a text is a version, and which of two
+ * versions is newer. Any layer may import this file: the host asks npm for versions and the core
+ * decides whether one is newer than the one that runs.
+ */
+// Semantic Versioning 2.0.0 without build metadata (`+...`), which npm drops anyway. A match
+// starts with a digit, so npm can never read it as an option, and holds no space or quote.
+const VERSION = /^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-(?:0|[1-9]\d*|\d*[A-Za-z-][0-9A-Za-z-]*)(?:\.(?:0|[1-9]\d*|\d*[A-Za-z-][0-9A-Za-z-]*))*)?$/;
+/** Whether `text` is a version number as npm publishes one: `0.2.0`, `1.0.0-rc.1`. */
+export function isVersion(text) {
+    return VERSION.test(text);
+}
+/** Semantic Versioning 2.0.0, rule 11: the order of two pre-release identifiers. */
+function identifierOrder(a, b) {
+    const numbers = [/^\d+$/.test(a), /^\d+$/.test(b)];
+    if (numbers[0] && numbers[1])
+        return Math.sign(Number(a) - Number(b));
+    // A numeric identifier is lower than an alphanumeric one.
+    if (numbers[0] !== numbers[1])
+        return numbers[0] ? -1 : 1;
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+/**
+ * Whether `candidate` takes precedence over `current` by Semantic Versioning 2.0.0, rule 11. A
+ * string that is no version is never newer, and nothing is newer than it.
+ */
+export function isNewer(candidate, current) {
+    if (!isVersion(candidate) || !isVersion(current))
+        return false;
+    const [cores, pres] = [candidate, current].map((text) => {
+        // The first hyphen ends the numbers; a pre-release may hold more of them.
+        const dash = text.indexOf("-");
+        const core = dash === -1 ? text : text.slice(0, dash);
+        return {
+            numbers: core.split(".").map(Number),
+            pre: dash === -1 ? null : text.slice(dash + 1).split("."),
+        };
+    });
+    for (let index = 0; index < 3; index += 1) {
+        const difference = cores.numbers[index] - pres.numbers[index];
+        if (difference !== 0)
+            return difference > 0;
+    }
+    // A release is newer than any pre-release of the same numbers.
+    if (cores.pre === null || pres.pre === null)
+        return cores.pre === null && pres.pre !== null;
+    for (let index = 0; index < Math.min(cores.pre.length, pres.pre.length); index += 1) {
+        const order = identifierOrder(cores.pre[index], pres.pre[index]);
+        if (order !== 0)
+            return order > 0;
+    }
+    return cores.pre.length > pres.pre.length;
+}

package/dist/text.js

@@ -0,0 +1,89 @@
+/**
+ * Strings the way Python's `str` treats them, where JavaScript's `String` differs: what counts
+ * as whitespace, and the order of two strings, and the quoting of a word for a shell. The texts the daemon cuts and sorts come out as
+ * Python cut and sorted them, and the goldens hold those results. Any layer imports this.
+ */
+// What Python's `str.split()`, `str.strip()` and `\s` take for whitespace (`str.isspace`), as
+// ranges of code points: JavaScript's `\s` lacks U+001C to U+001F and U+0085, and adds U+FEFF.
+const SPACE_RANGES = [
+    [0x09, 0x0d],
+    [0x1c, 0x20],
+    [0x85, 0x85],
+    [0xa0, 0xa0],
+    [0x1680, 0x1680],
+    [0x2000, 0x200a],
+    [0x2028, 0x2029],
+    [0x202f, 0x202f],
+    [0x205f, 0x205f],
+    [0x3000, 0x3000],
+];
+/** The UTF-16 unit `code` as it is written in a pattern built from codes. */
+export function escaped(code) {
+    return `\\u${code.toString(16).padStart(4, "0")}`;
+}
+/** The body of a regular expression class that matches Python's whitespace: `[${PY_SPACE}]`. */
+export const PY_SPACE = SPACE_RANGES.map(([first, last]) => first === last ? escaped(first) : `${escaped(first)}-${escaped(last)}`).join("");
+/** Whether the UTF-16 unit `code` is whitespace to Python: every such character is one unit. */
+export function isSpace(code) {
+    return SPACE_RANGES.some(([first, last]) => code >= first && code <= last);
+}
+/**
+ * Python's `text.strip()`. Read by code from each end: a pattern that ends on `$` would start
+ * again from every run of spaces, which is quadratic on a long text.
+ */
+export function strip(text) {
+    let start = 0;
+    let end = text.length;
+    while (start < end && isSpace(text.charCodeAt(start)))
+        start += 1;
+    while (end > start && isSpace(text.charCodeAt(end - 1)))
+        end -= 1;
+    return text.slice(start, end);
+}
+/** Whether `text` holds nothing but whitespace: Python's `not text.strip()`. */
+export function blank(text) {
+    for (let i = 0; i < text.length; i += 1) {
+        if (!isSpace(text.charCodeAt(i)))
+            return false;
+    }
+    return true;
+}
+/** Python's `sorted` on strings: by code point, where `Array.prototype.sort` goes by UTF-16 unit. */
+export function compareCodePoints(a, b) {
+    const left = Array.from(a);
+    const right = Array.from(b);
+    for (let i = 0; i < Math.min(left.length, right.length); i += 1) {
+        const x = left[i];
+        const y = right[i];
+        if (x !== y)
+            return x.codePointAt(0) - y.codePointAt(0);
+    }
+    return left.length - right.length;
+}
+/** Whether the UTF-16 unit `code` opens a surrogate pair. */
+export function isHigh(code) {
+    return code >= 0xd800 && code <= 0xdbff;
+}
+/** Whether the UTF-16 unit `code` closes a surrogate pair. */
+export function isLow(code) {
+    return code >= 0xdc00 && code <= 0xdfff;
+}
+/** Python's `len(text)`: the code points of a text. */
+export function len(text) {
+    let count = text.length;
+    for (let i = 0; i < text.length - 1; i += 1) {
+        if (isHigh(text.charCodeAt(i)) && isLow(text.charCodeAt(i + 1))) {
+            count -= 1;
+            i += 1;
+        }
+    }
+    return count;
+}
+/** `shlex.quote`: the word as one shell argument, quoted only when it needs to be. */
+export function shellQuote(word) {
+    if (word === "")
+        return "''";
+    if (/^[A-Za-z0-9_@%+=:,./-]+$/.test(word))
+        return word;
+    return `'${word.replaceAll("'", "'\"'\"'")}'`;
+}

package/dist/updates-host.js

@@ -0,0 +1,113 @@
+/**
+ * The machine as the core's update sees it (`UpdatesHost`, issue #361): the daemon's adapter from
+ * the host layer (npm, the service manager, the update lock) to the questions the core asks. One
+ * of the entry files above the layers, since it imports both sides.
+ */
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { machineHost } from "./cli.js";
+import { UpdateUnderWay, updateHeld, updateLock } from "./core/lock.js";
+import { installVersion, latestVersion, updatableCopy } from "./host/npm.js";
+import { programOf } from "./host/program.js";
+import { runAsync } from "./host/run.js";
+import { logPath } from "./host/service/launchd.js";
+import { loadedOn } from "./host/service/listing.js";
+import { getLogger } from "./log.js";
+import { errorCode, errorName } from "./values.js";
+import { changelogOf, packageVersion } from "./version.js";
+export const logger = getLogger("allaboard.updates-host");
+/** The machine allaboard runs on. The entry is read when asked: a test never reaches it. */
+export function realMachine() {
+    return {
+        run: runAsync,
+        entry: () => programOf(process.argv[1] ?? "", process.env.PATH ?? "", process.execPath).main,
+        service: (name) => machineHost.service({ name }),
+    };
+}
+/** `UpdatesHost` over `options.machine`. */
+export function updatesHost(options) {
+    const { machine, instance, home, installed } = options;
+    const manager = machine.service(instance.name);
+    let supervisor = null;
+    /** The other loaded instances on `copy`. */
+    const othersOn = (copy) => {
+        const listing = manager?.instances();
+        if (listing === undefined || "failure" in listing)
+            return [];
+        return loadedOn(listing.rows, copy).filter((row) => row.instance !== instance.name);
+    };
+    return {
+        installed,
+        logFile: logPath(home, instance.name),
+        latest: (signal) => latestVersion(machine.run, signal),
+        async updatable(signal) {
+            // While another process's `npm install -g` replaces the folder, the entry file is not
+            // there (npm moves the old folder away and fills a new one): that is no answer about the
+            // copy, and the host does not guess one.
+            let main;
+            try {
+                main = machine.entry();
+            }
+            catch (error) {
+                if (errorCode(error) === "ENOENT")
+                    return { swapping: true };
+                throw error;
+            }
+            if (!existsSync(main))
+                return { swapping: true };
+            return updatableCopy(machine.run, main, installed, signal);
+        },
+        copyVersion: (copy) => packageVersion(join(copy, "package.json")),
+        // A system with no service manager has nothing that starts the daemon again.
+        supervised() {
+            if (manager === null)
+                return false;
+            // Which process started this one cannot change while it lives, so a pid the manager reports
+            // settles it for good; the pages ask on every redraw, and the question is a blocking
+            // `launchctl list`. No pid is no answer: "not running" and "could not ask" look alike.
+            if (supervisor === null) {
+                const pid = manager.runningPid();
+                if (pid === null)
+                    return false;
+                supervisor = pid === process.pid;
+            }
+            return supervisor;
+        },
+        sharing: (copy) => othersOn(copy).map((row) => row.instance),
+        async lock() {
+            try {
+                return await updateLock(home);
+            }
+            catch (error) {
+                if (error instanceof UpdateUnderWay)
+                    return null;
+                throw error;
+            }
+        },
+        async updateHeld() {
+            try {
+                return await updateHeld(home);
+            }
+            catch (error) {
+                // Not an update under way: a daemon the system cannot answer for would otherwise start
+                // nothing at all.
+                logger.warning(`could not tell whether an update is under way: ${errorName(error)}`);
+                return false;
+            }
+        },
+        install: (copy, version, signal) => installVersion(machine.run, copy, version, signal),
+        async restartOthers(copy) {
+            const failed = [];
+            for (const row of othersOn(copy).filter((other) => other.pid !== null)) {
+                const report = machine.service(row.instance)?.restart();
+                if (report === undefined || report.code !== 0) {
+                    logger.warning(`could not restart instance ${row.instance ?? "(default)"}: ${report?.err.join(" ") ?? "no service manager"}`);
+                    failed.push({ instance: row.instance, status: report?.code ?? null });
+                }
+            }
+            return failed;
+        },
+        restart: options.restart,
+        changelog: changelogOf,
+    };
+}

package/dist/values.js

@@ -0,0 +1,30 @@
+/**
+ * Values nobody typed: what a parser returned and what a `catch` caught. Read by what they are
+ * at run time, never by a cast. Any layer imports this.
+ */
+/** Whether `value` is a JSON object: not null, not an array. */
+export function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** The JSON objects of a list; none for anything that is no list. */
+export function records(value) {
+    return Array.isArray(value) ? value.filter(isRecord) : [];
+}
+/** The errno code of a system error (`ENOENT`, `EACCES`); undefined for anything else. */
+export function errorCode(error) {
+    return error instanceof Error &&
+        "code" in error &&
+        typeof error.code === "string" &&
+        error.code !== ""
+        ? error.code
+        : undefined;
+}
+/**
+ * The name of a failure, all a log line or a reply may say of it, never its words: the code of
+ * a system error (`EACCES`), else the name the error gives itself (a `ChatError` is named by
+ * the chat's code). Never its class: a bundled library's is a minified name that changes with
+ * each release, so the daemon's own error classes set `name`.
+ */
+export function errorName(error) {
+    return error instanceof Error ? (errorCode(error) ?? error.name) : typeof error;
+}

package/dist/version.js

@@ -0,0 +1,54 @@
+/**
+ * The version of allaboard that runs, and the address of its setup guide. The version is the
+ * `version` of the package's own `package.json`, which sits one level above this file both in the
+ * sources (`src/`) and in the installed package (`dist/`), so a run from a checkout reads the
+ * checkout's and an installed copy its own. Any layer may import this file: a text that sends the
+ * owner to the guide names the page of the version that runs, since the package no longer carries
+ * `docs/`.
+ */
+import { readFileSync } from "node:fs";
+const REPOSITORY = "https://github.com/duqaXxX/allaboard";
+/**
+ * The sections of `docs/setup.md` a text of the core sends the owner to, by their anchor on
+ * GitHub; a module keeps the anchors of its own sections. `test/version.test.ts` holds each to a
+ * heading of the page.
+ */
+export const SETUP_SECTIONS = {
+    nodeOfItsOwn: "a-node-of-its-own",
+    configuration: "part-2-configuration",
+    protectedFolders: "folders-macos-protects",
+};
+let version = null;
+/**
+ * The `version` of the package whose `package.json` is `manifest`, or null when it cannot be read
+ * or has none. It names `node:fs` alone: this file is loaded before the Node is known to be new
+ * enough (`main.ts`).
+ */
+export function packageVersion(manifest) {
+    try {
+        const parsed = JSON.parse(readFileSync(manifest, "utf8"));
+        const found = typeof parsed === "object" && parsed !== null && "version" in parsed ? parsed.version : null;
+        return typeof found === "string" && found !== "" ? found : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** The `version` field of the package's `package.json`; throws when the file has none. */
+export function installedVersion() {
+    if (version !== null)
+        return version;
+    const found = packageVersion(new URL("../package.json", import.meta.url));
+    if (found === null)
+        throw new Error("package.json has no version");
+    version = found;
+    return version;
+}
+/** The address of the changelog as published with `version`: what that version changed. */
+export function changelogOf(version) {
+    return `${REPOSITORY}/blob/v${version}/docs/CHANGELOG.md`;
+}
+/** The address of `section` of the setup guide, as published with the version that runs. */
+export function setupGuide(section) {
+    return `${REPOSITORY}/blob/v${installedVersion()}/docs/setup.md#${section}`;
+}

package/package.json

@@ -1,6 +1,34 @@
 {
   "name": "allaboard",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.5.0",
+  "description": "Your Claude Code workspace in Slack: one channel per project, one thread per session, running on your own Mac.",
+  "keywords": [
+    "slack",
+    "coding-agent",
+    "claude-code",
+    "agent-sdk",
+    "remote",
+    "daemon"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/duqaXxX/allaboard.git"
+  },
+  "type": "module",
+  "bin": {
+    "allaboard": "dist/main.js"
+  },
+  "engines": {
+    "node": ">=22.19.0"
+  },
+  "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "0.3.302",
+    "@slack/bolt": "5.1.0",
+    "@slack/web-api": "8.2.0"
+  },
+  "files": [
+    "dist",
+    "slack-app-manifest.json"
+  ]
+}

package/slack-app-manifest.json

@@ -0,0 +1,50 @@
+{
+  "display_information": {
+    "name": "allaboard",
+    "description": "Drive the coding-agent sessions on your own computer from private Slack channels.",
+    "background_color": "#1f2328"
+  },
+  "features": {
+    "app_home": {
+      "home_tab_enabled": true,
+      "messages_tab_enabled": true,
+      "messages_tab_read_only_enabled": true
+    },
+    "bot_user": {
+      "display_name": "allaboard",
+      "always_online": true
+    }
+  },
+  "oauth_config": {
+    "scopes": {
+      "bot": [
+        "groups:history",
+        "groups:read",
+        "chat:write",
+        "files:read",
+        "files:write",
+        "reactions:write"
+      ],
+      "user": [
+        "chat:write"
+      ]
+    },
+    "pkce_enabled": false
+  },
+  "settings": {
+    "event_subscriptions": {
+      "bot_events": [
+        "message.groups",
+        "file_change"
+      ]
+    },
+    "interactivity": {
+      "is_enabled": true
+    },
+    "org_deploy_enabled": false,
+    "socket_mode_enabled": true,
+    "token_rotation_enabled": false,
+    "app_level_token_rotation_enabled": false,
+    "is_mcp_enabled": false
+  }
+}