@mingxy/cerebro-claude-code 0.3.11 → 0.3.13

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "cerebro",
   "description": "Persistent memory for Claude Code — memories survive across sessions, projects, and machines",
-  "version": "0.3.11",
+  "version": "0.3.13",
   "author": {
     "name": "mingxy-cerebro",
     "email": "hi@cerebro.dev"

package/hooks/common.mjs

@@ -231,11 +231,28 @@ function _log(level, msg) {
 const SESSIONS_DIR = join(HOME, ".config/cerebro/sessions");
 const WEB_PID_FILE = join(HOME, ".config/cerebro/web-server.pid");
 
+// CC runs hooks through a bash wrapper — process.ppid is the wrapper, which
+// dies the moment the hook exits. Climb past shells to the CC main process;
+// non-Linux (no /proc) or unclimbable chain falls back to the old behavior.
+function ccMainPid() {
+  let pid = process.ppid;
+  for (let i = 0; i < 4 && pid > 1; i++) {
+    try {
+      const comm = readFileSync(`/proc/${pid}/comm`, "utf-8").trim();
+      if (!/^(bash|sh|dash|zsh)$/.test(comm)) return pid;
+      const m = readFileSync(`/proc/${pid}/status`, "utf-8").match(/^PPid:\s+(\d+)/m);
+      if (!m) break;
+      pid = parseInt(m[1], 10);
+    } catch { break; }
+  }
+  return process.ppid;
+}
+
 export function writeLive(sid) {
   if (!sid) return;
   try {
     mkdirSync(SESSIONS_DIR, { recursive: true });
-    writeFileSync(join(SESSIONS_DIR, `${sid}.live`), String(process.ppid));
+    writeFileSync(join(SESSIONS_DIR, `${sid}.live`), String(ccMainPid()));
   } catch {}
 }
 
@@ -266,15 +283,26 @@ export function countLiveCC() {
 // Kill a stale web-server daemon so a fresh one can bind (rebirth on every
 // session start — no version sniffing). pid verified via /proc cmdline to
 // survive pid reuse; non-Linux (no /proc) degrades to no-op.
-export function killStaleWebServer() {
+export function killStaleWebServer(port = 5212) {
+  const pids = new Set();
+  // Path 1: port occupant via ss — catches zcode's web-server.js too (it never
+  // writes our PID_FILE; left alive it starves our spawn via EADDRINUSE and the
+  // port stays with a daemon that has no .live liveness model).
   try {
-    const pid = parseInt(readFileSync(WEB_PID_FILE, "utf-8").trim(), 10);
-    if (!pid || pid === process.pid) return;
-    const cmdline = readFileSync(`/proc/${pid}/cmdline`, "utf-8");
-    if (!cmdline.includes("web-server.mjs")) return; // not ours — don't touch
-    process.kill(pid, "SIGTERM");
-    setTimeout(() => { try { process.kill(pid, "SIGKILL"); } catch {} }, 500).unref();
+    const out = execSync(`ss -ltnpH 'sport = :${port}'`, { timeout: 2000 }).toString();
+    for (const m of out.matchAll(/pid=(\d+)/g)) pids.add(parseInt(m[1], 10));
   } catch {}
+  // Path 2: our own PID_FILE (the .mjs daemon writes it at listen-time).
+  try { pids.add(parseInt(readFileSync(WEB_PID_FILE, "utf-8").trim(), 10)); } catch {}
+  for (const pid of pids) {
+    if (!pid || pid === process.pid || Number.isNaN(pid)) continue;
+    try {
+      const cmdline = readFileSync(`/proc/${pid}/cmdline`, "utf-8");
+      if (!/web-server\.m?js/.test(cmdline)) continue; // not a cerebro web-server — don't touch
+      process.kill(pid, "SIGTERM");
+      setTimeout(() => { try { process.kill(pid, "SIGKILL"); } catch {} }, 500).unref();
+    } catch {}
+  }
 }
 
 // ─── Compact result handoff (PostCompact → SessionStart:compact) ─────────────

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mingxy/cerebro-claude-code",
-  "version": "0.3.11",
+  "version": "0.3.13",
   "description": "Persistent memory for Claude Code — memories survive across sessions, projects, and machines",
   "author": {
     "name": "mingxy-cerebro",

package/scripts/web-server.mjs

@@ -83,7 +83,12 @@ function serveFile(res, filePath) {
 }
 
 const indexPath = path.join(WEB_DIR, "index.html");
+// Traffic timestamp — any request refreshes it; the watchdog's idle escape
+// hatch (below) uses it to survive with zero CC sessions while the UI is in use.
+let lastActivity = Date.now();
 const server = http.createServer((req, res) => {
+  lastActivity = Date.now(); // traffic = the UI is in use; feeds the idle escape hatch
+
   if (req.url === "/health" || req.url === "/health/") {
     res.writeHead(200, { ...COMMON, "Content-Type": "application/json" });
     res.end(JSON.stringify({ status: "ok", service: "cerebro", port: PORT }));
@@ -133,9 +138,14 @@ server.listen(PORT, "127.0.0.1", () => {
 // CC main pid. Sweep on an interval, kill(pid, 0) each, sweep stale ones.
 // Zero CC sessions alive → count down the grace window → self-exit. Survives
 // killed terminals (no SessionEnd needed) — refcount bookkeeping is gone.
+// Traffic escape hatch: zcode reuses this daemon and keeps it alive by pinging
+// /health at every turn-end; an open web panel polls too. Requests mean
+// someone is using the UI — survive with zero live CC sessions until traffic
+// stops for IDLE_MS (mirrors the zcode daemon's idle semantics).
 const SESSIONS_DIR = path.join(process.env.HOME || process.env.USERPROFILE || "", ".config/cerebro/sessions");
 const GRACE_MS = parseInt(process.env.OMEM_WEB_GRACE_MS || "", 10) || 60_000;
 const WATCH_MS = parseInt(process.env.OMEM_WEB_WATCH_MS || "", 10) || 60_000;
+const IDLE_MS = parseInt(process.env.OMEM_WEB_IDLE_MS || "", 10) || 300_000;
 let zeroSince = 0; // 0 = CC alive (or unknown)
 
 setInterval(() => {
@@ -153,10 +163,10 @@ setInterval(() => {
       }
     }
   } catch {} // dir missing = no CC session ever
-  if (alive > 0) { zeroSince = 0; return; }
+  if (alive > 0 || Date.now() - lastActivity < IDLE_MS) { zeroSince = 0; return; }
   if (!zeroSince) zeroSince = Date.now();
   if (Date.now() - zeroSince >= GRACE_MS) {
-    console.log(`[cerebro web-server] no CC sessions alive for ${GRACE_MS / 1000}s, self-exiting`);
+    console.log(`[cerebro web-server] no CC sessions or traffic for ${IDLE_MS / 1000}s, self-exiting`);
     try { fs.unlinkSync(PID_FILE); } catch {}
     process.exit(0);
   }