bonecode 1.1.0 → 1.2.1

package/dist/src/cli.js

@@ -0,0 +1,687 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * BoneCode CLI
+ *
+ * Usage:
+ *   bonecode                          Start server + open TUI (default)
+ *   bonecode serve                    Start server only (headless)
+ *   bonecode run "fix the login bug"  Send a one-shot prompt, stream output
+ *   bonecode run -i                   Interactive mode (stream to terminal)
+ *   bonecode compile                  Recompile .bone files
+ *   bonecode migrate                  Run database migrations
+ *   bonecode status                   Show server status
+ *   bonecode --help                   Show help
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("dotenv/config");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const http = __importStar(require("http"));
+const child_process_1 = require("child_process");
+const PKG_ROOT = (() => {
+    // When running from compiled JS: __dirname = dist/src/ → go up 2 levels
+    // When running from source via ts-node: __dirname = src/ → go up 1 level
+    const fromSrc = path.resolve(__dirname, "..");
+    const fromDist = path.resolve(__dirname, "..", "..");
+    // Whichever has package.json is the real root
+    if (fs.existsSync(path.join(fromDist, "package.json")))
+        return fromDist;
+    return fromSrc;
+})();
+// Also load .env from package root when running globally (dotenv/config only loads from cwd)
+const pkgEnv = path.join(PKG_ROOT, ".env");
+if (pkgEnv !== path.join(process.cwd(), ".env") && fs.existsSync(pkgEnv)) {
+    require("dotenv").config({ path: pkgEnv, override: false });
+}
+const VERSION = JSON.parse(fs.readFileSync(path.join(PKG_ROOT, "package.json"), "utf-8")).version;
+// ─── ANSI helpers ─────────────────────────────────────────────────────────────
+const isTTY = process.stdout.isTTY;
+const c = {
+    reset: isTTY ? "\x1b[0m" : "",
+    bold: isTTY ? "\x1b[1m" : "",
+    dim: isTTY ? "\x1b[2m" : "",
+    cyan: isTTY ? "\x1b[36m" : "",
+    green: isTTY ? "\x1b[32m" : "",
+    yellow: isTTY ? "\x1b[33m" : "",
+    red: isTTY ? "\x1b[31m" : "",
+    blue: isTTY ? "\x1b[34m" : "",
+    magenta: isTTY ? "\x1b[35m" : "",
+};
+function logo() {
+    console.log(`
+${c.cyan}${c.bold}  ██████╗  ██████╗ ███╗   ██╗███████╗${c.reset}
+${c.cyan}${c.bold}  ██╔══██╗██╔═══██╗████╗  ██║██╔════╝${c.reset}
+${c.cyan}${c.bold}  ██████╔╝██║   ██║██╔██╗ ██║█████╗  ${c.reset}
+${c.cyan}${c.bold}  ██╔══██╗██║   ██║██║╚██╗██║██╔══╝  ${c.reset}
+${c.cyan}${c.bold}  ██████╔╝╚██████╔╝██║ ╚████║███████╗${c.reset}
+${c.cyan}${c.bold}  ╚═════╝  ╚═════╝ ╚═╝  ╚═══╝╚══════╝${c.reset}
+${c.dim}  BoneCode v${VERSION} — AI coding agent${c.reset}
+`);
+}
+function help() {
+    logo();
+    console.log(`${c.bold}Usage:${c.reset}
+  ${c.cyan}bonecode${c.reset}                          Start server and open interactive session
+  ${c.cyan}bonecode serve${c.reset}                    Start headless server only
+  ${c.cyan}bonecode run${c.reset} ${c.dim}[message]${c.reset}            Send a prompt and stream the response
+  ${c.cyan}bonecode run -i${c.reset}                   Interactive terminal mode
+  ${c.cyan}bonecode web${c.reset}                      Start server and open web UI in browser
+  ${c.cyan}bonecode stats${c.reset}                    Show token usage and cost statistics
+  ${c.cyan}bonecode export${c.reset} ${c.dim}[sessionID]${c.reset}       Export session as JSON
+  ${c.cyan}bonecode pr${c.reset} ${c.dim}<number>${c.reset}               Checkout a GitHub PR branch
+  ${c.cyan}bonecode github${c.reset}                   GitHub Actions agent management
+  ${c.cyan}bonecode compile${c.reset}                  Recompile .bone domain models
+  ${c.cyan}bonecode migrate${c.reset}                  Run database migrations
+  ${c.cyan}bonecode status${c.reset}                   Check if server is running
+  ${c.cyan}bonecode --version${c.reset}                Show version
+
+${c.bold}Options for ${c.cyan}run${c.reset}${c.bold}:${c.reset}
+  ${c.dim}-m, --model${c.reset}     Model to use (e.g. claude-sonnet-4-5, gpt-4o)
+  ${c.dim}-s, --session${c.reset}   Continue a specific session ID
+  ${c.dim}-c, --continue${c.reset}  Continue the last session
+  ${c.dim}--dir${c.reset}           Working directory (default: current directory)
+  ${c.dim}--port${c.reset}          Server port (default: 3000)
+  ${c.dim}-i, --interactive${c.reset} Stream output interactively
+
+${c.bold}Options for ${c.cyan}stats${c.reset}${c.bold}:${c.reset}
+  ${c.dim}--days N${c.reset}        Show stats for last N days (default: all time)
+  ${c.dim}--tools N${c.reset}       Show top N tools (default: all)
+  ${c.dim}--models N${c.reset}      Show top N models (default: hidden)
+  ${c.dim}--project ID${c.reset}    Filter by project ID
+
+${c.bold}Options for ${c.cyan}export${c.reset}${c.bold}:${c.reset}
+  ${c.dim}--sanitize${c.reset}      Redact sensitive data (file paths, tool outputs, etc.)
+
+${c.bold}Environment:${c.reset}
+  DATABASE_URL     PostgreSQL connection string
+  JWT_SECRET       JWT signing secret
+  DEFAULT_MODEL    Default LLM model
+  DEFAULT_PROVIDER Default LLM provider
+  PORT             Server port (default: 3000)
+  MDNS             Set to 'false' to disable mDNS discovery
+  MDNS_DOMAIN      Custom mDNS domain (default: bonecode.local)
+
+${c.bold}Examples:${c.reset}
+  ${c.dim}# Start the server and open a session in the browser${c.reset}
+  bonecode
+
+  ${c.dim}# Open the web UI${c.reset}
+  bonecode web
+
+  ${c.dim}# Send a one-shot prompt${c.reset}
+  bonecode run "fix the TypeScript errors in src/auth.ts"
+
+  ${c.dim}# Show cost and token stats${c.reset}
+  bonecode stats --days 7 --models 5
+
+  ${c.dim}# Export a session${c.reset}
+  bonecode export --sanitize > session.json
+
+  ${c.dim}# Checkout a GitHub PR${c.reset}
+  bonecode pr 42
+`);
+}
+// ─── Server health check ──────────────────────────────────────────────────────
+function checkServer(port) {
+    return new Promise((resolve) => {
+        const req = http.get(`http://localhost:${port}/health`, (res) => {
+            resolve(res.statusCode === 200);
+        });
+        req.on("error", () => resolve(false));
+        req.setTimeout(2000, () => { req.destroy(); resolve(false); });
+    });
+}
+// ─── Ensure server is running (in-process) ───────────────────────────────────
+let serverStarted = false;
+async function ensureServer(port) {
+    if (await checkServer(port))
+        return;
+    if (serverStarted)
+        return; // already starting
+    serverStarted = true;
+    await Promise.resolve().then(() => __importStar(require("./server")));
+    let attempts = 0;
+    while (attempts < 30) {
+        if (await checkServer(port))
+            return;
+        await new Promise(r => setTimeout(r, 500));
+        attempts++;
+    }
+    throw new Error("Server failed to start");
+}
+// ─── Commands ─────────────────────────────────────────────────────────────────
+async function cmdServe(args) {
+    const port = parseInt(args.find(a => a.startsWith("--port="))?.split("=")[1] || process.env.PORT || "3000");
+    process.env.PORT = String(port);
+    console.log(`${c.cyan}${c.bold}BoneCode${c.reset} server on port ${port} — press Ctrl+C to stop\n`);
+    // Start in-process and block forever (until SIGINT/SIGTERM)
+    await Promise.resolve().then(() => __importStar(require("./server")));
+    await new Promise(() => { }); // keep alive
+}
+async function cmdRun(args) {
+    // Parse flags
+    let message = "";
+    let model = process.env.DEFAULT_MODEL;
+    let provider = process.env.DEFAULT_PROVIDER || "openai_compatible";
+    let sessionId;
+    let continueSession = false;
+    let interactive = false;
+    let port = parseInt(process.env.PORT || "3000");
+    let dir = process.cwd();
+    const positional = [];
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === "-m" || a === "--model") {
+            const v = args[++i];
+            if (v?.includes("/")) {
+                const [p, ...m] = v.split("/");
+                provider = p;
+                model = m.join("/");
+            }
+            else {
+                model = v;
+            }
+        }
+        else if (a.startsWith("--model=")) {
+            const v = a.slice(8);
+            if (v.includes("/")) {
+                const [p, ...m] = v.split("/");
+                provider = p;
+                model = m.join("/");
+            }
+            else {
+                model = v;
+            }
+        }
+        else if (a === "-s" || a === "--session") {
+            sessionId = args[++i];
+        }
+        else if (a === "-c" || a === "--continue") {
+            continueSession = true;
+        }
+        else if (a === "-i" || a === "--interactive") {
+            interactive = true;
+        }
+        else if (a === "--port") {
+            port = parseInt(args[++i]);
+        }
+        else if (a.startsWith("--port=")) {
+            port = parseInt(a.slice(7));
+        }
+        else if (a === "--dir") {
+            dir = path.resolve(args[++i]);
+        }
+        else if (!a.startsWith("-")) {
+            positional.push(a);
+        }
+    }
+    message = positional.join(" ");
+    if (!message && !interactive && !continueSession && !sessionId) {
+        console.error(`${c.red}Error:${c.reset} provide a message or use ${c.cyan}-i${c.reset} for interactive mode`);
+        console.error(`  Example: bonecode run "fix the login bug"`);
+        process.exit(1);
+    }
+    await ensureServer(port);
+    // Get JWT token for API calls
+    const jwt = require("jsonwebtoken");
+    const secret = process.env.JWT_SECRET || "bonecode-dev-secret-do-not-use-in-production-at-all-ever";
+    const token = jwt.sign({ sub: "cli-user" }, secret, { expiresIn: "1h" });
+    const headers = {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${token}`,
+    };
+    const baseUrl = `http://localhost:${port}`;
+    // Resolve or create session
+    let sid = sessionId;
+    if (!sid && continueSession) {
+        const r = await fetch(`${baseUrl}/v2/session`, { headers });
+        const sessions = await r.json();
+        sid = sessions.find((s) => !s.parentID)?.id;
+    }
+    if (!sid) {
+        const r = await fetch(`${baseUrl}/v2/session`, {
+            method: "POST", headers,
+            body: JSON.stringify({ title: message.slice(0, 60) || "Interactive session", directory: dir }),
+        });
+        const sess = await r.json();
+        sid = sess.id;
+        if (!sid) {
+            console.error(`${c.red}Failed to create session${c.reset}`);
+            process.exit(1);
+        }
+    }
+    if (!message && interactive) {
+        // Interactive TUI mode
+        const jwtLib = require("jsonwebtoken");
+        const secret = process.env.JWT_SECRET || "bonecode-dev-secret-do-not-use-in-production-at-all-ever";
+        const token = jwtLib.sign({ sub: "tui-user" }, secret, { expiresIn: "24h" });
+        const { startInteractiveTUI } = await Promise.resolve().then(() => __importStar(require("./tui")));
+        process.env.BONECODE_TUI = "1";
+        await startInteractiveTUI({ port, token, model: model, provider, worktree: dir });
+        return;
+    }
+    // One-shot prompt with streaming output
+    console.log(`${c.dim}Session: ${sid}${c.reset}`);
+    console.log(`${c.dim}Model:   ${provider}/${model}${c.reset}\n`);
+    await streamPrompt(baseUrl, sid, message, model, provider, headers, interactive);
+}
+async function streamPrompt(baseUrl, sessionId, message, model, provider, headers, interactive) {
+    const r = await fetch(`${baseUrl}/v2/session/${sessionId}/prompt`, {
+        method: "POST", headers,
+        body: JSON.stringify({ content: message, modelID: model, providerID: provider }),
+    });
+    if (!r.ok) {
+        console.error(`${c.red}Error:${c.reset} ${await r.text()}`);
+        process.exit(1);
+    }
+    // Stream SSE events
+    const reader = r.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let inAssistantTurn = false;
+    while (true) {
+        const { value, done } = await reader.read();
+        if (done)
+            break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+            if (!line.startsWith("data: "))
+                continue;
+            try {
+                const event = JSON.parse(line.slice(6));
+                if (event.type === "part.delta" && event.delta?.type === "text") {
+                    if (!inAssistantTurn) {
+                        process.stdout.write(`\n${c.cyan}${c.bold}●${c.reset} `);
+                        inAssistantTurn = true;
+                    }
+                    process.stdout.write(event.delta.text);
+                }
+                if (event.type === "session.retry") {
+                    process.stdout.write(`\n${c.yellow}⟳ Retrying (attempt ${event.attempt}): ${event.message}${c.reset}\n`);
+                }
+                if (event.type === "error") {
+                    process.stdout.write(`\n${c.red}✗ ${event.properties?.message || "Unknown error"}${c.reset}\n`);
+                }
+                if (event.type === "tool.requested") {
+                    process.stdout.write(`\n${c.dim}⚙ ${event.tool_name}${c.reset}`);
+                }
+            }
+            catch { /* non-JSON line */ }
+        }
+    }
+    if (inAssistantTurn)
+        process.stdout.write("\n\n");
+}
+async function cmdStatus(args) {
+    const port = parseInt(args.find(a => a.startsWith("--port="))?.split("=")[1] || process.env.PORT || "3000");
+    const running = await checkServer(port);
+    if (running) {
+        console.log(`${c.green}${c.bold}●${c.reset} BoneCode server is ${c.green}running${c.reset} on port ${port}`);
+        console.log(`  ${c.dim}http://localhost:${port}/health${c.reset}`);
+    }
+    else {
+        console.log(`${c.red}${c.bold}●${c.reset} BoneCode server is ${c.red}not running${c.reset}`);
+        console.log(`  ${c.dim}Start with: bonecode serve${c.reset}`);
+    }
+}
+async function cmdCompile() {
+    console.log(`${c.cyan}Compiling .bone files...${c.reset}`);
+    try {
+        (0, child_process_1.execSync)(`node --max-old-space-size=512 ${path.join(PKG_ROOT, "scripts", "compile.js")}`, {
+            cwd: PKG_ROOT, stdio: "inherit",
+        });
+    }
+    catch {
+        process.exit(1);
+    }
+}
+async function cmdMigrate() {
+    console.log(`${c.cyan}Running migrations...${c.reset}`);
+    try {
+        (0, child_process_1.execSync)(`node --max-old-space-size=256 ${path.join(PKG_ROOT, "scripts", "migrate.js")}`, {
+            cwd: PKG_ROOT, stdio: "inherit",
+            env: { ...process.env },
+        });
+    }
+    catch {
+        process.exit(1);
+    }
+}
+async function cmdStats(args) {
+    const days = (() => {
+        const idx = args.findIndex(a => a === "--days");
+        if (idx >= 0)
+            return parseInt(args[idx + 1] || "0");
+        const match = args.find(a => a.startsWith("--days="));
+        if (match)
+            return parseInt(match.split("=")[1]);
+        return undefined;
+    })();
+    const toolLimit = (() => {
+        const idx = args.findIndex(a => a === "--tools");
+        if (idx >= 0)
+            return parseInt(args[idx + 1] || "10");
+        const match = args.find(a => a.startsWith("--tools="));
+        if (match)
+            return parseInt(match.split("=")[1]);
+        return undefined;
+    })();
+    const modelLimit = (() => {
+        const idx = args.findIndex(a => a === "--models");
+        if (idx >= 0) {
+            const val = args[idx + 1];
+            return val ? parseInt(val) : Infinity;
+        }
+        const match = args.find(a => a.startsWith("--models="));
+        if (match)
+            return parseInt(match.split("=")[1]);
+        return undefined;
+    })();
+    const projectFilter = (() => {
+        const idx = args.findIndex(a => a === "--project");
+        if (idx >= 0)
+            return args[idx + 1];
+        const match = args.find(a => a.startsWith("--project="));
+        if (match)
+            return match.split("=")[1];
+        return undefined;
+    })();
+    const port = parseInt(process.env.PORT || "3000");
+    await ensureServer(port);
+    // Use the stats module directly via the server's DB
+    const { aggregateStats, displayStats } = await Promise.resolve().then(() => __importStar(require("./stats")));
+    const { Pool } = await Promise.resolve().then(() => __importStar(require("pg")));
+    const pool = new Pool({ connectionString: process.env.DATABASE_URL });
+    try {
+        console.log(`${c.dim}Aggregating stats...${c.reset}`);
+        const stats = await aggregateStats(pool, { days, projectFilter });
+        displayStats(stats, toolLimit, modelLimit);
+    }
+    finally {
+        await pool.end();
+    }
+}
+async function cmdExport(args) {
+    const sessionId = args.find(a => !a.startsWith("-"));
+    const sanitize = args.includes("--sanitize");
+    const port = parseInt(process.env.PORT || "3000");
+    await ensureServer(port);
+    const { exportSession, listSessionsForExport } = await Promise.resolve().then(() => __importStar(require("./export")));
+    const { Pool } = await Promise.resolve().then(() => __importStar(require("pg")));
+    const pool = new Pool({ connectionString: process.env.DATABASE_URL });
+    try {
+        let sid = sessionId;
+        if (!sid) {
+            // Pick the most recent session
+            const sessions = await listSessionsForExport(pool);
+            if (sessions.length === 0) {
+                console.error(`${c.red}No sessions found${c.reset}`);
+                process.exit(1);
+            }
+            sid = sessions[0].id;
+            console.error(`${c.dim}Exporting most recent session: ${sid}${c.reset}`);
+        }
+        const json = await exportSession(pool, sid, { sanitize });
+        process.stdout.write(json + "\n");
+    }
+    finally {
+        await pool.end();
+    }
+}
+async function cmdWeb(args) {
+    const port = parseInt(args.find(a => a.startsWith("--port="))?.split("=")[1] || process.env.PORT || "3000");
+    process.env.PORT = String(port);
+    const alreadyRunning = await checkServer(port);
+    if (!alreadyRunning) {
+        console.log(`${c.cyan}${c.bold}BoneCode${c.reset} starting server on port ${port}...`);
+        await Promise.resolve().then(() => __importStar(require("./server")));
+        let attempts = 0;
+        while (attempts < 30) {
+            if (await checkServer(port))
+                break;
+            await new Promise(r => setTimeout(r, 500));
+            attempts++;
+        }
+    }
+    const url = `http://localhost:${port}/ui`;
+    console.log(`${c.cyan}${c.bold}BoneCode${c.reset} web UI: ${c.dim}${url}${c.reset}`);
+    // Open browser
+    const { exec } = require("child_process");
+    const openCmd = process.platform === "darwin" ? `open "${url}"`
+        : process.platform === "win32" ? `start "" "${url}"`
+            : `xdg-open "${url}"`;
+    exec(openCmd, (err) => {
+        if (err)
+            console.log(`${c.dim}Open manually: ${url}${c.reset}`);
+    });
+    // Keep alive
+    await new Promise(() => { });
+}
+async function cmdPr(args) {
+    const prNumber = parseInt(args[0] || "");
+    if (!prNumber || isNaN(prNumber)) {
+        console.error(`${c.red}Usage:${c.reset} bonecode pr <number>`);
+        process.exit(1);
+    }
+    const { execSync, spawnSync } = require("child_process");
+    const localBranch = `pr/${prNumber}`;
+    console.log(`${c.cyan}Fetching PR #${prNumber}...${c.reset}`);
+    // Check gh CLI is available
+    try {
+        execSync("gh --version", { stdio: "ignore" });
+    }
+    catch {
+        console.error(`${c.red}Error:${c.reset} gh CLI not found. Install from https://cli.github.com/`);
+        process.exit(1);
+    }
+    // Checkout the PR
+    const checkout = spawnSync("gh", ["pr", "checkout", String(prNumber), "--branch", localBranch, "--force"], {
+        stdio: "inherit",
+    });
+    if (checkout.status !== 0) {
+        console.error(`${c.red}Failed to checkout PR #${prNumber}${c.reset}`);
+        process.exit(1);
+    }
+    console.log(`${c.green}✓${c.reset} Checked out PR #${prNumber} as branch '${localBranch}'`);
+    console.log(`\n${c.dim}Starting BoneCode...${c.reset}\n`);
+    // Launch bonecode in the current directory
+    const result = spawnSync(process.execPath, [process.argv[1], "run", "-i"], {
+        stdio: "inherit",
+        cwd: process.cwd(),
+    });
+    process.exit(result.status || 0);
+}
+async function cmdGithub(args) {
+    const sub = args[0];
+    if (sub === "install") {
+        console.log(`${c.cyan}GitHub Agent Setup${c.reset}`);
+        console.log(`\nTo install the BoneCode GitHub agent:`);
+        console.log(`\n  1. Add a GitHub Actions workflow file:`);
+        console.log(`\n${c.dim}.github/workflows/bonecode.yml${c.reset}`);
+        console.log(`
+${c.dim}name: bonecode
+on:
+  issue_comment:
+    types: [created]
+  pull_request_review_comment:
+    types: [created]
+
+jobs:
+  bonecode:
+    if: |
+      contains(github.event.comment.body, '/bc') ||
+      startsWith(github.event.comment.body, '/bc')
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Run BoneCode
+        run: npx bonecode run "\${{ github.event.comment.body }}"
+        env:
+          ANTHROPIC_API_KEY: \${{ secrets.ANTHROPIC_API_KEY }}
+          DATABASE_URL: \${{ secrets.DATABASE_URL }}${c.reset}`);
+        console.log(`\n  2. Add your API key as a GitHub secret`);
+        console.log(`  3. Comment '/bc <task>' on any issue or PR\n`);
+    }
+    else if (sub === "run") {
+        // Run the GitHub agent from a workflow context
+        const prompt = process.env.PROMPT || args.slice(1).join(" ");
+        if (!prompt) {
+            console.error(`${c.red}Error:${c.reset} PROMPT env var or message required`);
+            process.exit(1);
+        }
+        const port = parseInt(process.env.PORT || "3000");
+        await ensureServer(port);
+        await cmdRun(["--interactive=false", prompt]);
+    }
+    else {
+        console.log(`${c.bold}bonecode github${c.reset} — GitHub agent management`);
+        console.log(`\n  ${c.cyan}bonecode github install${c.reset}   Show setup instructions`);
+        console.log(`  ${c.cyan}bonecode github run${c.reset}        Run agent (for CI/CD use)`);
+    }
+}
+async function cmdDefault() {
+    const port = parseInt(process.env.PORT || "3000");
+    const model = process.env.DEFAULT_MODEL || "local-model";
+    const provider = process.env.DEFAULT_PROVIDER || "openai_compatible";
+    const worktree = process.cwd();
+    const jwtLib = require("jsonwebtoken");
+    const secret = process.env.JWT_SECRET || "bonecode-dev-secret-do-not-use-in-production-at-all-ever";
+    const token = jwtLib.sign({ sub: "tui-user" }, secret, { expiresIn: "24h" });
+    // If server is already running externally (e.g. bonecode serve), just attach
+    const alreadyRunning = await checkServer(port);
+    if (!alreadyRunning) {
+        // Start the server IN-PROCESS — same Node.js instance as the CLI.
+        // This means the server dies automatically when the TUI exits.
+        // Suppress server startup logs in default (TUI) mode.
+        const origWrite = process.stdout.write.bind(process.stdout);
+        const origErr = process.stderr.write.bind(process.stderr);
+        let startupDone = false;
+        const suppress = (chunk) => {
+            if (startupDone)
+                return false; // let it through after startup
+            const s = chunk.toString();
+            // Only suppress JSON log lines and the server banner
+            if (s.startsWith("{") || s.startsWith("[BoneCode]") || s.startsWith("  OpenCode") ||
+                s.startsWith("  Health") || s.startsWith("  Domain") || s.startsWith("  WebSocket")) {
+                return true;
+            }
+            return false;
+        };
+        process.stdout.write = (chunk, ...args) => suppress(chunk) ? true : origWrite(chunk, ...args);
+        process.stderr.write = (chunk, ...args) => suppress(chunk) ? true : origErr(chunk, ...args);
+        try {
+            process.stdout.write(`${c.dim}Starting BoneCode...${c.reset}\n`);
+            await Promise.resolve().then(() => __importStar(require("./server")));
+            let attempts = 0;
+            while (attempts < 30) {
+                if (await checkServer(port))
+                    break;
+                await new Promise(r => setTimeout(r, 500));
+                attempts++;
+            }
+            if (!(await checkServer(port)))
+                throw new Error("Server failed to start");
+        }
+        catch (e) {
+            // Restore stdout before printing error
+            process.stdout.write = origWrite;
+            process.stderr.write = origErr;
+            console.error(`${c.red}Failed to start server:${c.reset} ${e.message}`);
+            process.exit(1);
+        }
+        // Restore stdout now that startup is done
+        startupDone = true;
+        process.stdout.write = origWrite;
+        process.stderr.write = origErr;
+    }
+    // Launch TUI — process stays alive until user exits
+    process.env.BONECODE_TUI = "1";
+    const { startInteractiveTUI } = await Promise.resolve().then(() => __importStar(require("./tui")));
+    await startInteractiveTUI({ port, token, model, provider, worktree });
+    // TUI exited — kill the process (takes the in-process server with it)
+    process.exit(0);
+}
+// ─── Main ─────────────────────────────────────────────────────────────────────
+async function main() {
+    const args = process.argv.slice(2);
+    const cmd = args[0];
+    if (cmd === "--version" || cmd === "-v") {
+        console.log(`bonecode v${VERSION}`);
+        return;
+    }
+    if (cmd === "--help" || cmd === "-h" || cmd === "help") {
+        help();
+        return;
+    }
+    switch (cmd) {
+        case "serve":
+            await cmdServe(args.slice(1));
+            break;
+        case "run":
+            await cmdRun(args.slice(1));
+            break;
+        case "status":
+            await cmdStatus(args.slice(1));
+            break;
+        case "compile":
+            await cmdCompile();
+            break;
+        case "migrate":
+            await cmdMigrate();
+            break;
+        case "stats":
+            await cmdStats(args.slice(1));
+            break;
+        case "export":
+            await cmdExport(args.slice(1));
+            break;
+        case "web":
+            await cmdWeb(args.slice(1));
+            break;
+        case "pr":
+            await cmdPr(args.slice(1));
+            break;
+        case "github":
+            await cmdGithub(args.slice(1));
+            break;
+        default:
+            if (cmd && !cmd.startsWith("-")) {
+                // Treat unknown first arg as a message to `run`
+                await cmdRun(args);
+            }
+            else {
+                await cmdDefault();
+            }
+    }
+}
+main().catch((e) => {
+    console.error(`${c.red}Error:${c.reset} ${e.message}`);
+    process.exit(1);
+});
+//# sourceMappingURL=cli.js.map