@context-engine-bridge/context-engine-mcp-bridge 0.0.6 → 0.0.8

package/package.json

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

package/src/authCli.js

@@ -1,5 +1,5 @@
 import process from "node:process";
-import { loadAuthEntry, saveAuthEntry, deleteAuthEntry } from "./authConfig.js";
+import { loadAuthEntry, saveAuthEntry, deleteAuthEntry, loadAnyAuthEntry } from "./authConfig.js";
 
 function parseAuthArgs(args) {
   let backendUrl = process.env.CTXCE_AUTH_BACKEND_URL || "";
@@ -19,9 +19,16 @@ function parseAuthArgs(args) {
       i += 1;
       continue;
     }
-    if ((a === "--username" || a === "--user") && i + 1 < args.length) {
-      username = args[i + 1];
-      i += 1;
+    if (a === "--username" || a === "--user") {
+      const hasNext = i + 1 < args.length;
+      const next = hasNext ? String(args[i + 1]) : "";
+      if (hasNext && !next.startsWith("-")) {
+        username = args[i + 1];
+        i += 1;
+      } else {
+        console.error("[ctxce] Missing value for --username/--user; expected a username.");
+        process.exit(1);
+      }
       continue;
     }
     if ((a === "--password" || a === "--pass") && i + 1 < args.length) {
@@ -41,6 +48,11 @@ function getBackendUrl(backendUrl) {
   return (backendUrl || process.env.CTXCE_AUTH_BACKEND_URL || "").trim();
 }
 
+function getDefaultUploadBackend() {
+  // Default to upload service when nothing else is configured
+  return (process.env.CTXCE_UPLOAD_ENDPOINT || process.env.UPLOAD_ENDPOINT || "http://localhost:8004").trim();
+}
+
 function requireBackendUrl(backendUrl) {
   const url = getBackendUrl(backendUrl);
   if (!url) {
@@ -67,7 +79,26 @@ function outputJsonStatus(url, state, entry, rawExpires) {
 
 async function doLogin(args) {
   const { backendUrl, token, username, password } = parseAuthArgs(args);
-  const url = requireBackendUrl(backendUrl);
+  let url = getBackendUrl(backendUrl);
+  if (!url) {
+    // Fallback: use any stored auth entry when no backend is provided
+    const any = loadAnyAuthEntry();
+    if (any && any.backendUrl) {
+      url = any.backendUrl;
+      console.error("[ctxce] Using stored backend for login:", url);
+    }
+  }
+  if (!url) {
+    // Final fallback: default upload endpoint (extension's upload endpoint or localhost:8004)
+    url = getDefaultUploadBackend();
+    if (url) {
+      console.error("[ctxce] Using default upload backend for login:", url);
+    }
+  }
+  if (!url) {
+    console.error("[ctxce] Auth backend URL not configured. Set CTXCE_AUTH_BACKEND_URL or use --backend-url.");
+    process.exit(1);
+  }
   const trimmedUser = (username || "").trim();
   const usePassword = trimmedUser && (password || "").length > 0;
 
@@ -124,13 +155,30 @@ async function doLogin(args) {
 
 async function doStatus(args) {
   const { backendUrl, outputJson } = parseAuthArgs(args);
-  const url = getBackendUrl(backendUrl);
+  let url = getBackendUrl(backendUrl);
+  let usedFallback = false;
+  if (!url) {
+    // Fallback: use any stored auth entry when no backend is provided
+    const any = loadAnyAuthEntry();
+    if (any && any.backendUrl) {
+      url = any.backendUrl;
+      usedFallback = true;
+    }
+  }
+  if (!url) {
+    // Final fallback: default upload endpoint
+    url = getDefaultUploadBackend();
+    if (url) {
+      usedFallback = true;
+      console.error("[ctxce] Using default upload backend for status:", url);
+    }
+  }
   if (!url) {
     if (outputJson) {
       outputJsonStatus("", "missing_backend", null, null);
       process.exit(1);
     }
-    console.error("[ctxce] Auth backend URL not configured. Set CTXCE_AUTH_BACKEND_URL or use --backend-url.");
+    console.error("[ctxce] Auth backend URL not configured and no stored sessions found. Set CTXCE_AUTH_BACKEND_URL or use --backend-url.");
     process.exit(1);
   }
   let entry;
@@ -149,7 +197,11 @@ async function doStatus(args) {
       outputJsonStatus(url, "missing", null, rawExpires);
       process.exit(1);
     }
-    console.error("[ctxce] Not logged in for", url);
+    if (usedFallback) {
+      console.error("[ctxce] Not logged in for stored backend", url);
+    } else {
+      console.error("[ctxce] Not logged in for", url);
+    }
     process.exit(1);
   }
 
@@ -158,7 +210,11 @@ async function doStatus(args) {
       outputJsonStatus(url, "expired", entry, rawExpires);
       process.exit(2);
     }
-    console.error("[ctxce] Stored auth session appears expired for", url);
+    if (usedFallback) {
+      console.error("[ctxce] Stored auth session appears expired for stored backend", url);
+    } else {
+      console.error("[ctxce] Stored auth session appears expired for", url);
+    }
     if (rawExpires) {
       console.error("[ctxce] Session expired at", rawExpires);
     }
@@ -169,6 +225,9 @@ async function doStatus(args) {
     outputJsonStatus(url, "ok", entry, rawExpires);
     return;
   }
+  if (usedFallback) {
+    console.error("[ctxce] Using stored backend for status:", url);
+  }
   console.error("[ctxce] Logged in to", url, "as", entry.userId || "<unknown>");
   if (rawExpires) {
     console.error("[ctxce] Session expires at", rawExpires);
@@ -177,7 +236,26 @@ async function doStatus(args) {
 
 async function doLogout(args) {
   const { backendUrl } = parseAuthArgs(args);
-  const url = requireBackendUrl(backendUrl);
+  let url = getBackendUrl(backendUrl);
+  if (!url) {
+    // Fallback: use any stored auth entry when no backend is provided
+    const any = loadAnyAuthEntry();
+    if (any && any.backendUrl) {
+      url = any.backendUrl;
+      console.error("[ctxce] Using stored backend for logout:", url);
+    }
+  }
+  if (!url) {
+    // Final fallback: default upload endpoint
+    url = getDefaultUploadBackend();
+    if (url) {
+      console.error("[ctxce] Using default upload backend for logout:", url);
+    }
+  }
+  if (!url) {
+    console.error("[ctxce] Auth backend URL not configured and no stored sessions found. Set CTXCE_AUTH_BACKEND_URL or use --backend-url.");
+    process.exit(1);
+  }
   const entry = loadAuthEntry(url);
   if (!entry) {
     console.error("[ctxce] No stored auth session for", url);

package/src/mcpServer.js

@@ -1,3 +1,17 @@
+import process from "node:process";
+import fs from "node:fs";
+import path from "node:path";
+import { execSync } from "node:child_process";
+import { createServer } from "node:http";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { loadAnyAuthEntry, loadAuthEntry } from "./authConfig.js";
+import { maybeRemapToolResult } from "./resultPathMapping.js";
+
 function debugLog(message) {
   try {
     const text = typeof message === "string" ? message : String(message);
@@ -236,19 +250,6 @@ function isTransientToolError(error) {
 // Acts as a low-level proxy for tools, forwarding tools/list and tools/call
 // to the remote qdrant-indexer MCP server while adding a local `ping` tool.
 
-import process from "node:process";
-import fs from "node:fs";
-import path from "node:path";
-import { execSync } from "node:child_process";
-import { createServer } from "node:http";
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
-import { loadAnyAuthEntry, loadAuthEntry } from "./authConfig.js";
-
 async function createBridgeServer(options) {
   const workspace = options.workspace || process.cwd();
   const indexerUrl = options.indexerUrl;
@@ -286,18 +287,20 @@ async function createBridgeServer(options) {
   const authBackendUrl = process.env.CTXCE_AUTH_BACKEND_URL || "";
   let sessionId = explicitSession;
 
-  if (!sessionId) {
+  function resolveSessionId() {
+    const explicit = process.env.CTXCE_SESSION_ID || "";
+    if (explicit) {
+      return explicit;
+    }
     let backendToUse = authBackendUrl;
     let entry = null;
-
     if (backendToUse) {
       try {
         entry = loadAuthEntry(backendToUse);
-      } catch (err) {
+      } catch {
         entry = null;
       }
     }
-
     if (!entry) {
       try {
         const any = loadAnyAuthEntry();
@@ -305,11 +308,10 @@ async function createBridgeServer(options) {
           backendToUse = any.backendUrl;
           entry = any.entry;
         }
-      } catch (err) {
+      } catch {
         entry = null;
       }
     }
-
     if (entry) {
       let expired = false;
       const rawExpires = entry.expiresAt;
@@ -320,11 +322,17 @@ async function createBridgeServer(options) {
         }
       }
       if (!expired && typeof entry.sessionId === "string" && entry.sessionId) {
-        sessionId = entry.sessionId;
-      } else if (expired) {
+        return entry.sessionId;
+      }
+      if (expired) {
         debugLog("[ctxce] Stored auth session appears expired; please run `ctxce auth login` again.");
       }
     }
+    return "";
+  }
+
+  if (!sessionId) {
+    sessionId = resolveSessionId();
   }
 
   if (!sessionId) {
@@ -477,7 +485,16 @@ async function createBridgeServer(options) {
 
     debugLog(`[ctxce] tools/call: ${name || "<no-name>"}`);
 
-    // Attach session id so the target server can apply per-session defaults.
+    // Refresh session before each call; re-init clients if session changes.
+    const freshSession = resolveSessionId() || sessionId;
+    if (freshSession && freshSession !== sessionId) {
+      sessionId = freshSession;
+      try {
+        await initializeRemoteClients(true);
+      } catch (err) {
+        debugLog("[ctxce] Failed to reinitialize clients after session refresh: " + String(err));
+      }
+    }
     if (sessionId && (args === undefined || args === null || typeof args === "object")) {
       const obj = args && typeof args === "object" ? { ...args } : {};
       if (!Object.prototype.hasOwnProperty.call(obj, "session")) {
@@ -525,7 +542,7 @@ async function createBridgeServer(options) {
           undefined,
           { timeout: timeoutMs },
         );
-        return result;
+        return maybeRemapToolResult(name, result, workspace);
       } catch (err) {
         lastError = err;
 

package/src/resultPathMapping.js

@@ -0,0 +1,338 @@
+import process from "node:process";
+import fs from "node:fs";
+import path from "node:path";
+
+function envTruthy(value, defaultVal = false) {
+  try {
+    if (value === undefined || value === null) {
+      return defaultVal;
+    }
+    const s = String(value).trim().toLowerCase();
+    if (!s) {
+      return defaultVal;
+    }
+    return s === "1" || s === "true" || s === "yes" || s === "on";
+  } catch {
+    return defaultVal;
+  }
+}
+
+function _posixToNative(rel) {
+  try {
+    if (!rel) {
+      return "";
+    }
+    return String(rel).split("/").join(path.sep);
+  } catch {
+    return rel;
+  }
+}
+
+function computeWorkspaceRelativePath(containerPath, hostPath) {
+  try {
+    const cont = typeof containerPath === "string" ? containerPath.trim() : "";
+    if (cont.startsWith("/work/")) {
+      const rest = cont.slice("/work/".length);
+      const parts = rest.split("/").filter(Boolean);
+      if (parts.length >= 2) {
+        return parts.slice(1).join("/");
+      }
+      if (parts.length === 1) {
+        return parts[0];
+      }
+    }
+  } catch {
+  }
+  try {
+    const hp = typeof hostPath === "string" ? hostPath.trim() : "";
+    if (!hp) {
+      return "";
+    }
+    // If we don't have a container path, at least try to return a basename.
+    return path.posix.basename(hp.replace(/\\/g, "/"));
+  } catch {
+    return "";
+  }
+}
+
+function remapRelatedPathToClient(p, workspaceRoot) {
+  try {
+    const s = typeof p === "string" ? p : "";
+    const root = typeof workspaceRoot === "string" ? workspaceRoot : "";
+    if (!s || !root) {
+      return p;
+    }
+
+    const sNorm = s.replace(/\\/g, path.sep);
+    if (sNorm.startsWith(root + path.sep) || sNorm === root) {
+      return sNorm;
+    }
+
+    if (s.startsWith("/work/")) {
+      const rest = s.slice("/work/".length);
+      const parts = rest.split("/").filter(Boolean);
+      if (parts.length >= 2) {
+        const rel = parts.slice(1).join("/");
+        const relNative = _posixToNative(rel);
+        return path.join(root, relNative);
+      }
+      return p;
+    }
+
+    // If it's already a relative path, join it to the workspace root.
+    if (!s.startsWith("/") && !s.includes(":") && !s.includes("\\")) {
+      const relPosix = s.trim();
+      if (relPosix && relPosix !== "." && !relPosix.startsWith("../") && relPosix !== "..") {
+        const relNative = _posixToNative(relPosix);
+        const joined = path.join(root, relNative);
+        const relCheck = path.relative(root, joined);
+        if (relCheck && !relCheck.startsWith(`..${path.sep}`) && relCheck !== "..") {
+          return joined;
+        }
+      }
+    }
+
+    return p;
+  } catch {
+    return p;
+  }
+}
+
+function remapHitPaths(hit, workspaceRoot) {
+  if (!hit || typeof hit !== "object") {
+    return hit;
+  }
+  const rawPath = typeof hit.path === "string" ? hit.path : "";
+  let hostPath = typeof hit.host_path === "string" ? hit.host_path : "";
+  let containerPath = typeof hit.container_path === "string" ? hit.container_path : "";
+  if (!hostPath && rawPath) {
+    hostPath = rawPath;
+  }
+  if (!containerPath && rawPath) {
+    containerPath = rawPath;
+  }
+  const relPath = computeWorkspaceRelativePath(containerPath, hostPath);
+  const out = { ...hit };
+  if (relPath) {
+    out.rel_path = relPath;
+  }
+  // Remap related_paths nested under each hit (repo_search/hybrid_search emit this per result).
+  try {
+    if (Array.isArray(out.related_paths)) {
+      out.related_paths = out.related_paths.map((p) => remapRelatedPathToClient(p, workspaceRoot));
+    }
+  } catch {
+    // ignore
+  }
+  if (workspaceRoot && relPath) {
+    try {
+      const relNative = _posixToNative(relPath);
+      const candidate = path.join(workspaceRoot, relNative);
+      const diagnostics = envTruthy(process.env.CTXCE_BRIDGE_PATH_DIAGNOSTICS, false);
+      const strictClientPath = envTruthy(process.env.CTXCE_BRIDGE_CLIENT_PATH_STRICT, false);
+      if (strictClientPath) {
+        out.client_path = candidate;
+        if (diagnostics) {
+          out.client_path_joined = candidate;
+          out.client_path_source = "workspace_join";
+        }
+      } else {
+        // Prefer a host_path that is within the current bridge workspace.
+        // This keeps provenance (host_path) intact while providing a user-local
+        // absolute path even when the bridge workspace is a parent directory.
+        const hp = typeof hostPath === "string" ? hostPath : "";
+        const hpNorm = hp ? hp.replace(/\\/g, path.sep) : "";
+        if (
+          hpNorm &&
+          hpNorm.startsWith(workspaceRoot) &&
+          (!fs.existsSync(candidate) || fs.existsSync(hpNorm))
+        ) {
+          out.client_path = hpNorm;
+          if (diagnostics) {
+            out.client_path_joined = candidate;
+            out.client_path_source = "host_path";
+          }
+        } else {
+          out.client_path = candidate;
+          if (diagnostics) {
+            out.client_path_joined = candidate;
+            out.client_path_source = "workspace_join";
+          }
+        }
+      }
+    } catch {
+      // ignore
+    }
+  }
+  const overridePath = envTruthy(process.env.CTXCE_BRIDGE_OVERRIDE_PATH, true);
+  if (overridePath) {
+    if (typeof out.client_path === "string" && out.client_path) {
+      out.path = out.client_path;
+    } else if (relPath) {
+      out.path = relPath;
+    }
+  }
+  return out;
+}
+
+function remapStringPath(p, workspaceRoot) {
+  try {
+    const s = typeof p === "string" ? p : "";
+    if (!s) {
+      return p;
+    }
+    // If this is already a path within the current client workspace, rewrite to a
+    // workspace-relative string when override is enabled.
+    try {
+      const root = typeof workspaceRoot === "string" ? workspaceRoot : "";
+      if (root) {
+        const sNorm = s.replace(/\\/g, path.sep);
+        if (sNorm.startsWith(root + path.sep) || sNorm === root) {
+          const relNative = path.relative(root, sNorm);
+          const relPosix = String(relNative).split(path.sep).join("/");
+          if (relPosix && !relPosix.startsWith("../") && relPosix !== "..") {
+            const override = envTruthy(process.env.CTXCE_BRIDGE_OVERRIDE_PATH, true);
+            if (override) {
+              return relPosix;
+            }
+          }
+        }
+      }
+    } catch {
+      // ignore
+    }
+    if (s.startsWith("/work/")) {
+      const rest = s.slice("/work/".length);
+      const parts = rest.split("/").filter(Boolean);
+      if (parts.length >= 2) {
+        const rel = parts.slice(1).join("/");
+        const override = envTruthy(process.env.CTXCE_BRIDGE_OVERRIDE_PATH, true);
+        if (override) {
+          return rel;
+        }
+        return p;
+      }
+    }
+    return p;
+  } catch {
+    return p;
+  }
+}
+
+function maybeParseToolJson(result) {
+  try {
+    if (
+      result &&
+      typeof result === "object" &&
+      result.structuredContent &&
+      typeof result.structuredContent === "object"
+    ) {
+      return { mode: "structured", value: result.structuredContent };
+    }
+  } catch {
+  }
+  try {
+    const content = result && result.content;
+    if (!Array.isArray(content)) {
+      return null;
+    }
+    const first = content.find(
+      (c) => c && c.type === "text" && typeof c.text === "string",
+    );
+    if (!first) {
+      return null;
+    }
+    const txt = String(first.text || "").trim();
+    if (!txt || !(txt.startsWith("{") || txt.startsWith("["))) {
+      return null;
+    }
+    return { mode: "text", value: JSON.parse(txt) };
+  } catch {
+    return null;
+  }
+}
+
+function applyPathMappingToPayload(payload, workspaceRoot) {
+  if (!payload || typeof payload !== "object") {
+    return payload;
+  }
+  const out = Array.isArray(payload) ? payload.slice() : { ...payload };
+
+  const mapHitsArray = (arr) => {
+    if (!Array.isArray(arr)) {
+      return arr;
+    }
+    return arr.map((h) => remapHitPaths(h, workspaceRoot));
+  };
+
+  // Common result shapes across tools
+  if (Array.isArray(out.results)) {
+    out.results = mapHitsArray(out.results);
+  }
+  if (Array.isArray(out.citations)) {
+    out.citations = mapHitsArray(out.citations);
+  }
+  if (Array.isArray(out.related_paths)) {
+    out.related_paths = out.related_paths.map((p) => remapRelatedPathToClient(p, workspaceRoot));
+  }
+
+  // Some tools nest under {result:{...}}
+  if (out.result && typeof out.result === "object") {
+    out.result = applyPathMappingToPayload(out.result, workspaceRoot);
+  }
+
+  return out;
+}
+
+export function maybeRemapToolResult(name, result, workspaceRoot) {
+  try {
+    if (!name || !result || !workspaceRoot) {
+      return result;
+    }
+    const enabled = envTruthy(process.env.CTXCE_BRIDGE_MAP_PATHS, true);
+    if (!enabled) {
+      return result;
+    }
+    const lower = String(name).toLowerCase();
+    const shouldMap = (
+      lower === "repo_search" ||
+      lower === "context_search" ||
+      lower === "context_answer" ||
+      lower.endsWith("search_tests_for") ||
+      lower.endsWith("search_config_for") ||
+      lower.endsWith("search_callers_for") ||
+      lower.endsWith("search_importers_for")
+    );
+    if (!shouldMap) {
+      return result;
+    }
+
+    const parsed = maybeParseToolJson(result);
+    if (!parsed) {
+      return result;
+    }
+
+    const mapped = applyPathMappingToPayload(parsed.value, workspaceRoot);
+    let outResult = result;
+    if (parsed.mode === "structured") {
+      outResult = { ...result, structuredContent: mapped };
+    }
+
+    // Replace text payload for clients that only read `content[].text`
+    try {
+      const content = Array.isArray(outResult.content) ? outResult.content.slice() : [];
+      const idx = content.findIndex(
+        (c) => c && c.type === "text" && typeof c.text === "string",
+      );
+      if (idx >= 0) {
+        content[idx] = { ...content[idx], text: JSON.stringify(mapped) };
+        outResult = { ...outResult, content };
+      }
+    } catch {
+      // ignore
+    }
+    return outResult;
+  } catch {
+    return result;
+  }
+}