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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@context-engine-bridge/context-engine-mcp-bridge",
-  "version": "0.0.25",
+  "version": "0.0.28",
   "description": "Context Engine MCP bridge (http/stdio proxy combining indexer + memory servers)",
   "bin": {
     "ctxce": "bin/ctxce.js",
@@ -18,6 +18,8 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.24.3",
+    "ignore": "^7.0.5",
+    "tar": "^7.5.9",
     "zod": "^3.25.0"
   },
   "devDependencies": {

package/src/connectCli.js

@@ -1,12 +1,8 @@
 import process from "node:process";
 import path from "node:path";
 import fs from "node:fs";
-import { execSync, spawn } from "node:child_process";
-import { fileURLToPath } from "node:url";
 import { saveAuthEntry } from "./authConfig.js";
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
+import { indexWorkspace } from "./uploader.js";
 
 const SAAS_ENDPOINTS = {
   uploadEndpoint: "https://dev.context-engine.ai/upload",
@@ -145,114 +141,31 @@ async function authenticateWithApiKey(apiKey) {
   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) {
+async function triggerIndexing(workspace, sessionId, authEntry) {
   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;
-  }
+  const result = await indexWorkspace(
+    workspace,
+    SAAS_ENDPOINTS.uploadEndpoint,
+    sessionId,
+    {
+      log: console.error,
+      orgId: authEntry?.org_id,
+      orgSlug: authEntry?.org_slug,
+    }
+  );
 
-  return await runUploadClient(workspace, sessionId, uploadClient, python);
+  return result.success;
 }
 
-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;
-  }
-
+function startWatcher(workspace, sessionId, authEntry, intervalMs) {
   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();
 
@@ -329,18 +242,26 @@ function startWatcher(workspace, sessionId, intervalMs) {
     console.error(`[ctxce] [${now}] Syncing changes...`);
 
     try {
-      const success = await runUploadClient(workspace, sessionId, uploadClient, python);
-      if (success) {
+      const result = await indexWorkspace(
+        workspace,
+        SAAS_ENDPOINTS.uploadEndpoint,
+        sessionId,
+        {
+          log: console.error,
+          orgId: authEntry?.org_id,
+          orgSlug: authEntry?.org_slug,
+        }
+      );
+      if (result.success) {
         console.error(`[ctxce] [${now}] Sync complete.`);
       } else {
-        console.error(`[ctxce] [${now}] Sync failed.`);
+        console.error(`[ctxce] [${now}] Sync failed: ${result.error}`);
       }
     } catch (err) {
       console.error(`[ctxce] [${now}] Sync error: ${err}`);
     }
 
     isRunning = false;
-    lastSyncTime = Date.now();
 
     if (pendingSync) {
       pendingSync = false;
@@ -428,7 +349,7 @@ export async function runConnectCommand(args) {
   }
 
   if (!skipIndex) {
-    const indexed = await triggerIndexing(resolvedWorkspace, authEntry.sessionId);
+    const indexed = await triggerIndexing(resolvedWorkspace, authEntry.sessionId, authEntry);
     if (!indexed) {
       console.error("[ctxce] Initial indexing failed, but will continue.");
     }
@@ -440,5 +361,5 @@ export async function runConnectCommand(args) {
   }
 
   printSuccess();
-  startWatcher(resolvedWorkspace, authEntry.sessionId, watchInterval);
+  startWatcher(resolvedWorkspace, authEntry.sessionId, authEntry, watchInterval);
 }

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

@@ -0,0 +1,323 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { create as tarCreate } from "tar";
+import ignore from "ignore";
+
+const CODE_EXTS = new Set([
+  ".py", ".js", ".ts", ".tsx", ".jsx", ".java", ".go", ".rs", ".rb", ".php",
+  ".c", ".h", ".cpp", ".cc", ".hpp", ".cs", ".csx", ".kt", ".swift", ".scala",
+  ".sh", ".ps1", ".psm1", ".psd1", ".pl", ".lua",
+  ".sql", ".md", ".yml", ".yaml", ".toml", ".ini", ".cfg", ".conf", ".json", ".xml",
+  ".csproj", ".config", ".resx",
+  ".html", ".htm", ".css", ".scss", ".sass", ".less", ".vue", ".svelte", ".cshtml", ".razor",
+  ".tf", ".tfvars", ".hcl", ".dockerfile",
+  ".ex", ".exs",
+  ".elm", ".dart", ".r", ".R", ".m", ".cljs", ".clj", ".hs", ".ml",
+  ".zig", ".nim", ".v", ".sv", ".vhdl", ".asm", ".s",
+]);
+
+const EXTENSIONLESS_FILES = new Set([
+  "dockerfile", "makefile", "gemfile", "rakefile", "procfile", "vagrantfile",
+  "jenkinsfile", ".gitignore", ".dockerignore", ".editorconfig",
+]);
+
+const DEFAULT_IGNORES = [
+  ".git", "node_modules", "__pycache__", ".venv", "venv", ".env",
+  "dist", "build", ".next", ".nuxt", "coverage", ".nyc_output",
+  "*.pyc", "*.pyo", "*.so", "*.dylib", "*.dll", "*.exe",
+  "*.jpg", "*.jpeg", "*.png", "*.gif", "*.ico", "*.svg", "*.webp",
+  "*.mp3", "*.mp4", "*.wav", "*.avi", "*.mov",
+  "*.zip", "*.tar", "*.gz", "*.rar", "*.7z",
+  "*.pdf", "*.doc", "*.docx", "*.xls", "*.xlsx",
+  ".DS_Store", "Thumbs.db",
+];
+
+const MAX_FILE_SIZE = 10 * 1024 * 1024;
+
+function loadGitignore(workspacePath) {
+  const ig = ignore();
+  ig.add(DEFAULT_IGNORES);
+
+  const gitignorePath = path.join(workspacePath, ".gitignore");
+  if (fs.existsSync(gitignorePath)) {
+    try {
+      const content = fs.readFileSync(gitignorePath, "utf-8");
+      ig.add(content);
+    } catch {
+    }
+  }
+
+  return ig;
+}
+
+function isCodeFile(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  if (CODE_EXTS.has(ext)) return true;
+
+  const basename = path.basename(filePath).toLowerCase();
+  if (EXTENSIONLESS_FILES.has(basename)) return true;
+  if (basename.startsWith("dockerfile")) return true;
+
+  return false;
+}
+
+function computeFileHash(filePath) {
+  const content = fs.readFileSync(filePath);
+  return createHash("sha256").update(content).digest("hex").slice(0, 16);
+}
+
+function computeLogicalRepoId(workspacePath) {
+  const normalized = workspacePath.replace(/\\/g, "/").replace(/\/+$/, "");
+  return createHash("sha256").update(normalized).digest("hex").slice(0, 12);
+}
+
+function scanWorkspace(workspacePath, ig) {
+  const files = [];
+
+  function walk(dir, relativePath = "") {
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      const relPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
+
+      if (ig.ignores(relPath) || ig.ignores(relPath + "/")) {
+        continue;
+      }
+
+      if (entry.isDirectory()) {
+        walk(fullPath, relPath);
+      } else if (entry.isFile() && isCodeFile(entry.name)) {
+        try {
+          const stat = fs.statSync(fullPath);
+          if (stat.size > 0 && stat.size < MAX_FILE_SIZE) {
+            files.push({
+              path: relPath,
+              fullPath,
+              size: stat.size,
+              mtime: stat.mtimeMs,
+            });
+          }
+        } catch {
+        }
+      }
+    }
+  }
+
+  walk(workspacePath);
+  return files;
+}
+
+export async function createBundle(workspacePath, options = {}) {
+  const { log = console.error } = options;
+
+  const ig = loadGitignore(workspacePath);
+  const files = scanWorkspace(workspacePath, ig);
+
+  if (files.length === 0) {
+    log("[uploader] No code files found in workspace");
+    return null;
+  }
+
+  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,
+    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",
+  };
+
+  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: tmpDir,
+        portable: true,
+      },
+      [bundleId]
+    );
+
+    const bundleSize = fs.statSync(bundlePath).size;
+    log(`[uploader] Created bundle: ${bundleSize} bytes`);
+
+    return {
+      bundlePath,
+      manifest,
+      tmpDir,
+      cleanup: () => {
+        try {
+          fs.rmSync(tmpDir, { recursive: true, force: true });
+        } catch {
+        }
+      },
+    };
+  } catch (err) {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+    throw err;
+  }
+}
+
+export async function uploadBundle(bundlePath, manifest, uploadEndpoint, sessionId, options = {}) {
+  const { log = console.error, orgId, orgSlug } = options;
+
+  const bundleData = fs.readFileSync(bundlePath);
+  const boundary = `----ctxce${Date.now()}${Math.random().toString(36).slice(2)}`;
+
+  const parts = [];
+
+  parts.push(
+    `--${boundary}\r\n`,
+    `Content-Disposition: form-data; name="bundle"; filename="bundle.tar.gz"\r\n`,
+    `Content-Type: application/gzip\r\n\r\n`,
+  );
+  parts.push(bundleData);
+  parts.push(`\r\n`);
+
+  const logicalRepoId = computeLogicalRepoId(manifest.workspace_path);
+  const fields = {
+    workspace_path: manifest.workspace_path,
+    collection_name: manifest.collection_name || logicalRepoId,
+    force: "true",
+    source_path: manifest.workspace_path,
+    logical_repo_id: logicalRepoId,
+    session: sessionId,
+  };
+
+  if (orgId) fields.org_id = orgId;
+  if (orgSlug) fields.org_slug = orgSlug;
+
+  for (const [key, value] of Object.entries(fields)) {
+    if (value) {
+      parts.push(
+        `--${boundary}\r\n`,
+        `Content-Disposition: form-data; name="${key}"\r\n\r\n`,
+        `${value}\r\n`,
+      );
+    }
+  }
+
+  parts.push(`--${boundary}--\r\n`);
+
+  const bodyParts = parts.map(p => typeof p === "string" ? Buffer.from(p) : p);
+  const body = Buffer.concat(bodyParts);
+
+  const url = `${uploadEndpoint}/api/v1/delta/upload`;
+  log(`[uploader] Uploading to ${url}...`);
+
+  const resp = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": `multipart/form-data; boundary=${boundary}`,
+      "Content-Length": String(body.length),
+    },
+    body,
+  });
+
+  let result;
+  try {
+    result = await resp.json();
+  } catch {
+    result = { success: false, error: { message: await resp.text() } };
+  }
+
+  if (!resp.ok || !result.success) {
+    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 };
+  }
+
+  log(`[uploader] Upload successful!`);
+  return { success: true, result };
+}
+
+export async function indexWorkspace(workspacePath, uploadEndpoint, sessionId, options = {}) {
+  const { log = console.error, orgId, orgSlug } = options;
+
+  log(`[uploader] Scanning workspace: ${workspacePath}`);
+
+  const bundle = await createBundle(workspacePath, { log });
+  if (!bundle) {
+    return { success: false, error: "No code files found" };
+  }
+
+  try {
+    const result = await uploadBundle(
+      bundle.bundlePath,
+      bundle.manifest,
+      uploadEndpoint,
+      sessionId,
+      { log, orgId, orgSlug }
+    );
+    return result;
+  } finally {
+    bundle.cleanup();
+  }
+}