agent-andon 0.1.0

package/dist/cli.js

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Agent Andon CLI — one binary, many verbs.
+ *
+ *   andon serve [--demo] [--port N] [--token T]   run the board
+ *   andon hook                                     Claude Code hook (stdin)
+ *   andon notify <json>                            Codex notify (argv)
+ *   andon post <state> <agent> [title] [message]   manual / wrapper push
+ *   andon install <claude|codex> [--dry-run]       auto-wire the hooks
+ *   andon doctor                                   check what's wired
+ *   andon help
+ *
+ * `hook` and `notify` MUST never block or crash the agent: they always exit 0.
+ */
+const serve_1 = require("./commands/serve");
+const hook_1 = require("./commands/hook");
+const notify_1 = require("./commands/notify");
+const post_1 = require("./commands/post");
+const install_1 = require("./commands/install");
+const doctor_1 = require("./commands/doctor");
+const HELP = `
+  🚦 Agent Andon — a traffic-light board for your AI coding agents
+
+  Usage:
+    andon serve [--demo] [--port N] [--host H] [--token T]
+        Run the status board. Open the printed URL on your iPad.
+        --demo   inject fake agents so you can verify the board first.
+
+    andon install claude        Wire Claude Code hooks (backs up settings.json)
+    andon install codex         Wire the Codex notify hook
+    andon doctor                Check server + what's wired, print the iPad URL
+
+    andon post <state> <agent> [title] [message]
+        Push a status by hand.  state: working|waiting|done|error|idle|gone
+        e.g.  andon post done claude "api" "shipped it"
+
+    andon hook                  (internal) Claude Code hook — reads stdin
+    andon notify <json>         (internal) Codex notifier — reads argv
+
+  Env:
+    AGENT_STATUS_URL   server base (default http://127.0.0.1:8787)
+    ANDON_TOKEN        shared token; required by /state and /event when set
+    ANDON_LABEL        per-terminal tile title
+    ANDON_SESSION      per-launch session id (set by the codex wrapper)
+
+  Quickstart:
+    andon serve --demo          # verify on the iPad, then Ctrl-C
+    andon serve                 # run for real
+    andon install claude        # wire it up, restart your Claude session
+`;
+async function main() {
+    const [cmd, ...rest] = process.argv.slice(2);
+    switch (cmd) {
+        case "serve":
+            (0, serve_1.serve)(rest);
+            return; // long-running; never returns
+        case "hook":
+            // Always exit 0 no matter what — see module docstring.
+            try {
+                await (0, hook_1.hook)();
+            }
+            catch {
+                /* swallow */
+            }
+            process.exit(0);
+            return;
+        case "notify":
+            try {
+                await (0, notify_1.notify)(rest[0]);
+            }
+            catch {
+                /* swallow */
+            }
+            process.exit(0);
+            return;
+        case "post":
+            process.exit(await (0, post_1.post)(rest));
+            return;
+        case "install":
+            process.exit((0, install_1.install)(rest));
+            return;
+        case "doctor":
+            process.exit(await (0, doctor_1.doctor)());
+            return;
+        case "help":
+        case "--help":
+        case "-h":
+        case undefined:
+            console.log(HELP);
+            process.exit(cmd ? 0 : 1);
+            return;
+        default:
+            console.error(`unknown command: ${cmd}\n${HELP}`);
+            process.exit(2);
+    }
+}
+void main();

package/dist/client.d.ts

@@ -0,0 +1,7 @@
+import type { AndonEvent } from "./types";
+export interface PostResult {
+    ok: boolean;
+    status?: number;
+    error?: string;
+}
+export declare function postEvent(ev: AndonEvent, timeoutMs?: number): Promise<PostResult>;

package/dist/client.js

@@ -0,0 +1,92 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.postEvent = postEvent;
+/**
+ * The one and only status poster. Hooks, the Codex notifier and the manual
+ * `post` command all funnel through here — no more copy-pasted request code.
+ *
+ * Contract for callers in a hook path: this NEVER throws and NEVER blocks for
+ * long. A missing server, refused connection or timeout all resolve to `false`
+ * so the calling hook can exit 0 without ever stalling the agent.
+ */
+const http = __importStar(require("http"));
+const https = __importStar(require("https"));
+const url_1 = require("url");
+const net_1 = require("./net");
+function postEvent(ev, timeoutMs = 1500) {
+    return new Promise((resolve) => {
+        let settled = false;
+        const finish = (r) => {
+            if (!settled) {
+                settled = true;
+                resolve(r);
+            }
+        };
+        try {
+            const token = process.env.ANDON_TOKEN;
+            const u = new url_1.URL((0, net_1.serverBase)() + "/event");
+            const body = Buffer.from(JSON.stringify(ev), "utf8");
+            const lib = u.protocol === "https:" ? https : http;
+            const headers = {
+                "Content-Type": "application/json",
+                "Content-Length": body.length,
+            };
+            // Send the token as a header, not a query param — keeps it out of URLs/logs.
+            if (token)
+                headers["x-andon-token"] = token;
+            const req = lib.request({
+                hostname: u.hostname,
+                port: u.port || (u.protocol === "https:" ? 443 : 80),
+                path: u.pathname + u.search,
+                method: "POST",
+                headers,
+            }, (res) => {
+                res.resume(); // drain
+                res.on("end", () => finish({ ok: (res.statusCode ?? 0) < 400, status: res.statusCode }));
+            });
+            req.on("error", (e) => finish({ ok: false, error: String(e?.message ?? e) }));
+            req.setTimeout(timeoutMs, () => {
+                req.destroy();
+                finish({ ok: false, error: "timeout" });
+            });
+            req.write(body);
+            req.end();
+        }
+        catch (e) {
+            finish({ ok: false, error: String(e?.message ?? e) });
+        }
+    });
+}

package/dist/commands/doctor.d.ts

@@ -0,0 +1 @@
+export declare function doctor(): Promise<number>;

package/dist/commands/doctor.js

@@ -0,0 +1,107 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.doctor = doctor;
+/** `andon doctor` — quick "is everything wired?" check. */
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const http = __importStar(require("http"));
+const net_1 = require("../net");
+function getJson(url, timeoutMs = 1200) {
+    return new Promise((resolve, reject) => {
+        const req = http.get(url, (res) => {
+            let body = "";
+            res.on("data", (c) => (body += c));
+            res.on("end", () => {
+                try {
+                    resolve(JSON.parse(body));
+                }
+                catch (e) {
+                    reject(e);
+                }
+            });
+        });
+        req.on("error", reject);
+        req.setTimeout(timeoutMs, () => {
+            req.destroy();
+            reject(new Error("timeout"));
+        });
+    });
+}
+async function doctor() {
+    const base = (0, net_1.serverBase)();
+    console.log("\n  Agent Andon — doctor\n  ─────────────────────");
+    // 1. server reachable?
+    let serverOk = false;
+    try {
+        const h = (await getJson(`${base}/healthz`));
+        serverOk = !!h.ok;
+        console.log(`  ✓ server up at ${base}  (${h.sessions ?? 0} session(s))`);
+        const m = base.match(/:(\d+)/);
+        const port = m ? m[1] : "8787";
+        console.log(`  → iPad: http://${(0, net_1.lanIp)()}:${port}`);
+    }
+    catch {
+        console.log(`  ✗ server NOT reachable at ${base}`);
+        console.log("    start it with:  andon serve");
+    }
+    // 2. claude wired?
+    const claudeCfg = path.join(os.homedir(), ".claude", "settings.json");
+    if (fs.existsSync(claudeCfg)) {
+        const txt = fs.readFileSync(claudeCfg, "utf8");
+        const wired = txt.includes("cli.js") && txt.includes("hook");
+        console.log(wired
+            ? "  ✓ Claude Code hooks wired"
+            : "  ○ Claude Code not wired — run:  andon install claude");
+    }
+    else {
+        console.log("  ○ no ~/.claude/settings.json — run:  andon install claude");
+    }
+    // 3. codex wired?
+    const codexCfg = path.join(os.homedir(), ".codex", "config.toml");
+    if (fs.existsSync(codexCfg)) {
+        const txt = fs.readFileSync(codexCfg, "utf8");
+        const wired = /notify\s*=.*cli\.js/.test(txt);
+        console.log(wired
+            ? "  ✓ Codex notify wired"
+            : "  ○ Codex notify not wired — run:  andon install codex");
+    }
+    else {
+        console.log("  ○ no ~/.codex/config.toml — run:  andon install codex (if you use Codex)");
+    }
+    console.log("");
+    return serverOk ? 0 : 1;
+}

package/dist/commands/hook.d.ts

@@ -0,0 +1,7 @@
+import type { AndonEvent } from "../types";
+/**
+ * Pure mapping from a Claude Code hook payload to a board event (no I/O).
+ * Returns null for events we don't track. Exported for testing.
+ */
+export declare function mapClaudeEvent(data: Record<string, unknown>): AndonEvent | null;
+export declare function hook(): Promise<void>;

package/dist/commands/hook.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapClaudeEvent = mapClaudeEvent;
+exports.hook = hook;
+/**
+ * `andon hook` — the Claude Code hook. Reads the hook JSON on stdin, maps the
+ * event to a board state, posts it. Wired to 5 events (see `andon install`):
+ *
+ *   UserPromptSubmit -> working   you just submitted, the agent is off
+ *   Notification     -> waiting   needs permission / your input
+ *   Stop             -> done      this turn finished
+ *   StopFailure      -> error     this turn failed (newer Claude Code only)
+ *   SessionEnd       -> gone      session ended, drop the tile
+ *
+ * Discipline: print nothing to stdout (UserPromptSubmit stdout is fed to the
+ * model as context), swallow every error, and let the caller always exit 0.
+ */
+const client_1 = require("../client");
+const shared_1 = require("./shared");
+const EVENT_TO_STATE = {
+    UserPromptSubmit: "working",
+    Notification: "waiting",
+    Stop: "done",
+    StopFailure: "error",
+    SessionEnd: "gone",
+};
+function readStdin() {
+    return new Promise((resolve) => {
+        let data = "";
+        let resolved = false;
+        const done = () => {
+            if (!resolved) {
+                resolved = true;
+                resolve(data);
+            }
+        };
+        if (process.stdin.isTTY)
+            return done(); // no piped input
+        process.stdin.setEncoding("utf8");
+        process.stdin.on("data", (c) => (data += c));
+        process.stdin.on("end", done);
+        process.stdin.on("error", done);
+        setTimeout(done, 800).unref(); // never hang the hook
+    });
+}
+const shorten = (t, n = 140) => String(t ?? "").split(/\s+/).join(" ").trim().slice(0, n);
+/**
+ * Pure mapping from a Claude Code hook payload to a board event (no I/O).
+ * Returns null for events we don't track. Exported for testing.
+ */
+function mapClaudeEvent(data) {
+    const evName = String(data.hook_event_name ?? "");
+    const state = EVENT_TO_STATE[evName];
+    if (!state)
+        return null; // unknown event: quietly do nothing
+    const cwd = String(data.cwd ?? process.cwd());
+    const id = String(data.session_id ?? "claude");
+    let message = "";
+    if (evName === "Notification")
+        message = shorten(data.message);
+    else if (evName === "Stop" || evName === "StopFailure")
+        message = shorten(data.last_assistant_message);
+    return { agent: "claude", id, state, title: (0, shared_1.labelFor)(cwd, "claude"), message };
+}
+async function hook() {
+    let data = {};
+    try {
+        data = JSON.parse((await readStdin()) || "{}");
+    }
+    catch {
+        data = {};
+    }
+    const ev = mapClaudeEvent(data);
+    if (ev)
+        await (0, client_1.postEvent)(ev);
+}

package/dist/commands/install.d.ts

@@ -0,0 +1 @@
+export declare function install(args: string[]): number;

package/dist/commands/install.js

@@ -0,0 +1,146 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.install = install;
+/**
+ * `andon install claude|codex [--dry-run]`
+ *
+ * Auto-wires the hooks so nobody hand-edits config paths (the exact thing that
+ * trips people up). Always backs up the original file first.
+ */
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+/** Absolute `node /abs/dist/cli.js` invocation — works regardless of PATH. */
+function andonCommand(sub) {
+    const cli = path.join(__dirname, "..", "cli.js");
+    return `"${process.execPath}" "${cli}" ${sub}`;
+}
+function backup(file) {
+    if (!fs.existsSync(file))
+        return null;
+    const bak = `${file}.andon-backup`;
+    fs.copyFileSync(file, bak);
+    return bak;
+}
+const CLAUDE_EVENTS = [
+    "UserPromptSubmit",
+    "Notification",
+    "Stop",
+    "StopFailure",
+    "SessionEnd",
+];
+function installClaude(dryRun) {
+    const file = path.join(os.homedir(), ".claude", "settings.json");
+    const cmd = andonCommand("hook");
+    let settings = {};
+    if (fs.existsSync(file)) {
+        try {
+            settings = JSON.parse(fs.readFileSync(file, "utf8") || "{}");
+        }
+        catch {
+            console.error(`✗ ${file} is not valid JSON — fix or move it, then retry.`);
+            return 1;
+        }
+    }
+    const hooks = (settings.hooks ??= {});
+    let added = 0;
+    for (const ev of CLAUDE_EVENTS) {
+        const groups = (hooks[ev] ??= []);
+        const already = groups.some((g) => (g.hooks ?? []).some((h) => h.command?.includes("cli.js") && h.command?.includes("hook")));
+        if (!already) {
+            groups.push({ hooks: [{ type: "command", command: cmd }] });
+            added++;
+        }
+    }
+    if (dryRun) {
+        console.log(`[dry-run] would write ${file}:\n`);
+        console.log(JSON.stringify(settings, null, 2));
+        return 0;
+    }
+    if (added === 0) {
+        console.log("✓ Claude Code is already wired to Andon. Nothing to do.");
+        return 0;
+    }
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const bak = backup(file);
+    fs.writeFileSync(file, JSON.stringify(settings, null, 2) + "\n");
+    console.log(`✓ Wired ${added} Claude Code event(s) into ${file}`);
+    if (bak)
+        console.log(`  backup: ${bak}`);
+    console.log("\n  → Start a new Claude Code session and it lights up the board.");
+    return 0;
+}
+function installCodex(dryRun) {
+    const file = path.join(os.homedir(), ".codex", "config.toml");
+    const cli = path.join(__dirname, "..", "cli.js");
+    const line = `notify = ["${process.execPath}", "${cli}", "notify"]`;
+    let body = "";
+    if (fs.existsSync(file))
+        body = fs.readFileSync(file, "utf8");
+    if (/^\s*notify\s*=/m.test(body)) {
+        console.log("ℹ A `notify = …` line already exists in ~/.codex/config.toml.");
+        console.log("  Leaving it untouched. To use Andon, set it to:");
+        console.log(`    ${line}`);
+        return 0;
+    }
+    // The notify key must sit ABOVE any [table] or TOML parses it into that table.
+    const next = `${line}\n${body.startsWith("\n") ? "" : "\n"}${body}`;
+    if (dryRun) {
+        console.log(`[dry-run] would prepend to ${file}:\n`);
+        console.log(line);
+        return 0;
+    }
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const bak = backup(file);
+    fs.writeFileSync(file, next);
+    console.log(`✓ Added Codex notify hook to ${file}`);
+    if (bak)
+        console.log(`  backup: ${bak}`);
+    console.log("\n  That gives you the green 'done' signal each turn.\n" +
+        "  For the blue 'working' signal too, source the wrapper:\n" +
+        "    examples/codex-wrapper.sh  (see README → Codex)\n");
+    return 0;
+}
+function install(args) {
+    const dryRun = args.includes("--dry-run");
+    const target = args.find((a) => !a.startsWith("--"));
+    if (target === "claude")
+        return installClaude(dryRun);
+    if (target === "codex")
+        return installCodex(dryRun);
+    console.error("usage: andon install <claude|codex> [--dry-run]");
+    return 2;
+}

package/dist/commands/notify.d.ts

@@ -0,0 +1,7 @@
+import type { AndonEvent } from "../types";
+/**
+ * Pure mapping from a Codex notify payload to a board event (no I/O).
+ * Returns null for anything other than agent-turn-complete. Exported for testing.
+ */
+export declare function mapCodexEvent(payloadArg: string | undefined): AndonEvent | null;
+export declare function notify(payloadArg: string | undefined): Promise<void>;

package/dist/commands/notify.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapCodexEvent = mapCodexEvent;
+exports.notify = notify;
+/**
+ * `andon notify` — the Codex CLI notifier. Codex passes its event as a single
+ * JSON string argument (not stdin). Today Codex only emits
+ * `agent-turn-complete`, so this maps that to "done".
+ *
+ * Field names are read tolerantly (both `last-assistant-message` and
+ * `last_assistant_message`, etc.) because Codex's notify schema has used
+ * hyphenated keys and may vary by version — the prototype assumed one spelling
+ * and would silently miss the message otherwise.
+ */
+const client_1 = require("../client");
+const shared_1 = require("./shared");
+const pick = (o, ...keys) => {
+    for (const k of keys)
+        if (o[k] != null)
+            return o[k];
+    return undefined;
+};
+/**
+ * Pure mapping from a Codex notify payload to a board event (no I/O).
+ * Returns null for anything other than agent-turn-complete. Exported for testing.
+ */
+function mapCodexEvent(payloadArg) {
+    if (!payloadArg)
+        return null;
+    let data;
+    try {
+        data = JSON.parse(payloadArg);
+    }
+    catch {
+        return null;
+    }
+    const type = String(pick(data, "type") ?? "");
+    if (type !== "agent-turn-complete")
+        return null; // only event Codex sends today
+    const cwd = String(pick(data, "cwd") ?? process.cwd());
+    const id = process.env.ANDON_SESSION ||
+        pick(data, "thread-id", "thread_id", "turn-id") ||
+        (0, shared_1.sessionId)("codex", cwd);
+    const message = String(pick(data, "last-assistant-message", "last_assistant_message", "message") ?? "")
+        .split(/\s+/)
+        .join(" ")
+        .trim()
+        .slice(0, 200);
+    return { agent: "codex", id, state: "done", title: (0, shared_1.labelFor)(cwd, "codex"), message };
+}
+async function notify(payloadArg) {
+    const ev = mapCodexEvent(payloadArg);
+    if (ev)
+        await (0, client_1.postEvent)(ev);
+}

package/dist/commands/post.d.ts

@@ -0,0 +1 @@
+export declare function post(args: string[]): Promise<number>;

package/dist/commands/post.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.post = post;
+/**
+ * `andon post <state> <agent> [title] [message]` — manual / wrapper pusher.
+ *
+ *   andon post working codex                 # codex wrapper: on launch
+ *   andon post gone    codex                 # codex wrapper: on exit
+ *   andon post done    claude "api" "shipped" # manual board test
+ */
+const client_1 = require("../client");
+const shared_1 = require("./shared");
+const STATES = ["working", "waiting", "done", "error", "idle", "gone"];
+async function post(args) {
+    // The codex wrapper calls `andon post` in the foreground on every launch, so
+    // pushing status is best-effort and SILENT by default — a missing server must
+    // not spam the terminal. Pass --verbose (-v) to see why a push failed.
+    const verbose = args.includes("--verbose") || args.includes("-v");
+    const [state, agent, title, message] = args.filter((a) => !a.startsWith("-"));
+    if (!state || !agent) {
+        console.error("usage: andon post <state> <agent> [title] [message]\n" +
+            `  state: ${STATES.join("|")}`);
+        return 2;
+    }
+    if (!STATES.includes(state)) {
+        console.error(`✗ unknown state "${state}" (expected: ${STATES.join("|")})`);
+        return 2;
+    }
+    const cwd = process.cwd();
+    const r = await (0, client_1.postEvent)({
+        agent,
+        id: (0, shared_1.sessionId)(agent, cwd),
+        state,
+        title: title || (0, shared_1.labelFor)(cwd, agent),
+        message: message || "",
+    });
+    if (!r.ok) {
+        if (verbose) {
+            console.error(`✗ could not reach the andon server (${r.error ?? "unknown"})`);
+        }
+        return 1; // non-zero for scripts, but quiet
+    }
+    return 0;
+}

package/dist/commands/serve.d.ts

@@ -0,0 +1,8 @@
+export interface ServeArgs {
+    port: number;
+    host: string;
+    demo: boolean;
+    token?: string;
+}
+export declare function parseServeArgs(argv: string[]): ServeArgs;
+export declare function serve(argv: string[]): void;