bonecode 1.0.0 → 1.2.0

package/src/export.ts

@@ -0,0 +1,122 @@
+/**
+ * Session export with optional PII redaction
+ * Ported from opencode's cli/cmd/export.ts — adapted for BoneCode's Postgres schema.
+ */
+
+import { Pool } from "pg"
+
+// ─── Redaction helpers (verbatim from opencode) ───────────────────────────────
+
+function redact(kind: string, id: string, value: string) {
+  return value.trim() ? `[redacted:${kind}:${id}]` : value
+}
+
+function redactData(kind: string, id: string, value: Record<string, unknown> | undefined) {
+  if (!value) return value
+  return Object.keys(value).length ? { redacted: `${kind}:${id}` } : value
+}
+
+function redactSpan(id: string, value: { value: string; start: number; end: number }) {
+  return { ...value, value: redact("file-text", id, value.value) }
+}
+
+function redactDiff(kind: string, diffs: { file?: string; patch?: string }[] | undefined) {
+  return diffs?.map((item, i) => ({
+    ...item,
+    file: item.file === undefined ? undefined : redact(`${kind}-file`, String(i), item.file),
+    patch: item.patch === undefined ? undefined : redact(`${kind}-patch`, String(i), item.patch),
+  }))
+}
+
+function sanitizePart(part: any): any {
+  const id = part.id || "unknown"
+  switch (part.part_type || part.type) {
+    case "text":
+      return {
+        ...part,
+        data: part.data ? { ...part.data, text: redact("text", id, part.data.text || "") } : part.data,
+      }
+    case "tool_invocation":
+      return {
+        ...part,
+        data: part.data ? { ...part.data, args: redactData("tool-input", id, part.data.args) } : part.data,
+      }
+    case "tool_result":
+      return {
+        ...part,
+        data: part.data ? { ...part.data, result: redact("tool-output", id, String(part.data.result || "")) } : part.data,
+      }
+    case "file":
+      return {
+        ...part,
+        data: part.data ? {
+          ...part.data,
+          url: redact("file-url", id, part.data.url || ""),
+          filename: part.data.filename ? redact("file-name", id, part.data.filename) : undefined,
+        } : part.data,
+      }
+    default:
+      return part
+  }
+}
+
+function sanitizeSession(session: any, messages: any[]): any {
+  return {
+    info: {
+      ...session,
+      title: redact("session-title", session.id, session.title || ""),
+      directory: redact("session-directory", session.id, session.directory || ""),
+    },
+    messages: messages.map((msg) => ({
+      ...msg,
+      parts: (msg.parts || []).map(sanitizePart),
+    })),
+  }
+}
+
+// ─── Export function ──────────────────────────────────────────────────────────
+
+export async function exportSession(
+  pool: Pool,
+  sessionId: string,
+  opts: { sanitize?: boolean } = {}
+): Promise<string> {
+  const sessionResult = await pool.query(
+    `SELECT * FROM sessions WHERE id = $1`,
+    [sessionId]
+  )
+  if (!sessionResult.rows[0]) {
+    throw new Error(`Session not found: ${sessionId}`)
+  }
+  const session = sessionResult.rows[0]
+
+  const messagesResult = await pool.query(
+    `SELECT m.*,
+            json_agg(
+              json_build_object(
+                'id', p.id,
+                'part_type', p.part_type,
+                'data', p.data,
+                'order_index', p.order_index
+              ) ORDER BY p.order_index
+            ) FILTER (WHERE p.id IS NOT NULL) as parts
+     FROM messages m
+     LEFT JOIN parts p ON p.message_id = m.id
+     WHERE m.session_id = $1
+     GROUP BY m.id
+     ORDER BY m.created_at ASC`,
+    [sessionId]
+  )
+  const messages = messagesResult.rows
+
+  const exportData = { info: session, messages }
+  const output = opts.sanitize ? sanitizeSession(session, messages) : exportData
+  return JSON.stringify(output, null, 2)
+}
+
+export async function listSessionsForExport(pool: Pool): Promise<Array<{ id: string; title: string; updated_at: string }>> {
+  const result = await pool.query(
+    `SELECT id, title, updated_at FROM sessions WHERE state != 'deleted' ORDER BY updated_at DESC LIMIT 100`
+  )
+  return result.rows
+}

package/src/mdns.ts

@@ -0,0 +1,53 @@
+/**
+ * mDNS / Bonjour local network discovery
+ * Ported from opencode's server/mdns.ts — no Effect.js dependency.
+ * All output is suppressed — mDNS is a background convenience feature.
+ */
+
+import { Bonjour } from "bonjour-service"
+
+let bonjour: Bonjour | undefined
+let currentPort: number | undefined
+
+export function publish(port: number, domain?: string) {
+  if (currentPort === port) return
+  if (bonjour) unpublish()
+
+  try {
+    const host = domain ?? "bonecode.local"
+    const name = `bonecode-${port}`
+    bonjour = new Bonjour()
+    const service = bonjour.publish({
+      name,
+      type: "http",
+      host,
+      port,
+      txt: { path: "/" },
+    })
+
+    // Silently swallow events — mDNS is best-effort
+    service.on("up", () => {})
+    service.on("error", () => {})
+
+    currentPort = port
+  } catch {
+    // mDNS unavailable (e.g. no Bonjour/Avahi installed) — ignore silently
+    if (bonjour) {
+      try { bonjour.destroy() } catch {}
+    }
+    bonjour = undefined
+    currentPort = undefined
+  }
+}
+
+export function unpublish() {
+  if (!bonjour) return
+  try {
+    bonjour.unpublishAll()
+    bonjour.destroy()
+  } catch {
+    // ignore
+  }
+  bonjour = undefined
+  currentPort = undefined
+}

package/src/server.ts

@@ -1,12 +1,8 @@
 /**
  * BoneCode Server Entry Point
  *
- * Wires together:
- *   1. The BoneScript-generated domain routes (session, agent, rag, workspace)
- *   2. The OpenCode v2 compatibility adapter (for existing TUI/Desktop/VS Code clients)
- *   3. The RAG ingestion worker (background job processor)
- *   4. The durable event bus worker
- *   5. WebSocket server for realtime channels
+ * Database: auto-detects Postgres (full RAG) or falls back to SQLite (sessions only).
+ * No Docker required for basic use — just run `bonecode`.
  */
 
 import "dotenv/config";
@@ -15,187 +11,186 @@ import { createServer } from "http";
 import cors from "cors";
 import helmet from "helmet";
 import rateLimit from "express-rate-limit";
-import { compatRouter } from "../compat/opencode_adapter";
-import { ragWorker } from "./rag_worker";
+import path from "path";
+import fs from "fs";
+import { initDatabase } from "./db_adapter";
 import { loadConfig } from "./config";
-
-// ─── Import generated domain routes ──────────────────────────────────────────
-// These are generated by `npm run compile` into bone/output/*/src/
-
-import { pool } from "../bone/output/session/src/db";
-import { eventBus } from "../bone/output/session/src/events";
-import { logger } from "../bone/output/session/src/logger";
-import { authMiddleware } from "../bone/output/session/src/auth";
-import { setupWebSocketServer, broadcastToChannel } from "../bone/output/session/src/websocket";
-
-// Generated routers
-import { projectsRouter } from "../bone/output/session/src/routes/project";
-import { sessionsRouter } from "../bone/output/session/src/routes/session";
-import { messagesRouter } from "../bone/output/session/src/routes/message";
-import { partsRouter } from "../bone/output/session/src/routes/part";
-import { permissionsRouter } from "../bone/output/session/src/routes/permission";
-
-import { agentInstancesRouter } from "../bone/output/agent/src/routes/agent_instance";
-import { tasksRouter } from "../bone/output/agent/src/routes/task";
-import { toolCallsRouter } from "../bone/output/agent/src/routes/tool_call";
-import { plansRouter } from "../bone/output/agent/src/routes/plan";
-import { buildStepsRouter } from "../bone/output/agent/src/routes/build_step";
-
-import { knowledgeBasesRouter } from "../bone/output/rag/src/routes/knowledge_base";
-import { codeFilesRouter } from "../bone/output/rag/src/routes/code_file";
-import { codeChunksRouter } from "../bone/output/rag/src/routes/code_chunk";
-import { memoryEntrysRouter } from "../bone/output/rag/src/routes/memory_entry";
-import { indexingJobsRouter } from "../bone/output/rag/src/routes/indexing_job";
-
-import { workspacesRouter } from "../bone/output/workspace/src/routes/workspace";
-import { snapshotsRouter } from "../bone/output/workspace/src/routes/snapshot";
-import { codebasesRouter } from "../bone/output/workspace/src/routes/codebase";
-
-// ─── App Setup ────────────────────────────────────────────────────────────────
+import * as MDNS from "./mdns";
 
 const config = loadConfig();
 const app = express();
 const httpServer = createServer(app);
 const PORT = config.port;
 
-// ─── Middleware ───────────────────────────────────────────────────────────────
-
 app.use(helmet());
-app.set("trust proxy", 1); // trust first proxy for rate limiting
-
-const allowedOrigins = config.allowedOrigins;
+app.set("trust proxy", 1);
 app.use(cors({
-  origin: allowedOrigins.length > 0
+  origin: config.allowedOrigins.length > 0
     ? (origin, cb) => {
-        if (!origin || allowedOrigins.includes(origin)) cb(null, true);
+        if (!origin || config.allowedOrigins.includes(origin)) cb(null, true);
         else cb(new Error("Not allowed by CORS"));
       }
     : false,
   credentials: true,
 }));
-
 app.use(express.json({ limit: "4mb" }));
 app.use(express.urlencoded({ extended: false, limit: "1mb" }));
-app.use(authMiddleware); // populate req.auth for all routes
-
-// Global rate limit
-app.use(rateLimit({ windowMs: 60_000, max: 1000, standardHeaders: true, legacyHeaders: false }));
-
-// Request timeout
-app.use((req: any, res: any, next: any) => {
-  const timer = setTimeout(() => {
-    if (!res.headersSent) {
-      res.status(503).json({ error: { code: "REQUEST_TIMEOUT", message: "Request timed out" } });
-    }
-  }, config.requestTimeoutMs);
-  res.on("finish", () => clearTimeout(timer));
-  next();
-});
-
-// ─── WebSocket server (generated by BoneScript) ───────────────────────────────
-setupWebSocketServer(httpServer);
-
-// ─── OpenCode v2 Compatibility Routes (must come first — clients use these) ──
-
-app.use(compatRouter);
-
-// ─── BoneCode Domain Routes ───────────────────────────────────────────────────
-
-// Session domain
-app.use("/projects", projectsRouter);
-app.use("/sessions", sessionsRouter);
-app.use("/messages", messagesRouter);
-app.use("/parts", partsRouter);
-app.use("/permissions", permissionsRouter);
-
-// Agent domain
-app.use("/agents", agentInstancesRouter);
-app.use("/tasks", tasksRouter);
-app.use("/tool-calls", toolCallsRouter);
-app.use("/plans", plansRouter);
-app.use("/build-steps", buildStepsRouter);
-
-// RAG domain
-app.use("/knowledge-bases", knowledgeBasesRouter);
-app.use("/code-files", codeFilesRouter);
-app.use("/code-chunks", codeChunksRouter);
-app.use("/memory-entries", memoryEntrysRouter);
-app.use("/indexing-jobs", indexingJobsRouter);
 
-// Workspace domain
-app.use("/workspaces", workspacesRouter);
-app.use("/snapshots", snapshotsRouter);
-app.use("/codebases", codebasesRouter);
+async function startServer() {
+  // ── 1. Database — Postgres or SQLite fallback ─────────────────────────────
+  const { pool: dbPool, mode } = await initDatabase(true);
 
-// ─── 404 Handler ─────────────────────────────────────────────────────────────
+  // Patch the generated db module so all generated routes use our pool.
+  // The generated pool is a lazy Proxy — we replace its backing _pool.
+  const dbModule = require("../bone/output/session/src/db");
+  (dbModule as any)._pool = dbPool;
 
-app.use((_req: any, res: any) => {
-  res.status(404).json({ error: { code: "NOT_FOUND", message: "Route not found" } });
-});
+  if (mode === "sqlite") {
+    process.env.DISABLE_RAG_WORKER = "true";
+  }
 
-// ─── Error Handler ────────────────────────────────────────────────────────────
+  // ── 2. Load modules that depend on the db pool ────────────────────────────
+  const { compatRouter } = await import("../compat/opencode_adapter");
+  const { ragWorker } = await import("./rag_worker");
+  const { pool } = await import("../bone/output/session/src/db");
+  const { eventBus } = await import("../bone/output/session/src/events");
+  const { logger } = await import("../bone/output/session/src/logger");
+  const { authMiddleware } = await import("../bone/output/session/src/auth");
+  const { setupWebSocketServer, broadcastToChannel } = await import("../bone/output/session/src/websocket");
+
+  // ── 3. Middleware ─────────────────────────────────────────────────────────
+  app.use(authMiddleware);
+  app.use(rateLimit({ windowMs: 60_000, max: 1000, standardHeaders: true, legacyHeaders: false }));
+  app.use((req: any, res: any, next: any) => {
+    const timer = setTimeout(() => {
+      if (!res.headersSent) res.status(503).json({ error: { code: "REQUEST_TIMEOUT", message: "Request timed out" } });
+    }, config.requestTimeoutMs);
+    res.on("finish", () => clearTimeout(timer));
+    next();
+  });
 
-app.use((err: any, _req: any, res: any, _next: any) => {
-  logger.error("unhandled_error", { event: "error", metadata: { message: err.message, stack: err.stack } });
-  res.status(500).json({ error: { code: "INTERNAL_ERROR", message: "Internal server error" } });
-});
+  setupWebSocketServer(httpServer);
+
+  // ── 4. Routes ─────────────────────────────────────────────────────────────
+  // OpenCode v2 compat routes — always available (SQLite or Postgres)
+  app.use(compatRouter);
+
+  // Full BoneScript domain routes — Postgres only
+  if (mode === "postgres") {
+    const { projectsRouter } = await import("../bone/output/session/src/routes/project");
+    const { sessionsRouter } = await import("../bone/output/session/src/routes/session");
+    const { messagesRouter } = await import("../bone/output/session/src/routes/message");
+    const { partsRouter } = await import("../bone/output/session/src/routes/part");
+    const { permissionsRouter } = await import("../bone/output/session/src/routes/permission");
+    const { agentInstancesRouter } = await import("../bone/output/agent/src/routes/agent_instance");
+    const { tasksRouter } = await import("../bone/output/agent/src/routes/task");
+    const { toolCallsRouter } = await import("../bone/output/agent/src/routes/tool_call");
+    const { plansRouter } = await import("../bone/output/agent/src/routes/plan");
+    const { buildStepsRouter } = await import("../bone/output/agent/src/routes/build_step");
+    const { knowledgeBasesRouter } = await import("../bone/output/rag/src/routes/knowledge_base");
+    const { codeFilesRouter } = await import("../bone/output/rag/src/routes/code_file");
+    const { codeChunksRouter } = await import("../bone/output/rag/src/routes/code_chunk");
+    const { memoryEntrysRouter } = await import("../bone/output/rag/src/routes/memory_entry");
+    const { indexingJobsRouter } = await import("../bone/output/rag/src/routes/indexing_job");
+    const { workspacesRouter } = await import("../bone/output/workspace/src/routes/workspace");
+    const { snapshotsRouter } = await import("../bone/output/workspace/src/routes/snapshot");
+    const { codebasesRouter } = await import("../bone/output/workspace/src/routes/codebase");
+
+    app.use("/projects", projectsRouter);
+    app.use("/sessions", sessionsRouter);
+    app.use("/messages", messagesRouter);
+    app.use("/parts", partsRouter);
+    app.use("/permissions", permissionsRouter);
+    app.use("/agents", agentInstancesRouter);
+    app.use("/tasks", tasksRouter);
+    app.use("/tool-calls", toolCallsRouter);
+    app.use("/plans", plansRouter);
+    app.use("/build-steps", buildStepsRouter);
+    app.use("/knowledge-bases", knowledgeBasesRouter);
+    app.use("/code-files", codeFilesRouter);
+    app.use("/code-chunks", codeChunksRouter);
+    app.use("/memory-entries", memoryEntrysRouter);
+    app.use("/indexing-jobs", indexingJobsRouter);
+    app.use("/workspaces", workspacesRouter);
+    app.use("/snapshots", snapshotsRouter);
+    app.use("/codebases", codebasesRouter);
+  }
 
-// ─── Start ────────────────────────────────────────────────────────────────────
+  // ── Web UI — serve built Vite app or dev fallback ────────────────────────
+  const webDistDir = path.join(__dirname, "..", "dist", "web");
+  const webDevDir = path.join(__dirname, "..", "web");
+  if (fs.existsSync(webDistDir)) {
+    // Production: serve built assets
+    app.use("/ui", express.static(webDistDir));
+    app.get("/ui/*", (_req: any, res: any) => {
+      res.sendFile(path.join(webDistDir, "index.html"));
+    });
+    console.log(`  Web UI:    http://localhost:${PORT}/ui`);
+  } else if (fs.existsSync(path.join(webDevDir, "index.html"))) {
+    // Dev: serve raw files (no bundling — works for simple TS-less HTML)
+    app.use("/ui", express.static(webDevDir));
+    app.get("/ui/*", (_req: any, res: any) => {
+      res.sendFile(path.join(webDevDir, "index.html"));
+    });
+    console.log(`  Web UI:    http://localhost:${PORT}/ui  (dev mode — run 'cd web && npm run dev' for hot reload)`);
+  }
 
-httpServer.listen(PORT, () => {
-  logger.info("server_started", { event: "startup", metadata: { port: PORT, node_env: process.env.NODE_ENV } });
+  app.use((_req: any, res: any) => {
+    res.status(404).json({ error: { code: "NOT_FOUND", message: "Route not found" } });
+  });
+  app.use((err: any, _req: any, res: any, _next: any) => {
+    logger.error("unhandled_error", { event: "error", metadata: { message: err.message } });
+    res.status(500).json({ error: { code: "INTERNAL_ERROR", message: "Internal server error" } });
+  });
 
-  console.log(`\n[BoneCode] Server running on port ${PORT}`);
-  console.log(`  OpenCode v2 API:  http://localhost:${PORT}/v2/session`);
-  console.log(`  Health:           http://localhost:${PORT}/health`);
-  console.log(`  Domain routes:    /sessions /agents /knowledge-bases /workspaces`);
-  console.log(`  WebSocket:        ws://localhost:${PORT}/ws`);
+  // ── 5. Listen ─────────────────────────────────────────────────────────────
+  httpServer.listen(PORT, () => {
+    logger.info("server_started", { event: "startup", metadata: { port: PORT, db: mode } });
+    console.log(`\n[BoneCode] Server running on port ${PORT} (${mode})`);
+    console.log(`  Health:    http://localhost:${PORT}/health`);
+    console.log(`  API:       http://localhost:${PORT}/v2`);
 
-  // Start durable event worker (no-op in in_process mode)
-  eventBus.startWorker(config.eventWorkerIntervalMs);
+    eventBus.startWorker(config.eventWorkerIntervalMs);
 
-  // Bridge eventBus events → WebSocket channels
-  // session_events channel: session lifecycle + message events
-  const sessionEventTypes = ["SessionCreated", "SessionStateChanged", "MessageAdded", "SessionCompacted"];
-  for (const type of sessionEventTypes) {
-    eventBus.subscribe(type, async (event) => {
-      broadcastToChannel("session_events", { type: type.toLowerCase().replace(/([A-Z])/g, ".$1").slice(1), ...event.payload });
-    });
-  }
-  // part_stream channel: realtime part deltas for live streaming
-  eventBus.subscribe("PartUpdated", async (event) => {
-    broadcastToChannel("part_stream", { type: "part.updated", ...event.payload });
-  });
-  // agent_events: tool calls, agent state changes
-  const agentEventTypes = ["AgentStarted", "AgentCompleted", "AgentFailed", "ToolCallRequested", "ToolCallCompleted", "PermissionRequired"];
-  for (const type of agentEventTypes) {
-    eventBus.subscribe(type, async (event) => {
-      broadcastToChannel("session_events", { type: type.toLowerCase().replace(/([A-Z])/g, ".$1").slice(1), ...event.payload });
-    });
-  }
+    // Bridge eventBus → WebSocket channels
+    const sessionTypes = ["SessionCreated", "SessionStateChanged", "MessageAdded", "SessionCompacted"];
+    for (const t of sessionTypes) {
+      eventBus.subscribe(t, async (e) => broadcastToChannel("session_events", { type: t.toLowerCase().replace(/([A-Z])/g, ".$1").slice(1), ...e.payload }));
+    }
+    eventBus.subscribe("PartUpdated", async (e) => broadcastToChannel("part_stream", { type: "part.updated", ...e.payload }));
+    const agentTypes = ["AgentStarted", "AgentCompleted", "AgentFailed", "ToolCallRequested", "ToolCallCompleted", "PermissionRequired"];
+    for (const t of agentTypes) {
+      eventBus.subscribe(t, async (e) => broadcastToChannel("session_events", { type: t.toLowerCase().replace(/([A-Z])/g, ".$1").slice(1), ...e.payload }));
+    }
 
-  // Start RAG ingestion worker
-  ragWorker.start();
-});
+    if (mode === "postgres") ragWorker.start();
 
-// ─── Graceful Shutdown ────────────────────────────────────────────────────────
-
-const shutdown = async (signal: string) => {
-  logger.info("server_stopping", { event: "shutdown", metadata: { signal } });
-  ragWorker.stop();
-  httpServer.close(async () => {
-    try {
-      await pool.end();
-      logger.info("server_stopped", { event: "shutdown", status: "success" });
-    } catch (e: any) {
-      logger.error("shutdown_error", { event: "shutdown", metadata: { error: e.message } });
+    // ── mDNS — publish on local network when not loopback ─────────────────
+    const hostname = process.env.HOST || "0.0.0.0";
+    const mdnsEnabled = process.env.MDNS !== "false";
+    if (mdnsEnabled && hostname !== "127.0.0.1" && hostname !== "localhost") {
+      MDNS.publish(PORT, process.env.MDNS_DOMAIN);
     }
-    process.exit(0);
   });
-  setTimeout(() => process.exit(1), 10_000);
-};
 
-process.on("SIGTERM", () => shutdown("SIGTERM"));
-process.on("SIGINT", () => shutdown("SIGINT"));
+  // ── 6. Graceful shutdown ──────────────────────────────────────────────────
+  const shutdown = async (signal: string) => {
+    logger.info("server_stopping", { event: "shutdown", metadata: { signal } });
+    MDNS.unpublish();
+    if (mode === "postgres") ragWorker.stop();
+    httpServer.close(async () => {
+      try { await pool.end(); } catch {}
+      process.exit(0);
+    });
+    setTimeout(() => process.exit(1), 10_000);
+  };
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+  process.on("SIGINT", () => shutdown("SIGINT"));
+}
+
+startServer().catch((e) => {
+  console.error("[BoneCode] Failed to start:", e.message);
+  process.exit(1);
+});
 
 export { app, httpServer };