@context-engine-bridge/context-engine-mcp-bridge 0.0.79 → 0.0.83

package/package.json

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

package/src/uploader.js

@@ -37,6 +37,7 @@ const DEFAULT_IGNORES = [
 ];
 
 const MAX_FILE_SIZE = 10 * 1024 * 1024;
+const ADMIN_SESSION_COOKIE_NAME = "ctxce_session";
 
 function sanitizeRepoName(repoName) {
   return String(repoName || "")
@@ -61,6 +62,116 @@ function getCollectionName(repoName) {
   return `${sanitized}-${hash}`;
 }
 
+function normalizeBackendUrl(raw) {
+  const value = String(raw || "").trim();
+  if (!value) return "";
+  try {
+    const parsed = new URL(value);
+    return `${parsed.protocol}//${parsed.host}`;
+  } catch {
+    return value.replace(/\/+$/, "");
+  }
+}
+
+function buildBridgeStateHeaders(sessionId) {
+  const headers = {
+    Accept: "application/json",
+  };
+  if (sessionId) {
+    headers.Authorization = `Bearer ${sessionId}`;
+    headers["X-Session-Id"] = sessionId;
+    headers.Cookie = `${ADMIN_SESSION_COOKIE_NAME}=${sessionId}`;
+  }
+  return headers;
+}
+
+async function fetchBridgeCollectionState({
+  workspacePath,
+  uploadEndpoint,
+  sessionId,
+  repoName,
+  logicalRepoId,
+  log = console.error,
+}) {
+  const backendUrl = normalizeBackendUrl(uploadEndpoint);
+  if (!backendUrl) {
+    return { kind: "skipped" };
+  }
+
+  try {
+    const url = new URL("/bridge/state", backendUrl);
+    if (workspacePath) {
+      url.searchParams.set("workspace", workspacePath);
+    }
+    if (repoName) {
+      url.searchParams.set("repo_name", repoName);
+    }
+    if (logicalRepoId) {
+      url.searchParams.set("logical_repo_id", logicalRepoId);
+    }
+
+    const resp = await fetch(url, {
+      method: "GET",
+      headers: buildBridgeStateHeaders(sessionId),
+    });
+    if (resp.status === 404) {
+      return { kind: "missing" };
+    }
+    if (resp.status === 401 || resp.status === 403) {
+      return { kind: "unavailable" };
+    }
+    if (!resp.ok) {
+      log(`[uploader] bridge/state lookup failed: HTTP ${resp.status}`);
+      return { kind: "unavailable" };
+    }
+
+    const data = await resp.json();
+    return {
+      kind: "ok",
+      state: data && typeof data === "object" ? data : null,
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    log(`[uploader] bridge/state lookup failed: ${message}`);
+    return { kind: "unavailable" };
+  }
+}
+
+async function resolveRepoScopedCollection(workspacePath, uploadEndpoint, sessionId, options = {}) {
+  const { log = console.error } = options;
+  const repoName = extractRepoNameFromPath(workspacePath);
+  const logicalRepoIdentity = computeLogicalRepoIdentity(workspacePath);
+
+  const stateResult = await fetchBridgeCollectionState({
+    workspacePath,
+    uploadEndpoint,
+    sessionId,
+    repoName,
+    logicalRepoId: logicalRepoIdentity.id,
+    log,
+  });
+
+  if (stateResult.kind !== "ok") {
+    return null;
+  }
+
+  const state = stateResult.state || {};
+  const servingCollection = typeof state.serving_collection === "string"
+    ? state.serving_collection.trim()
+    : "";
+  const activeCollection = typeof state.active_collection === "string"
+    ? state.active_collection.trim()
+    : "";
+  const resolvedCollection = servingCollection || activeCollection;
+
+  if (resolvedCollection) {
+    log(`[uploader] Resuming repo-scoped collection ${resolvedCollection} for ${logicalRepoIdentity.id}`);
+    return resolvedCollection;
+  }
+
+  return null;
+}
+
 export function findGitRoot(startPath) {
   let current = path.resolve(startPath);
   while (current !== path.dirname(current)) {
@@ -451,7 +562,13 @@ function scanWorkspace(workspacePath, ig) {
 }
 
 export async function createBundle(workspacePath, options = {}) {
-  const { log = console.error, gitHistory = null, gitState = null, allowEmpty = false } = options;
+  const {
+    log = console.error,
+    gitHistory = null,
+    gitState = null,
+    allowEmpty = false,
+    collectionName = null,
+  } = options;
 
   const ig = loadGitignore(workspacePath);
   const files = scanWorkspace(workspacePath, ig);
@@ -508,7 +625,7 @@ export async function createBundle(workspacePath, options = {}) {
     version: "1.0",
     bundle_id: bundleId,
     workspace_path: workspacePath,
-    collection_name: getCollectionName(repoName),
+    collection_name: collectionName || getCollectionName(repoName),
     created_at: createdAt,
     sequence_number: null,
     parent_sequence: null,
@@ -583,6 +700,12 @@ export async function uploadGitHistoryOnly(workspacePath, uploadEndpoint, sessio
   const { log = console.error, orgId, orgSlug, quietNoop = false } = options;
 
   try {
+    const resolvedCollection = await resolveRepoScopedCollection(
+      workspacePath,
+      uploadEndpoint,
+      sessionId,
+      { log, orgId, orgSlug }
+    );
     const gitHistory = collectGitHistory(workspacePath);
     if (!gitHistory) {
       if (!quietNoop) {
@@ -597,6 +720,7 @@ export async function uploadGitHistoryOnly(workspacePath, uploadEndpoint, sessio
       gitHistory,
       gitState,
       allowEmpty: true,
+      collectionName: resolvedCollection,
     });
     if (!bundle) {
       return { success: false, error: "failed_to_create_history_bundle" };
@@ -740,7 +864,16 @@ async function _indexWorkspaceInner(workspacePath, uploadEndpoint, sessionId, op
     });
   }
 
-  const bundle = await createBundle(workspacePath, { log });
+  const resolvedCollection = await resolveRepoScopedCollection(
+    workspacePath,
+    uploadEndpoint,
+    sessionId,
+    { log, orgId, orgSlug }
+  );
+  const bundle = await createBundle(workspacePath, {
+    log,
+    collectionName: resolvedCollection,
+  });
   if (!bundle) {
     return await uploadGitHistoryOnly(workspacePath, uploadEndpoint, sessionId, {
       log,