@context-engine-bridge/context-engine-mcp-bridge 0.0.2 → 0.0.4

package/package.json

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

package/src/cli.js

@@ -3,12 +3,62 @@
 import process from "node:process";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { runMcpServer } from "./mcpServer.js";
+import { runMcpServer, runHttpMcpServer } from "./mcpServer.js";
 
 export async function runCli() {
   const argv = process.argv.slice(2);
   const cmd = argv[0];
 
+  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 port = Number.parseInt(process.env.CTXCE_HTTP_PORT || "30810", 10) || 30810;
+
+    for (let i = 0; i < args.length; i += 1) {
+      const a = args[i];
+      if (a === "--workspace" || a === "--path") {
+        if (i + 1 < args.length) {
+          workspace = args[i + 1];
+          i += 1;
+          continue;
+        }
+      }
+      if (a === "--indexer-url") {
+        if (i + 1 < args.length) {
+          indexerUrl = args[i + 1];
+          i += 1;
+          continue;
+        }
+      }
+      if (a === "--memory-url") {
+        if (i + 1 < args.length) {
+          memoryUrl = args[i + 1];
+          i += 1;
+          continue;
+        }
+      }
+      if (a === "--port") {
+        if (i + 1 < args.length) {
+          const parsed = Number.parseInt(args[i + 1], 10);
+          if (!Number.isNaN(parsed) && parsed > 0) {
+            port = parsed;
+          }
+          i += 1;
+          continue;
+        }
+      }
+    }
+
+    // eslint-disable-next-line no-console
+    console.error(
+      `[ctxce] Starting HTTP MCP bridge: workspace=${workspace}, port=${port}, indexerUrl=${indexerUrl}, memoryUrl=${memoryUrl || "disabled"}`,
+    );
+    await runHttpMcpServer({ workspace, indexerUrl, memoryUrl, port });
+    return;
+  }
+
   if (cmd === "mcp-serve") {
     // Minimal flag parsing for PoC: allow passing workspace/root and indexer URL.
     // Supported flags:
@@ -59,7 +109,7 @@ export async function runCli() {
 
   // eslint-disable-next-line no-console
   console.error(
-    `Usage: ${binName} mcp-serve [--workspace <path>] [--indexer-url <url>] [--memory-url <url>]`,
+    `Usage: ${binName} mcp-serve [--workspace <path>] [--indexer-url <url>] [--memory-url <url>] | ${binName} mcp-http-serve [--workspace <path>] [--indexer-url <url>] [--memory-url <url>] [--port <port>]`,
   );
   process.exit(1);
 }

package/src/mcpServer.js

@@ -94,6 +94,22 @@ function withTimeout(promise, ms, label) {
   });
 }
 
+function getBridgeToolTimeoutMs() {
+  try {
+    const raw = process.env.CTXCE_TOOL_TIMEOUT_MSEC;
+    if (!raw) {
+      return 300000;
+    }
+    const parsed = Number.parseInt(String(raw), 10);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+      return 300000;
+    }
+    return parsed;
+  } catch {
+    return 300000;
+  }
+}
+
 function selectClientForTool(name, indexerClient, memoryClient) {
   if (!name) {
     return indexerClient;
@@ -112,13 +128,15 @@ import process from "node:process";
 import fs from "node:fs";
 import path from "node:path";
 import { execSync } from "node:child_process";
+import { 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";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 
-export async function runMcpServer(options) {
+async function createBridgeServer(options) {
   const workspace = options.workspace || process.cwd();
   const indexerUrl = options.indexerUrl;
   const memoryUrl = options.memoryUrl;
@@ -164,7 +182,6 @@ export async function runMcpServer(options) {
     await indexerClient.connect(indexerTransport);
   } catch (err) {
     debugLog("[ctxce] Failed to connect MCP HTTP client to indexer: " + String(err));
-    throw err;
   }
 
   let memoryClient = null;
@@ -299,15 +316,147 @@ export async function runMcpServer(options) {
       throw new Error(`Tool ${name} not available on any configured MCP server`);
     }
 
-    const result = await targetClient.callTool({
-      name,
-      arguments: args,
-    });
+    const timeoutMs = getBridgeToolTimeoutMs();
+    const result = await targetClient.callTool(
+      {
+        name,
+        arguments: args,
+      },
+      undefined,
+      { timeout: timeoutMs },
+    );
     return result;
   });
 
+  return server;
+}
+
+export async function runMcpServer(options) {
+  const server = await createBridgeServer(options);
   const transport = new StdioServerTransport();
   await server.connect(transport);
+
+  const exitOnStdinClose = process.env.CTXCE_EXIT_ON_STDIN_CLOSE !== "0";
+  if (exitOnStdinClose) {
+    const handleStdioClosed = () => {
+      try {
+        debugLog("[ctxce] Stdio transport closed; exiting MCP bridge process.");
+      } catch {
+        // ignore
+      }
+      // Allow any in-flight logs to flush, then exit.
+      setTimeout(() => {
+        process.exit(0);
+      }, 10).unref();
+    };
+
+    if (process.stdin && typeof process.stdin.on === "function") {
+      process.stdin.on("end", handleStdioClosed);
+      process.stdin.on("close", handleStdioClosed);
+      process.stdin.on("error", handleStdioClosed);
+    }
+  }
+}
+
+export async function runHttpMcpServer(options) {
+  const server = await createBridgeServer(options);
+  const port =
+    typeof options.port === "number"
+      ? options.port
+      : Number.parseInt(process.env.CTXCE_HTTP_PORT || "30810", 10) || 30810;
+
+  const transport = new StreamableHTTPServerTransport({
+    sessionIdGenerator: undefined,
+  });
+
+  await server.connect(transport);
+
+  const httpServer = createServer((req, res) => {
+    try {
+      if (!req.url || !req.url.startsWith("/mcp")) {
+        res.statusCode = 404;
+        res.setHeader("Content-Type", "application/json");
+        res.end(
+          JSON.stringify({
+            jsonrpc: "2.0",
+            error: { code: -32000, message: "Not found" },
+            id: null,
+          }),
+        );
+        return;
+      }
+
+      if (req.method !== "POST") {
+        res.statusCode = 405;
+        res.setHeader("Content-Type", "application/json");
+        res.end(
+          JSON.stringify({
+            jsonrpc: "2.0",
+            error: { code: -32000, message: "Method not allowed" },
+            id: null,
+          }),
+        );
+        return;
+      }
+
+      let body = "";
+      req.on("data", (chunk) => {
+        body += chunk;
+      });
+      req.on("end", async () => {
+        let parsed;
+        try {
+          parsed = body ? JSON.parse(body) : {};
+        } catch (err) {
+          debugLog("[ctxce] Failed to parse HTTP MCP request body: " + String(err));
+          res.statusCode = 400;
+          res.setHeader("Content-Type", "application/json");
+          res.end(
+            JSON.stringify({
+              jsonrpc: "2.0",
+              error: { code: -32700, message: "Invalid JSON" },
+              id: null,
+            }),
+          );
+          return;
+        }
+
+        try {
+          await transport.handleRequest(req, res, parsed);
+        } catch (err) {
+          debugLog("[ctxce] Error handling HTTP MCP request: " + String(err));
+          if (!res.headersSent) {
+            res.statusCode = 500;
+            res.setHeader("Content-Type", "application/json");
+            res.end(
+              JSON.stringify({
+                jsonrpc: "2.0",
+                error: { code: -32603, message: "Internal server error" },
+                id: null,
+              }),
+            );
+          }
+        }
+      });
+    } catch (err) {
+      debugLog("[ctxce] Unexpected error in HTTP MCP server: " + String(err));
+      if (!res.headersSent) {
+        res.statusCode = 500;
+        res.setHeader("Content-Type", "application/json");
+        res.end(
+          JSON.stringify({
+            jsonrpc: "2.0",
+            error: { code: -32603, message: "Internal server error" },
+            id: null,
+          }),
+        );
+      }
+    }
+  });
+
+  httpServer.listen(port, () => {
+    debugLog(`[ctxce] HTTP MCP bridge listening on port ${port}`);
+  });
 }
 
 function loadConfig(startDir) {