@context-engine-bridge/context-engine-mcp-bridge 0.0.55 → 0.0.56

package/package.json

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

package/src/mcpServer.js

@@ -47,6 +47,11 @@ function _lspCircuitRecordFailure() {
   }
 }
 
+function _errorMessage(error) {
+  return (error && typeof error.message === "string" && error.message) ||
+    (typeof error === "string" ? error : String(error || ""));
+}
+
 function _isValidPort(v) {
   const p = Number.parseInt(String(v), 10);
   return Number.isFinite(p) && p >= 1024 && p <= 65535;
@@ -97,6 +102,11 @@ function _readLspConnection(workspace) {
   return result;
 }
 
+const _ALLOWED_LSP_OPS = new Set([
+  "diagnostics", "definition", "references", "hover",
+  "document_symbols", "workspace_symbols", "code_actions", "diagnostics_recent",
+]);
+
 const _LSP_ENRICHABLE_TOOLS = new Set([
   "batch_search", "batch_symbol_graph", "batch_graph_query",
   "repo_search", "repo_search_compat", "symbol_graph", "search",
@@ -137,7 +147,7 @@ function _extractPaths(obj, paths, workspace, depth = 0) {
   }
 }
 
-function _callLspHandler(port, secret, operation, params) {
+function _callLspHandler(port, secret, operation, params, timeoutMs = 3000) {
   const postData = JSON.stringify(params);
   return new Promise((resolve) => {
     let settled = false;
@@ -152,7 +162,7 @@ function _callLspHandler(port, secret, operation, params) {
         "Content-Length": Buffer.byteLength(postData),
         ...(secret ? { "x-lsp-handler-token": secret } : {}),
       },
-      timeout: 3000,
+      timeout: timeoutMs,
     }, (res) => {
       const chunks = [];
       let totalBytes = 0;
@@ -317,9 +327,7 @@ function selectClientForTool(name, indexerClient, memoryClient) {
 
 function isSessionError(error) {
   try {
-    const msg =
-      (error && typeof error.message === "string" && error.message) ||
-      (typeof error === "string" ? error : String(error || ""));
+    const msg = _errorMessage(error);
     if (!msg) {
       return false;
     }
@@ -341,9 +349,7 @@ function isSessionError(error) {
  */
 function isAuthRejectionError(error) {
   try {
-    const msg =
-      (error && typeof error.message === "string" && error.message) ||
-      (typeof error === "string" ? error : String(error || ""));
+    const msg = _errorMessage(error);
     if (!msg) {
       return false;
     }
@@ -362,9 +368,7 @@ function isAuthRejectionError(error) {
  * Includes the backend URL and a hint to sign in via VS Code command palette.
  */
 function formatAuthRejectionError(originalError, backendUrl) {
-  const originalMsg =
-    (originalError && typeof originalError.message === "string" && originalError.message) ||
-    (typeof originalError === "string" ? originalError : String(originalError || "Unknown auth error"));
+  const originalMsg = _errorMessage(originalError) || "Unknown auth error";
 
   const serverInfo = backendUrl ? ` (server: ${backendUrl})` : "";
   const hint = "Run 'Context Engine: Sign In' from the VS Code command palette to authenticate.";
@@ -421,9 +425,7 @@ function getBridgeRetryDelayMs() {
 
 function isTransientToolError(error) {
   try {
-    const msg =
-      (error && typeof error.message === "string" && error.message) ||
-      (typeof error === "string" ? error : String(error || ""));
+    const msg = _errorMessage(error);
     if (!msg) {
       return false;
     }
@@ -463,7 +465,6 @@ function isTransientToolError(error) {
       return true;
     }
 
-    // StreamableHTTP transport errors after server restart
     if (
       lower.includes("failed to fetch") ||
       lower.includes("fetch failed") ||
@@ -490,15 +491,9 @@ function isTransientToolError(error) {
   }
 }
 
-/**
- * Detect connection-level errors that indicate the underlying transport is dead
- * and the client needs to be fully recreated (not just retried on the same socket).
- */
 function isConnectionDeadError(error) {
   try {
-    const msg =
-      (error && typeof error.message === "string" && error.message) ||
-      (typeof error === "string" ? error : String(error || ""));
+    const msg = _errorMessage(error);
     if (!msg) {
       return false;
     }
@@ -781,7 +776,6 @@ async function createBridgeServer(options) {
       expiresAt > 0 &&
       expiresAt < Math.floor(Date.now() / 1000)
     ) {
-      // Allow 5-minute grace period for clock skew; beyond that, reject
       const expiredSecs = Math.floor(Date.now() / 1000) - expiresAt;
       if (expiredSecs > 300) {
         debugLog(`[ctxce] Session expired ${expiredSecs}s ago (beyond 5min grace), triggering re-auth.`);
@@ -930,10 +924,6 @@ async function createBridgeServer(options) {
       }
     }
 
-    // Build requestInit with Authorization header for nginx auth_request passthrough.
-    // When the bridge connects to a remote endpoint (e.g. https://dev.example.com/indexer/mcp),
-    // nginx's auth_request subrequest checks the Authorization header. Without it, the
-    // connection is rejected with 401.
     const transportOpts = {};
     if (sessionId && !sessionId.startsWith("ctxce-")) {
       transportOpts.requestInit = {
@@ -943,7 +933,6 @@ async function createBridgeServer(options) {
       };
       debugLog(`[ctxce] Transport auth: injecting Authorization header (session ${sessionId.slice(0, 8)}...)`);
     } else {
-      // Check for API key in environment as fallback
       const envApiKey = (process.env.CTXCE_API_KEY || process.env.CTXCE_AUTH_TOKEN || "").trim();
       if (envApiKey) {
         transportOpts.requestInit = {
@@ -1040,8 +1029,6 @@ async function createBridgeServer(options) {
       }
       remote = await indexerClient.listTools();
     } catch (err) {
-      // If the transport is dead (server restarted), recreate clients and retry
-      // once before falling back to memory-only tools.
       if (isConnectionDeadError(err) || isSessionError(err)) {
         debugLog("[ctxce] tools/list: connection/session error, recreating clients and retrying: " + String(err));
         try {
@@ -1054,7 +1041,6 @@ async function createBridgeServer(options) {
         }
       }
 
-      // If we still don't have remote tools, fall back to memory-only
       if (!remote) {
         debugLog("[ctxce] Error calling remote tools/list: " + String(err));
         const memoryToolsFallback = await listMemoryTools(memoryClient);
@@ -1244,66 +1230,29 @@ async function createBridgeServer(options) {
         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 : "";
-      if (!lspPort) {
+      if (!lspConn) {
         return { content: [{ type: "text", text: JSON.stringify({ ok: false, error: "LSP proxy not available. Ensure VS Code extension has lsp.enabled=true." }) }] };
       }
-      const ALLOWED_LSP_OPS = new Set(['diagnostics','definition','references','hover','document_symbols','workspace_symbols','code_actions','diagnostics_recent']);
       const operation = name.toLowerCase().replace(/^lsp_/, "");
-      if (!ALLOWED_LSP_OPS.has(operation)) {
+      if (!_ALLOWED_LSP_OPS.has(operation)) {
         return { content: [{ type: "text", text: JSON.stringify({ ok: false, error: "Unknown LSP operation" }) }] };
       }
-      try {
-        const lspArgs = args || {};
-        const postData = JSON.stringify(lspArgs);
-        const result = await new Promise((resolve, reject) => {
-          const req = http.request({
-            hostname: "127.0.0.1",
-            port: parseInt(lspPort, 10),
-            path: `/lsp/${operation}`,
-            method: "POST",
-            headers: Object.assign({ "Content-Type": "application/json", "Content-Length": Buffer.byteLength(postData) }, lspSecret ? { "x-lsp-handler-token": lspSecret } : {}),
-            timeout: LSP_DIRECT_TIMEOUT_MS,
-          }, (res) => {
-            const chunks = [];
-            let totalBytes = 0;
-            let exceeded = false;
-            const MAX_RESP = 5 * 1024 * 1024;
-            res.on("error", () => { if (!exceeded) resolve({ ok: false, error: "LSP response stream error" }); });
-            res.on("data", chunk => {
-              if (exceeded) return;
-              const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-              totalBytes += buf.length;
-              if (totalBytes > MAX_RESP) { exceeded = true; req.destroy(); resolve({ ok: false, error: "Response too large" }); return; }
-              chunks.push(buf);
-            });
-            res.on("end", () => {
-              if (!exceeded) { try { resolve(JSON.parse(Buffer.concat(chunks).toString("utf8"))); } catch { resolve({ ok: false, error: "Invalid response from LSP handler" }); } }
-            });
-          });
-          req.on("error", reject);
-          req.on("timeout", () => { req.destroy(); reject(new Error("LSP request timeout")); });
-          req.write(postData);
-          req.end();
-        });
+      const result = await _callLspHandler(lspConn.port, lspConn.secret, operation, args || {}, LSP_DIRECT_TIMEOUT_MS);
+      if (result) {
         _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 }) }] };
       }
+      _lspCircuitRecordFailure();
+      debugLog("[ctxce] LSP proxy error: request returned null");
+      return { content: [{ type: "text", text: JSON.stringify({ ok: false, error: "LSP proxy error: request failed" }) }] };
     }
 
     await initializeRemoteClients(false);
 
-    const MAX_FANOUT_COLLECTIONS = 5;
     const primaryCollection = args && typeof args.collection === "string" ? args.collection : "";
     const primaryLower = primaryCollection.toLowerCase();
     const additionalCollections = _FANOUT_TOOLS.has(name)
-      ? _loadSessionCollections(workspace).filter(c => c.toLowerCase() !== primaryLower).slice(0, MAX_FANOUT_COLLECTIONS)
+      ? _loadSessionCollections(workspace, defaultCollection).filter(c => c.toLowerCase() !== primaryLower).slice(0, MAX_FANOUT_COLLECTIONS)
       : [];
     const shouldFanOut = additionalCollections.length > 0 && indexerClient;
 
@@ -1339,13 +1288,14 @@ async function createBridgeServer(options) {
         );
 
         if (shouldFanOut) {
-          const fanOutTimeoutMs = Math.min(timeoutMs, 10000);
+          const fanOutCallTimeoutMs = Math.min(timeoutMs, 10000);
+          const fanOutDeadlineMs = Math.round(fanOutCallTimeoutMs * 0.8);
           const fanOutPromises = additionalCollections.map(col => {
             const colArgs = { ...args, collection: col };
             return targetClient.callTool(
               { name, arguments: colArgs },
               undefined,
-              { timeout: fanOutTimeoutMs },
+              { timeout: fanOutCallTimeoutMs },
             ).catch(err => {
               debugLog(`[ctxce] Fan-out to ${col} failed: ${String(err)}`);
               return null;
@@ -1353,7 +1303,7 @@ async function createBridgeServer(options) {
           });
 
           let fanOutTimer;
-          const fanOutDeadline = new Promise(resolve => { fanOutTimer = setTimeout(() => resolve(null), fanOutTimeoutMs); });
+          const fanOutDeadline = new Promise(resolve => { fanOutTimer = setTimeout(() => resolve(null), fanOutDeadlineMs); });
           const fanOutResults = await Promise.race([
             Promise.all(fanOutPromises),
             fanOutDeadline.then(() => fanOutPromises.map(() => null)),
@@ -1410,9 +1360,6 @@ async function createBridgeServer(options) {
       } catch (err) {
         lastError = err;
 
-        // Connection-level error (ECONNREFUSED, ECONNRESET, etc.) means the
-        // transport is dead (e.g. server restarted).  Recreate clients so the
-        // next attempt uses a fresh connection.
         if (isConnectionDeadError(err) && !connectionRetried) {
           debugLog(
             "[ctxce] tools/call: connection dead (server may have restarted); recreating clients and retrying: " +
@@ -1752,7 +1699,6 @@ export async function runHttpMcpServer(options) {
         return;
       }
 
-      // Health check endpoint (used by VS Code extension health ping)
       if (parsedUrl.pathname === "/health") {
         res.writeHead(200, { "Content-Type": "application/json" });
         res.end(JSON.stringify({ status: "ok", sessions: sessions.size }));
@@ -1805,6 +1751,8 @@ export async function runHttpMcpServer(options) {
   process.on("SIGINT", () => shutdown("SIGINT"));
 }
 
+const MAX_FANOUT_COLLECTIONS = 5;
+
 const _FANOUT_TOOLS = new Set([
   "search", "repo_search", "code_search", "context_search",
   "symbol_graph", "pattern_search",
@@ -1817,29 +1765,73 @@ let _sessionCollectionsCache = null;
 let _sessionCollectionsMtime = 0;
 let _sessionCollectionsCacheKey = "";
 
-function _loadSessionCollections(workspacePath) {
-  if (!workspacePath) return [];
+function _findWorkspaceDirByCollection(collection) {
+  if (!collection) return null;
+  const wsRoot = path.join(os.homedir(), ".ctxce", "workspaces");
   try {
-    const wsDir = _computeWorkspaceDir(workspacePath);
-    const filePath = path.join(wsDir, "session_collections.json");
-    let mtime = 0;
-    try {
-      mtime = fs.statSync(filePath).mtimeMs;
-    } catch (_) {
-      _sessionCollectionsCache = null;
-      _sessionCollectionsMtime = 0;
-      _sessionCollectionsCacheKey = "";
-      return [];
-    }
-    if (_sessionCollectionsCache && mtime === _sessionCollectionsMtime && _sessionCollectionsCacheKey === workspacePath) {
-      return _sessionCollectionsCache;
+    const realWsRoot = fs.realpathSync(wsRoot);
+    const dirs = fs.readdirSync(wsRoot).slice(0, MAX_WS_SCAN);
+    for (const dir of dirs) {
+      if (dir === "." || dir === ".." || dir.includes("/") || dir.includes("\0")) continue;
+      const dirPath = path.join(wsRoot, dir);
+      try {
+        const realDir = fs.realpathSync(dirPath);
+        if (realDir !== realWsRoot && !realDir.startsWith(realWsRoot + path.sep)) continue;
+        if (!fs.lstatSync(realDir).isDirectory()) continue;
+      } catch (_) { continue; }
+      try {
+        const cfg = JSON.parse(fs.readFileSync(path.join(realDir, "ctx_config.json"), "utf8"));
+        if (cfg && cfg.default_collection === collection) {
+          return realDir;
+        }
+      } catch (_) {}
     }
+  } catch (_) {}
+  return null;
+}
+
+function _loadSessionCollections(workspacePath, fallbackCollection) {
+  if (!workspacePath && !fallbackCollection) return [];
+
+  let wsDir = workspacePath ? _computeWorkspaceDir(workspacePath) : null;
+  let filePath = wsDir ? path.join(wsDir, "session_collections.json") : null;
+  let mtime = 0;
+
+  if (filePath) {
+    try { mtime = fs.statSync(filePath).mtimeMs; } catch (_) { mtime = 0; }
+  }
+
+  if (!mtime && fallbackCollection) {
+    const altDir = _findWorkspaceDirByCollection(fallbackCollection);
+    if (altDir) {
+      wsDir = altDir;
+      filePath = path.join(altDir, "session_collections.json");
+      try { mtime = fs.statSync(filePath).mtimeMs; } catch (_) { mtime = 0; }
+      if (mtime) {
+        debugLog("[ctxce] Found session_collections via collection lookup: " + altDir);
+      }
+    }
+  }
+
+  if (!mtime || !filePath) {
+    _sessionCollectionsCache = null;
+    _sessionCollectionsMtime = 0;
+    _sessionCollectionsCacheKey = "";
+    return [];
+  }
+
+  const cacheKey = filePath;
+  if (_sessionCollectionsCache && mtime === _sessionCollectionsMtime && _sessionCollectionsCacheKey === cacheKey) {
+    return _sessionCollectionsCache;
+  }
+
+  try {
     const raw = fs.readFileSync(filePath, "utf8");
     const parsed = JSON.parse(raw);
     if (Array.isArray(parsed)) {
       _sessionCollectionsCache = parsed.filter(c => c && typeof c === "string" && c.length <= 128 && /^[a-zA-Z0-9][a-zA-Z0-9_.-]*$/.test(c));
       _sessionCollectionsMtime = mtime;
-      _sessionCollectionsCacheKey = workspacePath;
+      _sessionCollectionsCacheKey = cacheKey;
       return _sessionCollectionsCache;
     }
     return [];