@context-engine-bridge/context-engine-mcp-bridge 0.0.73 → 0.0.74

package/.claude/settings.local.json

@@ -0,0 +1,11 @@
+{
+  "enableAllProjectMcpServers": true,
+  "enabledMcpjsonServers": [
+    "context-engine"
+  ],
+  "permissions": {
+    "allow": [
+      "mcp__context-engine__repo_search"
+    ]
+  }
+}

package/package.json

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

package/src/authCli.js

@@ -1,6 +1,11 @@
 import process from "node:process";
 import { loadAuthEntry, saveAuthEntry, deleteAuthEntry, loadAnyAuthEntry } from "./authConfig.js";
 
+const SAAS_ENDPOINTS = {
+  uploadEndpoint: "https://dev.context-engine.ai/upload",
+  authBackendUrl: "https://dev.context-engine.ai",
+};
+
 function parseAuthArgs(args) {
   let backendUrl = process.env.CTXCE_AUTH_BACKEND_URL || "";
   let token = process.env.CTXCE_AUTH_TOKEN || "";
@@ -49,8 +54,12 @@ function getBackendUrl(backendUrl) {
 }
 
 function getDefaultUploadBackend() {
-  // Default to upload service when nothing else is configured
-  return (process.env.CTXCE_UPLOAD_ENDPOINT || process.env.UPLOAD_ENDPOINT || "http://localhost:8004").trim();
+  return (
+    process.env.CTXCE_AUTH_BACKEND_URL
+    || process.env.CTXCE_UPLOAD_ENDPOINT
+    || process.env.UPLOAD_ENDPOINT
+    || SAAS_ENDPOINTS.authBackendUrl
+  ).trim();
 }
 
 function requireBackendUrl(backendUrl) {

package/src/cli.js

@@ -7,6 +7,11 @@ import { runMcpServer, runHttpMcpServer } from "./mcpServer.js";
 import { runAuthCommand } from "./authCli.js";
 import { runConnectCommand } from "./connectCli.js";
 
+const SAAS_ENDPOINTS = {
+  mcpIndexerUrl: "https://dev.context-engine.ai/indexer/mcp",
+  mcpMemoryUrl: "https://dev.context-engine.ai/memory/mcp",
+};
+
 export async function runCli() {
   const argv = process.argv.slice(2);
   const cmd = argv[0];
@@ -27,8 +32,8 @@ export async function runCli() {
   if (cmd === "mcp-http-serve") {
     const args = argv.slice(1);
     let workspace = process.cwd();
-    let indexerUrl = process.env.CTXCE_INDEXER_URL || "http://localhost:8003/mcp";
-    let memoryUrl = process.env.CTXCE_MEMORY_URL || null;
+    let indexerUrl = process.env.CTXCE_INDEXER_URL || SAAS_ENDPOINTS.mcpIndexerUrl;
+    let memoryUrl = process.env.CTXCE_MEMORY_URL || SAAS_ENDPOINTS.mcpMemoryUrl;
     let port = Number.parseInt(process.env.CTXCE_HTTP_PORT || "30810", 10) || 30810;
     let collection = null;
 
@@ -86,12 +91,12 @@ export async function runCli() {
     // Minimal flag parsing for PoC: allow passing workspace/root and indexer URL.
     // Supported flags:
     //   --workspace / --path   : workspace root (default: cwd)
-    //   --indexer-url          : override MCP indexer URL (default env CTXCE_INDEXER_URL or http://localhost:8003/mcp)
+    //   --indexer-url          : override MCP indexer URL (default env CTXCE_INDEXER_URL or SaaS endpoint)
     //   --collection           : collection name to use for MCP calls
     const args = argv.slice(1);
     let workspace = process.cwd();
-    let indexerUrl = process.env.CTXCE_INDEXER_URL || "http://localhost:8003/mcp";
-    let memoryUrl = process.env.CTXCE_MEMORY_URL || null;
+    let indexerUrl = process.env.CTXCE_INDEXER_URL || SAAS_ENDPOINTS.mcpIndexerUrl;
+    let memoryUrl = process.env.CTXCE_MEMORY_URL || SAAS_ENDPOINTS.mcpMemoryUrl;
     let collection = null;
 
     for (let i = 0; i < args.length; i += 1) {

package/src/oauthHandler.js

@@ -198,7 +198,7 @@ export function getLoginPage(redirectUri, clientId, state, codeChallenge, codeCh
   <form id="loginForm">
     <div class="form-group">
       <label>Backend URL</label>
-      <input type="url" id="backendUrl" placeholder="http://localhost:8004" required>
+      <input type="url" id="backendUrl" placeholder="https://dev.context-engine.ai" required>
     </div>
     <div class="form-group">
       <label>Username (optional)</label>

package/src/uploader.js

@@ -2,6 +2,7 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { createHash } from "node:crypto";
+import { execFileSync } from "node:child_process";
 import { create as tarCreate } from "tar";
 import ignore from "ignore";
 
@@ -36,6 +37,29 @@ const DEFAULT_IGNORES = [
 
 const MAX_FILE_SIZE = 10 * 1024 * 1024;
 
+function sanitizeRepoName(repoName) {
+  return String(repoName || "")
+    .toLowerCase()
+    .trim()
+    .replace(/[^a-z0-9_.-]+/g, "-")
+    .replace(/-+/g, "-")
+    .replace(/^-|-$/g, "") || "workspace";
+}
+
+function extractRepoNameFromPath(workspacePath) {
+  try {
+    return path.basename(path.resolve(workspacePath));
+  } catch {
+    return "workspace";
+  }
+}
+
+function getCollectionName(repoName) {
+  const sanitized = sanitizeRepoName(repoName);
+  const hash = createHash("sha256").update(String(repoName || "")).digest("hex").slice(0, 8);
+  return `${sanitized}-${hash}`;
+}
+
 export function loadGitignore(workspacePath) {
   const ig = ignore();
   ig.add(DEFAULT_IGNORES);
@@ -68,9 +92,73 @@ function computeFileHash(filePath) {
   return createHash("sha256").update(content).digest("hex").slice(0, 16);
 }
 
+function normalizeGitRemoteUrl(rawRemote) {
+  const value = String(rawRemote || "").trim();
+  if (!value) return "";
+
+  if (!value.includes("://")) {
+    const match = value.match(/^(?:([^@/\s]+)@)?([^:/\s]+):(.+)$/);
+    if (match) {
+      const host = String(match[2] || "").trim().toLowerCase();
+      let repoPath = String(match[3] || "").trim().replace(/^\/+|\/+$/g, "");
+      repoPath = repoPath.replace(/\.git$/i, "");
+      if (host && repoPath) return `${host}/${repoPath}`;
+    }
+  }
+
+  try {
+    const parsed = new URL(value);
+    const host = String(parsed.hostname || "").trim().toLowerCase();
+    let repoPath = String(parsed.pathname || "").trim().replace(/^\/+|\/+$/g, "");
+    repoPath = repoPath.replace(/\.git$/i, "");
+    const port = parsed.port ? `:${parsed.port}` : "";
+    if (host && repoPath) return `${host}${port}/${repoPath}`;
+  } catch {
+  }
+
+  return "";
+}
+
+export function computeLogicalRepoIdentity(workspacePath) {
+  const resolved = path.resolve(workspacePath);
+
+  try {
+    const remote = execFileSync("git", ["config", "--get", "remote.origin.url"], {
+      cwd: resolved,
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"],
+    }).trim();
+    const normalizedRemote = normalizeGitRemoteUrl(remote);
+    if (normalizedRemote) {
+      const hash = createHash("sha1").update(normalizedRemote).digest("hex").slice(0, 16);
+      return { id: `git:${hash}`, source: "remote_origin" };
+    }
+  } catch {
+  }
+
+  try {
+    let commonDir = execFileSync("git", ["rev-parse", "--git-common-dir"], {
+      cwd: resolved,
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"],
+    }).trim();
+    if (commonDir) {
+      if (!path.isAbsolute(commonDir)) {
+        commonDir = path.resolve(resolved, commonDir);
+      }
+      const hash = createHash("sha1").update(commonDir).digest("hex").slice(0, 16);
+      return { id: `git:${hash}`, source: "git_common_dir" };
+    }
+  } catch {
+  }
+
+  const normalized = resolved.replace(/\\/g, "/").replace(/\/+$/, "");
+  const hash = createHash("sha1").update(normalized).digest("hex").slice(0, 16);
+  return { id: `fs:${hash}`, source: "filesystem_path" };
+}
+
 function computeLogicalRepoId(workspacePath) {
-  const normalized = workspacePath.replace(/\\/g, "/").replace(/\/+$/, "");
-  return createHash("sha256").update(normalized).digest("hex").slice(0, 12);
+  return computeLogicalRepoIdentity(workspacePath).id;
 }
 
 function scanWorkspace(workspacePath, ig) {
@@ -130,6 +218,7 @@ export async function createBundle(workspacePath, options = {}) {
 
   const bundleId = createHash("sha256").update(Date.now().toString() + Math.random().toString()).digest("hex").slice(0, 16);
   const createdAt = new Date().toISOString();
+  const repoName = extractRepoNameFromPath(workspacePath);
 
   const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "ctxce-"));
   const bundleDir = path.join(tmpDir, bundleId);
@@ -164,7 +253,7 @@ export async function createBundle(workspacePath, options = {}) {
     version: "1.0",
     bundle_id: bundleId,
     workspace_path: workspacePath,
-    collection_name: computeLogicalRepoId(workspacePath),
+    collection_name: getCollectionName(repoName),
     created_at: createdAt,
     sequence_number: null,
     parent_sequence: null,
@@ -228,13 +317,16 @@ export async function uploadBundle(bundlePath, manifest, uploadEndpoint, session
   const boundary = `----ctxce${Date.now()}${Math.random().toString(36).slice(2)}`;
 
   // Build form fields (small metadata -- kept in memory)
-  const logicalRepoId = computeLogicalRepoId(manifest.workspace_path);
+  const { id: logicalRepoId, source: logicalRepoSource } = computeLogicalRepoIdentity(
+    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,
+    logical_repo_source: logicalRepoSource,
     session: sessionId,
   };
   if (orgId) fields.org_id = orgId;
@@ -263,29 +355,16 @@ export async function uploadBundle(bundlePath, manifest, uploadEndpoint, session
   // This prevents OOM for large repositories (hundreds of MB bundles).
   const totalLength = filePreamble.length + bundleSize + fileEpilogue.length + fieldsBuffer.length;
 
-  const { Readable } = await import('node:stream');
-  const bodyStream = new Readable({
-    read() {
-      // Push preamble
-      this.push(filePreamble);
-      // Push file data in chunks via sync read to keep it simple
-      const CHUNK = 256 * 1024;  // 256KB chunks
-      const fd = fs.openSync(bundlePath, 'r');
-      try {
-        const buf = Buffer.allocUnsafe(CHUNK);
-        let bytesRead;
-        while ((bytesRead = fs.readSync(fd, buf, 0, CHUNK)) > 0) {
-          this.push(bytesRead === CHUNK ? buf : buf.subarray(0, bytesRead));
-        }
-      } finally {
-        fs.closeSync(fd);
-      }
-      // Push epilogue + fields + close
-      this.push(fileEpilogue);
-      this.push(fieldsBuffer);
-      this.push(null);  // EOF
+  const { Readable } = await import("node:stream");
+  const bodyStream = Readable.from((async function* buildMultipartStream() {
+    yield filePreamble;
+    const fileStream = fs.createReadStream(bundlePath, { highWaterMark: 256 * 1024 });
+    for await (const chunk of fileStream) {
+      yield chunk;
     }
-  });
+    yield fileEpilogue;
+    yield fieldsBuffer;
+  })());
 
   const url = `${uploadEndpoint}/api/v1/delta/upload`;
   log(`[uploader] Uploading to ${url} (${(bundleSize / 1024).toFixed(0)}KB bundle, streaming)...`);

package/test/uploader.test.mjs

@@ -0,0 +1,84 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+
+import { computeLogicalRepoIdentity, uploadBundle } from "../src/uploader.js";
+
+test("computeLogicalRepoIdentity prefers normalized remote origin", async () => {
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "ctxce-bridge-git-"));
+  try {
+    execFileSync("git", ["init"], { cwd: tmpDir, stdio: "ignore" });
+    execFileSync("git", ["remote", "add", "origin", "git@github.com:Context-Engine-AI/Context-Engine.git"], {
+      cwd: tmpDir,
+      stdio: "ignore",
+    });
+
+    const identity = computeLogicalRepoIdentity(tmpDir);
+    assert.equal(identity.source, "remote_origin");
+    assert.match(identity.id, /^git:[0-9a-f]{16}$/);
+  } finally {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  }
+});
+
+test("uploadBundle streams an exact multipart file payload", async () => {
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "ctxce-bridge-upload-"));
+  const workspacePath = path.join(tmpDir, "workspace");
+  fs.mkdirSync(workspacePath, { recursive: true });
+
+  const bundlePath = path.join(tmpDir, "bundle.tar.gz");
+  const bundleData = Buffer.from(Array.from({ length: 4096 }, (_, i) => i % 251));
+  fs.writeFileSync(bundlePath, bundleData);
+
+  let capturedBody = null;
+  let boundary = "";
+  const originalFetch = global.fetch;
+  global.fetch = async (_url, options) => {
+    boundary = String(options.headers["Content-Type"] || "").split("boundary=")[1] || "";
+    const chunks = [];
+    for await (const chunk of options.body) {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    capturedBody = Buffer.concat(chunks);
+    return {
+      ok: true,
+      async json() {
+        return { success: true };
+      },
+    };
+  };
+
+  try {
+    const result = await uploadBundle(
+      bundlePath,
+      {
+        workspace_path: workspacePath,
+        collection_name: "demo-collection",
+      },
+      "http://example.invalid",
+      "session-token",
+      { log: () => {} }
+    );
+
+    assert.equal(result.success, true);
+    assert.ok(capturedBody);
+    assert.ok(boundary);
+
+    const fileHeader = Buffer.from('Content-Disposition: form-data; name="bundle"; filename="bundle.tar.gz"\r\nContent-Type: application/gzip\r\n\r\n');
+    const headerIndex = capturedBody.indexOf(fileHeader);
+    assert.ok(headerIndex >= 0, "bundle header not found in multipart body");
+
+    const payloadStart = headerIndex + fileHeader.length;
+    const payloadEnd = capturedBody.indexOf(Buffer.from(`\r\n--${boundary}\r\n`), payloadStart);
+    assert.ok(payloadEnd > payloadStart, "bundle payload terminator not found");
+
+    const uploadedPayload = capturedBody.subarray(payloadStart, payloadEnd);
+    assert.deepEqual(uploadedPayload, bundleData);
+  } finally {
+    global.fetch = originalFetch;
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  }
+});