@context-engine-bridge/context-engine-mcp-bridge 0.0.82 → 0.0.84

package/package.json

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

package/src/authConfig.js

@@ -152,3 +152,26 @@ export function saveResolvedCollection(backendUrl, scope, collection) {
   };
   writeConfig(all);
 }
+
+export function clearResolvedCollection(backendUrl, scope) {
+  if (!backendUrl) {
+    return;
+  }
+  const scopeKey = buildResolvedCollectionScopeKey(scope);
+  if (!scopeKey) {
+    return;
+  }
+  const all = readConfig();
+  const key = String(backendUrl);
+  const existingEntry = all[key] && typeof all[key] === "object" ? all[key] : {};
+  const resolvedCollections = { ...getResolvedCollections(existingEntry) };
+  if (!Object.prototype.hasOwnProperty.call(resolvedCollections, scopeKey)) {
+    return;
+  }
+  delete resolvedCollections[scopeKey];
+  all[key] = {
+    ...existingEntry,
+    [RESOLVED_COLLECTIONS_KEY]: resolvedCollections,
+  };
+  writeConfig(all);
+}

package/src/mcpServer.js

@@ -12,6 +12,7 @@ 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 {
+  clearResolvedCollection,
   loadAnyAuthEntry,
   loadAuthEntry,
   loadResolvedCollection,
@@ -522,6 +523,70 @@ function isConnectionDeadError(error) {
   }
 }
 
+/**
+ * Detect a strong signal that the active collection has been deleted on the server.
+ * Only triggers on unambiguous signals to avoid false positives on transient errors.
+ *
+ * Signals recognized:
+ *   - HTTP 404 error whose message contains a collection-related keyword
+ *   - Error code "COLLECTION_DELETED"
+ *   - Error message containing "collection_deleted", "collection not found",
+ *     "collection doesn't exist", or "collection does not exist"
+ */
+function isCollectionDeletedSignal(error) {
+  try {
+    if (!error) return false;
+    // Explicit error code
+    if (
+      typeof error.code === "string" &&
+      error.code.toUpperCase() === "COLLECTION_DELETED"
+    ) {
+      return true;
+    }
+    const msg = _errorMessage(error);
+    if (!msg) return false;
+    const lower = msg.toLowerCase();
+    // 404 with a collection-related keyword is a strong signal
+    if (
+      (lower.includes("404") || lower.includes("not found")) &&
+      lower.includes("collection")
+    ) {
+      return true;
+    }
+    // Explicit deletion phrases
+    if (
+      lower.includes("collection_deleted") ||
+      lower.includes("collection not found") ||
+      lower.includes("collection doesn't exist") ||
+      lower.includes("collection does not exist")
+    ) {
+      return true;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Inspect a successful tool call result for an explicit collection_deleted flag.
+ * Returns true only when the response payload contains `collection_deleted: true`.
+ */
+function resultIndicatesCollectionDeleted(result) {
+  try {
+    if (!result || !Array.isArray(result.content)) return false;
+    const textBlock = result.content.find((c) => c && c.type === "text");
+    if (!textBlock || typeof textBlock.text !== "string") return false;
+    const parsed = JSON.parse(textBlock.text);
+    if (parsed && parsed.collection_deleted === true) return true;
+    // Also check nested result envelope
+    if (parsed && parsed.result && parsed.result.collection_deleted === true) return true;
+    return false;
+  } 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.
@@ -647,6 +712,12 @@ async function fetchBridgeCollectionState({
         );
         return null;
       }
+      if (resp.status === 404) {
+        // Server is reachable but has no workspace state — do NOT fall back to local caches.
+        // This can happen when workspace state was cleaned up during collection deletion.
+        debugLog("[ctxce] /bridge/state responded 404; server has no state for this workspace");
+        return { _server_reachable: true };
+      }
       throw new Error(`bridge/state responded ${resp.status}`);
     }
     debugLog(`[ctxce] bridge/state responded ${resp.status}`);
@@ -711,26 +782,11 @@ export async function buildDefaultsPayload({
     logicalRepoId = "";
   }
 
-  const exactWorkspaceCollection = !pinnedCollection
-    ? _readExactWorkspaceCachedCollection(workspace)
-    : null;
-
-  if (!defaultsPayload.collection && exactWorkspaceCollection) {
-    defaultsPayload.collection = exactWorkspaceCollection;
-    log(`[ctxce] Using exact workspace cached collection: ${exactWorkspaceCollection}`);
-  }
-
-  if (!defaultsPayload.collection && backendHint && logicalRepoId) {
-    const cachedCollection = loadResolvedCollectionHint(backendHint, {
-      orgId: resolvedAuthEntry?.org_id,
-      orgSlug: resolvedAuthEntry?.org_slug,
-      logicalRepoId,
-    });
-    if (cachedCollection) {
-      defaultsPayload.collection = cachedCollection;
-      log(`[ctxce] Using cached resolved collection from auth store: ${cachedCollection}`);
-    }
-  }
+  // --- Server-first collection resolution ---
+  // Priority: pinned > server /bridge/state > local caches (fallback only).
+  // This prevents stale local caches from winning over server truth
+  // after a collection is deleted.
+  let serverResolved = false;
 
   if (!pinnedCollection) {
     try {
@@ -745,31 +801,87 @@ export async function buildDefaultsPayload({
         uploadServiceUrl,
       });
       if (state) {
-        const servingCollection = typeof state.serving_collection === "string"
-          ? state.serving_collection.trim()
-          : "";
-        const activeCollection = typeof state.active_collection === "string"
-          ? state.active_collection.trim()
-          : "";
-        if (servingCollection) {
-          defaultsPayload.collection = servingCollection;
-          if (!configuredCollection || configuredCollection !== servingCollection) {
-            log(`[ctxce] Using serving collection from /bridge/state: ${servingCollection}`);
+        // Server responded 404 — reachable but no workspace state.
+        // Mark serverResolved to prevent falling back to stale local caches.
+        if (state._server_reachable && !state.collection_deleted && !state.serving_collection && !state.active_collection) {
+          serverResolved = true;
+          log("[ctxce] Server reachable but no workspace state found, skipping local cache fallback");
+        }
+        // Handle explicit collection_deleted signal from the server
+        if (state.collection_deleted === true) {
+          log("[ctxce] Server reports collection deleted, clearing all local caches");
+          defaultsPayload.collection = "";
+          serverResolved = true;
+          try {
+            _clearExactWorkspaceCachedCollection(workspace);
+          } catch (wsErr) {
+            log("[ctxce] Failed to clear workspace ctx_config.json default_collection: " + String(wsErr));
+          }
+          // Clear the auth.json resolved collection cache
+          try {
+            if (backendHint && logicalRepoId) {
+              clearResolvedCollection(backendHint, {
+                orgId: resolvedAuthEntry?.org_id,
+                orgSlug: resolvedAuthEntry?.org_slug,
+                logicalRepoId,
+              });
+            }
+          } catch (authErr) {
+            log("[ctxce] Failed to clear auth.json resolved collection: " + String(authErr));
           }
-          if (backendHint && logicalRepoId) {
-            saveResolvedCollectionHint(backendHint, {
-              orgId: resolvedAuthEntry?.org_id,
-              orgSlug: resolvedAuthEntry?.org_slug,
-              logicalRepoId,
-            }, servingCollection);
+        } else {
+          const servingCollection = typeof state.serving_collection === "string"
+            ? state.serving_collection.trim()
+            : "";
+          const activeCollection = typeof state.active_collection === "string"
+            ? state.active_collection.trim()
+            : "";
+          if (servingCollection) {
+            defaultsPayload.collection = servingCollection;
+            serverResolved = true;
+            if (!configuredCollection || configuredCollection !== servingCollection) {
+              log(`[ctxce] Using serving collection from /bridge/state: ${servingCollection}`);
+            }
+            // Update local caches to match server truth
+            if (backendHint && logicalRepoId) {
+              saveResolvedCollectionHint(backendHint, {
+                orgId: resolvedAuthEntry?.org_id,
+                orgSlug: resolvedAuthEntry?.org_slug,
+                logicalRepoId,
+              }, servingCollection);
+            }
+            _writeExactWorkspaceCachedCollection(workspace, servingCollection);
+          } else if (activeCollection) {
+            defaultsPayload.collection = activeCollection;
+            serverResolved = true;
+            log(`[ctxce] Using active collection from /bridge/state: ${activeCollection}`);
           }
-        } else if (!defaultsPayload.collection && activeCollection) {
-          defaultsPayload.collection = activeCollection;
-          log(`[ctxce] Using active collection from /bridge/state fallback: ${activeCollection}`);
         }
       }
     } catch (err) {
-      log("[ctxce] bridge/state lookup failed: " + String(err));
+      log("[ctxce] bridge/state lookup failed, falling back to local caches: " + String(err));
+    }
+  }
+
+  // Fallback to local caches ONLY when server is unreachable
+  if (!serverResolved && !pinnedCollection) {
+    const exactWorkspaceCollection = _readExactWorkspaceCachedCollection(workspace);
+
+    if (!defaultsPayload.collection && exactWorkspaceCollection) {
+      defaultsPayload.collection = exactWorkspaceCollection;
+      log(`[ctxce] WARNING: Using cached collection ${exactWorkspaceCollection} (server unavailable — may be stale)`);
+    }
+
+    if (!defaultsPayload.collection && backendHint && logicalRepoId) {
+      const cachedCollection = loadResolvedCollectionHint(backendHint, {
+        orgId: resolvedAuthEntry?.org_id,
+        orgSlug: resolvedAuthEntry?.org_slug,
+        logicalRepoId,
+      });
+      if (cachedCollection) {
+        defaultsPayload.collection = cachedCollection;
+        log(`[ctxce] WARNING: Using cached collection ${cachedCollection} from auth store (server unavailable — may be stale)`);
+      }
     }
   }
 
@@ -832,6 +944,74 @@ function _readExactWorkspaceCachedCollection(workspacePath) {
   }
 }
 
+function _writeExactWorkspaceCachedCollection(workspacePath, collection) {
+  try {
+    const resolvedWorkspace = _validateWorkspacePath(workspacePath);
+    if (!resolvedWorkspace) return;
+    const wsDir = _computeWorkspaceDir(resolvedWorkspace);
+    const configPath = path.join(wsDir, "ctx_config.json");
+    if (!fs.existsSync(configPath)) return;
+    const existing = JSON.parse(fs.readFileSync(configPath, "utf8"));
+    if (existing && typeof existing === "object") {
+      existing.default_collection = collection;
+      fs.writeFileSync(configPath, JSON.stringify(existing, null, 2), "utf8");
+    }
+  } catch (_) {}
+}
+
+function _clearExactWorkspaceCachedCollection(workspacePath) {
+  try {
+    const resolvedWorkspace = _validateWorkspacePath(workspacePath);
+    if (!resolvedWorkspace) return;
+    const wsDir = _computeWorkspaceDir(resolvedWorkspace);
+    // Clear default_collection from ctx_config.json
+    const configPath = path.join(wsDir, "ctx_config.json");
+    if (fs.existsSync(configPath)) {
+      try {
+        const existing = JSON.parse(fs.readFileSync(configPath, "utf8"));
+        if (existing && existing.default_collection) {
+          existing.default_collection = "";
+          fs.writeFileSync(configPath, JSON.stringify(existing, null, 2), "utf8");
+        }
+      } catch (_) {}
+    }
+    // Clear session_collections.json (may reference the deleted collection)
+    const sessionCollPath = path.join(wsDir, "session_collections.json");
+    try {
+      if (fs.existsSync(sessionCollPath)) {
+        fs.unlinkSync(sessionCollPath);
+        debugLog("[ctxce] Cleared session_collections.json after collection deletion");
+      }
+    } catch (_) {}
+    // Clear workspace hints (PID-keyed hint files in ~/.ctxce/workspace-hints/)
+    try {
+      const hintsDir = path.join(os.homedir(), ".ctxce", "workspace-hints");
+      if (fs.existsSync(hintsDir)) {
+        // Clear hint for current process tree (ppid is the VS Code process)
+        const currentPpid = process.ppid;
+        if (currentPpid && currentPpid > 1) {
+          const currentHint = path.join(hintsDir, `${currentPpid}.json`);
+          try {
+            if (fs.existsSync(currentHint)) {
+              fs.unlinkSync(currentHint);
+              debugLog(`[ctxce] Cleared workspace hint for current VS Code process (PID ${currentPpid})`);
+            }
+          } catch (_) {}
+        }
+        // Also clean up stale hints for dead PIDs
+        for (const name of fs.readdirSync(hintsDir)) {
+          if (!name.endsWith(".json")) continue;
+          const pid = parseInt(name.replace(".json", ""), 10);
+          if (!pid || pid <= 1) continue;
+          try { process.kill(pid, 0); } catch (_) {
+            try { fs.unlinkSync(path.join(hintsDir, name)); } catch (_) {}
+          }
+        }
+      }
+    } catch (_) {}
+  } catch (_) {}
+}
+
 const MAX_WS_SCAN = 50;
 
 function _resolveWorkspace(providedWorkspace) {
@@ -1523,10 +1703,123 @@ async function createBridgeServer(options) {
             }
           } catch (e) { debugLog("[ctxce] LSP not_available inject failed: " + String(e)); }
         }
+        // Detect explicit collection_deleted flag in a successful response
+        if (resultIndicatesCollectionDeleted(result)) {
+          debugLog("[ctxce] Collection appears deleted, clearing cache and re-resolving");
+          defaultsPayload.collection = "";
+          try {
+            _clearExactWorkspaceCachedCollection(workspace);
+          } catch (wsErr) {
+            debugLog("[ctxce] Failed to clear workspace collection cache: " + String(wsErr));
+          }
+          try {
+            if (backendHint) {
+              const authEntry = loadAuthEntry(backendHint);
+              let repoId = "";
+              try { repoId = computeLogicalRepoIdentity(workspace)?.id || ""; } catch { repoId = ""; }
+              clearResolvedCollection(backendHint, {
+                orgId: authEntry?.org_id,
+                orgSlug: authEntry?.org_slug,
+                logicalRepoId: repoId,
+              });
+            }
+          } catch (clearErr) {
+            debugLog("[ctxce] Failed to clear resolved collection cache: " + String(clearErr));
+          }
+          // Best-effort re-resolve via /bridge/state
+          try {
+            const freshPayload = await buildDefaultsPayload({
+              workspace,
+              sessionId,
+              explicitCollection: "",
+              defaultCollection: "",
+              defaultMode,
+              defaultUnder,
+              config,
+              backendHint,
+              uploadServiceUrl,
+            });
+            if (freshPayload.collection) {
+              defaultsPayload.collection = freshPayload.collection;
+              debugLog("[ctxce] Re-resolved collection after deletion: " + freshPayload.collection);
+            }
+          } catch (reResolveErr) {
+            debugLog("[ctxce] Failed to re-resolve collection after deletion: " + String(reResolveErr));
+          }
+          // Re-send session defaults so remote MCP servers stop using the stale collection
+          try {
+            if (indexerClient) {
+              await sendSessionDefaults(indexerClient, defaultsPayload, "indexer");
+            }
+            if (memoryClient) {
+              await sendSessionDefaults(memoryClient, defaultsPayload, "memory");
+            }
+            debugLog("[ctxce] Re-sent session defaults after collection deletion detection");
+          } catch (sdErr) {
+            debugLog("[ctxce] Failed to re-send session defaults after deletion: " + String(sdErr));
+          }
+        }
+
         return maybeRemapToolResult(name, result, workspace);
       } catch (err) {
         lastError = err;
 
+        // Detect collection deletion from error signals
+        if (isCollectionDeletedSignal(err)) {
+          debugLog("[ctxce] Collection appears deleted, clearing cache and re-resolving");
+          defaultsPayload.collection = "";
+          try {
+            _clearExactWorkspaceCachedCollection(workspace);
+          } catch (wsErr) {
+            debugLog("[ctxce] Failed to clear workspace collection cache: " + String(wsErr));
+          }
+          try {
+            if (backendHint) {
+              const authEntry = loadAuthEntry(backendHint);
+              let repoId = "";
+              try { repoId = computeLogicalRepoIdentity(workspace)?.id || ""; } catch { repoId = ""; }
+              clearResolvedCollection(backendHint, {
+                orgId: authEntry?.org_id,
+                orgSlug: authEntry?.org_slug,
+                logicalRepoId: repoId,
+              });
+            }
+          } catch (clearErr) {
+            debugLog("[ctxce] Failed to clear resolved collection cache: " + String(clearErr));
+          }
+          // Best-effort re-resolve via /bridge/state (fire-and-forget)
+          buildDefaultsPayload({
+            workspace,
+            sessionId,
+            explicitCollection: "",
+            defaultCollection: "",
+            defaultMode,
+            defaultUnder,
+            config,
+            backendHint,
+            uploadServiceUrl,
+          }).then(async (freshPayload) => {
+            if (freshPayload.collection) {
+              defaultsPayload.collection = freshPayload.collection;
+              debugLog("[ctxce] Re-resolved collection after deletion: " + freshPayload.collection);
+            }
+            // Re-send session defaults so remote MCP servers stop using the stale collection
+            try {
+              if (indexerClient) {
+                await sendSessionDefaults(indexerClient, defaultsPayload, "indexer");
+              }
+              if (memoryClient) {
+                await sendSessionDefaults(memoryClient, defaultsPayload, "memory");
+              }
+              debugLog("[ctxce] Re-sent session defaults after collection deletion detection (error path)");
+            } catch (sdErr) {
+              debugLog("[ctxce] Failed to re-send session defaults after deletion: " + String(sdErr));
+            }
+          }).catch((reResolveErr) => {
+            debugLog("[ctxce] Failed to re-resolve collection after deletion: " + String(reResolveErr));
+          });
+        }
+
         if (isConnectionDeadError(err) && !connectionRetried) {
           debugLog(
             "[ctxce] tools/call: connection dead (server may have restarted); recreating clients and retrying: " +