@context-engine-bridge/context-engine-mcp-bridge 0.0.33 → 0.0.35

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@context-engine-bridge/context-engine-mcp-bridge",
-  "version": "0.0.33",
+  "version": "0.0.35",
   "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;
@@ -90,16 +118,19 @@ function _extractPaths(obj, paths, workspace, depth = 0) {
     for (const item of obj) _extractPaths(item, paths, workspace, depth + 1);
     return;
   }
+  let rawPath = null;
   if (typeof obj.path === "string" && obj.path.length > 0) {
-    if (_isAbsolutePath(obj.path)) {
-      paths.add(obj.path);
-    } else if (workspace) {
-      const contained = _resolveAndContain(obj.path, workspace);
+    rawPath = obj.path;
+  } else if (typeof obj.rel_path === "string" && obj.rel_path.length > 0) {
+    rawPath = obj.rel_path;
+  }
+  if (rawPath) {
+    if (workspace) {
+      const contained = _resolveAndContain(rawPath, workspace);
       if (contained) paths.add(contained);
+    } else if (_isAbsolutePath(rawPath)) {
+      paths.add(rawPath);
     }
-  } 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;
@@ -142,26 +173,42 @@ function _callLspHandler(port, secret, operation, params) {
 
 async function _enrichWithLsp(result, lspConn, workspace) {
   try {
+    debugLog("[ctxce] LSP enrich: workspace=" + workspace + " port=" + lspConn?.port);
     if (!Array.isArray(result?.content)) return result;
     const textBlock = result.content.find(c => c.type === "text");
     if (!textBlock?.text) return result;
     let parsed;
-    try { parsed = JSON.parse(textBlock.text); } catch { return result; }
+    try { parsed = JSON.parse(textBlock.text); } catch (e) {
+      debugLog("[ctxce] LSP enrich: JSON parse failed: " + String(e));
+      return result;
+    }
     if (!parsed.ok) return result;
-    const paths = new Set();
-    _extractPaths(parsed, paths, workspace);
-    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 };
+    parsed._lsp_status = await _resolveLspStatus(parsed, lspConn, workspace);
     textBlock.text = JSON.stringify(parsed);
     return result;
   } catch (err) {
     debugLog("[ctxce] LSP enrichment failed: " + String(err));
+    _lspCircuitRecordFailure();
     return result;
   }
 }
 
+async function _resolveLspStatus(parsed, lspConn, workspace) {
+  if (_lspCircuitOpen()) return "circuit_open";
+  const paths = new Set();
+  _extractPaths(parsed, paths, workspace);
+  if (paths.size === 0) return "no_paths";
+  const diag = await _callLspHandler(lspConn.port, lspConn.secret, "diagnostics_recent", { paths: [...paths] });
+  if (!diag) {
+    _lspCircuitRecordFailure();
+    return "connection_failed";
+  }
+  _lspCircuitRecordSuccess();
+  if (!diag.ok || !diag.files || diag.total === 0) return "no_diagnostics";
+  parsed._lsp = { diagnostics: diag.files, total: diag.total };
+  return "ok";
+}
+
 function debugLog(message) {
   try {
     const text = typeof message === "string" ? message : String(message);
@@ -586,8 +633,73 @@ 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 bestMatch = null;
+    let bestTs = 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);
+              const notExpired = !conn.created_at || (now - conn.created_at) <= LSP_CONN_MAX_AGE;
+              if (notExpired) {
+                const connTs = typeof conn.created_at === "number" ? conn.created_at : 0;
+                if (connTs > bestTs) {
+                  bestTs = connTs;
+                  bestMatch = wp;
+                }
+              }
+            } catch (_) {}
+          }
+        } catch (_) {}
+      } catch (_) {}
+    }
+    if (bestMatch) {
+      debugLog("[ctxce] Resolved workspace from active LSP connection");
+      return bestMatch;
+    }
+  } 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;
@@ -1042,11 +1154,14 @@ async function createBridgeServer(options) {
     let args = params.arguments;
 
     let includeLsp = false;
-    if (args && typeof args === "object" && args.include_lsp === true && _LSP_ENRICHABLE_TOOLS.has(name)) {
-      includeLsp = true;
+    const rawLsp = args && typeof args === "object" ? args.include_lsp : undefined;
+    if (rawLsp !== undefined) {
       const { include_lsp: _stripped, ...rest } = args;
       args = rest;
     }
+    if ((rawLsp === true || rawLsp === "true" || rawLsp === 1 || rawLsp === "1") && _LSP_ENRICHABLE_TOOLS.has(name)) {
+      includeLsp = true;
+    }
 
     debugLog(`[ctxce] tools/call: ${name || "<no-name>"}`);
 
@@ -1089,6 +1204,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 : "";
@@ -1110,7 +1228,7 @@ 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;
@@ -1130,8 +1248,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 }) }] };
@@ -1168,7 +1288,21 @@ async function createBridgeServer(options) {
         );
         let finalResult = maybeRemapToolResult(name, result, workspace);
         const lspConn = includeLsp && _readLspConnection(workspace);
-        if (lspConn) finalResult = await _enrichWithLsp(finalResult, lspConn, workspace);
+        if (includeLsp) {
+          debugLog("[ctxce] LSP gate: tool=" + name + " lsp=" + (lspConn ? "port:" + lspConn.port : "null"));
+        }
+        if (lspConn) {
+          finalResult = await _enrichWithLsp(finalResult, lspConn, workspace);
+        } else if (includeLsp) {
+          try {
+            const tb = Array.isArray(finalResult?.content) && finalResult.content.find(c => c.type === "text");
+            if (tb?.text) {
+              const p = JSON.parse(tb.text);
+              p._lsp_status = "not_available";
+              tb.text = JSON.stringify(p);
+            }
+          } catch (_) {}
+        }
         return finalResult;
       } catch (err) {
         lastError = err;