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

package/package.json

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

package/src/mcpServer.js

@@ -1,7 +1,7 @@
 import process from "node:process";
 import fs from "node:fs";
 import path from "node:path";
-import { randomUUID } from "node:crypto";
+import { randomUUID, createHash } from "node:crypto";
 import { execSync } from "node:child_process";
 import os from "node:os";
 import http, { createServer } from "node:http";
@@ -15,40 +15,130 @@ import { loadAnyAuthEntry, loadAuthEntry, readConfig, saveAuthEntry } from "./au
 import { maybeRemapToolArgs, maybeRemapToolResult } from "./resultPathMapping.js";
 import * as oauthHandler from "./oauthHandler.js";
 
-let _lspConnCache;
-let _lspConnCacheTs = 0;
 const LSP_CONN_CACHE_TTL = 5000;
-const LSP_CONN_MAX_AGE = 60 * 60 * 1000;
+const LSP_CONN_MAX_AGE = 24 * 60 * 60 * 1000;
+let _lspConnCache = { value: undefined, ts: 0, key: "" };
 
 function _isValidPort(v) {
   const p = Number.parseInt(String(v), 10);
   return Number.isFinite(p) && p >= 1024 && p <= 65535;
 }
 
-function _readLspConnection() {
+function _computeWorkspaceDir(workspacePath) {
+  const normalized = path.resolve(workspacePath).replace(/\\/g, "/").toLowerCase();
+  const hash = createHash("sha256").update(normalized).digest("hex").slice(0, 12);
+  const safeName = path.basename(workspacePath).replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 50);
+  return path.join(os.homedir(), ".ctxce", "workspaces", `${safeName}-${hash}`);
+}
+
+function _tryReadConnFile(connPath, now) {
+  try {
+    const conn = JSON.parse(fs.readFileSync(connPath, "utf8"));
+    if (!conn.port || !_isValidPort(conn.port) || !conn.pid) return null;
+    try { process.kill(conn.pid, 0); } catch (_) { return null; }
+    if (conn.created_at && (now - conn.created_at) > LSP_CONN_MAX_AGE) return null;
+    return { port: String(conn.port), secret: conn.secret || "" };
+  } catch (_) {}
+  return null;
+}
+
+function _readLspConnection(workspace) {
   const envPort = process.env.CTXCE_LSP_PORT;
-  if (envPort && _isValidPort(envPort)) return { port: envPort, secret: process.env.CTXCE_LSP_SECRET || "" };
+  if (envPort && _isValidPort(envPort)) {
+    return { port: envPort, secret: process.env.CTXCE_LSP_SECRET || "" };
+  }
+
   const now = Date.now();
-  if (_lspConnCache !== undefined && (now - _lspConnCacheTs) < LSP_CONN_CACHE_TTL) return _lspConnCache;
+  const cacheKey = workspace || "";
+  if (_lspConnCache.value !== undefined && (now - _lspConnCache.ts) < LSP_CONN_CACHE_TTL && _lspConnCache.key === cacheKey) {
+    return _lspConnCache.value;
+  }
 
-  function _cacheNull() {
-    _lspConnCache = null;
-    _lspConnCacheTs = now;
-    return null;
+  let result = null;
+  if (workspace) {
+    const wsDir = _computeWorkspaceDir(workspace);
+    result = _tryReadConnFile(path.join(wsDir, "lsp-connection.json"), now);
+  }
+  if (!result) {
+    result = _tryReadConnFile(path.join(os.homedir(), ".ctxce", "lsp-connection.json"), now);
   }
 
+  _lspConnCache = { value: result, ts: now, key: cacheKey };
+  return result;
+}
+
+const _LSP_ENRICHABLE_TOOLS = new Set([
+  "batch_search", "batch_symbol_graph", "batch_graph_query",
+  "repo_search", "repo_search_compat", "symbol_graph", "search",
+  "code_search", "context_search", "search_tests_for",
+  "search_config_for", "search_callers_for", "search_importers_for",
+]);
+
+function _extractPaths(obj, paths, depth = 0) {
+  if (!obj || typeof obj !== "object" || depth > 20) return;
+  if (Array.isArray(obj)) {
+    for (const item of obj) _extractPaths(item, paths, depth + 1);
+    return;
+  }
+  if (typeof obj.path === "string" && (obj.path.startsWith("/") || /^[a-zA-Z]:[/\\]/.test(obj.path))) paths.add(obj.path);
+  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);
+  }
+}
+
+function _callLspHandler(port, secret, operation, params) {
+  const postData = JSON.stringify(params);
+  return new Promise((resolve) => {
+    const req = http.request({
+      hostname: "127.0.0.1",
+      port: parseInt(port, 10),
+      path: `/lsp/${operation}`,
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Content-Length": Buffer.byteLength(postData),
+        ...(secret ? { "x-lsp-handler-token": secret } : {}),
+      },
+      timeout: 3000,
+    }, (res) => {
+      let data = "";
+      let exceeded = false;
+      const MAX_RESP = 5 * 1024 * 1024;
+      res.on("data", chunk => {
+        if (exceeded) return;
+        data += chunk;
+        if (data.length > MAX_RESP) { exceeded = true; req.destroy(); resolve(null); }
+      });
+      res.on("end", () => { if (!exceeded) { try { resolve(JSON.parse(data)); } catch { resolve(null); } } });
+    });
+    req.on("error", () => resolve(null));
+    req.on("timeout", () => { req.destroy(); resolve(null); });
+    req.write(postData);
+    req.end();
+  });
+}
+
+async function _enrichWithLsp(result, lspConn) {
   try {
-    const connPath = path.join(os.homedir(), ".ctxce", "lsp-connection.json");
-    const conn = JSON.parse(fs.readFileSync(connPath, "utf8"));
-    if (conn.port && _isValidPort(conn.port) && conn.pid) {
-      try { process.kill(conn.pid, 0); } catch (_) { return _cacheNull(); }
-      if (conn.created_at && (now - conn.created_at) > LSP_CONN_MAX_AGE) return _cacheNull();
-      _lspConnCache = { port: String(conn.port), secret: conn.secret || "" };
-      _lspConnCacheTs = now;
-      return _lspConnCache;
-    }
-  } catch (_) {}
-  return _cacheNull();
+    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; }
+    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 };
+    textBlock.text = JSON.stringify(parsed);
+    return result;
+  } catch (err) {
+    debugLog("[ctxce] LSP enrichment failed: " + String(err));
+    return result;
+  }
 }
 
 function debugLog(message) {
@@ -837,8 +927,18 @@ async function createBridgeServer(options) {
     const memoryTools = await listMemoryTools(memoryClient);
     const tools = dedupeTools([...indexerTools, ...memoryTools]);
 
-    const lspAvailable = !!_readLspConnection();
+    const lspAvailable = !!_readLspConnection(workspace);
     if (lspAvailable) {
+      const lspProp = {
+        type: "boolean",
+        description: "When true, auto-enrich results with live LSP diagnostics (errors/warnings) for files in the response. Zero extra tool calls needed.",
+      };
+      for (const tool of tools) {
+        if (_LSP_ENRICHABLE_TOOLS.has(tool.name) && tool.inputSchema?.properties) {
+          tool.inputSchema = { ...tool.inputSchema, properties: { ...tool.inputSchema.properties, include_lsp: lspProp } };
+        }
+      }
+
       const pathProp = { type: "string", description: "Absolute file path" };
       const lineProp = { type: "integer", description: "0-based line" };
       const charProp = { type: "integer", description: "0-based column" };
@@ -920,6 +1020,13 @@ async function createBridgeServer(options) {
     const name = params.name;
     let args = params.arguments;
 
+    let includeLsp = false;
+    if (args && typeof args === "object" && args.include_lsp === true && _LSP_ENRICHABLE_TOOLS.has(name)) {
+      includeLsp = true;
+      const { include_lsp: _stripped, ...rest } = args;
+      args = rest;
+    }
+
     debugLog(`[ctxce] tools/call: ${name || "<no-name>"}`);
 
     // Refresh session before each call; re-init clients if session changes.
@@ -961,7 +1068,7 @@ async function createBridgeServer(options) {
     }
 
     if (name && name.toLowerCase().startsWith("lsp_")) {
-      const lspConn = _readLspConnection();
+      const lspConn = _readLspConnection(workspace);
       const lspPort = lspConn ? lspConn.port : null;
       const lspSecret = lspConn ? lspConn.secret : "";
       if (!lspPort) {
@@ -973,7 +1080,7 @@ async function createBridgeServer(options) {
         return { content: [{ type: "text", text: JSON.stringify({ ok: false, error: "Unknown LSP operation" }) }] };
       }
       try {
-        const lspArgs = params.arguments || {};
+        const lspArgs = args || {};
         const postData = JSON.stringify(lspArgs);
         const result = await new Promise((resolve, reject) => {
           const req = http.request({
@@ -985,9 +1092,15 @@ async function createBridgeServer(options) {
             timeout: 15000,
           }, (res) => {
             let data = "";
-            res.on("data", chunk => { data += chunk; });
+            let exceeded = false;
+            const MAX_RESP = 5 * 1024 * 1024;
+            res.on("data", chunk => {
+              if (exceeded) return;
+              data += chunk;
+              if (data.length > MAX_RESP) { exceeded = true; req.destroy(); resolve({ ok: false, error: "Response too large" }); }
+            });
             res.on("end", () => {
-              try { resolve(JSON.parse(data)); } catch { resolve({ ok: false, error: "Invalid response from LSP handler" }); }
+              if (!exceeded) { try { resolve(JSON.parse(data)); } catch { resolve({ ok: false, error: "Invalid response from LSP handler" }); } }
             });
           });
           req.on("error", reject);
@@ -997,7 +1110,9 @@ async function createBridgeServer(options) {
         });
         return { content: [{ type: "text", text: JSON.stringify(result) }] };
       } catch (err) {
-        return { content: [{ type: "text", text: JSON.stringify({ ok: false, error: `LSP proxy error: ${err.message || String(err)}` }) }] };
+        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 }) }] };
       }
     }
 
@@ -1029,7 +1144,10 @@ async function createBridgeServer(options) {
           undefined,
           { timeout: timeoutMs },
         );
-        return maybeRemapToolResult(name, result, workspace);
+        let finalResult = maybeRemapToolResult(name, result, workspace);
+        const lspConn = includeLsp && _readLspConnection(workspace);
+        if (lspConn) finalResult = await _enrichWithLsp(finalResult, lspConn);
+        return finalResult;
       } catch (err) {
         lastError = err;