@spinabot/brigade 0.1.0

package/dist/cli.js

@@ -0,0 +1,287 @@
+#!/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 { DEFAULT_PORT } from "./protocol.js";
+const VERSION = "0.1.0";
+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 (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",
+]);
+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 () => {
+        await runChatCommand();
+    },
+    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 () => {
+        // 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 */
+        }
+        await runChatCommand();
+    },
+    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) {
+    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;
+    }
+    // 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`));
+        if (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.
+        if (typeof code === "number")
+            process.exit(code);
+    })
+        .catch((err) => {
+        try {
+            process.stdout.write("\x1b[?25h\x1b[?1049l");
+        }
+        catch {
+            /* terminal already gone */
+        }
+        console.error(chalk.red(`Brigade crashed: ${err instanceof Error ? err.stack ?? err.message : String(err)}`));
+        process.exit(1);
+    });
+}
+//# sourceMappingURL=cli.js.map