@mingxy/cerebro 1.20.0 → 1.20.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mingxy/cerebro",
-  "version": "1.20.0",
+  "version": "1.20.2",
   "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",

package/src/config.ts

@@ -177,7 +177,7 @@ function configLog(message: string, fields?: Record<string, unknown>, level: str
   if (lvl < CONFIGURED_MIN_LEVEL) return;
   try {
     const logDir = join(homedir(), ".config", "cerebro", "logs");
-    const logPath = join(logDir, "plugin.log");
+    const logPath = join(logDir, "cerebro.log");
     const ts = new Date().toISOString().replace("T", " ").replace(/\.\d+Z$/, "");
     const parts = [`${level.padEnd(5)} ${ts} service=cerebro ${message}`];
     if (fields) {

package/src/index.ts

@@ -8,7 +8,7 @@ import { chatMessageRecallHook, autocontinueHook, compactingHook, sessionIdleHoo
 import { detectSaveKeyword, detectRecallKeyword, KEYWORD_NUDGE, RECALL_NUDGE } from "./keywords.js";
 import { getUserTag, getProjectTag } from "./tags.js";
 import { buildTools } from "./tools.js";
-import { logInfo, logDebug, logError } from "./logger.js";
+import { logInfo, logDebug, logError, setOpencodeClient } from "./logger.js";
 import { loadPluginConfig, resolveAgentPolicy } from "./config.js";
 import { checkAndUpdate } from "./updater.js";
 import { startWebServer, stopWebServer, type WebServerHandle } from "./web-server.js";
@@ -66,6 +66,8 @@ const OmemPlugin: Plugin = async (input) => {
   const config = loadPluginConfig(overrides as any);
   const toast = createToast(config);
 
+  setOpencodeClient(client);
+
   const cerebroClient = new CerebroClient(config.connection.apiUrl, config.connection.apiKey, config);
 
   try {

package/src/logger.ts

@@ -33,8 +33,12 @@ function getConfig() {
   return cachedConfig;
 }
 
-function getLogFilePath(): string {
-  return join(getConfig().logging.logDir, "plugin.log");
+function getLogFilePath(sessionId?: string): string {
+  const base = getConfig().logging.logDir;
+  if (sessionId) {
+    return join(base, `cerebro-${sessionId}.log`);
+  }
+  return join(base, "cerebro.log");
 }
 
 function getMinLevel(): number {
@@ -109,7 +113,8 @@ function writeLog(level: string, message: string, fields?: Record<string, unknow
   if (lvl < getMinLevel()) return;
 
   const cfg = getConfig();
-  const logFile = getLogFilePath();
+  const sid = (fields?.sessionId ?? fields?.sessionID) as string | undefined;
+  const logFile = getLogFilePath(sid);
   ensureLogDir(cfg.logging.logDir);
 
   const now = new Date();

package/src/updater.ts

@@ -5,6 +5,7 @@ import { join, dirname } from "node:path";
 import { homedir, tmpdir } from "node:os";
 import { openSync, closeSync, unlinkSync, statSync, writeSync, mkdtempSync, readdirSync, rmSync } from "node:fs";
 import { loadPluginConfig } from "./config.js";
+import { logInfo, logDebug, logError } from "./logger.js";
 
 const execFileAsync = promisify(execFile);
 const require = createRequire(import.meta.url);
@@ -14,8 +15,12 @@ const require = createRequire(import.meta.url);
 async function getLatestVersion(): Promise<string | null> {
   try {
     const { stdout } = await execFileAsync("npm", ["view", "@mingxy/cerebro", "version"], { timeout: 10000 });
+    logDebug("updater: fetched latest version", { version: stdout.trim() });
     return stdout.trim();
-  } catch { return null; }
+  } catch {
+    logError("updater: failed to fetch latest version");
+    return null;
+  }
 }
 
 // ── Semantic version comparison ─────────────────────────────────────
@@ -45,6 +50,7 @@ function getInstallDir(): string {
 
 async function installUpdate(targetDir: string): Promise<boolean> {
   const tmpDir = mkdtempSync(join(tmpdir(), "cerebro-update-"));
+  logInfo("updater: downloading update", { targetDir, tmpDir });
   try {
     // 1. Download tgz
     await execFileAsync("npm", ["pack", "@mingxy/cerebro@latest", "--pack-destination", tmpDir], { timeout: 60000 });
@@ -52,13 +58,18 @@ async function installUpdate(targetDir: string): Promise<boolean> {
     // 2. Find the tgz file
     const files = readdirSync(tmpDir);
     const tgz = files.find(f => f.endsWith(".tgz"));
-    if (!tgz) return false;
+    if (!tgz) {
+      logError("updater: no tgz found after npm pack", { tmpDir, files: files.join(",") });
+      return false;
+    }
 
     // 3. Extract to target dir (strip the "package/" prefix from tgz)
     await execFileAsync("tar", ["-xzf", join(tmpDir, tgz), "-C", targetDir, "--strip-components=1", "--no-same-owner", "--no-same-permissions"], { timeout: 30000 });
 
+    logInfo("updater: update installed successfully", { targetDir, tgz });
     return true;
-  } catch {
+  } catch (err) {
+    logError("updater: install failed", { error: err instanceof Error ? err.message : String(err) });
     return false;
   } finally {
     try { rmSync(tmpDir, { recursive: true }); } catch {}
@@ -78,13 +89,18 @@ function acquireLock(): boolean {
       const s = statSync(LOCK_FILE);
       if (Date.now() - s.mtimeMs > STALE_LOCK_MS) {
         unlinkSync(LOCK_FILE);
+        logDebug("updater: cleaned stale lock", { ageMs: Date.now() - s.mtimeMs });
       }
     } catch { /* lock file doesn't exist, normal */ }
 
     lockFd = openSync(LOCK_FILE, "wx");
     writeSync(lockFd, String(process.pid));
+    logDebug("updater: lock acquired", { pid: process.pid });
     return true;
-  } catch { return false; }
+  } catch {
+    logDebug("updater: lock acquisition failed (another process updating?)");
+    return false;
+  }
 }
 
 function releaseLock(): void {
@@ -92,6 +108,7 @@ function releaseLock(): void {
     try { closeSync(lockFd); } catch {}
     lockFd = null;
     try { unlinkSync(LOCK_FILE); } catch {}
+    logDebug("updater: lock released");
   }
 }
 
@@ -99,25 +116,38 @@ function releaseLock(): void {
 
 export async function checkAndUpdate(tui: any, currentVersion: string): Promise<void> {
   const config = loadPluginConfig();
-  if (!config.autoUpdate) return;
+  if (!config.autoUpdate) {
+    logDebug("updater: autoUpdate disabled, skipping");
+    return;
+  }
+
+  logInfo("updater: checking for updates", { currentVersion });
 
   const latest = await getLatestVersion();
   if (!latest) return;
 
-  if (compareVersions(latest, currentVersion) <= 0) return; // already up to date
+  if (compareVersions(latest, currentVersion) <= 0) {
+    logInfo("updater: already up to date", { currentVersion, latest });
+    return;
+  }
+
+  logInfo("updater: new version available", { currentVersion, latest });
 
-  if (!acquireLock()) return; // another process is updating
+  if (!acquireLock()) return;
 
   try {
     const targetDir = getInstallDir();
     const success = await installUpdate(targetDir);
 
     if (success) {
+      logInfo("updater: update completed", { from: currentVersion, to: latest });
       try {
         tui?.showToast?.({
           body: { message: `Cerebro updated to v${latest} — restart opencode to apply`, variant: "info" }
         });
       } catch {}
+    } else {
+      logError("updater: update failed", { targetDir });
     }
   } finally {
     releaseLock();

package/src/web-server-child.ts

@@ -10,6 +10,32 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import * as os from "node:os";
 
+// ── Lightweight file logger for child process ──────────────────────────
+// Cannot import logger.ts (no opencodeClient + circular dependency risk).
+// Writes to cerebro-web-child.log in the configured log directory.
+
+const CHILD_LOG_FILE = path.join(
+  process.env.OMEM_LOG_DIR || path.join(os.homedir(), ".config", "cerebro", "logs"),
+  "cerebro-web-child.log",
+);
+
+function childLog(level: string, message: string, fields?: Record<string, unknown>): void {
+  try {
+    const dir = path.dirname(CHILD_LOG_FILE);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    const now = new Date();
+    const ts = now.toISOString().replace("T", " ").replace(/\.\d+Z$/, "");
+    const parts = [`${level.padEnd(5)} ${ts} service=cerebro-web-child`];
+    if (fields) {
+      for (const [k, v] of Object.entries(fields)) {
+        parts.push(`${k}=${typeof v === "string" ? v : JSON.stringify(v)}`);
+      }
+    }
+    parts.push(message);
+    fs.appendFileSync(CHILD_LOG_FILE, parts.join(" ") + "\n");
+  } catch { /* best effort */ }
+}
+
 // ── Types ────────────────────────────────────────────────────────────────
 
 interface ChildConfig {
@@ -138,14 +164,14 @@ function startServer(config: ChildConfig): void {
   try {
     fs.writeFileSync(pidFilePath, String(process.pid));
   } catch {
-    console.error("[cerebro:web-child] Failed to write PID file");
+    childLog("ERROR", "Failed to write PID file");
   }
 
   // 初始 touch 心跳文件
   try {
     fs.writeFileSync(heartbeatFilePath, "");
   } catch {
-    console.error("[cerebro:web-child] Failed to create heartbeat file");
+    childLog("ERROR", "Failed to create heartbeat file");
   }
 
   server = http.createServer(
@@ -199,15 +225,13 @@ function startServer(config: ChildConfig): void {
   );
 
   server.on("error", (err: NodeJS.ErrnoException) => {
-    console.error(`[cerebro:web-child] Server error: ${err.message}`);
+    childLog("ERROR", "Server error", { error: err.message });
     process.send?.({ type: "error", message: err.message });
     cleanup();
   });
 
   server.listen(port, "127.0.0.1", () => {
-    console.log(
-      `[cerebro:web-child] Server listening on http://localhost:${port}`,
-    );
+    childLog("INFO", "Server listening", { port });
     process.send?.({ type: "ready", port });
   });
 
@@ -216,9 +240,7 @@ function startServer(config: ChildConfig): void {
     try {
       const stat = fs.statSync(heartbeatFilePath);
       if (Date.now() - stat.mtimeMs > 60_000) {
-        console.log(
-          "[cerebro:web-child] Heartbeat expired, shutting down",
-        );
+        childLog("INFO", "Heartbeat expired, shutting down");
         cleanup();
       }
     } catch {

package/src/web-server.ts

@@ -10,6 +10,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import * as os from "node:os";
 import { fileURLToPath } from "node:url";
+import { logInfo, logWarn, logError } from "./logger.js";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -75,7 +76,7 @@ export async function startWebServer(
 
   // ── Step 1: 检查端口是否已有 cerebro server ──
   if (await probeExistingServer(port)) {
-    console.log(`[cerebro:web] Reusing existing server on port ${port}`);
+    logInfo("web-server: reusing existing server", { port });
     return createHandle(port, heartbeatFilePath);
   }
 
@@ -87,9 +88,7 @@ export async function startWebServer(
       // 有其他进程正在 fork 或运行，等待 200ms 后重试
       await new Promise((r) => setTimeout(r, 200));
       if (await probeExistingServer(port)) {
-        console.log(
-          `[cerebro:web] Reusing server after PID check on port ${port}`,
-        );
+        logInfo("web-server: reusing server after PID check", { port });
         return createHandle(port, heartbeatFilePath);
       }
     } else {
@@ -101,15 +100,11 @@ export async function startWebServer(
   // ── Step 3: 检查 web 目录 ──
   const webDir = path.resolve(__dirname, "..", "web");
   if (!fs.existsSync(webDir)) {
-    console.warn(
-      `[cerebro:web] Web directory not found: ${webDir}, skipping server start`,
-    );
+    logWarn("web-server: web directory not found, skipping", { webDir });
     return null;
   }
   if (!fs.existsSync(path.join(webDir, "index.html"))) {
-    console.warn(
-      `[cerebro:web] index.html not found in ${webDir}, skipping server start`,
-    );
+    logWarn("web-server: index.html not found, skipping", { webDir });
     return null;
   }
 
@@ -119,11 +114,18 @@ export async function startWebServer(
   } catch { /* ignore */ }
 
   // ── Step 5: Fork 子进程 ──
-  const childPath = path.resolve(__dirname, "web-server-child.js");
+  // TS runtime: .ts exists; compiled: .js exists
+  const childTs = path.resolve(__dirname, "web-server-child.ts");
+  const childJs = path.resolve(__dirname, "web-server-child.js");
+  const childPath = fs.existsSync(childTs) ? childTs : childJs;
 
+  // Use the same executor as the parent process (tsx, node, etc.)
+  // so the child can run .ts files. Also inherit execArgv (--import tsx, etc.)
   const child = fork(childPath, [], {
     detached: true,
     stdio: ["pipe", "pipe", "pipe", "ipc"],
+    execPath: process.execPath,
+    execArgv: process.execArgv,
   });
 
   // Drain stdout/stderr to prevent pipe buffer from blocking the child
@@ -161,17 +163,13 @@ export async function startWebServer(
   });
 
   if (!ready) {
-    console.warn(
-      `[cerebro:web] Failed to start web server child process on port ${port}`,
-    );
+    logError("web-server: failed to start child process", { port });
     try { child.kill(); } catch { /* ignore */ }
     try { fs.unlinkSync(pidFilePath); } catch { /* ignore */ }
     return null;
   }
 
-  console.log(
-    `[cerebro:web] Web server child process started on port ${port}`,
-  );
+  logInfo("web-server: child process started", { port, pid: child.pid });
   return createHandle(port, heartbeatFilePath);
 }