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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@context-engine-bridge/context-engine-mcp-bridge",
-  "version": "0.0.24",
+  "version": "0.0.27",
   "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,8 +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 { saveAuthEntry } from "./authConfig.js";
+import { indexWorkspace } from "./uploader.js";
 
 const SAAS_ENDPOINTS = {
   uploadEndpoint: "https://dev.context-engine.ai/upload",
@@ -141,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();
 
@@ -325,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;
@@ -424,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.");
     }
@@ -436,5 +361,5 @@ export async function runConnectCommand(args) {
   }
 
   printSuccess();
-  startWatcher(resolvedWorkspace, authEntry.sessionId, watchInterval);
+  startWatcher(resolvedWorkspace, authEntry.sessionId, authEntry, watchInterval);
 }

package/src/uploader.js

@@ -0,0 +1,276 @@
+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 manifest = {
+    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(),
+  };
+
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "ctxce-"));
+  const bundlePath = path.join(tmpDir, `bundle-${bundleId}.tar.gz`);
+
+  try {
+    await tarCreate(
+      {
+        gzip: true,
+        file: bundlePath,
+        cwd: workspacePath,
+        portable: true,
+      },
+      files.map(f => f.path)
+    );
+
+    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 fields = {
+    workspace_path: manifest.workspace_path,
+    collection_name: manifest.logical_repo_id,
+    sequence_number: String(manifest.sequence_number),
+    force: "true",
+    source_path: manifest.workspace_path,
+    logical_repo_id: manifest.logical_repo_id,
+    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) {
+    const errorMsg = result.error?.message || result.detail || `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();
+  }
+}