@context-engine-bridge/context-engine-mcp-bridge 0.0.27 → 0.0.28

package/package.json

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

package/src/mcpServer.js

@@ -72,40 +72,6 @@ async function listMemoryTools(client) {
   }
 }
 
-function withTimeout(promise, ms, label) {
-  return new Promise((resolve, reject) => {
-    let settled = false;
-    const timer = setTimeout(() => {
-      if (settled) {
-        return;
-      }
-      settled = true;
-      const errorMessage =
-        label != null
-          ? `[ctxce] Timeout after ${ms}ms in ${label}`
-          : `[ctxce] Timeout after ${ms}ms`;
-      reject(new Error(errorMessage));
-    }, ms);
-    promise
-      .then((value) => {
-        if (settled) {
-          return;
-        }
-        settled = true;
-        clearTimeout(timer);
-        resolve(value);
-      })
-      .catch((err) => {
-        if (settled) {
-          return;
-        }
-        settled = true;
-        clearTimeout(timer);
-        reject(err);
-      });
-  });
-}
-
 function getBridgeToolTimeoutMs() {
   try {
     const raw = process.env.CTXCE_TOOL_TIMEOUT_MSEC;
@@ -705,7 +671,7 @@ async function createBridgeServer(options) {
 
     let nextIndexerClient = null;
     try {
-      const indexerTransport = new StreamableHTTPClientTransport(indexerUrl, transportOpts);
+      const indexerTransport = new StreamableHTTPClientTransport(new URL(indexerUrl), transportOpts);
       const client = new Client(
         {
           name: "ctx-context-engine-bridge-http-client",
@@ -729,7 +695,7 @@ async function createBridgeServer(options) {
     let nextMemoryClient = null;
     if (memoryUrl) {
       try {
-        const memoryTransport = new StreamableHTTPClientTransport(memoryUrl, transportOpts);
+        const memoryTransport = new StreamableHTTPClientTransport(new URL(memoryUrl), transportOpts);
         const client = new Client(
           {
             name: "ctx-context-engine-bridge-memory-client",
@@ -860,6 +826,9 @@ async function createBridgeServer(options) {
     args = maybeRemapToolArgs(name, args, workspace);
 
     if (name === "set_session_defaults") {
+      if (!indexerClient) {
+        throw new Error("Indexer client not connected");
+      }
       const indexerResult = await indexerClient.callTool({ name, arguments: args });
       if (memoryClient) {
         try {

package/src/uploader.js

@@ -129,33 +129,76 @@ export async function createBundle(workspacePath, options = {}) {
   log(`[uploader] Found ${files.length} code files`);
 
   const bundleId = createHash("sha256").update(Date.now().toString() + Math.random().toString()).digest("hex").slice(0, 16);
+  const createdAt = new Date().toISOString();
+
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "ctxce-"));
+  const bundleDir = path.join(tmpDir, bundleId);
+  const metadataDir = path.join(bundleDir, ".metadata");
+  const filesDir = path.join(bundleDir, "files");
+
+  fs.mkdirSync(metadataDir, { recursive: true });
+  fs.mkdirSync(filesDir, { recursive: true });
+
+  const operations = [];
+  const fileHashes = {};
+  let totalSize = 0;
+
+  for (const file of files) {
+    const destPath = path.join(filesDir, file.path);
+    fs.mkdirSync(path.dirname(destPath), { recursive: true });
+    fs.copyFileSync(file.fullPath, destPath);
+
+    const hash = computeFileHash(file.fullPath);
+    fileHashes[file.path] = hash;
+    totalSize += file.size;
+
+    operations.push({
+      op: "upsert",
+      path: file.path,
+      size: file.size,
+      hash,
+    });
+  }
 
   const manifest = {
+    version: "1.0",
     bundle_id: bundleId,
     workspace_path: workspacePath,
-    logical_repo_id: computeLogicalRepoId(workspacePath),
-    sequence_number: Date.now(),
-    file_count: files.length,
-    files: files.map(f => ({
-      path: f.path,
-      size: f.size,
-      hash: computeFileHash(f.fullPath),
-    })),
-    created_at: new Date().toISOString(),
+    collection_name: computeLogicalRepoId(workspacePath),
+    created_at: createdAt,
+    sequence_number: null,
+    parent_sequence: null,
+    operations: {
+      created: files.length,
+      updated: 0,
+      deleted: 0,
+      moved: 0,
+    },
+    total_files: files.length,
+    total_size_bytes: totalSize,
+    compression: "gzip",
+    encoding: "utf-8",
   };
 
-  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "ctxce-"));
-  const bundlePath = path.join(tmpDir, `bundle-${bundleId}.tar.gz`);
+  fs.writeFileSync(path.join(bundleDir, "manifest.json"), JSON.stringify(manifest, null, 2));
+  fs.writeFileSync(path.join(metadataDir, "operations.json"), JSON.stringify({ operations }, null, 2));
+  fs.writeFileSync(path.join(metadataDir, "hashes.json"), JSON.stringify({
+    workspace_path: workspacePath,
+    updated_at: createdAt,
+    file_hashes: fileHashes,
+  }, null, 2));
+
+  const bundlePath = path.join(tmpDir, `${bundleId}.tar.gz`);
 
   try {
     await tarCreate(
       {
         gzip: true,
         file: bundlePath,
-        cwd: workspacePath,
+        cwd: tmpDir,
         portable: true,
       },
-      files.map(f => f.path)
+      [bundleId]
     );
 
     const bundleSize = fs.statSync(bundlePath).size;
@@ -194,13 +237,13 @@ export async function uploadBundle(bundlePath, manifest, uploadEndpoint, session
   parts.push(bundleData);
   parts.push(`\r\n`);
 
+  const logicalRepoId = computeLogicalRepoId(manifest.workspace_path);
   const fields = {
     workspace_path: manifest.workspace_path,
-    collection_name: manifest.logical_repo_id,
-    sequence_number: String(manifest.sequence_number),
+    collection_name: manifest.collection_name || logicalRepoId,
     force: "true",
     source_path: manifest.workspace_path,
-    logical_repo_id: manifest.logical_repo_id,
+    logical_repo_id: logicalRepoId,
     session: sessionId,
   };
 
@@ -242,7 +285,11 @@ export async function uploadBundle(bundlePath, manifest, uploadEndpoint, session
   }
 
   if (!resp.ok || !result.success) {
-    const errorMsg = result.error?.message || result.detail || `HTTP ${resp.status}`;
+    let errorMsg = result.error?.message || result.detail || result.error;
+    if (typeof errorMsg === "object") {
+      errorMsg = JSON.stringify(errorMsg);
+    }
+    errorMsg = errorMsg || `HTTP ${resp.status}`;
     log(`[uploader] Upload failed: ${errorMsg}`);
     return { success: false, error: errorMsg };
   }