@context-engine-bridge/context-engine-mcp-bridge 0.0.22 → 0.0.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@context-engine-bridge/context-engine-mcp-bridge",
-  "version": "0.0.22",
+  "version": "0.0.24",
   "description": "Context Engine MCP bridge (http/stdio proxy combining indexer + memory servers)",
   "bin": {
     "ctxce": "bin/ctxce.js",
@@ -29,4 +29,4 @@
   "engines": {
     "node": ">=18.0.0"
   }
-}
+}

package/src/cli.js

@@ -5,11 +5,18 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { runMcpServer, runHttpMcpServer } from "./mcpServer.js";
 import { runAuthCommand } from "./authCli.js";
+import { runConnectCommand } from "./connectCli.js";
 
 export async function runCli() {
   const argv = process.argv.slice(2);
   const cmd = argv[0];
 
+  if (cmd === "connect") {
+    const args = argv.slice(1);
+    await runConnectCommand(args);
+    return;
+  }
+
   if (cmd === "auth") {
     const sub = argv[1] || "";
     const args = argv.slice(2);
@@ -134,7 +141,7 @@ export async function runCli() {
 
   // eslint-disable-next-line no-console
   console.error(
-    `Usage: ${binName} mcp-serve [--workspace <path>] [--indexer-url <url>] [--memory-url <url>] [--collection <name>] | ${binName} mcp-http-serve [--workspace <path>] [--indexer-url <url>] [--memory-url <url>] [--port <port>] [--collection <name>] | ${binName} auth <login|status|logout> [--backend-url <url>] [--token <token>] [--username <name> --password <pass>]`,
+    `Usage: ${binName} connect <api-key> [--workspace <path>] [--interval <sec>] [--no-watch] | ${binName} mcp-serve [--workspace <path>] [--indexer-url <url>] [--memory-url <url>] [--collection <name>] | ${binName} mcp-http-serve [--workspace <path>] [--indexer-url <url>] [--memory-url <url>] [--port <port>] [--collection <name>] | ${binName} auth <login|status|logout> [--backend-url <url>] [--token <token>] [--username <name> --password <pass>]`,
   );
   process.exit(1);
 }

package/src/connectCli.js

@@ -0,0 +1,440 @@
+import process from "node:process";
+import path from "node:path";
+import fs from "node:fs";
+import { execSync, spawn } from "node:child_process";
+import { saveAuthEntry } from "./authConfig.js";
+
+const SAAS_ENDPOINTS = {
+  uploadEndpoint: "https://dev.context-engine.ai/upload",
+  authBackendUrl: "https://dev.context-engine.ai",
+  mcpIndexerUrl: "https://dev.context-engine.ai/indexer/mcp",
+  mcpMemoryUrl: "https://dev.context-engine.ai/memory/mcp",
+};
+
+const DEFAULT_WATCH_INTERVAL_MS = 30000;
+const DEFAULT_DEBOUNCE_MS = 2000;
+
+function parseConnectArgs(args) {
+  let apiKey = "";
+  let workspace = process.cwd();
+  let skipIndex = false;
+  let noWatch = false;
+  let watchInterval = DEFAULT_WATCH_INTERVAL_MS;
+
+  for (let i = 0; i < args.length; i += 1) {
+    const a = args[i];
+
+    if (!a.startsWith("-") && !apiKey) {
+      apiKey = a;
+      continue;
+    }
+
+    if ((a === "--api-key" || a === "--key" || a === "-k") && i + 1 < args.length) {
+      apiKey = args[i + 1];
+      i += 1;
+      continue;
+    }
+
+    if ((a === "--workspace" || a === "--path" || a === "-w") && i + 1 < args.length) {
+      workspace = args[i + 1];
+      i += 1;
+      continue;
+    }
+
+    if (a === "--skip-index" || a === "--auth-only") {
+      skipIndex = true;
+      continue;
+    }
+
+    if (a === "--no-watch" || a === "--once") {
+      noWatch = true;
+      continue;
+    }
+
+    if (a === "--interval" && i + 1 < args.length) {
+      const parsed = parseInt(args[i + 1], 10);
+      if (!isNaN(parsed) && parsed > 0) {
+        watchInterval = parsed * 1000;
+      }
+      i += 1;
+      continue;
+    }
+  }
+
+  return { apiKey, workspace, skipIndex, noWatch, watchInterval };
+}
+
+async function authenticateWithApiKey(apiKey) {
+  const authUrl = `${SAAS_ENDPOINTS.authBackendUrl}/auth/login`;
+
+  console.error("[ctxce] Authenticating with Context Engine SaaS...");
+
+  const body = {
+    client: "ctxce-cli",
+    token: apiKey,
+    workspace: process.cwd(),
+  };
+
+  let resp;
+  try {
+    resp = await fetch(authUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+    });
+  } catch (err) {
+    console.error("[ctxce] Failed to connect to SaaS backend:", String(err));
+    return null;
+  }
+
+  if (!resp || !resp.ok) {
+    const status = resp ? resp.status : "<no-response>";
+    let errorMsg = `HTTP ${status}`;
+    try {
+      const errorData = await resp.json();
+      if (errorData.detail) {
+        errorMsg = errorData.detail;
+      }
+    } catch {
+    }
+    console.error("[ctxce] Authentication failed:", errorMsg);
+    return null;
+  }
+
+  let data;
+  try {
+    data = await resp.json();
+  } catch {
+    data = {};
+  }
+
+  const sessionId = data.session_id || data.sessionId || null;
+  const userId = data.user_id || data.userId || null;
+  const expiresAt = data.expires_at || data.expiresAt || null;
+  const orgId = data.org_id || data.orgId || null;
+  const orgSlug = data.org_slug || data.orgSlug || null;
+
+  if (!sessionId) {
+    console.error("[ctxce] Authentication response missing session ID.");
+    return null;
+  }
+
+  const entry = {
+    sessionId,
+    userId,
+    expiresAt,
+    org_id: orgId,
+    org_slug: orgSlug,
+    apiKey,
+  };
+
+  saveAuthEntry(SAAS_ENDPOINTS.authBackendUrl, entry);
+
+  console.error("[ctxce] Authenticated successfully!");
+  if (userId) {
+    console.error(`[ctxce] User: ${userId}`);
+  }
+  if (orgSlug) {
+    console.error(`[ctxce] Organization: ${orgSlug}`);
+  }
+
+  return entry;
+}
+
+function findUploadClient() {
+  const candidates = [
+    path.resolve(process.cwd(), "scripts", "standalone_upload_client.py"),
+    path.resolve(process.cwd(), "..", "scripts", "standalone_upload_client.py"),
+    path.resolve(__dirname, "..", "..", "scripts", "standalone_upload_client.py"),
+  ];
+
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+
+  return null;
+}
+
+function detectPython() {
+  for (const cmd of ["python3", "python"]) {
+    try {
+      execSync(`${cmd} --version`, { stdio: "ignore" });
+      return cmd;
+    } catch {
+    }
+  }
+  return null;
+}
+
+async function runUploadClient(workspace, sessionId, uploadClient, python) {
+  const env = {
+    ...process.env,
+    REMOTE_UPLOAD_ENDPOINT: SAAS_ENDPOINTS.uploadEndpoint,
+    CTXCE_AUTH_BACKEND_URL: SAAS_ENDPOINTS.authBackendUrl,
+    CTXCE_SESSION_ID: sessionId,
+    HOST_ROOT: workspace,
+    CONTAINER_ROOT: "/work",
+  };
+
+  return new Promise((resolve) => {
+    const args = [
+      uploadClient,
+      "--path", workspace,
+      "--endpoint", SAAS_ENDPOINTS.uploadEndpoint,
+      "--force",
+    ];
+
+    const proc = spawn(python, args, {
+      env,
+      stdio: ["ignore", "pipe", "pipe"],
+      cwd: workspace,
+    });
+
+    proc.stdout.on("data", (data) => {
+      const line = data.toString().trim();
+      if (line) {
+        console.error(`[upload] ${line}`);
+      }
+    });
+
+    proc.stderr.on("data", (data) => {
+      const line = data.toString().trim();
+      if (line) {
+        console.error(`[upload] ${line}`);
+      }
+    });
+
+    proc.on("close", (code) => {
+      resolve(code === 0);
+    });
+
+    proc.on("error", (err) => {
+      console.error(`[ctxce] Upload process error: ${err}`);
+      resolve(false);
+    });
+  });
+}
+
+async function triggerIndexing(workspace, sessionId) {
+  console.error("[ctxce] Starting workspace indexing...");
+  console.error(`[ctxce] Workspace: ${workspace}`);
+  console.error(`[ctxce] Endpoint: ${SAAS_ENDPOINTS.uploadEndpoint}`);
+
+  const uploadClient = findUploadClient();
+  const python = detectPython();
+
+  if (!uploadClient || !python) {
+    console.error("[ctxce] Python upload client not available.");
+    console.error("[ctxce] Install context-engine Python package or use VS Code extension.");
+    return false;
+  }
+
+  return await runUploadClient(workspace, sessionId, uploadClient, python);
+}
+
+function startWatcher(workspace, sessionId, intervalMs) {
+  const uploadClient = findUploadClient();
+  const python = detectPython();
+
+  if (!uploadClient || !python) {
+    console.error("[ctxce] Cannot start watcher: Python upload client not available.");
+    return null;
+  }
+
+  console.error(`[ctxce] Starting file watcher (sync every ${intervalMs / 1000}s)...`);
+  console.error("[ctxce] Press Ctrl+C to stop.");
+
+  let isRunning = false;
+  let pendingSync = false;
+  let lastSyncTime = Date.now();
+
+  const fileHashes = new Map();
+
+  function getFileHash(filePath) {
+    try {
+      const stat = fs.statSync(filePath);
+      return `${stat.mtime.getTime()}-${stat.size}`;
+    } catch {
+      return null;
+    }
+  }
+
+  function scanDirectory(dir, files = []) {
+    try {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        
+        if (entry.name.startsWith(".") || 
+            entry.name === "node_modules" || 
+            entry.name === "__pycache__" ||
+            entry.name === "venv" ||
+            entry.name === ".venv" ||
+            entry.name === "dist" ||
+            entry.name === "build") {
+          continue;
+        }
+
+        if (entry.isDirectory()) {
+          scanDirectory(fullPath, files);
+        } else if (entry.isFile()) {
+          files.push(fullPath);
+        }
+      }
+    } catch {
+    }
+    return files;
+  }
+
+  function detectChanges() {
+    const currentFiles = scanDirectory(workspace);
+    let hasChanges = false;
+
+    const currentPaths = new Set(currentFiles);
+
+    for (const filePath of currentFiles) {
+      const newHash = getFileHash(filePath);
+      const oldHash = fileHashes.get(filePath);
+      
+      if (newHash !== oldHash) {
+        hasChanges = true;
+        fileHashes.set(filePath, newHash);
+      }
+    }
+
+    for (const oldPath of fileHashes.keys()) {
+      if (!currentPaths.has(oldPath)) {
+        hasChanges = true;
+        fileHashes.delete(oldPath);
+      }
+    }
+
+    return hasChanges;
+  }
+
+  async function doSync() {
+    if (isRunning) {
+      pendingSync = true;
+      return;
+    }
+
+    isRunning = true;
+    const now = new Date().toLocaleTimeString();
+    console.error(`[ctxce] [${now}] Syncing changes...`);
+
+    try {
+      const success = await runUploadClient(workspace, sessionId, uploadClient, python);
+      if (success) {
+        console.error(`[ctxce] [${now}] Sync complete.`);
+      } else {
+        console.error(`[ctxce] [${now}] Sync failed.`);
+      }
+    } catch (err) {
+      console.error(`[ctxce] [${now}] Sync error: ${err}`);
+    }
+
+    isRunning = false;
+    lastSyncTime = Date.now();
+
+    if (pendingSync) {
+      pendingSync = false;
+      setTimeout(doSync, DEFAULT_DEBOUNCE_MS);
+    }
+  }
+
+  scanDirectory(workspace).forEach(f => {
+    fileHashes.set(f, getFileHash(f));
+  });
+
+  const intervalId = setInterval(() => {
+    if (detectChanges()) {
+      doSync();
+    }
+  }, intervalMs);
+
+  const cleanup = () => {
+    clearInterval(intervalId);
+    console.error("\n[ctxce] Watcher stopped.");
+  };
+
+  process.on("SIGINT", () => {
+    cleanup();
+    process.exit(0);
+  });
+
+  process.on("SIGTERM", () => {
+    cleanup();
+    process.exit(0);
+  });
+
+  return { intervalId, cleanup };
+}
+
+function printSuccess() {
+  console.error("");
+  console.error("=".repeat(60));
+  console.error(" Context Engine connected!");
+  console.error("=".repeat(60));
+  console.error("");
+  console.error("Indexing complete. Watching for file changes...");
+  console.error("Press Ctrl+C to stop.");
+  console.error("");
+}
+
+function printUsage() {
+  console.error("Usage: ctxce connect <api-key> [options]");
+  console.error("");
+  console.error("Connect to Context Engine SaaS, index workspace, and watch for changes.");
+  console.error("");
+  console.error("Arguments:");
+  console.error("  <api-key>              Your Context Engine API key");
+  console.error("");
+  console.error("Options:");
+  console.error("  --workspace, -w <path> Workspace path (default: current directory)");
+  console.error("  --interval <seconds>   Sync interval in seconds (default: 30)");
+  console.error("  --no-watch, --once     Index once and exit (don't watch for changes)");
+  console.error("  --skip-index           Only authenticate, skip initial indexing");
+  console.error("");
+  console.error("Examples:");
+  console.error("  ctxce connect sk_abc123xyz");
+  console.error("  ctxce connect sk_abc123xyz -w /path/to/repo");
+  console.error("  ctxce connect sk_abc123xyz --once");
+  console.error("");
+}
+
+export async function runConnectCommand(args) {
+  const { apiKey, workspace, skipIndex, noWatch, watchInterval } = parseConnectArgs(args || []);
+
+  if (!apiKey) {
+    printUsage();
+    process.exit(1);
+  }
+
+  const resolvedWorkspace = path.resolve(workspace);
+  if (!fs.existsSync(resolvedWorkspace)) {
+    console.error(`[ctxce] Workspace path does not exist: ${resolvedWorkspace}`);
+    process.exit(1);
+  }
+
+  const authEntry = await authenticateWithApiKey(apiKey);
+  if (!authEntry) {
+    process.exit(1);
+  }
+
+  if (!skipIndex) {
+    const indexed = await triggerIndexing(resolvedWorkspace, authEntry.sessionId);
+    if (!indexed) {
+      console.error("[ctxce] Initial indexing failed, but will continue.");
+    }
+  }
+
+  if (noWatch) {
+    console.error("[ctxce] Done.");
+    return;
+  }
+
+  printSuccess();
+  startWatcher(resolvedWorkspace, authEntry.sessionId, watchInterval);
+}

package/src/mcpServer.js

@@ -282,6 +282,16 @@ function isTransientToolError(error) {
       return true;
     }
 
+    // StreamableHTTP transport errors after server restart
+    if (
+      lower.includes("failed to fetch") ||
+      lower.includes("fetch failed") ||
+      lower.includes("socket hang up") ||
+      lower.includes("aborted")
+    ) {
+      return true;
+    }
+
     if (typeof error.code === "number" && error.code === -32001 && !isSessionError(error)) {
       return true;
     }
@@ -298,6 +308,35 @@ function isTransientToolError(error) {
     return false;
   }
 }
+
+/**
+ * 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 || ""));
+    if (!msg) {
+      return false;
+    }
+    const lower = msg.toLowerCase();
+    return (
+      lower.includes("econnrefused") ||
+      lower.includes("econnreset") ||
+      lower.includes("socket hang up") ||
+      lower.includes("fetch failed") ||
+      lower.includes("failed to fetch") ||
+      lower.includes("ehostunreach") ||
+      lower.includes("enetunreach") ||
+      lower.includes("aborted")
+    );
+  } catch {
+    return false;
+  }
+}
+
 // MCP stdio server implemented using the official MCP TypeScript SDK.
 // 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.
@@ -749,10 +788,27 @@ async function createBridgeServer(options) {
       }
       remote = await indexerClient.listTools();
     } catch (err) {
-      debugLog("[ctxce] Error calling remote tools/list: " + String(err));
-      const memoryToolsFallback = await listMemoryTools(memoryClient);
-      const toolsFallback = dedupeTools([...memoryToolsFallback]);
-      return { tools: toolsFallback };
+      // 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 {
+          await initializeRemoteClients(true);
+          if (indexerClient) {
+            remote = await indexerClient.listTools();
+          }
+        } catch (retryErr) {
+          debugLog("[ctxce] tools/list: retry after reconnect also failed: " + String(retryErr));
+        }
+      }
+
+      // 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);
+        const toolsFallback = dedupeTools([...memoryToolsFallback]);
+        return { tools: toolsFallback };
+      }
     }
 
     try {
@@ -795,6 +851,9 @@ async function createBridgeServer(options) {
       if (!Object.prototype.hasOwnProperty.call(obj, "session")) {
         obj.session = sessionId;
       }
+      if (defaultsPayload.collection && !Object.prototype.hasOwnProperty.call(obj, "collection")) {
+        obj.collection = defaultsPayload.collection;
+      }
       args = obj;
     }
 
@@ -818,6 +877,7 @@ async function createBridgeServer(options) {
     const maxAttempts = getBridgeRetryAttempts();
     const retryDelayMs = getBridgeRetryDelayMs();
     let sessionRetried = false;
+    let connectionRetried = false;
     let lastError;
 
     for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
@@ -843,6 +903,19 @@ 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: " +
+            String(err),
+          );
+          await initializeRemoteClients(true);
+          connectionRetried = true;
+          continue;
+        }
+
         if (isSessionError(err) && !sessionRetried) {
           debugLog(
             "[ctxce] tools/call: detected remote MCP session error; reinitializing clients and retrying once: " +

package/src/resultPathMapping.js

@@ -226,7 +226,6 @@ function remapRelatedPathToClient(p, workspaceRoot) {
       return path.join(root, relNative);
     }
 
-    // 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 !== "..") {
@@ -234,7 +233,13 @@ function remapRelatedPathToClient(p, workspaceRoot) {
         const joined = path.join(root, relNative);
         const relCheck = path.relative(root, joined);
         if (relCheck && !relCheck.startsWith(`..${path.sep}`) && relCheck !== "..") {
-          return joined;
+          try {
+            if (fs.existsSync(joined)) {
+              return joined;
+            }
+          } catch {
+            // ignore
+          }
         }
       }
     }
@@ -291,27 +296,37 @@ function remapHitPaths(hit, workspaceRoot) {
           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.
+        // Prefer host_path if it is an absolute path that exists on disk,
+        // regardless of whether it falls under workspaceRoot.  This handles
+        // the common case where the bridge workspace (cwd) differs from the
+        // actual repo location (e.g. workspace=/home/user but files live at
+        // /media/datadrive/project/).
         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))
+          path.isAbsolute(hpNorm) &&
+          fs.existsSync(hpNorm)
         ) {
           out.client_path = hpNorm;
           if (diagnostics) {
             out.client_path_joined = candidate;
             out.client_path_source = "host_path";
           }
-        } else {
+        } else if (fs.existsSync(candidate)) {
           out.client_path = candidate;
           if (diagnostics) {
             out.client_path_joined = candidate;
             out.client_path_source = "workspace_join";
           }
+        } else {
+          // Neither host_path nor the joined candidate exist on disk.
+          // Do NOT produce a wrong absolute path; leave client_path unset
+          // so the override logic below falls back to the relative path.
+          if (diagnostics) {
+            out.client_path_joined = candidate;
+            out.client_path_source = "fallback_relative";
+          }
         }
       }
     } catch {
@@ -448,8 +463,13 @@ export function maybeRemapToolResult(name, result, workspaceRoot) {
     const lower = String(name).toLowerCase();
     const shouldMap = (
       lower === "repo_search" ||
+      lower === "code_search" ||
       lower === "context_search" ||
       lower === "context_answer" ||
+      lower === "info_request" ||
+      lower === "symbol_graph" ||
+      lower === "pattern_search" ||
+      lower === "cross_repo_search" ||
       lower.endsWith("search_tests_for") ||
       lower.endsWith("search_config_for") ||
       lower.endsWith("search_callers_for") ||