@llmnesia/mcp 0.1.0

package/dist/llmnesia-claude-host.mjs

@@ -0,0 +1,251 @@
+#!/usr/bin/env node
+// LLMnesia native messaging host — reads local Claude Code sessions from
+// ~/.claude/projects and streams them to the LLMnesia browser extension, and
+// writes corpus sync deltas the extension sends back into the LLMnesia
+// corpus's inbox/ directory (see packages/../companion/src/paths.ts).
+//
+// It reads .jsonl session files under ~/.claude/projects, and writes only
+// inside the corpus root named in its own config (~/.llmnesia/config.json) —
+// never a path the caller supplies. It makes no network calls. The browser
+// launches it on demand (see the installed com.llmnesia.claude_code.json
+// manifest) and talks to it over stdio using Chrome's native-messaging
+// framing: a little-endian uint32 byte-length prefix followed by that many
+// bytes of UTF-8 JSON, in both directions.
+//
+// The write path only ever activates for a user who has explicitly run the
+// installer with --corpus (see install.mjs) to opt into the MCP companion;
+// without ~/.llmnesia/config.json this host is exactly as read-only as it
+// has always been for plain Claude Code indexing.
+//
+// Protocol (extension → host):
+//   { cmd: "ping" }                    → { type: "pong", version }
+//   { cmd: "list" }                    → { type: "list", sessions: [{sessionId, mtime, project}] }
+//   { cmd: "get", sessionId }          → one or more { type: "chunk", sessionId, seq, total, data }
+//                                        then { type: "sessionDone", sessionId }
+//                                        (or { type: "session", sessionId, notFound: true })
+//   { cmd: "corpusInfo" }              → { type: "corpusInfo", present, root? }
+//   { cmd: "putChunk", filename,
+//     seq, total, data }               → { type: "chunkAck", seq }
+//                                        (writes <root>/inbox/<filename> once
+//                                        every chunk 0..total-1 has arrived)
+
+import { chmod, mkdir, readdir, readFile, rename, stat, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const PROJECTS_DIR = join(homedir(), ".claude", "projects");
+const CONFIG_FILE = join(homedir(), ".llmnesia", "config.json");
+// Conservative chunk size (chars). After JSON-escaping + any multibyte chars the
+// on-wire message stays well under native messaging's 1 MB per-message ceiling.
+const CHUNK_CHARS = 256 * 1024;
+// Matches companion/src/corpus.ts DIR_MODE/FILE_MODE — the corpus holds
+// plaintext conversation history, so writes here should be no more readable
+// than the browser profile it was copied out of.
+const DIR_MODE = 0o700;
+const FILE_MODE = 0o600;
+
+function send(message) {
+  const body = Buffer.from(JSON.stringify(message), "utf8");
+  const header = Buffer.alloc(4);
+  header.writeUInt32LE(body.length, 0);
+  process.stdout.write(header);
+  process.stdout.write(body);
+}
+
+async function listSessions() {
+  const sessions = [];
+  let projectDirs;
+  try {
+    projectDirs = await readdir(PROJECTS_DIR, { withFileTypes: true });
+  } catch {
+    return sessions; // no ~/.claude/projects yet
+  }
+  for (const entry of projectDirs) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    const dir = join(PROJECTS_DIR, entry.name);
+    let files;
+    try {
+      files = await readdir(dir);
+    } catch {
+      continue;
+    }
+    for (const file of files) {
+      if (!file.endsWith(".jsonl")) {
+        continue;
+      }
+      const path = join(dir, file);
+      try {
+        const info = await stat(path);
+        sessions.push({
+          sessionId: file.replace(/\.jsonl$/, ""),
+          mtime: Math.floor(info.mtimeMs),
+          project: entry.name,
+          path
+        });
+      } catch {
+        // Skip unreadable files.
+      }
+    }
+  }
+  return sessions;
+}
+
+async function loadConfig() {
+  try {
+    const raw = await readFile(CONFIG_FILE, "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed.corpusRoot === "string" && parsed.corpusRoot.length > 0) {
+      return { corpusRoot: parsed.corpusRoot };
+    }
+    return null;
+  } catch {
+    return null; // no config yet, or unreadable/invalid — treat as "not installed"
+  }
+}
+
+// A filename must be a bare basename: no separators, no "..", nothing that
+// could walk outside the corpus's inbox/ directory. The host is the trust
+// boundary here — the extension is not trusted to name a write target.
+function sanitizeFilename(name) {
+  if (typeof name !== "string" || name.length === 0) {
+    return null;
+  }
+  if (name === "." || name === "..") {
+    return null;
+  }
+  if (name.includes("/") || name.includes("\\") || name.includes("..")) {
+    return null;
+  }
+  return name;
+}
+
+// filename → { chunks: string[], receivedSeqs: Set<number>, total } while a
+// multi-chunk putChunk transfer is in flight. Completeness is tracked via
+// receivedSeqs.size rather than scanning chunks for holes — `new Array(total)`
+// is sparse, and Array#some skips unset indices entirely, so a hole-scan would
+// silently call a partial transfer "complete" the moment the last-received
+// (not last-index) chunk lands.
+const pendingWrites = new Map();
+
+async function handlePutChunk(message) {
+  const { filename, seq, total, data } = message;
+  const safeName = sanitizeFilename(filename);
+  if (!safeName) {
+    send({ type: "error", error: `putChunk: rejected filename ${JSON.stringify(filename)}` });
+    return;
+  }
+  if (!Number.isInteger(seq) || !Number.isInteger(total) || seq < 0 || total < 1 || seq >= total) {
+    send({ type: "error", error: `putChunk: invalid seq/total for ${safeName}` });
+    return;
+  }
+  const config = await loadConfig();
+  if (!config) {
+    send({ type: "error", error: "putChunk: no corpus configured (run the installer)" });
+    return;
+  }
+
+  let entry = pendingWrites.get(safeName);
+  if (!entry || entry.total !== total) {
+    entry = { chunks: new Array(total).fill(""), receivedSeqs: new Set(), total };
+    pendingWrites.set(safeName, entry);
+  }
+  entry.chunks[seq] = typeof data === "string" ? data : "";
+  entry.receivedSeqs.add(seq);
+
+  if (entry.receivedSeqs.size < total) {
+    send({ type: "chunkAck", seq });
+    return;
+  }
+
+  pendingWrites.delete(safeName);
+  const inboxDir = join(config.corpusRoot, "inbox");
+  await mkdir(inboxDir, { recursive: true, mode: DIR_MODE });
+  await chmod(inboxDir, DIR_MODE).catch(() => {}); // mkdir's mode is masked by umask
+  const tmpPath = join(inboxDir, `${safeName}.part-${process.pid}`);
+  const finalPath = join(inboxDir, safeName);
+  await writeFile(tmpPath, entry.chunks.join(""), { encoding: "utf8", mode: FILE_MODE });
+  await rename(tmpPath, finalPath);
+  send({ type: "chunkAck", seq });
+}
+
+async function handle(message) {
+  if (!message || typeof message !== "object") {
+    return;
+  }
+  if (message.cmd === "ping") {
+    send({ type: "pong", version: 1 });
+    return;
+  }
+  if (message.cmd === "corpusInfo") {
+    const config = await loadConfig();
+    if (!config) {
+      send({ type: "corpusInfo", present: false });
+      return;
+    }
+    send({ type: "corpusInfo", present: true, root: config.corpusRoot });
+    return;
+  }
+  if (message.cmd === "putChunk") {
+    await handlePutChunk(message);
+    return;
+  }
+  if (message.cmd === "list") {
+    const sessions = await listSessions();
+    send({ type: "list", sessions: sessions.map(({ path, ...rest }) => rest) });
+    return;
+  }
+  if (message.cmd === "get") {
+    const sessions = await listSessions();
+    const match = sessions.find((s) => s.sessionId === message.sessionId);
+    if (!match) {
+      send({ type: "session", sessionId: message.sessionId, notFound: true });
+      return;
+    }
+    const text = await readFile(match.path, "utf8");
+    const total = Math.max(1, Math.ceil(text.length / CHUNK_CHARS));
+    for (let i = 0, seq = 0; seq < total; i += CHUNK_CHARS, seq++) {
+      send({
+        type: "chunk",
+        sessionId: message.sessionId,
+        seq,
+        total,
+        data: text.slice(i, i + CHUNK_CHARS)
+      });
+    }
+    send({ type: "sessionDone", sessionId: message.sessionId });
+    return;
+  }
+  send({ type: "error", error: `unknown command: ${String(message.cmd)}` });
+}
+
+// --- native-messaging stdin framing --------------------------------------
+let inbox = Buffer.alloc(0);
+let processing = Promise.resolve();
+
+process.stdin.on("data", (data) => {
+  inbox = Buffer.concat([inbox, data]);
+  while (inbox.length >= 4) {
+    const length = inbox.readUInt32LE(0);
+    if (inbox.length < 4 + length) {
+      break;
+    }
+    const payload = inbox.subarray(4, 4 + length).toString("utf8");
+    inbox = inbox.subarray(4 + length);
+    let message;
+    try {
+      message = JSON.parse(payload);
+    } catch {
+      continue;
+    }
+    // Serialize handling so chunk ordering per session is preserved.
+    processing = processing
+      .then(() => handle(message))
+      .catch((error) => send({ type: "error", error: String((error && error.message) || error) }));
+  }
+});
+
+process.stdin.on("end", () => {
+  processing.finally(() => process.exit(0));
+});