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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@context-engine-bridge/context-engine-mcp-bridge",
-  "version": "0.0.33",
+  "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;
@@ -92,7 +120,12 @@ function _extractPaths(obj, paths, workspace, depth = 0) {
   }
   if (typeof obj.path === "string" && obj.path.length > 0) {
     if (_isAbsolutePath(obj.path)) {
-      paths.add(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);
@@ -148,16 +181,34 @@ async function _enrichWithLsp(result, lspConn, workspace) {
     let parsed;
     try { parsed = JSON.parse(textBlock.text); } catch { 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 };
+    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;
   }
 }
@@ -586,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;
@@ -1089,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 : "";
@@ -1110,7 +1244,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 +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 }) }] };