@mingxy/cerebro 1.16.9 → 1.17.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mingxy/cerebro",
-  "version": "1.16.9",
+  "version": "1.17.0",
   "description": "Cerebro persistent memory plugin for OpenCode — auto-recall, auto-capture, 9 memory tools with clustering, project-scoped memory isolation",
   "type": "module",
   "main": "src/index.ts",
@@ -18,6 +18,10 @@
     "server",
     "tui"
   ],
+  "scripts": {
+    "build:web": "bash ../../scripts/build-plugin-web.sh",
+    "prepublishOnly": "npm run build:web && npx tsc --noEmit"
+  },
   "keywords": [
     "opencode",
     "memory",
@@ -28,6 +32,7 @@
     "project-isolation"
   ],
   "author": "mingxy-cerebro",
+  "files": ["src/", "web/"],
   "license": "Apache-2.0",
   "homepage": "https://github.com/mingxy-cerebro/cerebro-server",
   "repository": {

package/src/config.ts

@@ -38,6 +38,10 @@ export interface OmemPluginConfig {
   ui: {
     toastDelayMs: number;
   };
+  web?: {
+    enabled?: boolean;
+    port?: number;
+  };
   profile?: {
     ttlMs?: number;
   };
@@ -81,6 +85,9 @@ const DEFAULTS: OmemPluginConfig = {
   ui: {
     toastDelayMs: 7000,
   },
+  web: {
+    enabled: true,
+  },
   profile: {
     ttlMs: 300000,
   },
@@ -164,6 +171,7 @@ function deepMerge(base: OmemPluginConfig, overrides: Partial<OmemPluginConfig>)
     logging: { ...base.logging, ...overrides.logging },
     ui: { ...base.ui, ...overrides.ui },
   };
+  result.web = { ...base.web!, ...overrides.web };
   result.profile = { ...base.profile!, ...overrides.profile };
   if (overrides.agentMemoryPolicy) result.agentMemoryPolicy = overrides.agentMemoryPolicy;
   if (overrides.defaultPolicy) result.defaultPolicy = overrides.defaultPolicy;
@@ -227,7 +235,12 @@ export function loadPluginConfig(overrides?: Partial<OmemPluginConfig>): OmemPlu
     configLog("config.json load failed, using defaults", { error: String(e) });
   }
 
-  // Apply environment variable overrides (flat OMEM_* → nested paths)
+  // Apply explicit overrides (from opencode.json)
+  if (overrides) {
+    config = deepMerge(config, overrides);
+  }
+
+  // Apply environment variable overrides last — env vars have highest priority
   if (process.env.OMEM_API_URL) config.connection.apiUrl = process.env.OMEM_API_URL;
   if (process.env.OMEM_API_KEY) config.connection.apiKey = process.env.OMEM_API_KEY;
   if (process.env.OMEM_REQUEST_TIMEOUT_MS) {
@@ -246,9 +259,11 @@ export function loadPluginConfig(overrides?: Partial<OmemPluginConfig>): OmemPlu
     config.recall.maxRecallResults = parseInt(process.env.OMEM_MAX_RECALL_RESULTS, 10) || DEFAULTS.recall.maxRecallResults;
   }
 
-  // Apply explicit overrides (from opencode.json)
-  if (overrides) {
-    config = deepMerge(config, overrides);
+  if (process.env.OMEM_WEB_ENABLED === "false" || process.env.OMEM_WEB_ENABLED === "0") {
+    config.web = { ...config.web!, enabled: false };
+  }
+  if (process.env.OMEM_LOCAL_PORT) {
+    config.web = { ...config.web!, port: parseInt(process.env.OMEM_LOCAL_PORT, 10) || DEFAULTS.web!.port };
   }
 
   // Expand ~ to home directory in logDir

package/src/hooks.ts

@@ -494,24 +494,36 @@ export function autoRecallHook(client: CerebroClient, containerTags: string[], t
         },
       ): Promise<string | undefined> => {
         try {
+          const memoryLookup = new Map<string, SearchResult>();
+          if (shouldRecallRes.memories) {
+            for (const r of shouldRecallRes.memories) {
+              memoryLookup.set(r.memory.id, r);
+            }
+          }
           const items = clustered
             ? [
                 ...clustered.cluster_summaries.flatMap((cs) =>
-                  cs.key_memories.map((mem) => ({
+                  cs.key_memories.map((mem) => {
+                    const sr = memoryLookup.get(mem.id ?? "");
+                    return {
+                      memory_id: mem.id ?? "",
+                      score: cs.relevance_score,
+                      refine_relevance: sr?.refine_relevance,
+                      refine_reasoning: sr?.refine_reasoning,
+                      is_kept: opts.injectedMemoryIds.includes(mem.id ?? ""),
+                    };
+                  })
+                ),
+                ...clustered.standalone_memories.map((mem) => {
+                  const sr = memoryLookup.get(mem.id ?? "");
+                  return {
                     memory_id: mem.id ?? "",
-                    score: cs.relevance_score,
-                    refine_relevance: undefined,
-                    refine_reasoning: undefined,
+                    score: sr?.score ?? 0,
+                    refine_relevance: sr?.refine_relevance,
+                    refine_reasoning: sr?.refine_reasoning,
                     is_kept: opts.injectedMemoryIds.includes(mem.id ?? ""),
-                  }))
-                ),
-                ...clustered.standalone_memories.map((mem) => ({
-                  memory_id: mem.id ?? "",
-                  score: 0,
-                  refine_relevance: undefined,
-                  refine_reasoning: undefined,
-                  is_kept: opts.injectedMemoryIds.includes(mem.id ?? ""),
-                })),
+                  };
+                }),
               ]
             : [
                 ...(shouldRecallRes.memories?.map((r) => ({

package/src/index.ts

@@ -3,12 +3,14 @@ import { readFileSync, writeFileSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { tmpdir } from "node:os";
 import { fileURLToPath } from "node:url";
+import type { Server } from "node:http";
 import { CerebroClient } from "./client.js";
 import { autoRecallHook, autocontinueHook, compactingHook, keywordDetectionHook, sessionIdleHook, showToast as hooksShowToast } from "./hooks.js";
 import { getUserTag, getProjectTag } from "./tags.js";
 import { buildTools } from "./tools.js";
 import { logInfo, logDebug, logError } from "./logger.js";
 import { loadPluginConfig } from "./config.js";
+import { startWebServer, stopWebServer } from "./web-server.js";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -103,6 +105,34 @@ const OmemPlugin: Plugin = async (input) => {
 
   const recallHook = autoRecallHook(cerebroClient, containerTags, tui, config, () => cachedAgentName || agentId, directory);
 
+  let webServer: Server | null = null;
+  const webEnabled = config.web?.enabled !== false;
+  if (webEnabled) {
+    try {
+      webServer = await startWebServer({
+        apiUrl: config.connection.apiUrl,
+        port: config.web?.port,
+      });
+      if (webServer) {
+        const addr = webServer.address();
+        const actualPort = typeof addr === "object" && addr ? addr.port : config.web?.port || 5212;
+        hooksShowToast(tui, "🌐 Cerebro Web", `http://localhost:${actualPort}`, "info", 8000);
+        logInfo(`Web UI available at http://localhost:${actualPort}`);
+      }
+    } catch (err) {
+      logError(`Web server start failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+
+  const shutdown = async () => {
+    if (webServer) {
+      await stopWebServer(webServer);
+      webServer = null;
+    }
+  };
+  process.on("SIGTERM", shutdown);
+  process.on("SIGINT", shutdown);
+
   return {
     config: async (cfg: any) => {
       cfg.command ??= {};

package/src/web-server.ts

@@ -0,0 +1,180 @@
+import * as http from "node:http";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// ── Types ────────────────────────────────────────────────────────────────
+
+export interface WebServerConfig {
+  apiUrl: string;
+  port?: number;
+}
+
+// ── MIME map ─────────────────────────────────────────────────────────────
+
+const MIME_TYPES: Record<string, string> = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "application/javascript; charset=utf-8",
+  ".mjs": "application/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".eot": "application/vnd.ms-fontobject",
+  ".webp": "image/webp",
+  ".webmanifest": "application/manifest+json",
+  ".map": "application/json",
+  ".txt": "text/plain; charset=utf-8",
+};
+
+function getMimeType(ext: string): string {
+  return MIME_TYPES[ext] || "application/octet-stream";
+}
+
+// ── Safe path resolver (prevent traversal) ───────────────────────────────
+
+function resolveSafe(baseDir: string, pathname: string): string | null {
+  const resolved = path.resolve(baseDir, pathname);
+  if (!resolved.startsWith(baseDir + path.sep) && resolved !== baseDir) {
+    return null;
+  }
+  return resolved;
+}
+
+// ── Start / Stop ─────────────────────────────────────────────────────────
+
+export function startWebServer(config: WebServerConfig): Promise<http.Server | null> {
+  return new Promise((resolve) => {
+    const webDir = path.resolve(__dirname, "..", "web");
+
+    // Check web directory exists
+    if (!fs.existsSync(webDir)) {
+      console.warn(`[cerebro:web] Web directory not found: ${webDir}, skipping server start`);
+      resolve(null);
+      return;
+    }
+
+    const indexPath = path.join(webDir, "index.html");
+    if (!fs.existsSync(indexPath)) {
+      console.warn(`[cerebro:web] index.html not found in ${webDir}, skipping server start`);
+      resolve(null);
+      return;
+    }
+
+    const port = config.port || parseInt(process.env.OMEM_LOCAL_PORT || "", 10) || 5212;
+
+    const server = http.createServer(
+      (req: http.IncomingMessage, res: http.ServerResponse) => {
+        // Only handle GET / HEAD
+        if (req.method !== "GET" && req.method !== "HEAD") {
+          res.writeHead(405, { "Content-Type": "text/plain" });
+          res.end("Method Not Allowed");
+          return;
+        }
+
+        // Parse URL, strip query string
+        const url = new URL(req.url || "/", `http://localhost:${port}`);
+        const pathname = decodeURIComponent(url.pathname);
+
+        // Resolve safe file path
+        const safePath = resolveSafe(webDir, pathname);
+
+        if (!safePath) {
+          res.writeHead(403, { "Content-Type": "text/plain" });
+          res.end("Forbidden");
+          return;
+        }
+
+        // Try to serve the file directly
+        fs.stat(safePath, (statErr, stats) => {
+          if (!statErr && stats.isFile()) {
+            serveFile(res, safePath, config.apiUrl);
+            return;
+          }
+
+          // SPA fallback: serve index.html for non-file paths
+          fs.stat(indexPath, (idxErr, idxStats) => {
+            if (idxErr || !idxStats.isFile()) {
+              res.writeHead(404, { "Content-Type": "text/plain" });
+              res.end("Not Found");
+              return;
+            }
+            serveFile(res, indexPath, config.apiUrl);
+          });
+        });
+      },
+    );
+
+    server.on("error", (err: NodeJS.ErrnoException) => {
+      if (err.code === "EADDRINUSE") {
+        console.warn(`[cerebro:web] Port ${port} already in use, web server not started`);
+      } else {
+        console.warn(`[cerebro:web] Server error: ${err.message}`);
+      }
+      resolve(null);
+    });
+
+    server.listen(port, "127.0.0.1", () => {
+      const addr = server.address();
+      const actualPort = typeof addr === "object" && addr ? addr.port : port;
+      console.log(`[cerebro:web] Static server listening on http://localhost:${actualPort}`);
+      resolve(server);
+    });
+  });
+}
+
+// ── File serving ─────────────────────────────────────────────────────────
+
+function serveFile(
+  res: http.ServerResponse,
+  filePath: string,
+  apiUrl: string,
+): void {
+  const ext = path.extname(filePath).toLowerCase();
+  const contentType = getMimeType(ext);
+
+  fs.readFile(filePath, (err, data) => {
+    if (err) {
+      res.writeHead(500, { "Content-Type": "text/plain" });
+      res.end("Internal Server Error");
+      return;
+    }
+
+    let body: Buffer | string = data;
+
+    // Config injection: replace placeholder in index.html
+    if (ext === ".html" && data.includes("__OMEM_API_URL__")) {
+      body = data.toString("utf-8").replace(/__OMEM_API_URL__/g, () => apiUrl);
+    }
+
+    res.writeHead(200, {
+      "Content-Type": contentType,
+      "Cache-Control": ext === ".html" ? "no-cache, no-store, must-revalidate" : "public, max-age=86400",
+    });
+    res.end(body);
+  });
+}
+
+// ── Graceful shutdown ────────────────────────────────────────────────────
+
+export function stopWebServer(server: http.Server): Promise<void> {
+  return new Promise((resolve) => {
+    server.closeAllConnections?.();
+    const timer = setTimeout(resolve, 3000);
+    server.close(() => {
+      clearTimeout(timer);
+      console.log("[cerebro:web] Server stopped");
+      resolve();
+    });
+  });
+}