bonecode 1.0.0 → 1.2.0

package/src/cli.ts

@@ -17,10 +17,17 @@ import "dotenv/config";
 import * as path from "path";
 import * as fs from "fs";
 import * as http from "http";
-import * as os from "os";
-import { spawn, execSync } from "child_process";
-
-const PKG_ROOT = path.resolve(__dirname, "..");
+import { execSync } from "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");
@@ -66,6 +73,11 @@ function help() {
   ${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
@@ -79,25 +91,42 @@ ${c.bold}Options for ${c.cyan}run${c.reset}${c.bold}:${c.reset}
   ${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}# Continue last session interactively${c.reset}
-  bonecode run -i -c
+  ${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}# Use a specific model${c.reset}
-  bonecode run -m anthropic/claude-sonnet-4-5 "refactor the payment module"
+  ${c.dim}# Checkout a GitHub PR${c.reset}
+  bonecode pr 42
 `);
 }
 
@@ -113,97 +142,33 @@ function checkServer(port: number): Promise<boolean> {
   });
 }
 
-// ─── Start server ─────────────────────────────────────────────────────────────
-
-function startServer(port: number, detached = false): Promise<void> {
-  return new Promise((resolve, reject) => {
-    const serverScript = path.join(PKG_ROOT, "src", "server.ts");
-    const tsNode = path.join(PKG_ROOT, "node_modules", ".bin", "ts-node");
-
-    const child = spawn(
-      fs.existsSync(tsNode) ? tsNode : "ts-node",
-      ["--project", path.join(PKG_ROOT, "tsconfig.json"), serverScript],
-      {
-        cwd: process.cwd(),
-        env: { ...process.env, PORT: String(port) },
-        stdio: detached ? "ignore" : ["ignore", "pipe", "pipe"],
-        detached,
-      }
-    );
-
-    if (detached) {
-      child.unref();
-      // Wait for server to be ready
-      let attempts = 0;
-      const poll = setInterval(async () => {
-        attempts++;
-        if (await checkServer(port)) {
-          clearInterval(poll);
-          resolve();
-        } else if (attempts > 30) {
-          clearInterval(poll);
-          reject(new Error("Server failed to start within 30 seconds"));
-        }
-      }, 1000);
-      return;
-    }
+// ─── Ensure server is running (in-process) ───────────────────────────────────
 
-    // Pipe server output
-    child.stdout?.on("data", (d: Buffer) => process.stdout.write(d));
-    child.stderr?.on("data", (d: Buffer) => process.stderr.write(d));
-
-    child.on("error", reject);
-    child.on("exit", (code) => {
-      if (code !== 0) reject(new Error(`Server exited with code ${code}`));
-    });
-
-    // Resolve once server is ready
-    let ready = false;
-    child.stdout?.on("data", (d: Buffer) => {
-      if (!ready && d.toString().includes("Server running on port")) {
-        ready = true;
-        resolve();
-      }
-    });
-  });
-}
-
-// ─── Ensure server is running ─────────────────────────────────────────────────
+let serverStarted = false;
 
 async function ensureServer(port: number): Promise<void> {
   if (await checkServer(port)) return;
-
-  process.stdout.write(`${c.dim}Starting BoneCode server on port ${port}...${c.reset} `);
-  try {
-    await startServer(port, true);
-    console.log(`${c.green}ready${c.reset}`);
-  } catch (e: any) {
-    console.log(`${c.red}failed${c.reset}`);
-    throw e;
+  if (serverStarted) return; // already starting
+  serverStarted = true;
+  await import("./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: string[]) {
   const port = parseInt(args.find(a => a.startsWith("--port="))?.split("=")[1] || process.env.PORT || "3000");
-  console.log(`${c.cyan}${c.bold}BoneCode${c.reset} server starting on port ${port}...`);
-  console.log(`${c.dim}  API:       http://localhost:${port}/v2/session${c.reset}`);
-  console.log(`${c.dim}  Health:    http://localhost:${port}/health${c.reset}`);
-  console.log(`${c.dim}  WebSocket: ws://localhost:${port}/ws${c.reset}`);
-  console.log(`${c.dim}  Press Ctrl+C to stop${c.reset}\n`);
-
-  // Run server in foreground (blocking)
-  const serverScript = path.join(PKG_ROOT, "src", "server.ts");
-  const tsNode = path.join(PKG_ROOT, "node_modules", ".bin", "ts-node");
-  const child = spawn(
-    fs.existsSync(tsNode) ? tsNode : "ts-node",
-    ["--project", path.join(PKG_ROOT, "tsconfig.json"), serverScript],
-    { cwd: process.cwd(), env: { ...process.env, PORT: String(port) }, stdio: "inherit" }
-  );
-  child.on("exit", (code) => process.exit(code ?? 0));
-  process.on("SIGINT", () => child.kill("SIGINT"));
-  process.on("SIGTERM", () => child.kill("SIGTERM"));
+  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 import("./server");
+  await new Promise<void>(() => {}); // keep alive
 }
 
 async function cmdRun(args: string[]) {
@@ -275,6 +240,7 @@ async function cmdRun(args: string[]) {
     const token = jwtLib.sign({ sub: "tui-user" }, secret, { expiresIn: "24h" });
 
     const { startInteractiveTUI } = await import("./tui");
+    process.env.BONECODE_TUI = "1";
     await startInteractiveTUI({ port, token, model: model!, provider, worktree: dir });
     return;
   }
@@ -344,20 +310,6 @@ async function streamPrompt(
   }
 
   if (inAssistantTurn) process.stdout.write("\n\n");
-
-  // Fetch and display the final stored response
-  const msgsR = await fetch(`${baseUrl}/v2/session/${sessionId}/message`, { headers });
-  const msgs = await msgsR.json() as any[];
-  const lastAssistant = msgs.filter((m: any) => m.role === "assistant").slice(-1)[0];
-  if (lastAssistant && !inAssistantTurn) {
-    const text = (lastAssistant.parts || [])
-      .filter((p: any) => p.type === "text")
-      .map((p: any) => p.data?.text || p.text || "")
-      .join("");
-    if (text.trim()) {
-      console.log(`${c.cyan}${c.bold}●${c.reset} ${text.trim()}\n`);
-    }
-  }
 }
 
 async function cmdStatus(args: string[]) {
@@ -396,35 +348,269 @@ async function cmdMigrate() {
   }
 }
 
+async function cmdStats(args: string[]) {
+  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 import("./stats");
+  const { Pool } = await import("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: string[]) {
+  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 import("./export");
+  const { Pool } = await import("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: string[]) {
+  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 import("./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: any) => {
+    if (err) console.log(`${c.dim}Open manually: ${url}${c.reset}`);
+  });
+
+  // Keep alive
+  await new Promise<void>(() => {});
+}
+
+async function cmdPr(args: string[]) {
+  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: string[]) {
+  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() {
-  // Default: start server (if not running) then launch the interactive TUI
   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();
 
-  // Generate JWT for API calls
   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" });
 
-  // Start server in background if not already running
-  const running = await checkServer(port);
-  if (!running) {
-    process.stdout.write(`${c.dim}Starting BoneCode server on port ${port}...${c.reset} `);
+  // 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: any) => {
+      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 as any).write = (chunk: any, ...args: any[]) =>
+      suppress(chunk) ? true : origWrite(chunk, ...args);
+    (process.stderr as any).write = (chunk: any, ...args: any[]) =>
+      suppress(chunk) ? true : origErr(chunk, ...args);
+
     try {
-      await startServer(port, true);
-      console.log(`${c.green}ready${c.reset}`);
+      process.stdout.write(`${c.dim}Starting BoneCode...${c.reset}\n`);
+      await import("./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: any) {
-      console.error(`\n${c.red}Failed to start server:${c.reset} ${e.message}`);
-      console.error(`${c.dim}Try: bonecode serve${c.reset}`);
+      // Restore stdout before printing error
+      (process.stdout as any).write = origWrite;
+      (process.stderr as any).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 as any).write = origWrite;
+    (process.stderr as any).write = origErr;
   }
 
-  // Launch the interactive TUI
+  // Launch TUI — process stays alive until user exits
+  process.env.BONECODE_TUI = "1";
   const { startInteractiveTUI } = await import("./tui");
   await startInteractiveTUI({ port, token, model, provider, worktree });
+
+  // TUI exited — kill the process (takes the in-process server with it)
+  process.exit(0);
 }
 
 // ─── Main ─────────────────────────────────────────────────────────────────────
@@ -459,6 +645,21 @@ async function main() {
     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`