@spinabot/brigade 0.1.1 → 1.0.0

package/dist/cli/doctor-cmd.js

@@ -1,387 +0,0 @@
-/**
- * `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 { formatAuthLabel, listConfiguredProviders } from "../core/auth-label.js";
-import { getAppliedEnvKeys, loadBrigadeConfig } from "../core/brigade-config.js";
-import { DEFAULT_PORT } from "../protocol.js";
-/**
- * Translate raw Node `err.message` into a doctor-safe single line. Strips
- * absolute paths from EACCES/ENOENT/EPERM/EBUSY/EISDIR messages (no
- * `C:\\Users\\Bob\\.brigade\\auth.json` leaks into doctor output) and
- * collapses common errno tokens to plain English. Falls back to the raw
- * message when nothing matches — doctor's audience can read raw messages,
- * we just don't want absolute-path leaks.
- */
-function doctorFriendlyError(err) {
-    const raw = err instanceof Error ? err.message : String(err);
-    if (!raw)
-        return "unknown error";
-    // Match `EACCES: permission denied, open 'C:\\Users\\…\\file.json'` shape.
-    const fileErr = raw.match(/^(EACCES|EPERM|ENOENT|EBUSY|EISDIR|ENOTDIR|EROFS):\s*[^,]+,\s*\w+\s*['"]([^'"]+)['"]/);
-    if (fileErr) {
-        const code = fileErr[1];
-        const fullPath = fileErr[2] ?? "";
-        const basename = fullPath.split(/[/\\]/).pop() ?? "";
-        const friendly = {
-            EACCES: "permission denied",
-            EPERM: "permission denied",
-            ENOENT: "missing",
-            EBUSY: "locked by another process",
-            EISDIR: "path is a directory, expected a file",
-            ENOTDIR: "path is a file, expected a directory",
-            EROFS: "filesystem is read-only",
-        };
-        return `${friendly[code] ?? code}: ${basename}`;
-    }
-    // Truncate runaway error messages to keep doctor output scannable.
-    return raw.length > 240 ? `${raw.slice(0, 237)}…` : raw;
-}
-/**
- * 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} — ${doctorFriendlyError(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 — ${doctorFriendlyError(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 */
-                }
-            }
-            // Auth source per provider — surfaces WHERE each key came from
-            // (`brigade.json::env`, a shell env var, or unconfigured) so the
-            // user always knows what `rm -rf ~/.brigade` will and won't wipe.
-            try {
-                const cfg = await loadBrigadeConfig(BRIGADE_DIR);
-                const configured = listConfiguredProviders({
-                    provider: "",
-                    brigadeEnvBlock: cfg.env,
-                    processEnv: process.env,
-                    // Threading the boot-time applied set is what makes the
-                    // "file" vs "env" distinction honest: if the shell had a
-                    // key first, loadEnvIntoProcess skipped it, the key is NOT
-                    // in this set, and we correctly label it "env".
-                    appliedFromFile: getAppliedEnvKeys(),
-                });
-                for (const { provider, label } of configured) {
-                    checks.push({
-                        name: `auth source · ${provider}`,
-                        status: "pass",
-                        detail: formatAuthLabel(label),
-                    });
-                }
-            }
-            catch {
-                /* non-fatal — auth-source reporting is informational */
-            }
-        }
-        catch (err) {
-            checks.push({
-                name: "providers",
-                status: "fail",
-                detail: doctorFriendlyError(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} — ${doctorFriendlyError(err)}`,
-            });
-        }
-    }
-    // ── workspace dir present + persona layers seeded ───────────────────
-    // Brigade ships 7 default persona layers at the workspace root
-    // (SOUL / IDENTITY / AGENTS / TOOLS / USER / BOOTSTRAP / HEARTBEAT).
-    // 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",
-            "AGENTS.md",
-            "TOOLS.md",
-            "USER.md",
-            "BOOTSTRAP.md",
-            "BOOT.md",
-            "HEARTBEAT.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} — ${doctorFriendlyError(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 — ${doctorFriendlyError(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} — ${doctorFriendlyError(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} — ${doctorFriendlyError(err)}`,
-            });
-        });
-    });
-}
-//# sourceMappingURL=doctor-cmd.js.map

package/dist/cli/gateway-cmd.js

@@ -1,155 +0,0 @@
-/**
- * `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 chalk from "chalk";
-import { createConsoleStream } from "../core/console-stream.js";
-import { EXIT_CONFIG_ERROR, EXIT_FAILURE } from "../protocol.js";
-import { startServer } from "../core/server.js";
-import { restoreTerminal } from "../ui/terminal-cleanup.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);
-        // "no saved config" is a config error — exit with sysexits 78 so
-        // supervisors (systemd, launchd) STOP restarting. Restarting will
-        // produce the exact same error until the operator runs onboarding.
-        //
-        // Interactive enhancement (TTY only): rather than dead-ending the
-        // developer in their terminal with "go run another command", offer
-        // to launch chat (which handles onboarding inline) right now. Non-
-        // interactive supervisors get the message + exit 78 as before, so
-        // systemd doesn't sit waiting for stdin that will never come.
-        if (/no saved config|model .+ not in registry/i.test(msg)) {
-            process.stderr.write(chalk.yellow(`brigade-gateway: this gateway hasn't been set up yet.\n`) +
-                chalk.dim(`  Run ${chalk.bold("brigade chat")} to pick a provider + model, then re-launch.\n`));
-            if (process.stdin.isTTY && process.stdout.isTTY) {
-                const readline = await import("node:readline");
-                const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
-                const answer = await new Promise((resolve) => {
-                    rl.question(`\nLaunch ${chalk.bold("brigade chat")} now to onboard? [Y/n] `, (a) => {
-                        rl.close();
-                        resolve(a.trim().toLowerCase());
-                    });
-                });
-                if (answer === "" || answer === "y" || answer === "yes") {
-                    // Hand off to chat. It boots the TUI, runs onboarding, then
-                    // stays in chat — the user can `/exit` and re-run gateway
-                    // when they're ready. Don't auto-restart the gateway: chat
-                    // may have done other work (model switch, /provider add)
-                    // the operator wants to control.
-                    const { runChatCommand } = await import("./chat-cmd.js");
-                    await runChatCommand({});
-                    // Chat owns its own exit. The gateway never started, so
-                    // there's no teardown to run — return a no-op so the
-                    // caller's contract holds.
-                    return async () => { };
-                }
-            }
-            process.exit(EXIT_CONFIG_ERROR);
-        }
-        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(EXIT_FAILURE);
-        }
-        if (/EACCES/.test(msg)) {
-            // Privileged-port permission is a config issue (won't fix on retry).
-            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(EXIT_CONFIG_ERROR);
-        }
-        if (/ENOTFOUND|EAI_AGAIN|getaddrinfo/i.test(msg)) {
-            // Bad --host config (won't fix on retry).
-            process.stderr.write(`brigade-gateway: couldn't resolve host "${opts.host ?? "default"}". Check the --host value and your DNS.\n`);
-            process.exit(EXIT_CONFIG_ERROR);
-        }
-        if (/EHOSTUNREACH|ENETUNREACH/i.test(msg)) {
-            // Transient network — supervisor may retry.
-            process.stderr.write(`brigade-gateway: no network route to ${opts.host ?? "default"}. Check your network / firewall / VPN.\n`);
-            process.exit(EXIT_FAILURE);
-        }
-        // Unrecognized failure — short message line; raw `msg` only when the
-        // operator opts into BRIGADE_DEBUG=1.
-        process.stderr.write(`brigade-gateway: failed to start the server.\n`);
-        if (process.env.BRIGADE_DEBUG === "1") {
-            process.stderr.write(`  (debug: ${msg})\n`);
-        }
-        process.exit(EXIT_FAILURE);
-    }
-    // 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(() => {
-            // Gateway is headless and never enables raw mode itself, but the
-            // readline prompt above (the no-config Y/N) momentarily borrows the
-            // TTY. restoreTerminal() is idempotent and always safe — call it
-            // before exit so the next shell prompt is clean even if we ever
-            // add a richer interactive path here.
-            restoreTerminal();
-            process.exit(0);
-        });
-    };
-    process.once("SIGTERM", () => onSignal("SIGTERM"));
-    process.once("SIGINT", () => onSignal("SIGINT"));
-    return handle.stop;
-}
-//# sourceMappingURL=gateway-cmd.js.map