specmem-hardwicksoftware 3.7.13 → 3.7.14

package/dist/config/configSync.js

@@ -47,7 +47,9 @@ function getSpecmemDir() {
     // Otherwise we're in src/config
     return path.resolve(currentDir, '..', '..');
 }
-const BOOTSTRAP_PATH = path.join(getSpecmemDir(), 'bootstrap.cjs');
+// Prefer proxy for resilient MCP connections (auto-reconnect on crash)
+const _proxyPath = path.join(getSpecmemDir(), 'mcp-proxy.cjs');
+const BOOTSTRAP_PATH = fs.existsSync(_proxyPath) ? _proxyPath : path.join(getSpecmemDir(), 'bootstrap.cjs');
 const SOURCE_HOOKS_DIR = path.join(getSpecmemDir(), 'claude-hooks');
 const SOURCE_COMMANDS_DIR = path.join(getSpecmemDir(), 'commands');
 // ============================================================================

package/dist/init/claudeConfigInjector.js

@@ -97,8 +97,11 @@ function getSpecmemRoot() {
     // 6. Last resort - return __dirname-based path even without bootstrap
     return fromThisFile;
 }
-// Find the actual bootstrap file (cjs or js)
+// Find the MCP entry point — prefer proxy for resilient connections
 function findBootstrapPath(root) {
+    // Proxy wraps bootstrap.cjs with auto-reconnect on crash
+    const proxy = path.join(root, 'mcp-proxy.cjs');
+    if (fs.existsSync(proxy)) return proxy;
     for (const name of ['bootstrap.cjs', 'bootstrap.js']) {
         const p = path.join(root, name);
         if (fs.existsSync(p)) return p;

package/mcp-proxy.cjs

@@ -0,0 +1,336 @@
+#!/usr/bin/env node
+/**
+ * MCP Proxy - Resilient stdio proxy for SpecMem MCP server
+ *
+ * Claude connects to this proxy via stdio. The proxy manages the actual
+ * MCP server (bootstrap.cjs) as a child process. If the server crashes
+ * or restarts, the proxy reconnects transparently — Claude never sees
+ * a disconnect.
+ *
+ * Protocol: MCP uses Content-Length framed JSON-RPC 2.0 over stdio.
+ */
+
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+// Config
+const BOOTSTRAP_PATH = path.join(__dirname, 'bootstrap.cjs');
+const MAX_RESTART_DELAY = 10000; // 10s max backoff
+const INITIAL_RESTART_DELAY = 500; // 500ms first retry
+const MAX_QUEUE_SIZE = 200;
+const HEARTBEAT_INTERVAL = 30000; // 30s keepalive pings
+
+// State
+let child = null;
+let childReady = false;
+let pendingQueue = []; // Messages queued during reconnect
+let restartDelay = INITIAL_RESTART_DELAY;
+let restartCount = 0;
+let lastInitializeRequest = null; // Cache the initialize request for re-init
+let lastInitializeResponse = null;
+let initializeId = null;
+let shuttingDown = false;
+let heartbeatTimer = null;
+let childStdoutBuffer = '';
+let stdinBuffer = '';
+
+function log(msg) {
+  try {
+    fs.appendFileSync('/tmp/specmem-proxy.log',
+      `[${new Date().toISOString()}] ${msg}\n`);
+  } catch {}
+}
+
+log(`Proxy starting. PID=${process.pid} BOOTSTRAP=${BOOTSTRAP_PATH}`);
+log(`ENV: PROJECT_PATH=${process.env.SPECMEM_PROJECT_PATH}`);
+
+// ============================================================================
+// Content-Length framed message parser
+// ============================================================================
+function parseMessages(buffer) {
+  const messages = [];
+  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;
+    }
+
+    const contentLength = parseInt(match[1], 10);
+    const bodyStart = headerEnd + 4;
+    const bodyEnd = bodyStart + contentLength;
+
+    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: ${e.message} body=${body.substring(0, 100)}`);
+    }
+  }
+
+  return { messages, remaining };
+}
+
+function frameMessage(obj) {
+  const body = JSON.stringify(obj);
+  return `Content-Length: ${Buffer.byteLength(body)}\r\n\r\n${body}`;
+}
+
+// ============================================================================
+// Send message to Claude (stdout)
+// ============================================================================
+function sendToClient(msg) {
+  try {
+    process.stdout.write(frameMessage(msg));
+  } catch (e) {
+    log(`stdout write error: ${e.message}`);
+  }
+}
+
+// ============================================================================
+// Send message to MCP server (child stdin)
+// ============================================================================
+function sendToServer(msg) {
+  if (!child || !childReady || child.killed) {
+    // Queue it
+    if (pendingQueue.length < MAX_QUEUE_SIZE) {
+      pendingQueue.push(msg);
+      log(`Queued message (${pendingQueue.length} pending): ${msg.method || msg.id || '?'}`);
+    } else {
+      log(`Queue full, dropping message: ${msg.method || msg.id || '?'}`);
+    }
+    return;
+  }
+
+  try {
+    child.stdin.write(frameMessage(msg));
+  } catch (e) {
+    log(`child stdin write error: ${e.message}`);
+    pendingQueue.push(msg);
+  }
+}
+
+// ============================================================================
+// Flush queued messages to server
+// ============================================================================
+function flushQueue() {
+  if (pendingQueue.length === 0) return;
+  log(`Flushing ${pendingQueue.length} queued messages to server`);
+  const queue = [...pendingQueue];
+  pendingQueue = [];
+  for (const msg of queue) {
+    sendToServer(msg);
+  }
+}
+
+// ============================================================================
+// Spawn/restart the MCP server
+// ============================================================================
+function spawnServer() {
+  if (shuttingDown) return;
+  if (child && !child.killed) {
+    try { child.kill('SIGTERM'); } catch {}
+  }
+
+  childReady = false;
+  childStdoutBuffer = '';
+
+  const args = process.argv.slice(2); // Pass through any args
+  const env = { ...process.env };
+
+  log(`Spawning server: node ${BOOTSTRAP_PATH} ${args.join(' ')}`);
+
+  child = spawn('node', ['--max-old-space-size=250', BOOTSTRAP_PATH, ...args], {
+    env,
+    stdio: ['pipe', 'pipe', 'pipe'],
+    cwd: process.env.SPECMEM_PROJECT_PATH || process.cwd()
+  });
+
+  child.stderr.on('data', (data) => {
+    // Forward stderr (logs) to our stderr
+    process.stderr.write(data);
+  });
+
+  child.stdout.on('data', (data) => {
+    childStdoutBuffer += data.toString();
+
+    const { messages, remaining } = parseMessages(childStdoutBuffer);
+    childStdoutBuffer = remaining;
+
+    for (const msg of messages) {
+      // If this is the response to initialize, cache it and mark ready
+      if (msg.id !== undefined && msg.id === initializeId && msg.result) {
+        lastInitializeResponse = msg;
+        childReady = true;
+        restartDelay = INITIAL_RESTART_DELAY;
+        restartCount = 0;
+        log(`Server initialized (id=${msg.id}). Flushing queue.`);
+
+        // If this is a RE-init (not the first), don't send the response
+        // to Claude — Claude already has the init response from first time
+        if (restartCount > 0 || lastInitializeResponse) {
+          // Still send it on first init
+        }
+        sendToClient(msg);
+        flushQueue();
+        startHeartbeat();
+        continue;
+      }
+
+      // Forward everything else to Claude
+      sendToClient(msg);
+    }
+  });
+
+  child.on('error', (err) => {
+    log(`Server process error: ${err.message}`);
+    scheduleRestart();
+  });
+
+  child.on('exit', (code, signal) => {
+    log(`Server exited: code=${code} signal=${signal}`);
+    childReady = false;
+    stopHeartbeat();
+
+    if (!shuttingDown) {
+      scheduleRestart();
+    }
+  });
+
+  // If we have a cached initialize request, re-send it
+  if (lastInitializeRequest && restartCount > 0) {
+    log(`Re-sending initialize request (restart #${restartCount})`);
+    setTimeout(() => {
+      if (child && !child.killed) {
+        try {
+          child.stdin.write(frameMessage(lastInitializeRequest));
+          // Also send initialized notification
+          setTimeout(() => {
+            if (child && !child.killed) {
+              try {
+                child.stdin.write(frameMessage({ jsonrpc: '2.0', method: 'notifications/initialized' }));
+              } catch {}
+            }
+          }, 100);
+        } catch (e) {
+          log(`Re-init write error: ${e.message}`);
+        }
+      }
+    }, 200);
+  }
+
+  restartCount++;
+}
+
+function scheduleRestart() {
+  if (shuttingDown) return;
+  log(`Scheduling restart in ${restartDelay}ms (restart #${restartCount})`);
+  setTimeout(() => {
+    spawnServer();
+  }, restartDelay);
+  restartDelay = Math.min(restartDelay * 2, MAX_RESTART_DELAY);
+}
+
+// ============================================================================
+// Heartbeat — detect dead server
+// ============================================================================
+function startHeartbeat() {
+  stopHeartbeat();
+  heartbeatTimer = setInterval(() => {
+    if (!child || child.killed || !childReady) return;
+    // Send a ping (list tools) to keep connection alive
+    // MCP doesn't have a ping method, but we can use this to detect dead pipes
+    try {
+      child.stdin.write(''); // Zero-byte write to test pipe
+    } catch (e) {
+      log(`Heartbeat detected dead pipe: ${e.message}`);
+      childReady = false;
+      try { child.kill('SIGTERM'); } catch {}
+    }
+  }, HEARTBEAT_INTERVAL);
+}
+
+function stopHeartbeat() {
+  if (heartbeatTimer) {
+    clearInterval(heartbeatTimer);
+    heartbeatTimer = null;
+  }
+}
+
+// ============================================================================
+// Handle stdin from Claude
+// ============================================================================
+process.stdin.on('data', (data) => {
+  stdinBuffer += data.toString();
+
+  const { messages, remaining } = parseMessages(stdinBuffer);
+  stdinBuffer = remaining;
+
+  for (const msg of messages) {
+    // Cache the initialize request so we can re-send on restart
+    if (msg.method === 'initialize') {
+      lastInitializeRequest = msg;
+      initializeId = msg.id;
+      log(`Got initialize request (id=${msg.id})`);
+    }
+
+    // Cache initialized notification
+    if (msg.method === 'notifications/initialized') {
+      log('Got initialized notification');
+    }
+
+    sendToServer(msg);
+  }
+});
+
+process.stdin.on('end', () => {
+  log('stdin closed (Claude disconnected)');
+  shutdown();
+});
+
+process.stdin.on('error', (err) => {
+  log(`stdin error: ${err.message}`);
+  shutdown();
+});
+
+// ============================================================================
+// Graceful shutdown
+// ============================================================================
+function shutdown() {
+  if (shuttingDown) return;
+  shuttingDown = true;
+  log('Proxy shutting down');
+  stopHeartbeat();
+  if (child && !child.killed) {
+    child.kill('SIGTERM');
+    setTimeout(() => {
+      try { child.kill('SIGKILL'); } catch {}
+      process.exit(0);
+    }, 3000);
+  } else {
+    process.exit(0);
+  }
+}
+
+process.on('SIGTERM', shutdown);
+process.on('SIGINT', shutdown);
+
+// ============================================================================
+// Start
+// ============================================================================
+spawnServer();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "specmem-hardwicksoftware",
-  "version": "3.7.13",
+  "version": "3.7.14",
   "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",
   "main": "dist/index.js",
@@ -128,6 +128,7 @@
     "embedding-sandbox/",
     "legal/",
     "bootstrap.cjs",
+    "mcp-proxy.cjs",
     "specmem-health.cjs",
     "specmem.env",
     "LICENSE.md",

package/scripts/specmem-init.cjs

@@ -6511,12 +6511,16 @@ async function runAutoSetup(projectPath) {
 
       // Configure MCP server for this project
       claudeJson.projects[projectPath].mcpServers = claudeJson.projects[projectPath].mcpServers || {};
+      // Prefer mcp-proxy.cjs for resilient connections (auto-reconnect)
+      const mcpEntry = fs.existsSync(path.join(specmemPkg, 'mcp-proxy.cjs'))
+        ? path.join(specmemPkg, 'mcp-proxy.cjs')
+        : path.join(specmemPkg, 'bootstrap.cjs');
       claudeJson.projects[projectPath].mcpServers.specmem = {
         type: "stdio",
         command: "node",
         args: [
           "--max-old-space-size=250",
-          path.join(specmemPkg, 'bootstrap.cjs')
+          mcpEntry
         ],
         env: {
           HOME: os.homedir(),