@spinabot/brigade 0.1.0

package/dist/cli/doctor-cmd.js

@@ -0,0 +1,317 @@
+/**
+ * `brigade doctor` — local health check. Non-interactive, exit code 0/1.
+ *
+ * Reports on the things most likely to make Brigade misbehave silently:
+ *   - Node version matches engines requirement
+ *   - ~/.brigade/ exists and is writable
+ *   - config.json present + parses
+ *   - At least one provider in the registry has a usable key
+ *   - Today's log file is being written
+ *   - (Optional with --gateway) Gateway port is reachable
+ *
+ * Returns exit code 0 if every check passes, 1 if any FAIL. Warnings don't
+ * fail the run — they print but exit 0 so doctor is safe to use in CI.
+ */
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import process from "node:process";
+import { AuthStorage, ModelRegistry } from "@mariozechner/pi-coding-agent";
+import chalk from "chalk";
+import { BRIGADE_DIR, loadConfig } from "../core/config.js";
+import { getTodayLogPath } from "../core/event-logger.js";
+import { assembleSystemPrompt, getPromptDir, seedDefaultPrompts, } from "../core/system-prompt.js";
+import { findProvider, PROVIDERS } from "../providers/catalog.js";
+import { DEFAULT_PORT } from "../protocol.js";
+/**
+ * Run the full set of checks. Prints a coloured summary to stderr (so the
+ * stdout stream stays free for any future machine-readable mode) and returns
+ * the structured report so tests can assert against it.
+ */
+export async function runDoctorCommand(opts = {}) {
+    const checks = [];
+    // ── Node version (engines.node = ">=20") ────────────────────────────
+    const nodeMajor = Number(process.versions.node.split(".")[0]);
+    checks.push(nodeMajor >= 20
+        ? { name: "node version", status: "pass", detail: `v${process.versions.node}` }
+        : {
+            name: "node version",
+            status: "fail",
+            detail: `v${process.versions.node} — Brigade requires Node 20+`,
+        });
+    // ── ~/.brigade exists and is writable ───────────────────────────────
+    let brigadeDirOk = true;
+    try {
+        await fs.mkdir(BRIGADE_DIR, { recursive: true });
+        const probe = path.join(BRIGADE_DIR, ".doctor-probe");
+        await fs.writeFile(probe, "ok", "utf8");
+        await fs.unlink(probe);
+        checks.push({ name: "brigade dir", status: "pass", detail: BRIGADE_DIR });
+    }
+    catch (err) {
+        brigadeDirOk = false;
+        checks.push({
+            name: "brigade dir",
+            status: "fail",
+            detail: `${BRIGADE_DIR} — ${err instanceof Error ? err.message : String(err)}`,
+        });
+    }
+    // ── config.json parses ──────────────────────────────────────────────
+    if (brigadeDirOk) {
+        try {
+            const cfg = await loadConfig();
+            const hasDefault = !!(cfg.defaultProvider && cfg.defaultModelId);
+            checks.push({
+                name: "config.json",
+                status: hasDefault ? "pass" : "warn",
+                detail: hasDefault
+                    ? `default: ${cfg.defaultProvider}/${cfg.defaultModelId}`
+                    : "no default provider/model — run `brigade onboard`",
+            });
+        }
+        catch (err) {
+            checks.push({
+                name: "config.json",
+                status: "warn",
+                detail: `unparseable — ${err instanceof Error ? err.message : String(err)}`,
+            });
+        }
+    }
+    // ── at least one provider with a usable key ─────────────────────────
+    if (brigadeDirOk) {
+        try {
+            const auth = AuthStorage.create(`${BRIGADE_DIR}/auth.json`);
+            const registry = ModelRegistry.create(auth, `${BRIGADE_DIR}/models.json`);
+            const available = registry.getAvailable();
+            if (available.length === 0) {
+                checks.push({
+                    name: "providers",
+                    status: "fail",
+                    detail: "no models available — run `brigade onboard`",
+                });
+            }
+            else {
+                // Group by provider for the summary line.
+                const byProvider = new Map();
+                for (const m of available) {
+                    byProvider.set(m.provider, (byProvider.get(m.provider) ?? 0) + 1);
+                }
+                const summary = [...byProvider.entries()]
+                    .map(([p, n]) => `${findProvider(p)?.name ?? p} (${n})`)
+                    .join(", ");
+                checks.push({
+                    name: "providers",
+                    status: "pass",
+                    detail: `${available.length} models · ${summary}`,
+                });
+            }
+            // Sanity-check api keys for each cloud provider in the catalog. We
+            // don't validate over the network here — that's `brigade onboard`'s
+            // job — but we verify the key file is readable for each configured
+            // provider so we catch corrupted auth.json early.
+            for (const p of PROVIDERS) {
+                if (p.noAuth)
+                    continue;
+                try {
+                    const key = await auth.getApiKey(p.id);
+                    if (key && key.length < 16) {
+                        checks.push({
+                            name: `auth · ${p.id}`,
+                            status: "warn",
+                            detail: "key looks too short — re-run onboard if requests fail",
+                        });
+                    }
+                }
+                catch {
+                    /* missing key for this provider is normal — skip */
+                }
+            }
+        }
+        catch (err) {
+            checks.push({
+                name: "providers",
+                status: "fail",
+                detail: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    // ── today's log path is writable ────────────────────────────────────
+    if (brigadeDirOk) {
+        const logPath = getTodayLogPath();
+        try {
+            await fs.mkdir(path.dirname(logPath), { recursive: true });
+            await fs.appendFile(logPath, ""); // 0-byte append — touches without changing
+            checks.push({ name: "log sink", status: "pass", detail: logPath });
+        }
+        catch (err) {
+            checks.push({
+                name: "log sink",
+                status: "warn",
+                detail: `${logPath} — ${err instanceof Error ? err.message : String(err)}`,
+            });
+        }
+    }
+    // ── prompt directory present + seeded ───────────────────────────────
+    // Brigade ships 4 default prompt layers (soul / identity / instructions /
+    // tools). seedDefaultPrompts is idempotent — it never overwrites existing
+    // files, so it's safe to call here too. We then count how many of the
+    // expected layers exist; missing layers are "warn", not "fail" because
+    // the assembler always falls back to embedded defaults.
+    if (brigadeDirOk) {
+        const promptDir = getPromptDir();
+        const expectedLayers = ["soul.md", "identity.md", "instructions.md", "tools.md"];
+        try {
+            await seedDefaultPrompts(promptDir);
+            let presentCount = 0;
+            for (const basename of expectedLayers) {
+                try {
+                    const stat = await fs.stat(path.join(promptDir, basename));
+                    if (stat.isFile() && stat.size > 0)
+                        presentCount++;
+                }
+                catch {
+                    /* missing — counted as 0 */
+                }
+            }
+            if (presentCount === expectedLayers.length) {
+                checks.push({
+                    name: "prompts",
+                    status: "pass",
+                    detail: `${presentCount}/${expectedLayers.length} layers in ${promptDir}`,
+                });
+            }
+            else if (presentCount === 0) {
+                checks.push({
+                    name: "prompts",
+                    status: "warn",
+                    detail: `no layers in ${promptDir} — assembler will use embedded defaults`,
+                });
+            }
+            else {
+                checks.push({
+                    name: "prompts",
+                    status: "warn",
+                    detail: `${presentCount}/${expectedLayers.length} layers in ${promptDir} — missing layers fall back to embedded defaults`,
+                });
+            }
+        }
+        catch (err) {
+            checks.push({
+                name: "prompts",
+                status: "warn",
+                detail: `${promptDir} — ${err instanceof Error ? err.message : String(err)}`,
+            });
+        }
+    }
+    // ── system prompt assembles cleanly ─────────────────────────────────
+    // Run a dry assembly (no model bound, no tools) to verify the assembler
+    // can read the layered files end-to-end without throwing. Catches:
+    // corrupt prompt files, permission issues that escaped seedDefaultPrompts,
+    // and any future regressions in the assembler itself.
+    if (brigadeDirOk) {
+        try {
+            const assembled = await assembleSystemPrompt({ cwd: process.cwd() });
+            checks.push({
+                name: "system prompt",
+                status: "pass",
+                detail: `assembles to ${assembled.text.length.toLocaleString()} chars (${assembled.dynamicSuffix.length} dynamic)`,
+            });
+        }
+        catch (err) {
+            checks.push({
+                name: "system prompt",
+                status: "fail",
+                detail: `assembly failed — ${err instanceof Error ? err.message : String(err)}`,
+            });
+        }
+    }
+    // ── (optional) gateway reachability ─────────────────────────────────
+    if (opts.gatewayUrl) {
+        const reach = await probeGateway(opts.gatewayUrl);
+        checks.push(reach);
+    }
+    else {
+        checks.push({
+            name: "gateway",
+            status: "warn",
+            detail: `not probed (pass --gateway ws://127.0.0.1:${DEFAULT_PORT} to check)`,
+        });
+    }
+    // ── summary ─────────────────────────────────────────────────────────
+    const ok = checks.every((c) => c.status !== "fail");
+    for (const c of checks) {
+        const tag = c.status === "pass"
+            ? chalk.green("PASS")
+            : c.status === "warn"
+                ? chalk.yellow("WARN")
+                : chalk.red("FAIL");
+        const line = `  ${tag}  ${c.name}${c.detail ? chalk.dim(` — ${c.detail}`) : ""}`;
+        process.stderr.write(`${line}\n`);
+    }
+    const verdict = ok
+        ? chalk.green("brigade is healthy")
+        : chalk.red("brigade has problems — see FAIL lines above");
+    process.stderr.write(`\n${verdict}\n`);
+    if (!opts.noExit) {
+        process.exit(ok ? 0 : 1);
+    }
+    return { ok, checks };
+}
+/**
+ * Open a one-shot WebSocket to the gateway URL and wait briefly for the
+ * initial state frame the server emits on connect. If we get the frame, the
+ * gateway is alive; if the socket never opens or the frame never arrives,
+ * report fail with the underlying reason.
+ */
+async function probeGateway(url) {
+    const { default: WebSocket } = await import("ws");
+    return new Promise((resolve) => {
+        let ws;
+        const timer = setTimeout(() => {
+            try {
+                ws?.close();
+            }
+            catch {
+                /* ignore */
+            }
+            resolve({
+                name: "gateway",
+                status: "fail",
+                detail: `${url} — no response in 3s (is \`brigade gateway\` running?)`,
+            });
+        }, 3_000);
+        try {
+            ws = new WebSocket(url);
+        }
+        catch (err) {
+            clearTimeout(timer);
+            resolve({
+                name: "gateway",
+                status: "fail",
+                detail: `${url} — ${err instanceof Error ? err.message : String(err)}`,
+            });
+            return;
+        }
+        ws.on("open", () => {
+            // We're connected. The server pushes a state frame on connect, but
+            // for a doctor probe getting the OPEN is enough — the socket is
+            // reachable and the server is accepting. Close immediately.
+            clearTimeout(timer);
+            try {
+                ws?.close();
+            }
+            catch {
+                /* ignore */
+            }
+            resolve({ name: "gateway", status: "pass", detail: url });
+        });
+        ws.on("error", (err) => {
+            clearTimeout(timer);
+            resolve({
+                name: "gateway",
+                status: "fail",
+                detail: `${url} — ${err instanceof Error ? err.message : String(err)}`,
+            });
+        });
+    });
+}
+//# sourceMappingURL=doctor-cmd.js.map

package/dist/cli/gateway-cmd.js

@@ -0,0 +1,92 @@
+/**
+ * `brigade gateway` — start the WebSocket gateway server, no TUI.
+ *
+ * Long-running headless process that owns the Pi session and broadcasts
+ * events to any connected clients (Brigade TUI, future web/mobile, etc.).
+ * One server per machine is the assumed model — bind defaults to localhost
+ * to avoid LAN exposure.
+ *
+ * Logging defaults to ON at `info` level — when you run `brigade gateway`
+ * you SEE what's happening (Pi events, WS req/res, client connect/disconnect)
+ * in real time. The same events also land in the JSONL log file. Use
+ * `--verbose` for token-level detail, or `--quiet` for a near-silent
+ * supervisor-friendly boot.
+ *
+ * Flags:
+ *   --port <n>           Port (default: BRIGADE_PORT env or 7777)
+ *   --host <addr>        Bind address (default: 127.0.0.1; use 0.0.0.0 for LAN)
+ *   --verbose            Bump log level to `debug` — adds message_update
+ *                        deltas (one per token) and message_start/end. Useful
+ *                        when debugging streaming or thinking blocks.
+ *   --log-level <level>  error | warn | info | debug. Overrides --verbose
+ *                        and the default. Use `warn` for retries+errors only.
+ *   --quiet              Disable the console stream entirely. Just two boot
+ *                        lines on stderr, then silence. Use under systemd /
+ *                        nohup / tmux when you want JSONL only.
+ */
+import process from "node:process";
+import { createConsoleStream } from "../core/console-stream.js";
+import { startServer } from "../core/server.js";
+/**
+ * Boot the gateway. Resolves once the port is bound. Wires SIGINT/SIGTERM
+ * to a clean shutdown so the listening socket is released even on Ctrl+C.
+ *
+ * Returns a stop() function so callers (tests, cli supervisor) can shut
+ * the server down without sending a signal.
+ */
+export async function runGatewayCommand(opts = {}) {
+    // Console stream is ON by default. Operators expect to SEE what their
+    // daemon is doing without flipping a flag — that was the point of moving
+    // from `npm run server` to `brigade gateway`. Precedence:
+    //   --quiet           → no stream at all (silent supervisor mode)
+    //   --log-level X     → explicit level X
+    //   --verbose         → debug
+    //   (default)         → info
+    const level = opts.quiet
+        ? "off"
+        : (opts.logLevel ?? (opts.verbose ? "debug" : "info"));
+    const consoleStream = level === "off" ? undefined : createConsoleStream({ level });
+    let handle;
+    try {
+        handle = await startServer({
+            port: opts.port,
+            host: opts.host,
+            consoleStream,
+        });
+    }
+    catch (err) {
+        // Translate the most common boot failures into actionable messages.
+        // EADDRINUSE = something already on the port (often a leftover gateway
+        // from a prior run, or another app). Tell the user how to recover
+        // instead of dumping a Node stack trace.
+        const msg = err instanceof Error ? err.message : String(err);
+        const port = opts.port ?? (Number(process.env.BRIGADE_PORT) || 7777);
+        if (/EADDRINUSE/.test(msg)) {
+            process.stderr.write(`brigade-gateway: port ${port} is already in use.\n` +
+                `  - find the process: PowerShell> Get-NetTCPConnection -LocalPort ${port}\n` +
+                `  - or pick a different port: brigade gateway --port ${port + 1}\n`);
+            process.exit(1);
+        }
+        if (/EACCES/.test(msg)) {
+            process.stderr.write(`brigade-gateway: permission denied binding port ${port} (privileged ports require admin).\n` +
+                `  - pick an unprivileged port: brigade gateway --port 7777\n`);
+            process.exit(1);
+        }
+        // Unrecognized failure — surface the message but skip the stack.
+        process.stderr.write(`brigade-gateway: failed to start: ${msg}\n`);
+        process.exit(1);
+    }
+    // Banner already printed by startServer (verbose path uses consoleStream;
+    // quiet path writes the two plain lines). No additional banner needed here.
+    // Wire signal handlers so the listening socket gets released cleanly. The
+    // shared chat command's SIGINT handler is process-wide; we install our own
+    // here because the gateway runs without the TUI and never reaches that path.
+    const onSignal = (sig) => {
+        process.stderr.write(`brigade-gateway: ${sig} received, shutting down\n`);
+        void handle.stop().then(() => process.exit(0));
+    };
+    process.once("SIGTERM", () => onSignal("SIGTERM"));
+    process.once("SIGINT", () => onSignal("SIGINT"));
+    return handle.stop;
+}
+//# sourceMappingURL=gateway-cmd.js.map