fix: worker crash resilience — auto-restart, embed timeout, proxy retry on timeout

If the embed worker thread crashes (OOM, unhandled rejection, etc.), the server
becomes a zombie: /ping responds but /search hangs forever because embed() returns
a promise that never resolves.

Three fixes:
1. Worker auto-restarts on crash (exit handler with 2s backoff)
2. embed() has 60s timeout — rejects instead of hanging forever
3. Proxy callServerWithRetry now catches timeout errors (not just ECONNREFUSED)
   so a zombie server triggers relaunch instead of surfacing a timeout to the user.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: BrainSlugs83

index.js

@@ -250,8 +250,9 @@ async function callServerWithRetry(path, body) {
   try {
     return await callServer(path, body);
   } catch (err) {
-    if (err.message && (err.message.includes("ECONNREFUSED") || err.message.includes("ECONNRESET"))) {
-      // Server isn't responding — (re)launch and wait for it
+    const msg = err.message || "";
+    if (msg.includes("ECONNREFUSED") || msg.includes("ECONNRESET") || msg.includes("timeout")) {
+      // Server isn't responding or timed out — (re)launch and wait for it
       await ensureServer();
       const ready = await waitForServer(300_000); // 5 minutes for first-run model download
       if (!ready) {

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "ghcp-cli-vector-memory-mcp",
-  "version": "1.5.0",
+  "version": "1.5.1",
   "description": "MCP server that gives GitHub Copilot CLI persistent long-term memory via local semantic vector search. Install: npx -y ghcp-cli-vector-memory-mcp",
   "main": "index.js",
   "bin": {

package.json

@@ -26,35 +26,73 @@ let isIndexing = false;
 
 // --- Embedding via Worker Thread ---
 
-// Worker is started lazily after we win the singleton race
+// Worker is started lazily after we win the singleton race.
+// Auto-restarts on crash to prevent zombie server state.
 let worker;
+let workerAlive = false;
 let embedIdCounter = 0;
-const pendingEmbeds = new Map();
+const pendingEmbeds = new Map(); // id → { resolve, reject }
+const EMBED_TIMEOUT_MS = 60_000;
+
+function rejectAllPending(reason) {
+  for (const [id, { reject }] of pendingEmbeds) {
+    reject(new Error(reason));
+  }
+  pendingEmbeds.clear();
+}
 
 function initWorker() {
   worker = new Worker(join(__dirname, "embed-worker.js"));
+  workerAlive = true;
+
   worker.on("message", (msg) => {
     if (msg.type === "ready") return;
     if (msg.type === "error") {
       process.stderr.write(`[vector-memory] Embedding model error: ${msg.message}\n`);
       return;
     }
-    const resolve = pendingEmbeds.get(msg.id);
-    if (resolve) {
+    const pending = pendingEmbeds.get(msg.id);
+    if (pending) {
+      clearTimeout(pending.timer);
       pendingEmbeds.delete(msg.id);
-      resolve(msg.embedding);
+      pending.resolve(msg.embedding);
     }
   });
+
   worker.on("error", (err) => {
     process.stderr.write(`[vector-memory] Worker crashed: ${err.message}\n`);
+    workerAlive = false;
+    rejectAllPending("Worker crashed: " + err.message);
+  });
+
+  worker.on("exit", (code) => {
+    workerAlive = false;
+    if (code !== 0) {
+      process.stderr.write(`[vector-memory] Worker exited with code ${code} — restarting in 2s\n`);
+      rejectAllPending("Worker exited with code " + code);
+      setTimeout(() => initWorker(), 2000);
+    }
   });
 }
 
 function embed(text) {
-  return new Promise((resolve) => {
+  return new Promise((resolve, reject) => {
+    if (!workerAlive) {
+      return reject(new Error("Embed worker is not running"));
+    }
     const id = embedIdCounter++;
-    pendingEmbeds.set(id, resolve);
-    worker.postMessage({ id, text });
+    const timer = setTimeout(() => {
+      pendingEmbeds.delete(id);
+      reject(new Error("Embedding timed out after " + EMBED_TIMEOUT_MS + "ms"));
+    }, EMBED_TIMEOUT_MS);
+    pendingEmbeds.set(id, { resolve, reject, timer });
+    try {
+      worker.postMessage({ id, text });
+    } catch (err) {
+      clearTimeout(timer);
+      pendingEmbeds.delete(id);
+      reject(err);
+    }
   });
 }