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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@context-engine-bridge/context-engine-mcp-bridge",
-  "version": "0.0.31",
+  "version": "0.0.33",
   "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,56 @@ 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);
   }
 
-  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();
+  _lspConnCache = { value: result, ts: now, key: cacheKey };
+  return result;
 }
 
 const _LSP_ENRICHABLE_TOOLS = new Set([
@@ -58,16 +74,36 @@ 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)) {
+      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);
   }
 }
 
@@ -89,6 +125,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;
@@ -103,7 +140,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");
@@ -112,7 +149,7 @@ async function _enrichWithLsp(result, lspConn) {
     try { parsed = JSON.parse(textBlock.text); } catch { return result; }
     if (!parsed.ok) return result;
     const paths = new Set();
-    _extractPaths(parsed, paths);
+    _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;
@@ -911,7 +948,7 @@ 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",
@@ -1052,7 +1089,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) {
@@ -1064,7 +1101,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({
@@ -1078,6 +1115,7 @@ async function createBridgeServer(options) {
             let data = "";
             let exceeded = false;
             const MAX_RESP = 5 * 1024 * 1024;
+            res.on("error", () => {});
             res.on("data", chunk => {
               if (exceeded) return;
               data += chunk;
@@ -1129,8 +1167,8 @@ async function createBridgeServer(options) {
           { timeout: timeoutMs },
         );
         let finalResult = maybeRemapToolResult(name, result, workspace);
-        const lspConn = includeLsp && _readLspConnection();
-        if (lspConn) finalResult = await _enrichWithLsp(finalResult, lspConn);
+        const lspConn = includeLsp && _readLspConnection(workspace);
+        if (lspConn) finalResult = await _enrichWithLsp(finalResult, lspConn, workspace);
         return finalResult;
       } catch (err) {
         lastError = err;