tono 0.2.1 → 0.3.1

package/README.md

@@ -1,8 +1,8 @@
 # tono
 
-A self-hosted gateway that turns labeled GitHub issues and PRs into running CLI agents.
+Self-hosted orchestrator for CLI agent tools (Claude Code, Codex CLI, OpenCode) triggered by GitHub issue labels.
 
-> *The name is the middle of **au·tono·mous** — fitting for a tool whose whole job is letting agents run unattended.*
+> *Etymology: **tono** is the middle of **au·tono·mous** — fitting for a tool whose whole job is letting agents run unattended.*
 
 > **Heads up: this project was entirely vibe-coded by AI.** Every line of code, every commit, every README revision (including this one). Read accordingly — there are no human-reviewed parts. Use at your own risk.
 
@@ -63,21 +63,14 @@ Run `tono config labels` to print the table for your current config.
 - **[`gh`](https://cli.github.com)** installed and authenticated (`gh auth login`). Tono shells out to `gh` for issue polling, PR polling, and PR-merge tracking.
 - **The agent CLI(s) you want to use, on `$PATH`.** At least one of:
   - **Claude Code** — [install instructions](https://docs.claude.com/en/docs/claude-code/quickstart). Verify `claude --version`.
-  - **Codex CLI** — `npm install -g @openai/codex` or follow the [Codex CLI repo](https://github.com/openai/codex). Verify `codex --version`.
+  - **Codex CLI** — `pnpm add -g @openai/codex` or follow the [Codex CLI repo](https://github.com/openai/codex). Verify `codex --version`.
   - **OpenCode** — see [opencode.ai](https://opencode.ai). Verify `opencode --version`.
 
 ## Install
 
-Tono is on npm — install it globally with whichever package manager you use:
+Tono is on npm. Install it globally with [pnpm](https://pnpm.io):
 
 ```bash
-# npm (recommended — runs install scripts by default, so native modules just work)
-npm install -g tono
-
-# yarn
-yarn global add tono
-
-# pnpm
 pnpm add -g tono
 pnpm approve-builds -g    # one-time: allow better-sqlite3 and node-pty to fetch prebuilds
 ```
@@ -85,26 +78,46 @@ pnpm approve-builds -g    # one-time: allow better-sqlite3 and node-pty to fetch
 Verify it landed on your `$PATH`:
 
 ```bash
-tono --version    # → 0.2.0
-which tono        # → /usr/local/bin/tono (or your manager's bin path)
+tono --version
+which tono                # → ~/.local/share/pnpm/tono (or your pnpm bin path)
 ```
 
 To upgrade later:
 
 ```bash
-npm install -g tono@latest
-tono gateway restart    # picks up the new binary in the background daemon
+pnpm add -g tono@latest
+tono gateway restart      # pick up the new binary in the background daemon
 ```
 
+If you have remote workers, upgrade each worker machine the same way and
+restart the worker daemon:
+
+```bash
+# on each worker machine
+pnpm add -g tono@latest
+tono worker restart
+```
+
+DB migrations (gateway-side) run automatically on the next `tono start` /
+`tono gateway restart`. Tono backs up `~/.tono/tono.db` to
+`~/.tono/tono.db.bak.v<N>` before any version-stepped migration runs, so an
+upgrade is safe to roll back: stop the gateway, copy the backup over the
+live db, downgrade `tono`, and start.
+
+Workers and gateways must run the **same minor** version of tono (e.g. all
+on `0.3.x`). Patch upgrades within a minor are guaranteed to interop. If a
+worker's minor differs from the gateway's, the gateway logs a warning on
+connect and may fail to dispatch tasks if the protocol shape has drifted.
+
 To uninstall:
 
 ```bash
-tono gateway uninstall  # remove the LaunchAgent first
-npm uninstall -g tono
-rm -rf ~/.tono          # optional — drops config, db, worktrees
+tono gateway uninstall    # remove the LaunchAgent first
+pnpm remove -g tono
+rm -rf ~/.tono            # optional — drops config, db, worktrees
 ```
 
-> **About native modules:** tono pulls in `better-sqlite3` and `node-pty`, which need to compile or fetch a prebuilt binary. Both ship prebuilds for macOS arm64/x64; npm and yarn run their install scripts automatically. **pnpm v10 disables install scripts by default** for safety, hence the extra `pnpm approve-builds -g` step.
+> **About native modules:** tono pulls in `better-sqlite3` and `node-pty`, which need to compile or fetch a prebuilt binary. Both ship prebuilds for macOS arm64/x64. **pnpm disables install scripts by default** for safety, hence the extra `pnpm approve-builds -g` step. If you prefer npm or yarn, the install commands work too — those run install scripts by default and skip the approve-builds step.
 
 ## Get started
 
@@ -291,10 +304,102 @@ What's next:
 
 - **Webhook triggers** to drop polling latency from ~60s to sub-second (Tailscale Funnel or smee.io).
 - **Manual review-task trigger** in the UI (today: label the PR).
-- **Distributed workers.** Designed but unbuilt. The gateway becomes a coordinator; workers connect over WebSocket and run agents on their own filesystems. Tailscale required, no app-level auth.
 - **Cost / token tracking.**
 - **Inline review comments** posted by tono itself rather than asking the agent to call `gh api`.
 
+## Distributed workers
+
+Tono can be split across multiple machines: one **gateway** (always-on box —
+e.g. your Mac mini) plus any number of **workers** (your MacBook, a Windows
+laptop, …) that connect outbound over a tailnet and execute agent runs on
+their own filesystem. Each connected worker adds capacity for the
+`(agent, kind)` partitions it advertises.
+
+**Topology.** The gateway owns the SQLite state, GitHub poller, PR watcher,
+scheduler, browser UI, and config. Workers own a local `node-pty` and a
+local `.bare/` clone cache. Tasks flow:
+
+```
+poller (gateway) → scheduler picks an eligible worker
+                 → task.assign over WS → worker creates worktree, spawns agent
+                 → PTY data streams back to gateway → browser UI
+```
+
+`tono start` continues to work unchanged on a single box: it launches an
+**embedded local worker** in the same process that connects to its own
+gateway over `127.0.0.1`. The embedded worker is fungible with remote ones —
+the scheduler just sees more capacity once a remote worker connects.
+
+**Prerequisites (per worker machine):**
+
+- [Tailscale](https://tailscale.com) with the worker on the same tailnet as
+  the gateway. There is no app-level auth — reachability over the tailnet IS
+  the trust boundary. The gateway should bind on its tailnet IP (or
+  `0.0.0.0` if the LAN is also trusted).
+- `gh` CLI, authenticated (`gh auth login`). The worker bare-clones repos
+  itself; it does not pull git data through the gateway.
+- The agent CLIs you want this worker to run (`claude`, `codex`,
+  `opencode`). The worker auto-detects which are on PATH and advertises
+  those as its capabilities.
+
+**Run a remote worker (foreground):**
+
+```bash
+tono worker run --gateway <gateway-host>:7040
+# advertise specific agent commands and concurrency:
+tono worker run \
+  --gateway my-mac-mini:7040 \
+  --agent claude-code=claude \
+  --concurrency claude-code=3/2
+```
+
+**Run a remote worker as a background daemon (macOS):**
+
+```bash
+# first time: install + load the LaunchAgent (com.tono.worker)
+tono worker start --gateway my-mac-mini:7040
+
+# later: lifecycle commands mirror `tono gateway`
+tono worker stop
+tono worker restart            # reload after settings changes
+tono worker status             # plist state + connection
+tono worker logs               # tail ~/.tono/logs/worker.out.log
+tono worker uninstall          # remove the LaunchAgent
+```
+
+Settings persist in `~/.tono/worker.json` (gateway URL, agent commands,
+concurrency, paths). The first `start` / `run` writes them; later
+invocations don't need flags. Pass new flags to override and re-persist
+(`tono worker restart --concurrency claude-code=4/2` updates the JSON and
+reloads the daemon). The same file holds a stable worker UUID so reconnects
+pick up the same identity.
+
+Workers reconnect with exponential backoff; if the gateway is offline the
+worker sits idle until it returns.
+
+**Disconnect handling.** When a worker drops mid-run (laptop sleeps, Wi-Fi
+blip), the gateway holds the task as `running` for `workers.graceMs`
+(default 60 000 ms). Reconnect within the window resumes the live stream.
+After the grace expires the task is marked `failed` with `exit_code = -3`
+and you can retry it. The setting lives in `~/.tono/config.json` under
+the optional `workers` block:
+
+```json
+{
+  "workers": { "graceMs": 60000 }
+}
+```
+
+**Caveats (v1):**
+
+- No worker affinity / pinning yet — workers are fungible by capability.
+- Worktree cleanup runs on the gateway's filesystem only. For tasks that
+  ran on a remote worker, the worktree under that worker's
+  `~/.tono/workspaces/` is left in place; clean it up there manually with
+  `git worktree remove`.
+- Free-form shells in the UI are gateway-local (they always run in the
+  gateway process, not on workers).
+
 ## License
 
 [MIT](./LICENSE).

package/dist/cli/checks.js

@@ -0,0 +1,504 @@
+import { spawnSync } from "node:child_process";
+import { accessSync, constants, existsSync, statSync } from "node:fs";
+import * as gh from "../server/github/gh.js";
+import { ConfigError, configPath, expandHome, loadConfig, } from "../server/config/load.js";
+import { dbPath, openDb } from "../server/db/client.js";
+import { GATEWAY_LABEL, plistPath } from "./launchd.js";
+/** Run every check in a sensible order, returning a flat list of results. */
+export async function runChecks(opts = {}) {
+    const out = [];
+    // External tools — always required.
+    out.push(await checkGitInstalled());
+    out.push(await checkGhInstalled());
+    // Config — try to load. If we can't, downstream checks (agents, repos) are skipped.
+    const cfgResult = await checkConfig();
+    out.push(cfgResult.result);
+    const cfg = cfgResult.cfg;
+    // gh auth — only meaningful if gh is installed. We still attempt the check
+    // (it'll just report the same error) so the user sees a clear "log in" hint.
+    out.push(await checkGhAuth());
+    if (cfg) {
+        out.push(await checkAgentsDeclared(cfg));
+        for (const agent of Object.keys(cfg.agents)) {
+            out.push(await checkAgentInstalled(cfg, agent));
+        }
+        out.push(checkWorkspaces(cfg));
+        out.push(checkRepoPaths(cfg));
+    }
+    out.push(checkSchemaVersion());
+    if (!opts.skipGateway) {
+        out.push(checkGatewayPlist());
+        if (cfg)
+            out.push(await checkGatewayHealthy(cfg));
+    }
+    return out;
+}
+function which(cmd) {
+    const r = spawnSync("/usr/bin/env", ["sh", "-c", `command -v ${cmd}`], { encoding: "utf8" });
+    if (r.status === 0)
+        return r.stdout.trim() || null;
+    return null;
+}
+function tryRun(cmd, args, timeoutMs = 5000) {
+    const r = spawnSync(cmd, args, { encoding: "utf8", timeout: timeoutMs });
+    return {
+        ok: r.status === 0,
+        stdout: (r.stdout ?? "").trim(),
+        stderr: (r.stderr ?? "").trim(),
+    };
+}
+// — Individual checks —————————————————————————————————————————————————————
+async function checkGitInstalled() {
+    const path = which("git");
+    if (!path) {
+        return {
+            id: "git.installed",
+            category: "required",
+            status: "fail",
+            title: "git",
+            detail: "not found on $PATH",
+            hint: "install git via Xcode Command Line Tools (`xcode-select --install`) or Homebrew (`brew install git`).",
+        };
+    }
+    const v = tryRun("git", ["--version"]);
+    return {
+        id: "git.installed",
+        category: "required",
+        status: "ok",
+        title: "git",
+        detail: v.stdout || path,
+    };
+}
+async function checkGhInstalled() {
+    const path = which("gh");
+    if (!path) {
+        return {
+            id: "gh.installed",
+            category: "required",
+            status: "fail",
+            title: "gh (GitHub CLI)",
+            detail: "not found on $PATH",
+            hint: "install via Homebrew (`brew install gh`) or from https://cli.github.com.",
+        };
+    }
+    const v = tryRun("gh", ["--version"]);
+    // First line of `gh --version` is "gh version X.Y.Z (...)". Keep only that.
+    const firstLine = v.stdout.split("\n")[0] ?? path;
+    return {
+        id: "gh.installed",
+        category: "required",
+        status: "ok",
+        title: "gh (GitHub CLI)",
+        detail: firstLine,
+    };
+}
+async function checkGhAuth() {
+    if (!which("gh")) {
+        return {
+            id: "gh.authenticated",
+            category: "required",
+            status: "fail",
+            title: "gh authentication",
+            detail: "skipped — gh is not installed",
+        };
+    }
+    try {
+        const r = await gh.authStatus();
+        if (r.ok) {
+            // `gh auth status` lists each host; keep it concise — first non-empty line.
+            const summary = r.detail.split("\n").map((l) => l.trim()).find((l) => l.length > 0) ?? "authenticated";
+            return {
+                id: "gh.authenticated",
+                category: "required",
+                status: "ok",
+                title: "gh authentication",
+                detail: summary.length > 80 ? summary.slice(0, 77) + "…" : summary,
+            };
+        }
+        return {
+            id: "gh.authenticated",
+            category: "required",
+            status: "fail",
+            title: "gh authentication",
+            detail: "not authenticated",
+            hint: "run `gh auth login` and grant access to your repos.",
+        };
+    }
+    catch (err) {
+        return {
+            id: "gh.authenticated",
+            category: "required",
+            status: "fail",
+            title: "gh authentication",
+            detail: err.message,
+        };
+    }
+}
+async function checkConfig() {
+    const path = configPath();
+    if (!existsSync(path)) {
+        return {
+            cfg: null,
+            result: {
+                id: "config.exists",
+                category: "required",
+                status: "fail",
+                title: "config",
+                detail: `not found at ${path}`,
+                hint: "run `tono init` (or `tono configure`) to create one.",
+            },
+        };
+    }
+    try {
+        const cfg = loadConfig();
+        return {
+            cfg,
+            result: {
+                id: "config.exists",
+                category: "required",
+                status: "ok",
+                title: "config",
+                detail: `valid · ${path}`,
+            },
+        };
+    }
+    catch (err) {
+        const message = err instanceof ConfigError ? err.message.split("\n")[0] : err.message;
+        return {
+            cfg: null,
+            result: {
+                id: "config.exists",
+                category: "required",
+                status: "fail",
+                title: "config",
+                detail: message,
+                hint: "fix the config file or re-run `tono configure`.",
+            },
+        };
+    }
+}
+async function checkAgentsDeclared(cfg) {
+    const declared = Object.keys(cfg.agents);
+    if (declared.length === 0) {
+        return {
+            id: "agents.declared",
+            category: "required",
+            status: "fail",
+            title: "agents declared",
+            detail: "no agents declared in config",
+            hint: "declare at least one of claude-code, codex, opencode in `agents` (or run `tono configure`).",
+        };
+    }
+    return {
+        id: "agents.declared",
+        category: "required",
+        status: "ok",
+        title: "agents declared",
+        detail: declared.join(", "),
+    };
+}
+async function checkAgentInstalled(cfg, agent) {
+    const a = cfg.agents[agent];
+    if (!a) {
+        // Shouldn't happen — checkAgentsDeclared already filters — but defensive.
+        return {
+            id: `agent.${agent}.installed`,
+            category: "required",
+            status: "fail",
+            title: `agent: ${agent}`,
+            detail: "no config block",
+        };
+    }
+    const path = which(a.command);
+    if (!path) {
+        return {
+            id: `agent.${agent}.installed`,
+            category: "required",
+            status: "fail",
+            title: `agent: ${agent}`,
+            detail: `\`${a.command}\` not found on $PATH`,
+            hint: hintForAgent(agent),
+        };
+    }
+    const v = tryRun(a.command, ["--version"]);
+    const firstLine = v.stdout.split("\n")[0] ?? path;
+    return {
+        id: `agent.${agent}.installed`,
+        category: "required",
+        status: "ok",
+        title: `agent: ${agent}`,
+        detail: firstLine,
+    };
+}
+function hintForAgent(agent) {
+    switch (agent) {
+        case "claude-code":
+            return "install Claude Code: https://docs.claude.com/en/docs/claude-code/quickstart";
+        case "codex":
+            return "install Codex CLI: `npm install -g @openai/codex` or https://github.com/openai/codex";
+        case "opencode":
+            return "install OpenCode: https://opencode.ai";
+    }
+}
+function checkWorkspaces(cfg) {
+    const root = cfg.workspaces.root;
+    if (!existsSync(root)) {
+        return {
+            id: "workspaces.exists",
+            category: "required",
+            status: "warn",
+            title: "workspaces root",
+            detail: `${root} does not exist (will be created on first task)`,
+        };
+    }
+    try {
+        accessSync(root, constants.W_OK);
+    }
+    catch {
+        return {
+            id: "workspaces.exists",
+            category: "required",
+            status: "fail",
+            title: "workspaces root",
+            detail: `${root} is not writable`,
+            hint: "fix the directory permissions or change `workspaces.root` in the config.",
+        };
+    }
+    return {
+        id: "workspaces.exists",
+        category: "required",
+        status: "ok",
+        title: "workspaces root",
+        detail: root,
+    };
+}
+function checkRepoPaths(cfg) {
+    const withPaths = cfg.repos.filter((r) => r.path && r.path.trim().length > 0);
+    if (withPaths.length === 0) {
+        return {
+            id: "repos.paths",
+            category: "optional",
+            status: "ok",
+            title: "repo paths",
+            detail: cfg.repos.length === 0
+                ? "no repos configured"
+                : `${cfg.repos.length} repo(s); none use a custom path (tono will bare-clone via gh)`,
+        };
+    }
+    const broken = [];
+    for (const r of withPaths) {
+        const p = expandHome(r.path);
+        if (!existsSync(p)) {
+            broken.push(`${r.slug} → ${p} (missing)`);
+            continue;
+        }
+        try {
+            if (!statSync(p).isDirectory())
+                broken.push(`${r.slug} → ${p} (not a directory)`);
+        }
+        catch {
+            broken.push(`${r.slug} → ${p} (unreadable)`);
+        }
+    }
+    if (broken.length > 0) {
+        return {
+            id: "repos.paths",
+            category: "required",
+            status: "fail",
+            title: "repo paths",
+            detail: broken.join("; "),
+            hint: "either fix the path on disk, set `path` to a valid clone, or remove the field to bare-clone via gh.",
+        };
+    }
+    return {
+        id: "repos.paths",
+        category: "required",
+        status: "ok",
+        title: "repo paths",
+        detail: `${withPaths.length}/${cfg.repos.length} repo(s) use a custom path; all valid`,
+    };
+}
+function checkSchemaVersion() {
+    const path = dbPath();
+    if (!existsSync(path)) {
+        return {
+            id: "db.schema",
+            category: "optional",
+            status: "ok",
+            title: "database schema",
+            detail: "database not yet created (will be on first run)",
+        };
+    }
+    try {
+        const db = openDb(path);
+        const row = db.prepare("SELECT version FROM schema_version LIMIT 1").get();
+        db.close();
+        return {
+            id: "db.schema",
+            category: "optional",
+            status: "ok",
+            title: "database schema",
+            detail: row ? `v${row.version}` : "uninitialized (will be set on next run)",
+        };
+    }
+    catch (err) {
+        return {
+            id: "db.schema",
+            category: "required",
+            status: "fail",
+            title: "database schema",
+            detail: err.message,
+            hint: "if the DB is corrupted, remove ~/.tono/tono.db* and re-run; tasks history will be lost.",
+        };
+    }
+}
+function checkGatewayPlist() {
+    const file = plistPath();
+    const r = spawnSync("launchctl", ["list", GATEWAY_LABEL], { encoding: "utf8" });
+    const loaded = r.status === 0;
+    if (!existsSync(file) && !loaded) {
+        return {
+            id: "gateway.plist",
+            category: "optional",
+            status: "ok",
+            title: "gateway",
+            detail: "not installed (run `tono gateway start` to install)",
+        };
+    }
+    if (!existsSync(file)) {
+        return {
+            id: "gateway.plist",
+            category: "optional",
+            status: "warn",
+            title: "gateway",
+            detail: "loaded by launchctl but plist file missing — re-run `tono gateway start` to fix",
+        };
+    }
+    if (!loaded) {
+        return {
+            id: "gateway.plist",
+            category: "optional",
+            status: "warn",
+            title: "gateway",
+            detail: "plist exists but is not loaded",
+            hint: "run `tono gateway start` (or `restart`) to load it.",
+        };
+    }
+    return {
+        id: "gateway.plist",
+        category: "optional",
+        status: "ok",
+        title: "gateway",
+        detail: "installed and loaded",
+    };
+}
+async function checkGatewayHealthy(cfg) {
+    const host = cfg.server.host === "0.0.0.0" ? "127.0.0.1" : cfg.server.host;
+    const url = `http://${host}:${cfg.server.port}/api/health`;
+    try {
+        const res = await fetch(url, { signal: AbortSignal.timeout(2000) });
+        if (!res.ok) {
+            return {
+                id: "gateway.healthy",
+                category: "optional",
+                status: "warn",
+                title: "gateway HTTP",
+                detail: `${url} → HTTP ${res.status}`,
+            };
+        }
+        const j = (await res.json());
+        return {
+            id: "gateway.healthy",
+            category: "optional",
+            status: "ok",
+            title: "gateway HTTP",
+            detail: `${url} OK${j.version ? ` (v${j.version})` : ""}`,
+        };
+    }
+    catch (err) {
+        return {
+            id: "gateway.healthy",
+            category: "optional",
+            status: "warn",
+            title: "gateway HTTP",
+            detail: `${url} unreachable`,
+            hint: (err.name === "AbortError" || err.message.includes("ECONNREFUSED"))
+                ? "if you expect tono to be running, check `tono gateway status` and `tono gateway logs err`."
+                : err.message,
+        };
+    }
+}
+// — Formatting helpers ————————————————————————————————————————————————————
+const COLOR = {
+    reset: "\x1b[0m",
+    dim: "\x1b[2m",
+    bold: "\x1b[1m",
+    green: "\x1b[32m",
+    yellow: "\x1b[33m",
+    red: "\x1b[31m",
+    blue: "\x1b[34m",
+};
+function symbolFor(status) {
+    switch (status) {
+        case "ok":
+            return `${COLOR.green}✓${COLOR.reset}`;
+        case "warn":
+            return `${COLOR.yellow}⚠${COLOR.reset}`;
+        case "fail":
+            return `${COLOR.red}✗${COLOR.reset}`;
+    }
+}
+function categoryTag(c) {
+    return c === "required"
+        ? `${COLOR.dim}[required]${COLOR.reset}`
+        : `${COLOR.dim}[optional]${COLOR.reset}`;
+}
+/** Format a list of check results as a human-readable report (with ANSI colors). */
+export function formatReport(results) {
+    const lines = [];
+    for (const r of results) {
+        lines.push(`${symbolFor(r.status)} ${r.title.padEnd(20)} ${categoryTag(r.category)} ${COLOR.dim}${r.detail}${COLOR.reset}`);
+        if (r.status !== "ok" && r.hint) {
+            lines.push(`  ${COLOR.dim}↳ ${r.hint}${COLOR.reset}`);
+        }
+    }
+    return lines.join("\n");
+}
+export function tally(results) {
+    const t = { total: results.length, ok: 0, warnings: 0, failures: 0, requiredFailures: 0 };
+    for (const r of results) {
+        if (r.status === "ok")
+            t.ok++;
+        else if (r.status === "warn")
+            t.warnings++;
+        else {
+            t.failures++;
+            if (r.category === "required")
+                t.requiredFailures++;
+        }
+    }
+    return t;
+}
+export function summarize(t) {
+    const parts = [`${t.ok} ok`];
+    if (t.warnings)
+        parts.push(`${COLOR.yellow}${t.warnings} warning${t.warnings === 1 ? "" : "s"}${COLOR.reset}`);
+    if (t.failures)
+        parts.push(`${COLOR.red}${t.failures} failure${t.failures === 1 ? "" : "s"}${COLOR.reset}`);
+    if (t.requiredFailures)
+        parts.push(`${COLOR.bold}${COLOR.red}${t.requiredFailures} required${COLOR.reset}`);
+    return parts.join(", ");
+}
+/** Hint string for the requirements section that init/doctor both print. */
+export function requirementsBanner() {
+    return [
+        `${COLOR.bold}Required tools:${COLOR.reset}`,
+        `  • ${COLOR.bold}gh${COLOR.reset} (GitHub CLI, authenticated)`,
+        `  • ${COLOR.bold}git${COLOR.reset}`,
+        `  • At least one of these agent CLIs (configure the ones you have):`,
+        `      - ${COLOR.bold}claude${COLOR.reset}     — Claude Code (https://docs.claude.com/en/docs/claude-code/quickstart)`,
+        `      - ${COLOR.bold}codex${COLOR.reset}      — Codex CLI (\`npm install -g @openai/codex\`)`,
+        `      - ${COLOR.bold}opencode${COLOR.reset}   — OpenCode (https://opencode.ai)`,
+    ].join("\n");
+}
+//# sourceMappingURL=checks.js.map