@bragi-gmbh/codebus 1.2.0

package/dist/commands/init.js

@@ -0,0 +1,97 @@
+import { createInterface } from "node:readline/promises";
+import { loadFileConfig, saveFileConfig, CONFIG_FILE } from "../config.js";
+import { validateConnection, detectEnvironment, OK, WARN } from "./login.js";
+import { buildGraphOutOfBand, registerGraphSnapshot } from "../graph-bootstrap.js";
+import { makeCtx, workspaceId as resolveWorkspaceId } from "../client.js";
+import { installGitHooks } from "../git-hooks.js";
+// `codebus init` — onboarding, not just config. Detects the environment, asks
+// only what it cannot detect, writes ~/.codebus/config.json, and validates the
+// connection when a token is available. Users never touch Supabase env vars;
+// power users can still override anything with CODEBUS_* / SUPABASE_ANON_KEY.
+//
+// Non-interactive: pass --url/--anon-key/--workspace/--token/--person with
+// --yes (used by the bootstrap script and CI).
+export async function initCmd(o) {
+    const detected = await detectEnvironment();
+    const existing = loadFileConfig();
+    console.log("CodeBus init — environment:");
+    console.log(`  git user:      ${detected.gitName ?? "—"} <${detected.gitEmail ?? "—"}>`);
+    console.log(`  repo/branch:   ${detected.repo ?? "—"}${detected.branch ? `@${detected.branch}` : ""}`);
+    console.log(`  Claude Code:   ${detected.claude ? "available" : "not found"}`);
+    console.log(`  Codex:         ${detected.codex ? "available" : "not found"}`);
+    if (detected.envVars.length)
+        console.log(`  env overrides: ${detected.envVars.join(", ")} (env always beats config.json)`);
+    if (existing.url)
+        console.log(`  existing config: ${CONFIG_FILE}`);
+    let { url, anonKey, workspace, token, person } = {
+        url: o.url ?? existing.url,
+        anonKey: o.anonKey ?? existing.anonKey,
+        workspace: o.workspace ?? existing.workspace ?? "default",
+        token: o.token ?? existing.token,
+        person: o.person ?? existing.person,
+    };
+    if (!o.yes) {
+        const rl = createInterface({ input: process.stdin, output: process.stdout });
+        const ask = async (q, dflt) => {
+            const a = (await rl.question(dflt ? `${q} [${dflt}]: ` : `${q}: `)).trim();
+            return a || dflt || undefined;
+        };
+        person = await ask("Who are you? (person slug, e.g. nikolaj)", person ?? detected.gitName?.toLowerCase().replace(/\s+/g, "-"));
+        workspace = (await ask("Which workspace?", workspace));
+        url = await ask("CodeBus URL", url);
+        anonKey = await ask("Anon key (from your workspace admin)", anonKey);
+        token = await ask("Agent token for this machine (leave blank to `codebus login` later)", token);
+        rl.close();
+    }
+    saveFileConfig({
+        ...(url ? { url } : {}), ...(anonKey ? { anonKey } : {}),
+        workspace, ...(token ? { token } : {}), ...(person ? { person } : {}),
+    });
+    console.log(`${OK} Wrote ${CONFIG_FILE}`);
+    // Install git hooks for local graph freshness (non-fatal if fails)
+    try {
+        const hooks = installGitHooks(process.cwd());
+        if (hooks.postMerge.installed) {
+            console.log(`${OK} ${hooks.postMerge.message}`);
+        }
+        if (hooks.postCommit.installed) {
+            console.log(`${OK} ${hooks.postCommit.message}`);
+        }
+        if (!hooks.postMerge.installed && !hooks.postCommit.installed) {
+            console.log(`${OK} Git hooks already installed (CodeBus)`);
+        }
+    }
+    catch (err) {
+        console.warn(`${WARN} Git hooks not installed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    if (url && anonKey && token) {
+        const facts = await validateConnection({ url, anonKey, workspace, token });
+        saveFileConfig({ agent: facts.agent, ...(facts.person ? { person: facts.person } : {}) });
+        console.log(`Ready. Next: codebus session start`);
+        // Trigger out-of-band graph bootstrap (non-blocking)
+        try {
+            await buildGraphOutOfBand(process.cwd(), { detached: true });
+            // Register snapshot in artifacts registry (idempotent)
+            const ctx = await makeCtx({
+                url,
+                anonKey,
+                workspace,
+                token,
+            });
+            const wsId = await resolveWorkspaceId(ctx);
+            await registerGraphSnapshot(ctx.supabase, wsId, facts.agent);
+        }
+        catch (err) {
+            // Non-fatal: log but don't block init
+            console.warn(`Graph bootstrap skipped: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    else {
+        console.log(`${WARN} Not validated yet — finish with: codebus login --token <token>`);
+    }
+    if (detected.claude)
+        console.log(`Tip: codebus install claude   # statusline + session-start hook`);
+    if (detected.codex)
+        console.log(`Tip: codebus install codex    # session-start wrapper`);
+}
+//# sourceMappingURL=init.js.map

package/dist/commands/init.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.js","sourceRoot":"","sources":["../../src/commands/init.ts"],"names":[],"mappings":"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"}

package/dist/commands/install.js

@@ -0,0 +1,520 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync, chmodSync, copyFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { OK, WARN } from "./login.js";
+import { readCachedDigest } from "./digest.js";
+import { createRequire } from "node:module";
+import { buildGraphOutOfBand } from "../graph-bootstrap.js";
+import { installGitHooks } from "../git-hooks.js";
+import { hookEventHasCommand } from "../mail-latency.js";
+import { loadFileConfig, saveFileConfig } from "../config.js";
+import { ONE_LINER } from "../positioning.js";
+import { createClient } from "@supabase/supabase-js";
+// F5: derive the reported tool count from the actual registry instead of a
+// hardcoded number that rots every time a tool is added/removed. Imported
+// from mcp-registry.ts, NOT mcp.ts (F1): mcp-registry.ts is side-effect-free
+// at import time (no stdio, no transport), so this can never start the MCP
+// server as a side effect of running `codebus install mcp` — regardless of
+// how mcp.ts's own entry-point guard behaves for its bin invocation.
+import { TOOL_REGISTRY } from "../mcp-registry.js";
+// `codebus install claude|codex|mcp` — wires CodeBus into agent launchers.
+// Adoption rule: if it appears automatically it becomes the operating system;
+// if users must remember to run it, it dies.
+const CLAUDE_SETTINGS = () => join(homedir(), ".claude", "settings.json");
+const pkg = createRequire(import.meta.url)("../../package.json");
+const STATUSLINE_CONFIG = { type: "command", command: "codebus statusline" };
+// --hook: identity-explicit-or-silent (same contract as tick --hook). This
+// hook is machine-wide — every Claude Code session on the box runs it — so
+// checked-in directories auto-orient as their bound agent and everything else
+// stays silent, instead of every unrelated session orienting as the author's
+// config.json identity.
+const SESSION_START_HOOK = {
+    hooks: [{ type: "command", command: "codebus session start --hook" }],
+};
+// Turn-boundary participation (docs/checkin-design-brief.md): on Stop, surface
+// NEW mail into the live session. `tick --hook` is identity-explicit (silent in
+// sessions with no CODEBUS_TOKEN / cwd binding), honors stop_hook_active, and
+// swallows every error — a bus outage must never block coding.
+const STOP_HOOK = {
+    hooks: [{ type: "command", command: "codebus tick --hook" }],
+};
+function manualClaudeInstructions() {
+    return [
+        "Manual fallback — add to ~/.claude/settings.json:",
+        '  "statusLine": { "type": "command", "command": "codebus statusline" },',
+        '  "hooks": { "SessionStart": [ { "hooks": [ { "type": "command", "command": "codebus session start --hook" } ] } ] }',
+    ].join("\n");
+}
+async function installClaude(o) {
+    const path = CLAUDE_SETTINGS();
+    let settings = {};
+    try {
+        if (existsSync(path)) {
+            settings = JSON.parse(readFileSync(path, "utf8"));
+            copyFileSync(path, `${path}.codebus-backup`); // never destroy user settings
+        }
+    }
+    catch (e) {
+        console.log(`${WARN} Could not parse ${path}: ${e.message}`);
+        console.log(manualClaudeInstructions());
+        process.exit(1);
+    }
+    // statusline: only claim the slot if free (or --force) — users may have one.
+    if (!settings.statusLine || o.force || (settings.statusLine?.command ?? "").includes("codebus")) {
+        settings.statusLine = STATUSLINE_CONFIG;
+        console.log(`${OK} statusline → codebus statusline`);
+    }
+    else {
+        console.log(`${WARN} statusLine already set (${settings.statusLine.command}); keeping it. Use --force to replace.`);
+        console.log(manualClaudeInstructions());
+    }
+    // SessionStart hook: append if no codebus hook is present yet. Earlier
+    // installs wired the hookless "codebus session start", which orients EVERY
+    // session on the machine as the author's config.json identity — upgrade
+    // those entries in place to the identity-explicit --hook form.
+    settings.hooks = settings.hooks ?? {};
+    const sessionStart = settings.hooks.SessionStart ?? [];
+    let upgraded = false;
+    for (const entry of sessionStart) {
+        for (const h of entry?.hooks ?? []) {
+            if (h?.command === "codebus session start") {
+                h.command = "codebus session start --hook";
+                upgraded = true;
+            }
+        }
+    }
+    const already = JSON.stringify(sessionStart).includes("codebus session start --hook");
+    if (upgraded) {
+        settings.hooks.SessionStart = sessionStart;
+        console.log(`${OK} SessionStart hook upgraded → codebus session start --hook (bound dirs auto-orient; others stay silent)`);
+    }
+    else if (!already) {
+        sessionStart.push(SESSION_START_HOOK);
+        settings.hooks.SessionStart = sessionStart;
+        console.log(`${OK} SessionStart hook → codebus session start --hook`);
+    }
+    else {
+        console.log(`${OK} SessionStart hook already installed`);
+    }
+    // Stop hook: turn-boundary mail surfacing (identity-explicit; silent elsewhere).
+    const stop = settings.hooks.Stop ?? [];
+    const stopAlready = JSON.stringify(stop).includes("codebus tick");
+    if (!stopAlready) {
+        stop.push(STOP_HOOK);
+        settings.hooks.Stop = stop;
+        console.log(`${OK} Stop hook → codebus tick --hook (new-mail surfacing at turn boundaries)`);
+    }
+    else {
+        console.log(`${OK} Stop hook already installed`);
+    }
+    mkdirSync(join(homedir(), ".claude"), { recursive: true });
+    writeFileSync(path, JSON.stringify(settings, null, 2) + "\n");
+    console.log(`${OK} Wrote ${path}${existsSync(`${path}.codebus-backup`) ? ` (backup: ${path}.codebus-backup)` : ""}`);
+    // Verify the statusline path works (local read only — never network).
+    const snap = await readCachedDigest();
+    console.log(snap
+        ? `${OK} codebus statusline renders from cached digest`
+        : `${WARN} no digest cache yet — run \`codebus session start\` once; statusline shows a hint until then`);
+}
+// RC3 (docs/checkin-design-brief.md follow-up): Codex CLI's native
+// lifecycle-hooks engine (codex-rs/hooks; Feature::CodexHooks — stage Stable,
+// default_enabled true) ships a genuine turn-boundary "Stop" hook. Codex reads
+// hooks from a global ~/.codex/hooks.json and (with its own precedence/merge
+// rules) a project-local .codex/hooks.json; `codebus install codex` manages the
+// GLOBAL file only, and detection below is deliberately scoped to that same file
+// so install and coverage-detection always agree — we never claim coverage for a
+// project-local hook whose Codex resolution semantics we don't replicate here.
+// Its contract mirrors Claude Code's Stop hook closely enough to reuse verbatim:
+// the handler gets
+// `stop_hook_active` on stdin (same loop-guard field), and a
+// `{"decision":"block","reason":"..."}` stdout response feeds `reason` back
+// as the agent's next prompt (codex-rs/hooks/src/events/stop.rs). `codebus
+// tick --hook` already speaks exactly that contract — no Codex-specific
+// binary is needed, the SAME command wires both tools' Stop hooks.
+const CODEX_HOOKS_FILE = () => join(homedir(), ".codex", "hooks.json");
+const CODEX_STOP_HOOK_GROUP = { hooks: [{ type: "command", command: "codebus tick --hook" }] };
+const CODEX_SESSION_START_HOOK_GROUP = { hooks: [{ type: "command", command: "codebus session start --hook" }] };
+/**
+ * Register CodeBus's Stop + SessionStart handlers in ~/.codex/hooks.json.
+ * Merge-only, like installClaude: never touches any OTHER event's handlers a
+ * user already configured, and backs up the file before writing. Idempotent —
+ * checks for "codebus tick"/"codebus session start --hook" substrings before
+ * appending, same convention installClaude uses for ~/.claude/settings.json.
+ *
+ * Returns whether the hooks are actually installed after this call (false on
+ * any failure) — ai-review finding: the caller must NOT print "durable
+ * auto-check installed" when this silently failed to write anything, or a
+ * malformed/unreadable hooks.json leaves the user believing coverage exists
+ * when it doesn't (an undetected mail-delivery gap).
+ */
+// A plain JSON object: not null, not an array. Used to validate every level
+// of hooks.json we're about to read/mutate — ai-review finding: checking only
+// the TOP-level shape let `{"hooks":[]}` or `{"hooks":{"Stop":{}}}` slip past
+// as "valid", then either silently produce a file with no hook actually
+// installed (arrays swallow non-index properties on JSON.stringify) or throw
+// on `stop.push` for a non-array Stop value. Every level we touch — the
+// top-level file, `hooks`, and `hooks.Stop`/`hooks.SessionStart` (only if
+// present) — must have the exact shape we expect, or we fail closed the same
+// way a syntax error does, before ever claiming success.
+function isPlainObject(x) {
+    return typeof x === "object" && x !== null && !Array.isArray(x);
+}
+function installCodexHooks() {
+    const path = CODEX_HOOKS_FILE();
+    let file = {};
+    try {
+        if (existsSync(path)) {
+            const parsed = JSON.parse(readFileSync(path, "utf8"));
+            if (!isPlainObject(parsed)) {
+                throw new Error(`expected a JSON object at the top level, got ${Array.isArray(parsed) ? "an array" : typeof parsed}`);
+            }
+            if (parsed.hooks !== undefined && !isPlainObject(parsed.hooks)) {
+                throw new Error(`expected "hooks" to be a JSON object, got ${Array.isArray(parsed.hooks) ? "an array" : typeof parsed.hooks}`);
+            }
+            const hooksObj = parsed.hooks ?? {};
+            for (const key of ["Stop", "SessionStart"]) {
+                if (hooksObj[key] !== undefined && !Array.isArray(hooksObj[key])) {
+                    throw new Error(`expected "hooks.${key}" to be a JSON array, got ${typeof hooksObj[key]}`);
+                }
+            }
+            file = parsed;
+            copyFileSync(path, `${path}.codebus-backup`); // never destroy user hooks
+        }
+    }
+    catch (e) {
+        console.log(`${WARN} Could not parse ${path}: ${e.message} — leaving Codex hooks untouched`);
+        console.log(`  Manual fallback — add to ${path}:`);
+        console.log(`    { "hooks": { "Stop": [ { "hooks": [ { "type": "command", "command": "codebus tick --hook" } ] } ] } }`);
+        return false;
+    }
+    file.hooks = file.hooks ?? {};
+    const stop = file.hooks.Stop ?? [];
+    // Exact command match, not a substring over serialized JSON — an unrelated
+    // hook merely containing "codebus tick" must not suppress installing the real
+    // handler (ai-review finding; same matcher the detection path uses).
+    if (!hookEventHasCommand(stop, "codebus tick --hook")) {
+        stop.push(CODEX_STOP_HOOK_GROUP);
+        file.hooks.Stop = stop;
+        console.log(`${OK} Codex Stop hook → codebus tick --hook (new-mail surfacing at Codex turn boundaries)`);
+    }
+    else {
+        console.log(`${OK} Codex Stop hook already installed`);
+    }
+    const sessionStart = file.hooks.SessionStart ?? [];
+    if (!hookEventHasCommand(sessionStart, "codebus session start --hook")) {
+        sessionStart.push(CODEX_SESSION_START_HOOK_GROUP);
+        file.hooks.SessionStart = sessionStart;
+        console.log(`${OK} Codex SessionStart hook → codebus session start --hook`);
+    }
+    else {
+        console.log(`${OK} Codex SessionStart hook already installed`);
+    }
+    mkdirSync(join(homedir(), ".codex"), { recursive: true });
+    writeFileSync(path, JSON.stringify(file, null, 2) + "\n");
+    console.log(`${OK} Wrote ${path}${existsSync(`${path}.codebus-backup`) ? ` (backup: ${path}.codebus-backup)` : ""}`);
+    return true;
+}
+export function installCodex() {
+    const binDir = join(homedir(), ".codebus", "bin");
+    const wrapper = join(binDir, "codex");
+    mkdirSync(binDir, { recursive: true });
+    // Safer v1 (deliberate): session start only. No auto session-end posts until
+    // users trust the ritual — an unwanted handoff message erodes trust fast.
+    writeFileSync(wrapper, [
+        "#!/usr/bin/env bash",
+        "# CodeBus wrapper: pull the bus before Codex starts. Best-effort — a bus",
+        "# outage must never block coding.",
+        "codebus session start || true",
+        'exec codex "$@"',
+        "",
+    ].join("\n"));
+    chmodSync(wrapper, 0o755);
+    console.log(`${OK} Wrote ${wrapper}`);
+    console.log(`Add to your shell profile so it shadows the real codex:`);
+    console.log(`  export PATH="$HOME/.codebus/bin:$PATH"`);
+    console.log(`(session end stays manual for now: codebus session end --summary "...")`);
+    // Register the MCP server so a Codex session can PULL (codebus_inbox/
+    // codebus_next) natively via tool calls.
+    installCodexMcp();
+    // Durable turn-boundary auto-check (the actual RC3 fix): wire Codex's own
+    // Stop hook, same mechanism/command as Claude Code's Stop hook above. Only
+    // claim coverage when the write actually succeeded (ai-review finding: a
+    // malformed/unreadable hooks.json must not be papered over with a false
+    // "durable auto-check installed" success message).
+    if (installCodexHooks()) {
+        console.log(`${OK} Durable auto-check: Codex's Stop hook now runs \`codebus tick --hook\` at every turn`);
+        console.log(`   boundary — same mechanism as Claude Code (Codex feeds the reported mail back as your`);
+        console.log(`   next prompt). \`codebus checkin\` no longer needs to keep a blocking watch window alive.`);
+    }
+    else {
+        console.log(`${WARN} Durable auto-check NOT installed — fix ~/.codex/hooks.json (see above) and re-run \`codebus install codex\`.`);
+        console.log(`   Until then, \`codebus checkin\` falls back to arming one watch window at a time.`);
+    }
+}
+/**
+ * installMcp — register the codebus-mcp server in Claude Code settings.
+ * OPT-IN only: never modifies config silently. Prints what will be written first.
+ * A12 / artifacts-hook policy: explicit user consent required.
+ */
+export async function installMcp(o = {}) {
+    const path = CLAUDE_SETTINGS();
+    let settings = {};
+    try {
+        if (existsSync(path)) {
+            settings = JSON.parse(readFileSync(path, "utf8"));
+        }
+    }
+    catch (e) {
+        console.log(`${WARN} Could not parse ${path}: ${e.message}`);
+        console.log("Manual fallback — add to ~/.claude/settings.json:");
+        printMcpServerConfig();
+        process.exit(1);
+    }
+    // Prepare the MCP server config.
+    const mcpConfig = buildMcpServerConfig();
+    // Check if already installed.
+    const mcpServers = settings.mcpServers ?? {};
+    if (mcpServers.codebus) {
+        console.log(`${OK} codebus-mcp already registered in mcpServers`);
+        return;
+    }
+    // A12 / artifacts-hook policy: non-interactive without explicit opt-in → abort.
+    // Non-TTY (piped, CI, another tool) + no --yes → user cannot consent.
+    if (!process.stdin.isTTY && !o.yes) {
+        console.log(`${WARN} non-interactive: re-run with --yes to opt in`);
+        process.exit(1);
+    }
+    // Print what will be written (A12 explicit consent gate).
+    console.log("\nWill register codebus-mcp in ~/.claude/settings.json:\n");
+    console.log(JSON.stringify({ mcpServers: { codebus: mcpConfig } }, null, 2));
+    console.log();
+    // Confirm before writing (interactive mode only — non-TTY would have aborted above).
+    if (!o.yes) {
+        const answer = await getUserConfirmation("Proceed with registration? (y/n): ");
+        if (!answer.toLowerCase().startsWith("y")) {
+            console.log(`${WARN} Installation cancelled.`);
+            process.exit(0);
+        }
+    }
+    // Write the config.
+    mkdirSync(join(homedir(), ".claude"), { recursive: true });
+    if (!settings.mcpServers) {
+        settings.mcpServers = {};
+    }
+    settings.mcpServers.codebus = mcpConfig;
+    // Backup existing config.
+    if (existsSync(path)) {
+        copyFileSync(path, `${path}.codebus-backup`);
+    }
+    writeFileSync(path, JSON.stringify(settings, null, 2) + "\n");
+    console.log(`${OK} Registered codebus-mcp in ${path}`);
+    console.log(`${OK} Backup saved to ${path}.codebus-backup`);
+    console.log("\nCodeBus MCP tools are now available in Claude Code:");
+    console.log("  • ask_graph — Query CodeBus graph snapshot");
+    console.log("  • codebus_state — Session digest (counts, next item)");
+    console.log("  • codebus_next — Ranked next work item");
+    console.log("  • codebus_inbox — Read inbox items");
+    console.log("  • question_create — Create a question");
+    console.log("  • question_answer — Answer an open question");
+    console.log("  • task_create — Create a task");
+    console.log("  • task_claim — Claim a task");
+    console.log("  • task_done — Mark task as done");
+    console.log("  • decision_record — Record a decision");
+    console.log("  • decision_accept — Accept a decision");
+    console.log("  • send — Send a message to agents");
+    console.log("  • session_end — End session with handoff/note");
+    console.log("  • compile_pack — Cited, budget-trimmed context pack");
+    console.log("  • resolve_refs — List typed refs attached to a task/message");
+    console.log("  • graph_search — Search a connected repo's remote graph");
+    console.log("  • blast_radius — What breaks if I change this (local or remote)");
+    console.log("  • graph_gaps — Knowledge gaps in a connected repo's graph");
+    console.log("  • plan_status — Per-plan task/ticket/PR/coverage/health rollup");
+    console.log("  • delivery_status — Paginated per-plan delivery + quality rollup");
+}
+function buildMcpServerConfig() {
+    // Absolute paths, deliberately: a bare "codebus-mcp" resolves only through
+    // whatever PATH the launching app inherited — under fnm that's an EPHEMERAL
+    // per-shell shim dir (fnm_multishells/<pid>_<ts>/bin), so a Claude/Codex
+    // instance launched outside an fnm-initialized shell silently fails to start
+    // the server. process.execPath is the real node binary running this install;
+    // mcp.js resolves relative to the installed package (dist/commands → dist/).
+    // Trade-off: a node upgrade breaks this loudly (re-run install), instead of
+    // PATH drift breaking it silently.
+    return {
+        command: process.execPath,
+        args: [join(dirname(fileURLToPath(import.meta.url)), "..", "mcp.js")],
+    };
+}
+/**
+ * Register the codebus MCP server in Codex's ~/.codex/config.toml
+ * ([mcp_servers.codebus]). Append-only with a backup — Codex configs carry
+ * hand-written sections (the user's real one has several mcp_servers already),
+ * so we never parse/rewrite, only add our section when it's absent.
+ */
+function installCodexMcp() {
+    const path = join(homedir(), ".codex", "config.toml");
+    const cfg = buildMcpServerConfig();
+    const section = [
+        "",
+        "# CodeBus MCP server (written by `codebus install codex`)",
+        "[mcp_servers.codebus]",
+        `command = ${JSON.stringify(cfg.command)}`,
+        `args = [${cfg.args.map((a) => JSON.stringify(a)).join(", ")}]`,
+        "",
+    ].join("\n");
+    let existing = "";
+    try {
+        existing = readFileSync(path, "utf8");
+    }
+    catch { /* no config yet — we'll create it */ }
+    if (existing.includes("[mcp_servers.codebus]")) {
+        console.log(`${OK} codebus MCP already registered in ${path}`);
+        return;
+    }
+    if (existing)
+        copyFileSync(path, `${path}.codebus-backup`);
+    mkdirSync(join(homedir(), ".codex"), { recursive: true });
+    writeFileSync(path, existing + section);
+    console.log(`${OK} Registered [mcp_servers.codebus] in ${path}${existing ? ` (backup: ${path}.codebus-backup)` : ""}`);
+    console.log(`   Codex sessions get the ${TOOL_REGISTRY.length} codebus tools on next launch.`);
+}
+function printMcpServerConfig() {
+    const config = buildMcpServerConfig();
+    console.log('  "mcpServers": {');
+    console.log('    "codebus": ' + JSON.stringify(config, null, 6));
+    console.log("  }");
+}
+/**
+ * Prompt user for confirmation (blocking).
+ * Only called from interactive TTY contexts (non-TTY + no --yes is rejected earlier).
+ */
+function getUserConfirmation(prompt) {
+    return new Promise((resolve) => {
+        process.stdout.write(prompt);
+        let data = "";
+        process.stdin.setEncoding("utf8");
+        process.stdin.once("data", (chunk) => {
+            resolve(chunk.trim());
+            process.stdin.pause();
+        });
+        process.stdin.resume();
+    });
+}
+export async function installAll(o = {}) {
+    const repoRoot = o.cwd ?? process.cwd();
+    // ── 1. Build graph out-of-band ───────────────────────────────────────────
+    if (!o.skipGraph) {
+        const isGitDir = existsSync(join(repoRoot, ".git"));
+        if (!isGitDir) {
+            console.log(`${WARN} Not a git repository — skipping graph build. Run inside a git repo for the full aha.`);
+        }
+        else {
+            try {
+                await buildGraphOutOfBand(repoRoot, { graphifyCmd: o.graphifyCmd ?? "graphify" });
+            }
+            catch {
+                console.log(`${WARN} graphify not found or failed — skipping graph build. Install graphify or run again inside a graphified repo.`);
+            }
+        }
+    }
+    // ── 2. Install git hooks ─────────────────────────────────────────────────
+    const isGitDir = existsSync(join(repoRoot, ".git"));
+    if (isGitDir) {
+        try {
+            const hooks = installGitHooks(repoRoot);
+            if (hooks.postMerge.installed)
+                console.log(`${OK} post-merge hook → graph refresh`);
+            else
+                console.log(`${OK} post-merge hook already installed`);
+            if (hooks.postCommit.installed)
+                console.log(`${OK} post-commit hook → graph refresh`);
+            else
+                console.log(`${OK} post-commit hook already installed`);
+        }
+        catch (e) {
+            console.log(`${WARN} git hooks: ${e.message}`);
+        }
+    }
+    // ── 3. Install Claude SessionStart hook ─────────────────────────────────
+    await installClaude({ force: o.force });
+    // ── 4. Provision <login>-claude agent (when token is available) ──────────
+    const cfg = loadFileConfig();
+    const url = process.env.CODEBUS_URL ?? cfg.url;
+    const token = process.env.CODEBUS_TOKEN ?? cfg.token;
+    const anonKey = process.env.SUPABASE_ANON_KEY ?? cfg.anonKey ?? "";
+    if (!token || !url) {
+        console.log(`\n${WARN} No token/URL configured — skipping agent provision.`);
+        console.log(`  Run \`codebus join <code>\` to join a workspace, then re-run \`codebus install\`.`);
+    }
+    else {
+        try {
+            const agentSlug = await provisionMyAgent({ url, token, anonKey });
+            console.log(`${OK} Agent provisioned: ${agentSlug}`);
+            // Persist the agent slug so subsequent commands use it automatically.
+            saveFileConfig({ agent: agentSlug });
+        }
+        catch (e) {
+            console.log(`${WARN} Agent provision skipped: ${e.message}`);
+        }
+    }
+    // ── 5. Aha hint ──────────────────────────────────────────────────────────
+    console.log(`\n${OK} CodeBus installed.`);
+    console.log(`\n  ${ONE_LINER}`);
+    console.log(`\n  Indexed locally — nothing left this machine. Try:\n    codebus ask "..."`);
+}
+// Calls provision_my_agent RPC with the caller's token.
+// Returns the provisioned agent slug.
+export async function provisionMyAgent(opts) {
+    const { url, token, anonKey, slugSuffix = "claude", tool = "claude-code", _client } = opts;
+    // Build a supabase client authenticated with the caller's token.
+    const supabase = _client ?? createClient(url, anonKey, {
+        global: { headers: { Authorization: `Bearer ${token}`, apikey: anonKey } },
+        auth: { persistSession: false, autoRefreshToken: false },
+    });
+    // Derive the login slug from the current person (via agents.slug heuristic).
+    // We use the agents table to look up the caller's own slug, then build
+    // <login>-<tool> as the new agent slug.
+    const { data: me, error: meErr } = await supabase
+        .from("agents")
+        .select("slug")
+        .single();
+    if (meErr || !me)
+        throw new Error(meErr?.message ?? "could not resolve caller agent");
+    // Derive the base: strip trailing -<tool> or -default suffix if any.
+    const baseSlug = me.slug.replace(/-(claude|codex|default|mcp)$/, "");
+    const agentSlug = `${baseSlug}-${slugSuffix}`;
+    const displayName = `${baseSlug} (${slugSuffix})`;
+    const { data, error } = await supabase.rpc("provision_my_agent", {
+        p_slug: agentSlug,
+        p_display_name: displayName,
+        p_tool: tool,
+    });
+    if (error)
+        throw new Error(error.message);
+    return data.agent_slug;
+}
+/**
+ * Pure helper: derives the target agent slug from the caller's own agent slug.
+ * Strips any trailing recognized suffix (-claude|-codex|-default|-mcp), then
+ * appends `slugSuffix` (default "claude").
+ *
+ * Exported so unit tests can verify the regex without needing a supabase client.
+ */
+export function deriveAgentSlug(callerSlug, slugSuffix = "claude") {
+    const base = callerSlug.replace(/-(claude|codex|default|mcp)$/, "");
+    return `${base}-${slugSuffix}`;
+}
+export function registerInstall(program, g) {
+    const install = program
+        .command("install")
+        .description("wire CodeBus into agent launchers (run without subcommand for zero-config setup)")
+        .action(installAll);
+    g(install.command("claude")).option("--force", "replace an existing statusLine").action(installClaude);
+    g(install.command("codex")).action(installCodex);
+    g(install.command("mcp"))
+        .option("--yes", "skip confirmation prompt (opt-in gate)")
+        .description("register codebus-mcp server in Claude Code settings (opt-in only)")
+        .action(installMcp);
+}
+//# sourceMappingURL=install.js.map