@llmnesia/mcp 0.2.11 → 0.2.12

package/dist/llmnesia-claude-host.mjs

@@ -19,11 +19,13 @@
 // without ~/.llmnesia/config.json this host is exactly as read-only as it
 // has always been for plain session indexing.
 //
-// Protocol v4 (extension → host). v1 was Claude-Code-only: `list` carried no
+// Protocol v5 (extension → host). v1 was Claude-Code-only: `list` carried no
 // `source` and `get` took a bare sessionId. Both remain accepted, so an
 // extension older than this host keeps working; an extension NEWER than the
 // host detects v1 from the pong and syncs Claude Code only.
 //
+// v5 adds per-source listing health and putSourceHealth metadata updates,
+// keeping diagnostics separate from the conversation inbox.
 // v4 adds ZCode to `list`/`get` (the first source backed by a SQLite database
 // rather than per-session files; `get` materializes the transcript as JSONL).
 // The version is informational in both directions, as below: a v3 host never
@@ -34,7 +36,7 @@
 // treats that as "nothing to fetch", so the version is informational: hosts are
 // installed out of band and an extension upgraded ahead of its host is the
 // ordinary case, not a fault.
-//   { cmd: "ping" }                    → { type: "pong", version: 4 }
+//   { cmd: "ping" }                    → { type: "pong", version: 5 }
 //   { cmd: "list" }                    → { type: "list", sessions:
 //                                          [{source, sessionId, mtime, project?, title?}] }
 //   { cmd: "get", source, sessionId }  → one or more { type: "chunk", sessionId, seq, total, data }
@@ -59,10 +61,10 @@ import { chmod, mkdir, readdir, readFile, rename, stat, writeFile } from "node:f
 import { homedir } from "node:os";
 import { join } from "node:path";
 
-// 4 adds ZCode (see the protocol comment above). Do not make it a gate: hosts
+// 5 adds per-source listing health (see the protocol comment above). Do not make it a gate: hosts
 // are installed out of band and a version check would strand every user who
 // upgraded the extension first.
-const PROTOCOL_VERSION = 4;
+const PROTOCOL_VERSION = 5;
 const PROJECTS_DIR = join(homedir(), ".claude", "projects");
 // ZCode keeps every session in one SQLite database (WAL mode) — the first
 // source with no per-session file. The host opens it READ-ONLY and materializes
@@ -134,12 +136,13 @@ function send(message) {
 // One entry per session: { source, sessionId, mtime, project?, title?, path }.
 // `path` is stripped before anything goes on the wire.
 
-async function listClaudeCodeSessions() {
+async function listClaudeCodeSessions(issues) {
   const sessions = [];
   let projectDirs;
   try {
     projectDirs = await readdir(PROJECTS_DIR, { withFileTypes: true });
   } catch {
+    if (issues) issues.failed += 1;
     return sessions; // no ~/.claude/projects yet
   }
   for (const entry of projectDirs) {
@@ -151,6 +154,7 @@ async function listClaudeCodeSessions() {
     try {
       files = await readdir(dir);
     } catch {
+      if (issues) issues.failed += 1;
       continue;
     }
     for (const file of files) {
@@ -168,6 +172,7 @@ async function listClaudeCodeSessions() {
           path
         });
       } catch {
+        if (issues) issues.failed += 1;
         // Skip unreadable files.
       }
     }
@@ -186,18 +191,19 @@ function codexSessionId(filename) {
   return match ? match[1].toLowerCase() : base;
 }
 
-async function walkCodexDir(dir, depth, out) {
+async function walkCodexDir(dir, depth, out, issues) {
   let entries;
   try {
     entries = await readdir(dir, { withFileTypes: true });
   } catch {
+    if (issues) issues.failed += 1;
     return out; // missing or unreadable — nothing to add
   }
   for (const entry of entries) {
     const path = join(dir, entry.name);
     if (entry.isDirectory()) {
       if (depth > 0) {
-        await walkCodexDir(path, depth - 1, out);
+        await walkCodexDir(path, depth - 1, out, issues);
       }
       continue;
     }
@@ -213,6 +219,7 @@ async function walkCodexDir(dir, depth, out) {
         path
       });
     } catch {
+      if (issues) issues.failed += 1;
       // Skip unreadable files.
     }
   }
@@ -249,8 +256,8 @@ async function readCodexThreadNames(codexHome) {
   return titles;
 }
 
-async function listCodexSessions(codexHome) {
-  const sessions = await walkCodexDir(join(codexHome, "sessions"), CODEX_MAX_DEPTH, []);
+async function listCodexSessions(codexHome, issues) {
+  const sessions = await walkCodexDir(join(codexHome, "sessions"), CODEX_MAX_DEPTH, [], issues);
   if (sessions.length === 0) {
     return sessions;
   }
@@ -299,9 +306,10 @@ async function openZcodeDb() {
  * title ("New Session"); only real titles are attached, so the extension's
  * derived "<project> · <first prompt>" still wins when ZCode has no name.
  */
-async function listZcodeSessions() {
+async function listZcodeSessions(issues) {
   const db = await openZcodeDb();
   if (!db) {
+    if (issues) issues.failed += 1;
     return [];
   }
   try {
@@ -331,6 +339,7 @@ async function listZcodeSessions() {
     }
     return sessions;
   } catch {
+    if (issues) issues.failed += 1;
     return []; // unreadable or mid-migration database — ZCode contributes nothing
   } finally {
     db.close();
@@ -467,6 +476,36 @@ async function listSessions() {
   return [...claude, ...codex, ...zcode];
 }
 
+// A missing root and an unreadable source must not both appear as a healthy,
+// empty scan. Paths and transcript data never enter these diagnostics.
+async function listSessionsWithHealth() {
+  const config = await loadConfig();
+  const codexHome = config?.codexHome || DEFAULT_CODEX_HOME;
+  const sources = [
+    ["claude_code", PROJECTS_DIR, (issues) => listClaudeCodeSessions(issues)],
+    ["codex", join(codexHome, "sessions"), (issues) => listCodexSessions(codexHome, issues)],
+    ["zcode", ZCODE_DB, (issues) => listZcodeSessions(issues)]
+  ];
+  const sessions = [];
+  const sourceStatus = {};
+  for (const [source, path, list] of sources) {
+    try {
+      await stat(path);
+    } catch (error) {
+      sourceStatus[source] = { state: error?.code === "ENOENT" ? "missing" : "error" };
+      continue;
+    }
+    const issues = { failed: 0 };
+    try {
+      sessions.push(...await list(issues));
+      sourceStatus[source] = { state: issues.failed > 0 ? "partial" : "ok" };
+    } catch {
+      sourceStatus[source] = { state: "error" };
+    }
+  }
+  return { sessions, sourceStatus };
+}
+
 async function loadConfig() {
   try {
     const raw = await readFile(CONFIG_FILE, "utf8");
@@ -648,6 +687,43 @@ async function readCorpusMemories(corpusRoot) {
   return { memories, skipped };
 }
 
+// A separate metadata channel keeps health heartbeats out of the conversation
+// inbox. Older MCP readers ignore this file and keep their true data age.
+function sourceHealthRow(value) {
+  if (!value || typeof value !== "object") return null;
+  const { source, observedAt, connection, state, lastAttemptAt, lastSuccessfulSyncAt, lastCaptureAt, failedSessions } = value;
+  const time = (v) => Number.isSafeInteger(v) && v >= 0;
+  if (!["claude_code", "codex", "zcode"].includes(source) || !["connected", "disconnected"].includes(connection) ||
+      !["ok", "partial", "missing", "error", "unknown"].includes(state) || !time(observedAt) ||
+      observedAt > Date.now() + 300000 || !time(lastAttemptAt) || lastAttemptAt > observedAt ||
+      (lastSuccessfulSyncAt !== null && (!time(lastSuccessfulSyncAt) || lastSuccessfulSyncAt > observedAt)) ||
+      (lastCaptureAt !== null && (!time(lastCaptureAt) || lastCaptureAt > observedAt)) || !time(failedSessions)) return null;
+  return { source, observedAt, connection, state, lastAttemptAt, lastSuccessfulSyncAt, lastCaptureAt, failedSessions };
+}
+
+async function handleSourceHealth(message) {
+  const config = await loadConfig();
+  if (!config?.corpusRoot || !Array.isArray(message.rows) || message.rows.length > 3) {
+    send({ type: "error", error: "source health: invalid rows or no corpus configured" }); return;
+  }
+  const rows = message.rows.map(sourceHealthRow);
+  if (rows.some((row) => !row)) {
+    send({ type: "error", error: "source health: invalid report" }); return;
+  }
+  const path = join(config.corpusRoot, "source-health-v1.json");
+  let previous = [];
+  try { previous = JSON.parse(await readFile(path, "utf8")); } catch { /* First report. */ }
+  const current = new Map((Array.isArray(previous) ? previous : []).map(sourceHealthRow).filter(Boolean).map((row) => [row.source, row]));
+  for (const row of rows) {
+    if ((current.get(row.source)?.observedAt ?? -1) < row.observedAt) current.set(row.source, row);
+  }
+  await mkdir(config.corpusRoot, { recursive: true, mode: 0o700 });
+  const temp = `${path}.${process.pid}.tmp`;
+  await writeFile(temp, JSON.stringify([...current.values()]) + "\n", { mode: FILE_MODE });
+  await rename(temp, path);
+  send({ type: "sourceHealthAck" });
+}
+
 async function handle(message) {
   if (!message || typeof message !== "object") {
     return;
@@ -662,7 +738,11 @@ async function handle(message) {
       send({ type: "corpusInfo", present: false });
       return;
     }
-    send({ type: "corpusInfo", present: true, root: config.corpusRoot });
+    send({ type: "corpusInfo", present: true, root: config.corpusRoot, sourceHealthSupported: true });
+    return;
+  }
+  if (message.cmd === "putSourceHealth") {
+    await handleSourceHealth(message);
     return;
   }
   if (message.cmd === "putChunk") {
@@ -680,8 +760,8 @@ async function handle(message) {
     return;
   }
   if (message.cmd === "list") {
-    const sessions = await listSessions();
-    send({ type: "list", sessions: sessions.map(({ path, ...rest }) => rest) });
+    const { sessions, sourceStatus } = await listSessionsWithHealth();
+    send({ type: "list", sessions: sessions.map(({ path, ...rest }) => rest), sourceStatus });
     return;
   }
   if (message.cmd === "get") {