bonecode 1.0.0 → 1.1.0

package/compat/opencode_adapter.ts

@@ -25,6 +25,7 @@ import { Router, Request, Response } from "express";
 import { pool } from "../bone/output/session/src/db";
 import { eventBus } from "../bone/output/session/src/events";
 import { requireAuth } from "../bone/output/session/src/auth";
+import { subscribeToChannel, unsubscribeFromChannel } from "../bone/output/session/src/websocket";
 import { v4 as uuid } from "uuid";
 
 export const compatRouter = Router();
@@ -160,34 +161,50 @@ compatRouter.post("/v2/session/:id/prompt", requireAuth, async (req: Request, re
       [session_id]
     );
 
-    // Emit session.updated event to SSE subscribers
     sendSSE(res, "session.updated", { type: "session.updated", properties: { id: session_id } });
     sendSSE(res, "message.updated", { type: "message.updated", properties: { id: message_id, sessionID: session_id } });
 
-    // Subscribe to part updates for this session (live streaming)
-    const unsubscribe = subscribeToSessionEvents(session_id, (event) => {
+    // Subscribe to part_stream BEFORE starting the agent so we don't miss any deltas.
+    // The agent loop calls broadcastToChannel("part_stream", {type:"part.delta",...})
+    // synchronously during streaming — this handler forwards them straight to SSE.
+    const channelHandler = (msg: any) => {
+      if (msg.session_id !== session_id) return;
+      if (msg.type === "part.delta") {
+        sendSSE(res, "part.delta", {
+          type: "part.delta",
+          delta: msg.delta,
+          partID: msg.part_id,
+          messageID: msg.message_id,
+        });
+      }
+    };
+    subscribeToChannel("part_stream", channelHandler);
+
+    // Subscribe to eventBus for tool calls and agent state changes
+    const unsubscribeEvents = subscribeToSessionEvents(session_id, (event) => {
       sendSSE(res, event.type, event.data);
     });
 
-    // Start the agent turn (async — results come via events)
+    const cleanup = () => {
+      unsubscribeFromChannel("part_stream", channelHandler);
+      unsubscribeEvents();
+    };
+
+    req.on("close", cleanup);
+
+    // Start agent — runs async, deltas flow via channelHandler above
     startAgentTurn(session_id, message_id, modelID, providerID)
       .then(() => {
         sendSSE(res, "session.updated", { type: "session.updated", properties: { id: session_id } });
         res.end();
       })
       .catch((e) => {
-        console.error("[AgentLoop] Error:", e.message, e.stack?.split("\n").slice(0,5).join(" | "));
+        console.error("[AgentLoop] Error:", e.message);
         sendSSE(res, "error", { type: "error", properties: { message: e.message } });
         res.end();
       })
-      .finally(() => {
-        unsubscribe();
-      });
+      .finally(cleanup);
 
-    // Handle client disconnect
-    req.on("close", () => {
-      unsubscribe();
-    });
   } catch (e: any) {
     sendSSE(res, "error", { type: "error", properties: { message: e.message } });
     res.end();
@@ -248,11 +265,71 @@ compatRouter.get("/v2/event", (req: Request, res: Response) => {
 // GET /v2/provider — list available providers
 compatRouter.get("/v2/provider", (_req: Request, res: Response) => {
   res.json([
-    { id: "anthropic", name: "Anthropic", models: ["claude-opus-4-5", "claude-sonnet-4-5", "claude-haiku-3-5"] },
-    { id: "openai", name: "OpenAI", models: ["gpt-4o", "gpt-4o-mini", "o1", "o3-mini"] },
-    { id: "google", name: "Google", models: ["gemini-2.0-flash", "gemini-1.5-pro"] },
-    { id: "ollama", name: "Ollama (local)", models: [] },
-    { id: "openrouter", name: "OpenRouter", models: [] },
+    {
+      id: "anthropic", name: "Anthropic",
+      models: ["claude-opus-4-5", "claude-sonnet-4-5", "claude-haiku-3-5"],
+      keyEnv: "ANTHROPIC_API_KEY", url: "https://console.anthropic.com/",
+    },
+    {
+      id: "openai", name: "OpenAI",
+      models: ["gpt-4o", "gpt-4o-mini", "o3-mini", "o4-mini"],
+      keyEnv: "OPENAI_API_KEY", url: "https://platform.openai.com/api-keys",
+    },
+    {
+      id: "google", name: "Google Gemini",
+      models: ["gemini-2.0-flash", "gemini-2.5-pro", "gemini-1.5-flash"],
+      keyEnv: "GOOGLE_API_KEY", url: "https://aistudio.google.com/apikey",
+      free: true, freeNote: "Free tier available via Google AI Studio",
+    },
+    {
+      id: "groq", name: "Groq",
+      models: ["llama-3.3-70b-versatile", "llama-3.1-8b-instant", "mixtral-8x7b-32768", "gemma2-9b-it"],
+      keyEnv: "GROQ_API_KEY", url: "https://console.groq.com/keys",
+      free: true, freeNote: "Generous free tier — very fast inference",
+    },
+    {
+      id: "cerebras", name: "Cerebras",
+      models: ["llama3.1-8b", "llama3.1-70b", "llama-4-scout-17b-16e-instruct"],
+      keyEnv: "CEREBRAS_API_KEY", url: "https://cloud.cerebras.ai/",
+      free: true, freeNote: "Free tier — fastest inference available",
+    },
+    {
+      id: "deepseek", name: "DeepSeek",
+      models: ["deepseek-chat", "deepseek-reasoner"],
+      keyEnv: "DEEPSEEK_API_KEY", url: "https://platform.deepseek.com/api_keys",
+      free: false, freeNote: "Paid API but very cheap (~$0.07/1M tokens). Free access via OpenRouter: deepseek/deepseek-chat-v3-0324:free — or via opencode.ai/go (OpenCode's own hosted service)",
+    },
+    {
+      id: "openrouter", name: "OpenRouter",
+      models: [
+        "deepseek/deepseek-chat-v3-0324:free",
+        "deepseek/deepseek-r1:free",
+        "meta-llama/llama-3.3-70b-instruct:free",
+        "google/gemma-3-27b-it:free",
+        "mistralai/mistral-7b-instruct:free",
+      ],
+      keyEnv: "OPENROUTER_API_KEY", url: "https://openrouter.ai/keys",
+      free: true, freeNote: "Free models available — append :free to any model ID. DeepSeek V3 and R1 are free here",
+    },
+    {
+      id: "ollama", name: "Ollama (local)",
+      models: [],
+      keyEnv: null, url: "https://ollama.com/",
+      free: true, freeNote: "Fully local — no API key needed",
+    },
+    {
+      id: "openai_compatible", name: "OpenAI-compatible (LM Studio, vLLM, etc.)",
+      models: [],
+      keyEnv: "OPENAI_API_KEY", url: "https://lmstudio.ai/",
+      free: true, freeNote: "Local models via any OpenAI-compatible endpoint",
+    },
+    {
+      id: "local", name: "Local config (.env)",
+      models: [process.env.DEFAULT_MODEL || ""].filter(Boolean),
+      keyEnv: null, url: null,
+      free: true,
+      freeNote: `Uses DEFAULT_PROVIDER=${process.env.DEFAULT_PROVIDER || "openai_compatible"} and DEFAULT_MODEL=${process.env.DEFAULT_MODEL || "(not set)"} from your .env`,
+    },
   ]);
 });
 

package/package.json

@@ -1,9 +1,17 @@
 {
   "name": "bonecode",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "private": false,
   "description": "BoneCode — a production-grade AI coding agent with BoneScript-generated backend and pgvector RAG",
-  "keywords": ["ai", "coding-agent", "llm", "rag", "pgvector", "opencode", "bonescript"],
+  "keywords": [
+    "ai",
+    "coding-agent",
+    "llm",
+    "rag",
+    "pgvector",
+    "opencode",
+    "bonescript"
+  ],
   "author": "BoneCode Contributors",
   "license": "MIT",
   "homepage": "https://github.com/Doorman11991/bonecode",
@@ -38,10 +46,15 @@
   },
   "dependencies": {
     "@ai-sdk/anthropic": "1.2.12",
+    "@ai-sdk/cerebras": "^2.0.51",
     "@ai-sdk/google": "1.2.18",
+    "@ai-sdk/groq": "^3.0.39",
     "@ai-sdk/openai": "1.3.22",
     "@modelcontextprotocol/sdk": "1.10.2",
+    "@openrouter/ai-sdk-provider": "^2.9.0",
+    "@types/better-sqlite3": "^7.6.13",
     "ai": "4.3.16",
+    "better-sqlite3": "^12.10.0",
     "cors": "2.8.5",
     "dotenv": "16.3.1",
     "express": "4.18.2",

package/src/cli.ts

@@ -17,8 +17,7 @@ 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";
+import { execSync } from "child_process";
 
 const PKG_ROOT = path.resolve(__dirname, "..");
 
@@ -113,97 +112,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;
-    }
-
-    // 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 (in-process) ───────────────────────────────────
 
-// ─── 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 +210,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 +280,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[]) {
@@ -397,34 +319,71 @@ async function cmdMigrate() {
 }
 
 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 ─────────────────────────────────────────────────────────────────────