@context-engine-bridge/context-engine-mcp-bridge 0.0.32 → 0.0.34

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@context-engine-bridge/context-engine-mcp-bridge",
-  "version": "0.0.32",
+  "version": "0.0.34",
   "description": "Context Engine MCP bridge (http/stdio proxy combining indexer + memory servers)",
   "bin": {
     "ctxce": "bin/ctxce.js",

package/src/mcpServer.js

@@ -19,6 +19,34 @@ const LSP_CONN_CACHE_TTL = 5000;
 const LSP_CONN_MAX_AGE = 24 * 60 * 60 * 1000;
 let _lspConnCache = { value: undefined, ts: 0, key: "" };
 
+const LSP_CB_THRESHOLD = 3;
+const LSP_CB_COOLDOWN_MS = 30000;
+const LSP_DIRECT_TIMEOUT_MS = 8000;
+let _lspCircuitBreaker = { failures: 0, openUntil: 0 };
+
+function _lspCircuitOpen() {
+  if (_lspCircuitBreaker.failures < LSP_CB_THRESHOLD) return false;
+  if (Date.now() >= _lspCircuitBreaker.openUntil) {
+    _lspCircuitBreaker.failures = 0;
+    _lspCircuitBreaker.openUntil = 0;
+    return false;
+  }
+  return true;
+}
+
+function _lspCircuitRecordSuccess() {
+  _lspCircuitBreaker.failures = 0;
+  _lspCircuitBreaker.openUntil = 0;
+}
+
+function _lspCircuitRecordFailure() {
+  _lspCircuitBreaker.failures = Math.min(_lspCircuitBreaker.failures + 1, LSP_CB_THRESHOLD);
+  if (_lspCircuitBreaker.failures >= LSP_CB_THRESHOLD) {
+    _lspCircuitBreaker.openUntil = Date.now() + LSP_CB_COOLDOWN_MS;
+    debugLog(`[ctxce] LSP circuit breaker open for ${LSP_CB_COOLDOWN_MS}ms after ${_lspCircuitBreaker.failures} consecutive failures`);
+  }
+}
+
 function _isValidPort(v) {
   const p = Number.parseInt(String(v), 10);
   return Number.isFinite(p) && p >= 1024 && p <= 65535;
@@ -74,16 +102,41 @@ const _LSP_ENRICHABLE_TOOLS = new Set([
   "search_config_for", "search_callers_for", "search_importers_for",
 ]);
 
-function _extractPaths(obj, paths, depth = 0) {
+function _isAbsolutePath(p) {
+  return p.startsWith("/") || /^[a-zA-Z]:[/\\]/.test(p);
+}
+
+function _resolveAndContain(relPath, workspace) {
+  const resolved = path.resolve(workspace, relPath);
+  if (resolved === workspace || resolved.startsWith(workspace + path.sep)) return resolved;
+  return null;
+}
+
+function _extractPaths(obj, paths, workspace, depth = 0) {
   if (!obj || typeof obj !== "object" || depth > 20) return;
   if (Array.isArray(obj)) {
-    for (const item of obj) _extractPaths(item, paths, depth + 1);
+    for (const item of obj) _extractPaths(item, paths, workspace, depth + 1);
     return;
   }
-  if (typeof obj.path === "string" && (obj.path.startsWith("/") || /^[a-zA-Z]:[/\\]/.test(obj.path))) paths.add(obj.path);
+  if (typeof obj.path === "string" && obj.path.length > 0) {
+    if (_isAbsolutePath(obj.path)) {
+      if (workspace) {
+        const contained = _resolveAndContain(obj.path, workspace);
+        if (contained) paths.add(contained);
+      } else {
+        paths.add(obj.path);
+      }
+    } else if (workspace) {
+      const contained = _resolveAndContain(obj.path, workspace);
+      if (contained) paths.add(contained);
+    }
+  } else if (typeof obj.rel_path === "string" && obj.rel_path.length > 0 && workspace) {
+    const contained = _resolveAndContain(obj.rel_path, workspace);
+    if (contained) paths.add(contained);
+  }
   for (const [key, val] of Object.entries(obj)) {
     if (key === "__proto__" || key === "constructor" || key === "prototype") continue;
-    if (val && typeof val === "object") _extractPaths(val, paths, depth + 1);
+    if (val && typeof val === "object") _extractPaths(val, paths, workspace, depth + 1);
   }
 }
 
@@ -105,6 +158,7 @@ function _callLspHandler(port, secret, operation, params) {
       let data = "";
       let exceeded = false;
       const MAX_RESP = 5 * 1024 * 1024;
+      res.on("error", () => {});
       res.on("data", chunk => {
         if (exceeded) return;
         data += chunk;
@@ -119,7 +173,7 @@ function _callLspHandler(port, secret, operation, params) {
   });
 }
 
-async function _enrichWithLsp(result, lspConn) {
+async function _enrichWithLsp(result, lspConn, workspace) {
   try {
     if (!Array.isArray(result?.content)) return result;
     const textBlock = result.content.find(c => c.type === "text");
@@ -127,16 +181,34 @@ async function _enrichWithLsp(result, lspConn) {
     let parsed;
     try { parsed = JSON.parse(textBlock.text); } catch { return result; }
     if (!parsed.ok) return result;
-    const paths = new Set();
-    _extractPaths(parsed, paths);
-    if (paths.size === 0) return result;
-    const diag = await _callLspHandler(lspConn.port, lspConn.secret, "diagnostics_recent", { paths: [...paths] });
-    if (!diag?.ok || !diag.files || diag.total === 0) return result;
-    parsed._lsp = { diagnostics: diag.files, total: diag.total };
+    if (_lspCircuitOpen()) {
+      parsed._lsp_status = "circuit_open";
+    } else {
+      const paths = new Set();
+      _extractPaths(parsed, paths, workspace);
+      if (paths.size === 0) {
+        parsed._lsp_status = "no_paths";
+      } else {
+        const diag = await _callLspHandler(lspConn.port, lspConn.secret, "diagnostics_recent", { paths: [...paths] });
+        if (!diag) {
+          _lspCircuitRecordFailure();
+          parsed._lsp_status = "connection_failed";
+        } else {
+          _lspCircuitRecordSuccess();
+          if (!diag.ok || !diag.files || diag.total === 0) {
+            parsed._lsp_status = "no_diagnostics";
+          } else {
+            parsed._lsp = { diagnostics: diag.files, total: diag.total };
+            parsed._lsp_status = "ok";
+          }
+        }
+      }
+    }
     textBlock.text = JSON.stringify(parsed);
     return result;
   } catch (err) {
     debugLog("[ctxce] LSP enrichment failed: " + String(err));
+    _lspCircuitRecordFailure();
     return result;
   }
 }
@@ -565,8 +637,88 @@ async function fetchBridgeCollectionState({
   }
 }
 
+function _validateWorkspacePath(raw) {
+  if (typeof raw !== "string" || raw.length === 0) return null;
+  const resolved = path.resolve(raw);
+  if (!_isAbsolutePath(resolved)) return null;
+  try {
+    const stat = fs.statSync(resolved);
+    if (!stat.isDirectory()) return null;
+  } catch (_) {
+    return null;
+  }
+  return resolved;
+}
+
+const MAX_WS_SCAN = 50;
+
+function _resolveWorkspace(providedWorkspace) {
+  const wsDir = _computeWorkspaceDir(providedWorkspace);
+  const now = Date.now();
+  const connResult = _tryReadConnFile(path.join(wsDir, "lsp-connection.json"), now);
+  if (connResult) return providedWorkspace;
+
+  const wsRoot = path.join(os.homedir(), ".ctxce", "workspaces");
+  try {
+    const dirs = fs.readdirSync(wsRoot).slice(0, MAX_WS_SCAN);
+    let bestLspMatch = null;
+    let bestLspTs = 0;
+    let bestMetaMatch = null;
+    let bestMetaTs = 0;
+    for (const dir of dirs) {
+      if (dir === "." || dir === ".." || dir.includes("/") || dir.includes("\0")) continue;
+      const dirPath = path.join(wsRoot, dir);
+      try {
+        const lstat = fs.lstatSync(dirPath);
+        if (!lstat.isDirectory()) continue;
+      } catch (_) { continue; }
+      try {
+        const meta = JSON.parse(fs.readFileSync(path.join(dirPath, "meta.json"), "utf8"));
+        const wp = _validateWorkspacePath(meta.workspace_path);
+        if (!wp) continue;
+        const connPath = path.join(dirPath, "lsp-connection.json");
+        try {
+          const conn = JSON.parse(fs.readFileSync(connPath, "utf8"));
+          if (conn.pid && conn.port && _isValidPort(conn.port)) {
+            try {
+              process.kill(conn.pid, 0);
+              if (conn.created_at && (now - conn.created_at) > LSP_CONN_MAX_AGE) {
+              } else {
+                const connTs = typeof conn.created_at === "number" ? conn.created_at : 0;
+                if (connTs > bestLspTs) {
+                  bestLspTs = connTs;
+                  bestLspMatch = wp;
+                }
+              }
+            } catch (_) {}
+          }
+        } catch (_) {}
+        const updatedAt = typeof meta.updated_at === "number"
+          ? meta.updated_at
+          : typeof meta.updated_at === "string"
+            ? new Date(meta.updated_at).getTime() || 0
+            : 0;
+        if (updatedAt > bestMetaTs) {
+          bestMetaTs = updatedAt;
+          bestMetaMatch = wp;
+        }
+      } catch (_) {}
+    }
+    if (bestLspMatch) {
+      debugLog("[ctxce] Resolved workspace from active LSP connection");
+      return bestLspMatch;
+    }
+    if (bestMetaMatch) {
+      debugLog("[ctxce] Resolved workspace from most recent meta.json");
+      return bestMetaMatch;
+    }
+  } catch (_) {}
+
+  return providedWorkspace;
+}
+
 async function createBridgeServer(options) {
-  const workspace = options.workspace || process.cwd();
+  const workspace = _resolveWorkspace(options.workspace || process.cwd());
   const indexerUrl = options.indexerUrl;
   const memoryUrl = options.memoryUrl;
   const explicitCollection = options.collection;
@@ -1068,6 +1220,9 @@ async function createBridgeServer(options) {
     }
 
     if (name && name.toLowerCase().startsWith("lsp_")) {
+      if (_lspCircuitOpen()) {
+        return { content: [{ type: "text", text: JSON.stringify({ ok: false, error: "LSP proxy temporarily unavailable (circuit breaker open after repeated failures). Will retry automatically." }) }] };
+      }
       const lspConn = _readLspConnection(workspace);
       const lspPort = lspConn ? lspConn.port : null;
       const lspSecret = lspConn ? lspConn.secret : "";
@@ -1089,11 +1244,12 @@ async function createBridgeServer(options) {
             path: `/lsp/${operation}`,
             method: "POST",
             headers: Object.assign({ "Content-Type": "application/json", "Content-Length": Buffer.byteLength(postData) }, lspSecret ? { "x-lsp-handler-token": lspSecret } : {}),
-            timeout: 15000,
+            timeout: LSP_DIRECT_TIMEOUT_MS,
           }, (res) => {
             let data = "";
             let exceeded = false;
             const MAX_RESP = 5 * 1024 * 1024;
+            res.on("error", () => {});
             res.on("data", chunk => {
               if (exceeded) return;
               data += chunk;
@@ -1108,8 +1264,10 @@ async function createBridgeServer(options) {
           req.write(postData);
           req.end();
         });
+        _lspCircuitRecordSuccess();
         return { content: [{ type: "text", text: JSON.stringify(result) }] };
       } catch (err) {
+        _lspCircuitRecordFailure();
         debugLog("[ctxce] LSP proxy error: " + String(err));
         const safeMsg = (err && err.code) ? `LSP proxy error: ${err.code}` : "LSP proxy error: request failed";
         return { content: [{ type: "text", text: JSON.stringify({ ok: false, error: safeMsg }) }] };
@@ -1146,7 +1304,7 @@ async function createBridgeServer(options) {
         );
         let finalResult = maybeRemapToolResult(name, result, workspace);
         const lspConn = includeLsp && _readLspConnection(workspace);
-        if (lspConn) finalResult = await _enrichWithLsp(finalResult, lspConn);
+        if (lspConn) finalResult = await _enrichWithLsp(finalResult, lspConn, workspace);
         return finalResult;
       } catch (err) {
         lastError = err;