@spinabot/brigade 0.1.1 → 1.0.0

package/dist/cli.js

@@ -1,328 +0,0 @@
-#!/usr/bin/env node
-/**
- * Brigade — your personal AI crew.
- *
- * Single-binary CLI with subcommands, like `git`.
- *
- *   brigade                           # = brigade chat (default)
- *   brigade chat                      # in-process TUI + Pi session
- *   brigade gateway                   # WebSocket gateway server, no TUI
- *   brigade connect                   # TUI that talks to a running gateway
- *   brigade onboard                   # provider/model setup wizard
- *   brigade doctor                    # local health check
- *   brigade config list|get|set|unset # ~/.brigade/config.json
- *   brigade --version
- *   brigade --help
- *
- * All subcommands forward unrecognised flags through to the subcommand
- * handler — the dispatcher itself only knows about top-level flags.
- *
- * IMPORTANT: do not add an external CLI library. The argv shape is small
- * enough for hand-parsing. Adding a dependency would inflate the install
- * and slow `brigade --version`.
- */
-import process from "node:process";
-import { pathToFileURL } from "node:url";
-import chalk from "chalk";
-import { runChatCommand } from "./cli/chat-cmd.js";
-import { runConfigCommand } from "./cli/config-cmd.js";
-import { runConnectCommand } from "./cli/connect-cmd.js";
-import { runDoctorCommand } from "./cli/doctor-cmd.js";
-import { runGatewayCommand } from "./cli/gateway-cmd.js";
-import { installTerminalCleanupHandler, restoreTerminal } from "./ui/terminal-cleanup.js";
-import { loadBrigadeConfig, loadEnvIntoProcess, migrateBrigadeConfigV1toV2, migrateLegacyConfig, } from "./core/brigade-config.js";
-import { BRIGADE_DIR } from "./core/config.js";
-import { DEFAULT_PORT } from "./protocol.js";
-import { BRIGADE_CLI_VERSION } from "./core/version.js";
-const VERSION = BRIGADE_CLI_VERSION;
-const HELP = `${chalk.bold("brigade")} — your personal AI crew
-
-${chalk.dim("usage:")}
-  brigade [subcommand] [flags]
-
-${chalk.dim("subcommands:")}
-  ${chalk.bold("chat")}         start the in-process TUI (default if no subcommand)
-  ${chalk.bold("gateway")}      run the WebSocket gateway server, no TUI
-  ${chalk.bold("connect")}      TUI that talks to a running gateway
-  ${chalk.bold("onboard")}      run the provider/model setup wizard
-  ${chalk.bold("doctor")}       check the local environment is healthy
-  ${chalk.bold("config")}       read & write ~/.brigade/config.json
-
-${chalk.dim("flags (all subcommands respect):")}
-  --help            show help (per-subcommand if applicable)
-  --version         print version
-
-${chalk.dim("flags (chat / onboard):")}
-  --no-env-detect   ignore API keys exported in the shell env (typed-key only)
-
-${chalk.dim("flags (gateway):")}
-  --port <n>        listen port (default: ${DEFAULT_PORT}; env: BRIGADE_PORT)
-  --host <addr>     bind address (default: 127.0.0.1)
-  --verbose         bump log level to debug (token deltas + intra-message events)
-  --quiet           disable the live console stream (JSONL log only)
-  --log-level <l>   error | warn | info | debug (default: info — overrides --verbose)
-
-${chalk.dim("flags (connect):")}
-  --host <addr>     gateway host (default: 127.0.0.1)
-  --port <n>        gateway port (default: ${DEFAULT_PORT})
-  --timeout <ms>    per-request timeout (default: 60000)
-
-${chalk.dim("flags (doctor):")}
-  --gateway <url>   probe a running gateway URL too
-
-${chalk.dim("examples:")}
-  brigade                              # start chatting
-  brigade gateway --port 7777          # daemon mode, terminal #1
-  brigade connect --port 7777          # client mode, terminal #2
-  brigade doctor --gateway ws://127.0.0.1:7777
-  brigade config set defaultModelId claude-sonnet-4-6
-`;
-/** Flags that NEVER take a value — listing them here prevents the next-token
- *  consumption trap. Add new boolean flags here when introducing them. */
-export const BOOLEAN_FLAGS = new Set([
-    "help",
-    "h",
-    "version",
-    "v",
-    "verbose",
-    "quiet",
-    "force",
-    "no-env-detect",
-]);
-export function parseArgs(argv) {
-    const positional = [];
-    const flags = {};
-    let sawSeparator = false;
-    for (let i = 0; i < argv.length; i++) {
-        const tok = argv[i];
-        if (sawSeparator) {
-            positional.push(tok);
-            continue;
-        }
-        if (tok === "--") {
-            sawSeparator = true;
-            continue;
-        }
-        if (tok.startsWith("--")) {
-            const body = tok.slice(2);
-            const eq = body.indexOf("=");
-            if (eq >= 0) {
-                // --flag=value — explicit, never consumes the next token
-                flags[body.slice(0, eq)] = body.slice(eq + 1);
-                continue;
-            }
-            const key = body;
-            if (BOOLEAN_FLAGS.has(key)) {
-                flags[key] = true;
-                continue;
-            }
-            // Value flag: consume next token UNLESS it's another flag or
-            // missing entirely. A flag with no value is treated as `true`
-            // so callers that didn't expect it can still detect it.
-            const next = argv[i + 1];
-            if (next !== undefined && !next.startsWith("--") && next !== "--") {
-                flags[key] = next;
-                i++;
-            }
-            else {
-                flags[key] = true;
-            }
-        }
-        else {
-            positional.push(tok);
-        }
-    }
-    return { positional, flags };
-}
-/**
- * The subcommand registry. Adding a new subcommand:
- *   1. Build src/cli/<name>-cmd.ts exporting an async runXxxCommand(opts)
- *   2. Add an entry here that maps the literal to a handler
- *   3. Mention it in HELP above
- */
-const SUBCOMMANDS = {
-    chat: async ({ flags }) => {
-        const noEnvDetect = flags["no-env-detect"] === true;
-        await runChatCommand({ noEnvDetect });
-    },
-    gateway: async ({ flags }) => {
-        const port = typeof flags.port === "string"
-            ? Number(flags.port)
-            : undefined;
-        const host = typeof flags.host === "string" ? flags.host : undefined;
-        const verbose = flags.verbose === true;
-        const quiet = flags.quiet === true;
-        const logLevelRaw = typeof flags["log-level"] === "string" ? flags["log-level"] : undefined;
-        if (port !== undefined && (!Number.isFinite(port) || port < 1 || port > 65_535)) {
-            process.stderr.write(chalk.red(`invalid --port value: ${flags.port}\n`));
-            return 2;
-        }
-        if (verbose && quiet) {
-            process.stderr.write(chalk.red(`--verbose and --quiet are mutually exclusive\n`));
-            return 2;
-        }
-        const validLevels = ["error", "warn", "info", "debug"];
-        if (logLevelRaw && !validLevels.includes(logLevelRaw)) {
-            process.stderr.write(chalk.red(`invalid --log-level value: ${logLevelRaw} (use error|warn|info|debug)\n`));
-            return 2;
-        }
-        const logLevel = logLevelRaw;
-        await runGatewayCommand({ port, host, verbose, quiet, logLevel });
-        // runGatewayCommand resolves once the server is listening; the process
-        // stays alive on its own (the WebSocketServer + http.Server hold the
-        // event loop). Don't return — let the process keep running until SIGINT.
-        await new Promise(() => { });
-    },
-    connect: async ({ flags }) => {
-        const host = typeof flags.host === "string" ? flags.host : undefined;
-        const port = typeof flags.port === "string"
-            ? Number(flags.port)
-            : undefined;
-        const timeout = typeof flags.timeout === "string"
-            ? Number(flags.timeout)
-            : undefined;
-        if (port !== undefined && (!Number.isFinite(port) || port < 1 || port > 65_535)) {
-            process.stderr.write(chalk.red(`invalid --port value: ${flags.port}\n`));
-            return 2;
-        }
-        await runConnectCommand({ host, port, requestTimeoutMs: timeout });
-        // Same as gateway — the TUI's stdin handler keeps the process alive.
-        await new Promise(() => { });
-    },
-    onboard: async ({ flags }) => {
-        // Onboarding lives inside chat-cmd's boot path today (it runs when no
-        // saved config is present). For an explicit `brigade onboard`, force
-        // the wizard by deleting the saved default before booting chat — the
-        // wizard re-runs and writes a fresh default.
-        //
-        // Implemented as "chat with forced re-onboarding" instead of duplicating
-        // the wizard call site so future onboarding changes (e.g., MCP setup)
-        // stay in one place.
-        const fs = await import("node:fs/promises");
-        const path = await import("node:path");
-        const os = await import("node:os");
-        const cfgPath = path.join(os.homedir(), ".brigade", "config.json");
-        try {
-            const existing = JSON.parse(await fs.readFile(cfgPath, "utf8"));
-            delete existing.defaultProvider;
-            delete existing.defaultModelId;
-            await fs.writeFile(cfgPath, JSON.stringify(existing, null, 2), "utf8");
-        }
-        catch {
-            /* missing config is fine — wizard will run regardless */
-        }
-        const noEnvDetect = flags["no-env-detect"] === true;
-        await runChatCommand({ noEnvDetect });
-    },
-    doctor: async ({ flags }) => {
-        const gatewayUrl = typeof flags.gateway === "string" ? flags.gateway : undefined;
-        await runDoctorCommand({ gatewayUrl });
-        // runDoctorCommand calls process.exit on its own.
-    },
-    config: async ({ positional }) => {
-        // positional[0] is the subcommand (e.g. "set"); the rest are its args.
-        const result = await runConfigCommand(positional);
-        return result.exitCode;
-    },
-};
-/**
- * Top-level dispatch. Exported so tests can call directly without spawning
- * a subprocess.
- */
-export async function runCli(argv) {
-    // Install the process-wide terminal-cleanup safety net the moment runCli
-    // is called. Idempotent — repeated invocations (tests, embedded callers)
-    // register the listener at most once. Covers ALL exit paths (normal
-    // return, throw, signal, process.exit) so kitty keyboard escape sequences
-    // can never leak into the user's shell after Brigade exits.
-    installTerminalCleanupHandler();
-    const parsed = parseArgs(argv);
-    // Top-level flags first.
-    if (parsed.flags.version === true || parsed.flags.v === true) {
-        process.stdout.write(`brigade ${VERSION}\n`);
-        return 0;
-    }
-    if (parsed.flags.help === true || parsed.flags.h === true) {
-        process.stdout.write(HELP);
-        return 0;
-    }
-    // Boot init — runs once per process before any subcommand. Four stages:
-    //   1. Auto-migrate legacy 3-file config (auth.json + config.json + settings.json)
-    //      to the unified brigade.json super-config. Idempotent.
-    //   2. Auto-migrate brigade.json from v1 → v2 super-config schema. Idempotent.
-    //      Order matters: stage 1 may produce a v2 file directly (so this is a
-    //      no-op for fresh installs), but a v1 file from an earlier Brigade
-    //      build needs lifting BEFORE we read it in stage 3.
-    //   3. Load brigade.json + overlay its `env` block into process.env so Pi's
-    //      auth resolution finds Brigade-managed keys. Existing shell env vars
-    //      take priority — we never overwrite a key the user explicitly exported.
-    //   4. Errors here are non-fatal. The agent must always boot so the user can
-    //      run `brigade doctor` and diagnose.
-    try {
-        await migrateLegacyConfig(BRIGADE_DIR);
-        await migrateBrigadeConfigV1toV2(BRIGADE_DIR);
-        const cfg = await loadBrigadeConfig(BRIGADE_DIR);
-        loadEnvIntoProcess(cfg);
-    }
-    catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        process.stderr.write(chalk.dim(`brigade: config init warning — ${msg}\n`));
-    }
-    // Default subcommand: chat
-    const sub = parsed.positional[0] ?? "chat";
-    // Help on a specific subcommand: `brigade <sub> --help` falls through to
-    // the per-subcommand handler so it can print its own usage if it wants
-    // to. For now they don't have rich per-subcommand help — surface the
-    // global one as a fallback.
-    if (!(sub in SUBCOMMANDS)) {
-        process.stderr.write(chalk.red(`unknown subcommand: ${sub}\n\n`));
-        process.stderr.write(HELP);
-        return 2;
-    }
-    // Strip the subcommand from positional before forwarding.
-    const handler = SUBCOMMANDS[sub];
-    const subArgs = {
-        positional: parsed.positional.slice(1),
-        flags: parsed.flags,
-    };
-    try {
-        const code = await handler(subArgs);
-        return typeof code === "number" ? code : 0;
-    }
-    catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        process.stderr.write(chalk.red(`brigade ${sub}: ${msg}\n`));
-        // Stack traces leak `node_modules/.../` paths into user-facing output
-        // — same B2B-jargon class as Pi's `/login` leak. Suppress by default;
-        // surface only when the operator explicitly opts in via env.
-        if (process.env.BRIGADE_DEBUG === "1" && err instanceof Error && err.stack) {
-            process.stderr.write(chalk.dim(`${err.stack}\n`));
-        }
-        return 1;
-    }
-}
-/**
- * Entry point — only runs when this file is invoked directly (not when
- * imported by tests). Mirrors the canonical Node pattern.
- */
-const entry = process.argv[1] ? pathToFileURL(process.argv[1]).href : "";
-if (import.meta.url === entry) {
-    runCli(process.argv.slice(2))
-        .then((code) => {
-        // Most subcommands keep the loop alive (gateway, connect, chat).
-        // Only short-lived ones (config, doctor, --help) reach this point.
-        restoreTerminal();
-        if (typeof code === "number")
-            process.exit(code);
-    })
-        .catch((err) => {
-        restoreTerminal();
-        const msg = err instanceof Error ? err.message : String(err);
-        console.error(chalk.red(`Brigade crashed: ${msg}`));
-        if (process.env.BRIGADE_DEBUG === "1" && err instanceof Error && err.stack) {
-            console.error(chalk.dim(err.stack));
-        }
-        process.exit(1);
-    });
-}
-//# sourceMappingURL=cli.js.map