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

package/package.json

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

package/src/connectCli.js

@@ -2,7 +2,7 @@ import process from "node:process";
 import path from "node:path";
 import fs from "node:fs";
 import { saveAuthEntry } from "./authConfig.js";
-import { indexWorkspace } from "./uploader.js";
+import { indexWorkspace, loadGitignore, isCodeFile } from "./uploader.js";
 
 const SAAS_ENDPOINTS = {
   uploadEndpoint: "https://dev.context-engine.ai/upload",
@@ -160,12 +160,35 @@ async function triggerIndexing(workspace, sessionId, authEntry) {
   return result.success;
 }
 
-function startWatcher(workspace, sessionId, authEntry, intervalMs) {
+function startWatcher(workspace, initialSessionId, 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 sessionId = initialSessionId;
+
+  async function refreshSessionIfNeeded() {
+    // If the auth entry has an expiry and we're within 5 minutes of it,
+    // re-authenticate using the stored API key.
+    if (!authEntry || !authEntry.apiKey) return;
+    const expiresAt = authEntry.expiresAt;
+    if (typeof expiresAt !== "number" || !Number.isFinite(expiresAt) || expiresAt <= 0) return;
+    const nowSecs = Math.floor(Date.now() / 1000);
+    const remainingSecs = expiresAt - nowSecs;
+    if (remainingSecs > 300) return;  // still valid for > 5 min
+    console.error("[ctxce] Session approaching expiry, refreshing...");
+    try {
+      const refreshed = await authenticateWithApiKey(authEntry.apiKey);
+      if (refreshed && refreshed.sessionId) {
+        sessionId = refreshed.sessionId;
+        authEntry = refreshed;
+        console.error("[ctxce] Session refreshed successfully.");
+      }
+    } catch (err) {
+      console.error(`[ctxce] Session refresh failed: ${err}`);
+    }
+  }
 
   const fileHashes = new Map();
 
@@ -178,26 +201,29 @@ function startWatcher(workspace, sessionId, authEntry, intervalMs) {
     }
   }
 
+  // Use gitignore from uploader.js so the watcher ignores the same files as
+  // the bundle creator -- prevents redundant uploads for generated/ignored files.
+  const _ig = loadGitignore(workspace);
+
   function scanDirectory(dir, files = []) {
     try {
       const entries = fs.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
+        if (entry.isSymbolicLink()) continue;
         const fullPath = path.join(dir, entry.name);
-        
-        if (entry.name.startsWith(".") || 
-            entry.name === "node_modules" || 
-            entry.name === "__pycache__" ||
-            entry.name === "venv" ||
-            entry.name === ".venv" ||
-            entry.name === "dist" ||
-            entry.name === "build") {
-          continue;
-        }
+        // Normalize to forward slashes for the `ignore` library (expects POSIX paths)
+        const relPath = path.relative(workspace, fullPath).split(path.sep).join('/');
 
+        // Use the same ignore rules as the bundle creator
+        // Directories need a trailing slash for gitignore pattern matching
         if (entry.isDirectory()) {
+          if (_ig.ignores(relPath + '/')) continue;
           scanDirectory(fullPath, files);
         } else if (entry.isFile()) {
-          files.push(fullPath);
+          if (_ig.ignores(relPath)) continue;
+          if (isCodeFile(fullPath)) {
+            files.push(fullPath);
+          }
         }
       }
     } catch {
@@ -242,6 +268,9 @@ function startWatcher(workspace, sessionId, authEntry, intervalMs) {
     console.error(`[ctxce] [${now}] Syncing changes...`);
 
     try {
+      // Refresh session before upload if approaching expiry
+      await refreshSessionIfNeeded();
+
       const result = await indexWorkspace(
         workspace,
         SAAS_ENDPOINTS.uploadEndpoint,

package/src/mcpServer.js

@@ -3,7 +3,8 @@ import fs from "node:fs";
 import path from "node:path";
 import { randomUUID } from "node:crypto";
 import { execSync } from "node:child_process";
-import { createServer } from "node:http";
+import os from "node:os";
+import http, { createServer } from "node:http";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
@@ -14,6 +15,42 @@ import { loadAnyAuthEntry, loadAuthEntry, readConfig, saveAuthEntry } from "./au
 import { maybeRemapToolArgs, maybeRemapToolResult } from "./resultPathMapping.js";
 import * as oauthHandler from "./oauthHandler.js";
 
+let _lspConnCache;
+let _lspConnCacheTs = 0;
+const LSP_CONN_CACHE_TTL = 5000;
+const LSP_CONN_MAX_AGE = 60 * 60 * 1000;
+
+function _isValidPort(v) {
+  const p = Number.parseInt(String(v), 10);
+  return Number.isFinite(p) && p >= 1024 && p <= 65535;
+}
+
+function _readLspConnection() {
+  const envPort = process.env.CTXCE_LSP_PORT;
+  if (envPort && _isValidPort(envPort)) return { port: envPort, secret: process.env.CTXCE_LSP_SECRET || "" };
+  const now = Date.now();
+  if (_lspConnCache !== undefined && (now - _lspConnCacheTs) < LSP_CONN_CACHE_TTL) return _lspConnCache;
+
+  function _cacheNull() {
+    _lspConnCache = null;
+    _lspConnCacheTs = now;
+    return null;
+  }
+
+  try {
+    const connPath = path.join(os.homedir(), ".ctxce", "lsp-connection.json");
+    const conn = JSON.parse(fs.readFileSync(connPath, "utf8"));
+    if (conn.port && _isValidPort(conn.port) && conn.pid) {
+      try { process.kill(conn.pid, 0); } catch (_) { return _cacheNull(); }
+      if (conn.created_at && (now - conn.created_at) > LSP_CONN_MAX_AGE) return _cacheNull();
+      _lspConnCache = { port: String(conn.port), secret: conn.secret || "" };
+      _lspConnCacheTs = now;
+      return _lspConnCache;
+    }
+  } catch (_) {}
+  return _cacheNull();
+}
+
 function debugLog(message) {
   try {
     const text = typeof message === "string" ? message : String(message);
@@ -97,6 +134,9 @@ function selectClientForTool(name, indexerClient, memoryClient) {
   if (memoryClient && lowered.startsWith("memory")) {
     return memoryClient;
   }
+  if (lowered.startsWith("lsp_")) {
+    return null;
+  }
   return indexerClient;
 }
 
@@ -501,7 +541,13 @@ async function createBridgeServer(options) {
       expiresAt > 0 &&
       expiresAt < Math.floor(Date.now() / 1000)
     ) {
-      debugLog("[ctxce] Stored auth session has local expiry in the past; attempting to use it anyway (server will validate).");
+      // Allow 5-minute grace period for clock skew; beyond that, reject
+      const expiredSecs = Math.floor(Date.now() / 1000) - expiresAt;
+      if (expiredSecs > 300) {
+        debugLog(`[ctxce] Session expired ${expiredSecs}s ago (beyond 5min grace), triggering re-auth.`);
+        return "";
+      }
+      debugLog("[ctxce] Session expired but within 5min grace period; using it (server will validate).");
       return entry.sessionId;
     }
     return entry.sessionId;
@@ -790,6 +836,80 @@ async function createBridgeServer(options) {
     const indexerTools = Array.isArray(remote?.tools) ? remote.tools.slice() : [];
     const memoryTools = await listMemoryTools(memoryClient);
     const tools = dedupeTools([...indexerTools, ...memoryTools]);
+
+    const lspAvailable = !!_readLspConnection();
+    if (lspAvailable) {
+      const pathProp = { type: "string", description: "Absolute file path" };
+      const lineProp = { type: "integer", description: "0-based line" };
+      const charProp = { type: "integer", description: "0-based column" };
+      const positionProps = { path: pathProp, line: lineProp, character: charProp };
+      const positionRequired = ["path", "line", "character"];
+
+      tools.push(
+        {
+          name: "lsp_diagnostics",
+          description: "Get compiler diagnostics (errors, warnings) for a file from the active language server.",
+          inputSchema: { type: "object", properties: { path: pathProp }, required: ["path"] },
+        },
+        {
+          name: "lsp_definition",
+          description: "Go to definition of symbol at position.",
+          inputSchema: { type: "object", properties: { ...positionProps }, required: positionRequired },
+        },
+        {
+          name: "lsp_references",
+          description: "Find all references to symbol at position.",
+          inputSchema: {
+            type: "object",
+            properties: { ...positionProps, includeDeclaration: { type: "boolean", description: "Include the declaration itself" } },
+            required: positionRequired,
+          },
+        },
+        {
+          name: "lsp_hover",
+          description: "Get hover information (type, docs) for symbol at position.",
+          inputSchema: { type: "object", properties: { ...positionProps }, required: positionRequired },
+        },
+        {
+          name: "lsp_document_symbols",
+          description: "Get all symbols in a document.",
+          inputSchema: { type: "object", properties: { path: pathProp }, required: ["path"] },
+        },
+        {
+          name: "lsp_workspace_symbols",
+          description: "Search for symbols across the workspace.",
+          inputSchema: { type: "object", properties: { query: { type: "string", description: "Symbol search query" } }, required: ["query"] },
+        },
+        {
+          name: "lsp_code_actions",
+          description: "Get available code actions (quick fixes, refactors) for a range.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              path: pathProp,
+              startLine: { type: "integer" },
+              startChar: { type: "integer" },
+              endLine: { type: "integer" },
+              endChar: { type: "integer" },
+            },
+            required: ["path", "startLine", "startChar", "endLine", "endChar"],
+          },
+        },
+        {
+          name: "lsp_diagnostics_recent",
+          description: "Get recently collected diagnostics from file edits (errors and warnings auto-collected via language server).",
+          inputSchema: {
+            type: "object",
+            properties: {
+              paths: { type: "array", items: { type: "string" }, description: "Filter to specific file paths" },
+              severity_filter: { type: "string", enum: ["error", "warning", "info", "hint"], description: "Filter by severity" },
+              since_ms: { type: "integer", description: "Only return diagnostics newer than this Unix timestamp in ms" },
+            },
+          },
+        },
+      );
+    }
+
     debugLog(`[ctxce] tools/list: returning ${tools.length} tools`);
     return { tools };
   });
@@ -840,6 +960,47 @@ async function createBridgeServer(options) {
       return indexerResult;
     }
 
+    if (name && name.toLowerCase().startsWith("lsp_")) {
+      const lspConn = _readLspConnection();
+      const lspPort = lspConn ? lspConn.port : null;
+      const lspSecret = lspConn ? lspConn.secret : "";
+      if (!lspPort) {
+        return { content: [{ type: "text", text: JSON.stringify({ ok: false, error: "LSP proxy not available. Ensure VS Code extension has lsp.enabled=true." }) }] };
+      }
+      const ALLOWED_LSP_OPS = new Set(['diagnostics','definition','references','hover','document_symbols','workspace_symbols','code_actions','diagnostics_recent']);
+      const operation = name.toLowerCase().replace(/^lsp_/, "");
+      if (!ALLOWED_LSP_OPS.has(operation)) {
+        return { content: [{ type: "text", text: JSON.stringify({ ok: false, error: "Unknown LSP operation" }) }] };
+      }
+      try {
+        const lspArgs = params.arguments || {};
+        const postData = JSON.stringify(lspArgs);
+        const result = await new Promise((resolve, reject) => {
+          const req = http.request({
+            hostname: "127.0.0.1",
+            port: parseInt(lspPort, 10),
+            path: `/lsp/${operation}`,
+            method: "POST",
+            headers: Object.assign({ "Content-Type": "application/json", "Content-Length": Buffer.byteLength(postData) }, lspSecret ? { "x-lsp-handler-token": lspSecret } : {}),
+            timeout: 15000,
+          }, (res) => {
+            let data = "";
+            res.on("data", chunk => { data += chunk; });
+            res.on("end", () => {
+              try { resolve(JSON.parse(data)); } catch { resolve({ ok: false, error: "Invalid response from LSP handler" }); }
+            });
+          });
+          req.on("error", reject);
+          req.on("timeout", () => { req.destroy(); reject(new Error("LSP request timeout")); });
+          req.write(postData);
+          req.end();
+        });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: JSON.stringify({ ok: false, error: `LSP proxy error: ${err.message || String(err)}` }) }] };
+      }
+    }
+
     await initializeRemoteClients(false);
 
     const timeoutMs = getBridgeToolTimeoutMs();
@@ -856,7 +1017,7 @@ async function createBridgeServer(options) {
 
       const targetClient = selectClientForTool(name, indexerClient, memoryClient);
       if (!targetClient) {
-        throw new Error(`Tool ${name} not available on any configured MCP server`);
+        return { content: [{ type: "text", text: JSON.stringify({ ok: false, error: `Tool ${name} not available on any configured MCP server` }) }] };
       }
 
       try {

package/src/uploader.js

@@ -36,7 +36,7 @@ const DEFAULT_IGNORES = [
 
 const MAX_FILE_SIZE = 10 * 1024 * 1024;
 
-function loadGitignore(workspacePath) {
+export function loadGitignore(workspacePath) {
   const ig = ignore();
   ig.add(DEFAULT_IGNORES);
 
@@ -52,7 +52,7 @@ function loadGitignore(workspacePath) {
   return ig;
 }
 
-function isCodeFile(filePath) {
+export function isCodeFile(filePath) {
   const ext = path.extname(filePath).toLowerCase();
   if (CODE_EXTS.has(ext)) return true;
 
@@ -224,19 +224,10 @@ export async function createBundle(workspacePath, options = {}) {
 export async function uploadBundle(bundlePath, manifest, uploadEndpoint, sessionId, options = {}) {
   const { log = console.error, orgId, orgSlug } = options;
 
-  const bundleData = fs.readFileSync(bundlePath);
+  const bundleSize = fs.statSync(bundlePath).size;
   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`);
-
+  // Build form fields (small metadata -- kept in memory)
   const logicalRepoId = computeLogicalRepoId(manifest.workspace_path);
   const fields = {
     workspace_path: manifest.workspace_path,
@@ -246,35 +237,67 @@ export async function uploadBundle(bundlePath, manifest, uploadEndpoint, session
     logical_repo_id: logicalRepoId,
     session: sessionId,
   };
-
   if (orgId) fields.org_id = orgId;
   if (orgSlug) fields.org_slug = orgSlug;
 
+  // Build multipart preamble (file header) and epilogue (fields + close)
+  const filePreamble = Buffer.from(
+    `--${boundary}\r\n` +
+    `Content-Disposition: form-data; name="bundle"; filename="bundle.tar.gz"\r\n` +
+    `Content-Type: application/gzip\r\n\r\n`
+  );
+  const fileEpilogue = Buffer.from(`\r\n`);
+
+  let fieldsPart = '';
   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`,
-      );
+      fieldsPart += `--${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);
+  fieldsPart += `--${boundary}--\r\n`;
+  const fieldsBuffer = Buffer.from(fieldsPart);
+
+  // Stream the bundle file instead of loading it entirely into memory.
+  // 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 url = `${uploadEndpoint}/api/v1/delta/upload`;
-  log(`[uploader] Uploading to ${url}...`);
+  log(`[uploader] Uploading to ${url} (${(bundleSize / 1024).toFixed(0)}KB bundle, streaming)...`);
 
   const resp = await fetch(url, {
     method: "POST",
     headers: {
       "Content-Type": `multipart/form-data; boundary=${boundary}`,
-      "Content-Length": String(body.length),
+      "Content-Length": String(totalLength),
     },
-    body,
+    body: bodyStream,
+    duplex: "half",  // required for streaming request bodies in Node.js fetch
   });
 
   let result;
@@ -298,8 +321,23 @@ export async function uploadBundle(bundlePath, manifest, uploadEndpoint, session
   return { success: true, result };
 }
 
+let _indexInFlight = false;
 export async function indexWorkspace(workspacePath, uploadEndpoint, sessionId, options = {}) {
   const { log = console.error, orgId, orgSlug } = options;
+  if (_indexInFlight) {
+    log("[uploader] indexWorkspace already in progress, skipping concurrent call");
+    return { success: false, error: "already_in_progress" };
+  }
+  _indexInFlight = true;
+  try {
+    return await _indexWorkspaceInner(workspacePath, uploadEndpoint, sessionId, options);
+  } finally {
+    _indexInFlight = false;
+  }
+}
+
+async function _indexWorkspaceInner(workspacePath, uploadEndpoint, sessionId, options = {}) {
+  const { log = console.error, orgId, orgSlug } = options;
 
   log(`[uploader] Scanning workspace: ${workspacePath}`);
 

package/.claude/settings.local.json

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

package/.sisyphus/ultrawork-state.json

@@ -1,7 +0,0 @@
-{
-  "active": true,
-  "started_at": "2026-01-25T14:25:53.146Z",
-  "original_prompt": "/oh-my-claude-sisyphus:ultrawork we need to figure out, research context engine a bit.... how to make our agent tools better via mcp... (the claude.example.md is\n  clear) but maybe we need an agents.md, we have claude skills... can we make the descriptors better? research alot fo other\n  tools and see",
-  "reinforcement_count": 5,
-  "last_checked_at": "2026-01-25T14:43:28.449Z"
-}

package/docs/debugging.md

@@ -1,20 +0,0 @@
-{
-  "mcpServers": {
-    "context-engine": {
-      "command": "node",
-      "args": [
-        "C:/Users/Admin/Documents/GitHub/Context-Engine/ctx-mcp-bridge/bin/ctxce.js",
-        "mcp-serve",
-        "--indexer-url",
-        "http://192.168.100.249:30806/mcp",
-        "--memory-url",
-        "http://192.168.100.249:30804/mcp",
-        "--workspace",
-        "C:/Users/Admin/Documents/GitHub/Pirate Survivors"
-      ],
-      "env": {
-        "CTXCE_DEBUG_LOG": "C:/Users/Admin/ctxce-mcp.log"
-      }
-    }
-  }
-}

package/publish.sh

@@ -1,34 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-# Simple helper to login (if needed) and publish the package.
-# Usage:
-#   ./publish.sh            # publishes current version
-#   ./publish.sh 0.0.2      # bumps version to 0.0.2 then publishes
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-cd "$SCRIPT_DIR"
-
-PACKAGE_NAME="@context-engine-bridge/context-engine-mcp-bridge"
-
-echo "[publish] Verifying npm authentication..."
-if ! npm whoami >/dev/null 2>&1; then
-  echo "[publish] Not logged in; running npm login"
-  npm login
-else
-  echo "[publish] Already authenticated as $(npm whoami)"
-fi
-
-if [[ $# -gt 0 ]]; then
-  VERSION="$1"
-  echo "[publish] Bumping version to $VERSION"
-  npm version "$VERSION" --no-git-tag-version
-fi
-
-echo "[publish] Packing $PACKAGE_NAME for verification..."
-npm pack >/dev/null
-
-echo "[publish] Publishing $PACKAGE_NAME..."
-npm publish --access public
-
-echo "[publish] Done!"