specmem-hardwicksoftware 3.7.17 → 3.7.20

package/mcp-proxy.cjs

@@ -53,50 +53,84 @@ function parseMessages(buffer) {
   let remaining = buffer;
 
   while (remaining.length > 0) {
-    // Look for Content-Length header
-    const headerEnd = remaining.indexOf('\r\n\r\n');
-    if (headerEnd === -1) break;
-
-    const header = remaining.substring(0, headerEnd);
-    const match = header.match(/Content-Length:\s*(\d+)/i);
-    if (!match) {
-      // Skip malformed data
-      remaining = remaining.substring(headerEnd + 4);
-      continue;
-    }
+    remaining = remaining.trimStart();
+    if (remaining.length === 0) break;
+
+    // Mode 1: Content-Length framed (MCP spec)
+    if (remaining.startsWith('Content-Length:')) {
+      const headerEnd = remaining.indexOf('\r\n\r\n');
+      if (headerEnd === -1) break;
+
+      const header = remaining.substring(0, headerEnd);
+      const match = header.match(/Content-Length:\s*(\d+)/i);
+      if (!match) {
+        remaining = remaining.substring(headerEnd + 4);
+        continue;
+      }
+
+      const contentLength = parseInt(match[1], 10);
+      const bodyStart = headerEnd + 4;
+      const bodyEnd = bodyStart + contentLength;
 
-    const contentLength = parseInt(match[1], 10);
-    const bodyStart = headerEnd + 4;
-    const bodyEnd = bodyStart + contentLength;
+      if (remaining.length < bodyEnd) break;
 
-    if (remaining.length < bodyEnd) {
-      break; // Incomplete message, wait for more data
+      const body = remaining.substring(bodyStart, bodyEnd);
+      remaining = remaining.substring(bodyEnd);
+
+      try {
+        messages.push(JSON.parse(body));
+      } catch (e) {
+        log(`Parse error (framed): ${e.message}`);
+      }
+      continue;
     }
 
-    const body = remaining.substring(bodyStart, bodyEnd);
-    remaining = remaining.substring(bodyEnd);
+    // Mode 2: Raw JSON (newline-delimited) — Claude Code sends this
+    if (remaining[0] === '{') {
+      // Find the end of this JSON object by tracking braces
+      let depth = 0;
+      let inString = false;
+      let escape = false;
+      let end = -1;
+      for (let i = 0; i < remaining.length; i++) {
+        const ch = remaining[i];
+        if (escape) { escape = false; continue; }
+        if (ch === '\\' && inString) { escape = true; continue; }
+        if (ch === '"') { inString = !inString; continue; }
+        if (inString) continue;
+        if (ch === '{') depth++;
+        if (ch === '}') { depth--; if (depth === 0) { end = i + 1; break; } }
+      }
+      if (end === -1) break; // Incomplete JSON
+
+      const jsonStr = remaining.substring(0, end);
+      remaining = remaining.substring(end);
 
-    try {
-      messages.push(JSON.parse(body));
-    } catch (e) {
-      log(`Parse error: ${e.message} body=${body.substring(0, 100)}`);
+      try {
+        messages.push(JSON.parse(jsonStr));
+      } catch (e) {
+        log(`Parse error (raw): ${e.message}`);
+      }
+      continue;
     }
+
+    // Skip unknown byte
+    remaining = remaining.substring(1);
   }
 
   return { messages, remaining };
 }
 
-function frameMessage(obj) {
-  const body = JSON.stringify(obj);
-  return `Content-Length: ${Buffer.byteLength(body)}\r\n\r\n${body}`;
+function serializeMessage(obj) {
+  return JSON.stringify(obj) + '\n';
 }
 
 // ============================================================================
-// Send message to Claude (stdout)
+// Send message to Claude (stdout) — newline-delimited JSON per MCP SDK
 // ============================================================================
 function sendToClient(msg) {
   try {
-    process.stdout.write(frameMessage(msg));
+    process.stdout.write(serializeMessage(msg));
   } catch (e) {
     log(`stdout write error: ${e.message}`);
   }
@@ -130,7 +164,7 @@ function sendToServer(msg) {
   }
 
   try {
-    child.stdin.write(frameMessage(msg));
+    child.stdin.write(serializeMessage(msg));
   } catch (e) {
     log(`child stdin write error: ${e.message}`);
     pendingQueue.push(msg);
@@ -170,8 +204,8 @@ function spawnServer() {
   // CRITICAL: Do NOT hardcode --max-old-space-size here
   // The proxy's own heap limit is set by Claude config args (e.g. --max-old-space-size=250)
   // but the child bootstrap needs MORE memory for all its initialization
-  const heapLimit = process.env.SPECMEM_MAX_HEAP_MB || '512';
-  child = spawn('node', [`--max-old-space-size=${heapLimit}`, BOOTSTRAP_PATH, ...args], {
+  const heapLimit = process.env.SPECMEM_MAX_HEAP_MB || '1024';
+  child = spawn('node', ['--expose-gc', `--max-old-space-size=${heapLimit}`, BOOTSTRAP_PATH, ...args], {
     env,
     stdio: ['pipe', 'pipe', 'pipe'],
     cwd: process.env.SPECMEM_PROJECT_PATH || process.cwd()
@@ -183,9 +217,12 @@ function spawnServer() {
   });
 
   child.stdout.on('data', (data) => {
-    childStdoutBuffer += data.toString();
+    const raw = data.toString();
+    log(`CHILD STDOUT (${raw.length} bytes): ${raw.substring(0, 200)}`);
+    childStdoutBuffer += raw;
 
     const { messages, remaining } = parseMessages(childStdoutBuffer);
+    log(`CHILD PARSED: ${messages.length} messages, ${remaining.length} bytes remaining`);
     childStdoutBuffer = remaining;
 
     for (const msg of messages) {
@@ -224,7 +261,15 @@ function spawnServer() {
     stopHeartbeat();
 
     if (!shuttingDown) {
-      scheduleRestart();
+      // If bootstrap was intentionally killed (SIGTERM/SIGKILL from init or system),
+      // don't restart — exit the proxy too. Init will start a fresh bootstrap.
+      // Only restart on crashes (non-zero exit code without signal).
+      if (signal === 'SIGTERM' || signal === 'SIGKILL') {
+        log(`Bootstrap was intentionally killed (${signal}) — proxy exiting`);
+        shutdown();
+      } else {
+        scheduleRestart();
+      }
     }
   });
 
@@ -234,12 +279,12 @@ function spawnServer() {
     setTimeout(() => {
       if (child && !child.killed) {
         try {
-          child.stdin.write(frameMessage(lastInitializeRequest));
+          child.stdin.write(serializeMessage(lastInitializeRequest));
           // Also send initialized notification
           setTimeout(() => {
             if (child && !child.killed) {
               try {
-                child.stdin.write(frameMessage({ jsonrpc: '2.0', method: 'notifications/initialized' }));
+                child.stdin.write(serializeMessage({ jsonrpc: '2.0', method: 'notifications/initialized' }));
               } catch {}
             }
           }, 100);
@@ -292,9 +337,12 @@ function stopHeartbeat() {
 // Handle stdin from Claude
 // ============================================================================
 process.stdin.on('data', (data) => {
-  stdinBuffer += data.toString();
+  const raw = data.toString();
+  log(`STDIN RAW (${raw.length} bytes): ${raw.substring(0, 200)}`);
+  stdinBuffer += raw;
 
   const { messages, remaining } = parseMessages(stdinBuffer);
+  log(`STDIN PARSED: ${messages.length} messages, ${remaining.length} bytes remaining`);
   stdinBuffer = remaining;
 
   for (const msg of messages) {
@@ -346,6 +394,15 @@ function shutdown() {
 process.on('SIGTERM', shutdown);
 process.on('SIGINT', shutdown);
 
+// Orphan detection: if parent (Claude) dies, proxy gets reparented to PID 1
+// Check every 10s and exit if orphaned
+setInterval(() => {
+  if (process.ppid === 1) {
+    log('Parent died (PPID=1), proxy shutting down');
+    shutdown();
+  }
+}, 10000);
+
 // ============================================================================
 // Start
 // ============================================================================

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "specmem-hardwicksoftware",
-  "version": "3.7.17",
+  "version": "3.7.20",
   "type": "module",
-  "description": "Persistent memory system for coding sessions - semantic search with pgvector, token compression, team coordination, file watching. Needs root: installs system-wide hooks, manages docker/PostgreSQL, writes global configs, handles screen sessions. justcalljon.pro",
+  "description": "Your Claude Code sessions don't have to start from scratch anymore — SpecMem gives your AI real memory. It won't forget your conversations, your code, or your architecture decisions between sessions. That's the whole point. Semantic code indexing that actually works: TypeScript, JavaScript, Python, Go, Rust, Java, Kotlin, C, C++, HTML and more. It doesn't just track functions — it gets classes, methods, fields, constants, enums, macros, imports, structs, the whole codebase graph. There's chat memory too, powered by pgvector embeddings. You've also got token compression, team coordination, multi-agent comms, and file watching built in. 74+ MCP tools. Runs on PostgreSQL + Docker. It's kind of a big deal. justcalljon.pro",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "bin": {
@@ -44,7 +44,18 @@
     "anthropic",
     "embeddings",
     "context",
-    "hooks"
+    "hooks",
+    "code-indexing",
+    "typescript",
+    "javascript",
+    "python",
+    "java",
+    "cpp",
+    "rust",
+    "html",
+    "codebase-analysis",
+    "multi-language",
+    "team-coordination"
   ],
   "author": {
     "name": "Jonathan Hardwick",

package/scripts/specmem-init.cjs

@@ -6531,7 +6531,7 @@ async function runAutoSetup(projectPath) {
           SPECMEM_DB_NAME: "specmem_westayunprofessional",
           SPECMEM_DB_USER: "specmem_westayunprofessional",
           SPECMEM_DB_PASSWORD: "specmem_westayunprofessional",
-          SPECMEM_MAX_HEAP_MB: "512"
+          SPECMEM_MAX_HEAP_MB: "1024"
         }
       };
       claudeJson.projects[projectPath].hasTrustDialogAccepted = true;