@llmnesia/mcp 0.2.9 → 0.2.11

package/dist/cli.js

@@ -3,7 +3,7 @@ import { createRequire as __llmnesiaCreateRequire } from "node:module";
 const require = __llmnesiaCreateRequire(import.meta.url);
 import {
   VERSION
-} from "./chunk-YT6GNKKG.js";
+} from "./chunk-ZYE6VY6A.js";
 
 // src/nodeDownload.ts
 var NODE_DOWNLOAD_URLS = {
@@ -141,7 +141,7 @@ async function bootstrap() {
     await guideUnsupportedNodeVersion(process.versions.node);
     return 1;
   }
-  const { main } = await import("./cli-KHY7ADCU.js");
+  const { main } = await import("./cli-RQMFEW5J.js");
   return main();
 }
 bootstrap().then((code) => {

package/dist/llmnesia-claude-host.mjs

@@ -78,9 +78,29 @@ const DEFAULT_CODEX_HOME = process.env.CODEX_HOME || join(homedir(), ".codex");
 // Codex nests rollouts as sessions/<year>/<month>/<day>/*.jsonl. Bounded so a
 // misconfigured codexHome can't turn into an unbounded filesystem walk.
 const CODEX_MAX_DEPTH = 3;
-// 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;
+// Conservative chunk size. Native messaging caps a single message at 1 MB,
+// and the wire size of a chunk is the JSON-ESCAPED UTF-8 length of `data`
+// (an astral character is 4 raw bytes; a literal backslash doubles), so
+// chunks are budgeted by measuring exactly that as they are built: a chunk
+// can never push the framed message over the ceiling no matter what the
+// transcript contains.
+const MAX_CHUNK_ESCAPED_BYTES = 256 * 1024;
+// JSON-escaped UTF-8 byte length of one UTF-16 code unit of `text` as
+// JSON.stringify would emit it: quotes/backslashes and the short escapes
+// double, other control characters become \u00XX (6 bytes), a lone surrogate
+// becomes \udXXX, BMP non-ASCII passes through at its UTF-8 width, and a
+// surrogate PAIR is one 4-byte astral character.
+function escapedUnitBytes(unit, nextUnit) {
+  if (unit >= 0xd800 && unit <= 0xdbff) {
+    return nextUnit >= 0xdc00 && nextUnit <= 0xdfff ? 4 : 6; // astral char or lone high surrogate
+  }
+  if (unit >= 0xdc00 && unit <= 0xdfff) return 6; // lone low surrogate
+  if (unit === 0x22 || unit === 0x5c) return 2; // " and \
+  if (unit < 0x20) return [0x08, 0x09, 0x0a, 0x0c, 0x0d].includes(unit) ? 2 : 6;
+  if (unit < 0x80) return 1;
+  if (unit < 0x800) return 2;
+  return 3;
+}
 // 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.
@@ -690,14 +710,31 @@ async function handle(message) {
       }
       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++) {
+    const chunks = [];
+    let chunk = "";
+    let chunkBytes = 0;
+    for (let i = 0; i < text.length; i++) {
+      const unit = text.charCodeAt(i);
+      const size = escapedUnitBytes(unit, i + 1 < text.length ? text.charCodeAt(i + 1) : NaN);
+      if (chunk && chunkBytes + size > MAX_CHUNK_ESCAPED_BYTES) {
+        chunks.push(chunk);
+        chunk = "";
+        chunkBytes = 0;
+      }
+      chunk += text[i];
+      chunkBytes += size;
+    }
+    if (chunk) {
+      chunks.push(chunk);
+    }
+    const total = Math.max(1, chunks.length);
+    for (let seq = 0; seq < total; seq++) {
       send({
         type: "chunk",
         sessionId: message.sessionId,
         seq,
         total,
-        data: text.slice(i, i + CHUNK_CHARS)
+        data: chunks[seq] ?? ""
       });
     }
     send({ type: "sessionDone", sessionId: message.sessionId });
@@ -728,7 +765,16 @@ process.stdin.on("data", (data) => {
     // 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) }));
+      .catch((error) =>
+        // Attribute the failure to the command's session when it names one, so
+        // the extension's fetch loop can drop a STALE error that arrives after
+        // it gave up on that session instead of failing the next one.
+        send({
+          type: "error",
+          ...(typeof message.sessionId === "string" ? { sessionId: message.sessionId } : {}),
+          error: String((error && error.message) || error)
+        })
+      );
   }
 });