@context-engine-bridge/context-engine-mcp-bridge 0.0.1 → 0.0.3

package/docs/debugging.md

@@ -0,0 +1,20 @@
+{
+  "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/package.json

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

package/publish.sh

@@ -0,0 +1,34 @@
+#!/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!"

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

@@ -1,3 +1,15 @@
+function debugLog(message) {
+  try {
+    const text = typeof message === "string" ? message : String(message);
+    console.error(text);
+    const dest = process.env.CTXCE_DEBUG_LOG;
+    if (dest) {
+      fs.appendFileSync(dest, `${new Date().toISOString()} ${text}\n`, "utf8");
+    }
+  } catch {
+  }
+}
+
 async function sendSessionDefaults(client, payload, label) {
   if (!client) {
     return;
@@ -36,15 +48,52 @@ async function listMemoryTools(client) {
     return [];
   }
   try {
-    const remote = await client.listTools();
+    const remote = await withTimeout(
+      client.listTools(),
+      5000,
+      "memory tools/list",
+    );
     return Array.isArray(remote?.tools) ? remote.tools.slice() : [];
   } catch (err) {
-    // eslint-disable-next-line no-console
-    console.error("[ctxce] Error calling memory tools/list:", err);
+    debugLog("[ctxce] Error calling memory tools/list: " + String(err));
     return [];
   }
 }
 
+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 selectClientForTool(name, indexerClient, memoryClient) {
   if (!name) {
     return indexerClient;
@@ -63,13 +112,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;
@@ -84,8 +135,7 @@ export async function runMcpServer(options) {
   const defaultUnder =
     config && typeof config.default_under === "string" ? config.default_under : null;
 
-  // eslint-disable-next-line no-console
-  console.error(
+  debugLog(
     `[ctxce] MCP low-level stdio bridge starting: workspace=${workspace}, indexerUrl=${indexerUrl}`,
   );
 
@@ -115,9 +165,7 @@ export async function runMcpServer(options) {
   try {
     await indexerClient.connect(indexerTransport);
   } catch (err) {
-    // eslint-disable-next-line no-console
-    console.error("[ctxce] Failed to connect MCP HTTP client to indexer:", err);
-    throw err;
+    debugLog("[ctxce] Failed to connect MCP HTTP client to indexer: " + String(err));
   }
 
   let memoryClient = null;
@@ -138,11 +186,9 @@ export async function runMcpServer(options) {
         },
       );
       await memoryClient.connect(memoryTransport);
-      // eslint-disable-next-line no-console
-      console.error("[ctxce] Connected memory MCP client:", memoryUrl);
+      debugLog(`[ctxce] Connected memory MCP client: ${memoryUrl}`);
     } catch (err) {
-      // eslint-disable-next-line no-console
-      console.error("[ctxce] Failed to connect memory MCP client:", err);
+      debugLog("[ctxce] Failed to connect memory MCP client: " + String(err));
       memoryClient = null;
     }
   }
@@ -186,45 +232,47 @@ export async function runMcpServer(options) {
     },
   );
 
-  // tools/list → fetch tools from remote indexer and append local ping tool
+  // tools/list → fetch tools from remote indexer
   server.setRequestHandler(ListToolsRequestSchema, async () => {
     let remote;
     try {
-      remote = await indexerClient.listTools();
+      debugLog("[ctxce] tools/list: fetching tools from indexer");
+      remote = await withTimeout(
+        indexerClient.listTools(),
+        10000,
+        "indexer tools/list",
+      );
     } catch (err) {
-      // eslint-disable-next-line no-console
-      console.error("[ctxce] Error calling remote tools/list:", err);
-      return { tools: [buildPingTool()] };
+      debugLog("[ctxce] Error calling remote tools/list: " + String(err));
+      const memoryToolsFallback = await listMemoryTools(memoryClient);
+      const toolsFallback = dedupeTools([...memoryToolsFallback]);
+      return { tools: toolsFallback };
     }
 
-    // eslint-disable-next-line no-console
-    console.error("[ctxce] tools/list remote result:", JSON.stringify(remote));
+    try {
+      const toolNames =
+        remote && Array.isArray(remote.tools)
+          ? remote.tools.map((t) => (t && typeof t.name === "string" ? t.name : "<unnamed>"))
+          : [];
+      debugLog("[ctxce] tools/list remote result tools: " + JSON.stringify(toolNames));
+    } catch (err) {
+      debugLog("[ctxce] tools/list remote result: <unserializable> " + String(err));
+    }
 
     const indexerTools = Array.isArray(remote?.tools) ? remote.tools.slice() : [];
     const memoryTools = await listMemoryTools(memoryClient);
-    const tools = dedupeTools([...indexerTools, ...memoryTools, buildPingTool()]);
+    const tools = dedupeTools([...indexerTools, ...memoryTools]);
+    debugLog(`[ctxce] tools/list: returning ${tools.length} tools`);
     return { tools };
   });
 
-  // tools/call → handle ping locally, everything else is proxied to indexer
+  // tools/call → proxied to indexer or memory server
   server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const params = request.params || {};
     const name = params.name;
     let args = params.arguments;
 
-    if (name === "ping") {
-      const branch = detectGitBranch(workspace);
-      const text = args && typeof args.text === "string" ? args.text : "pong";
-      const suffix = branch ? ` (branch=${branch})` : "";
-      return {
-        content: [
-          {
-            type: "text",
-            text: `${text}${suffix}`,
-          },
-        ],
-      };
-    }
+    debugLog(`[ctxce] tools/call: ${name || "<no-name>"}`);
 
     // Attach session id so the target server can apply per-session defaults.
     if (sessionId && (args === undefined || args === null || typeof args === "object")) {
@@ -241,8 +289,7 @@ export async function runMcpServer(options) {
         try {
           await memoryClient.callTool({ name, arguments: args });
         } catch (err) {
-          // eslint-disable-next-line no-console
-          console.error("[ctxce] Memory set_session_defaults failed:", err);
+          debugLog("[ctxce] Memory set_session_defaults failed: " + String(err));
         }
       }
       return indexerResult;
@@ -260,10 +307,116 @@ export async function runMcpServer(options) {
     return result;
   });
 
+  return server;
+}
+
+export async function runMcpServer(options) {
+  const server = await createBridgeServer(options);
   const transport = new StdioServerTransport();
   await server.connect(transport);
 }
 
+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) {
   try {
     let dir = startDir;
@@ -295,23 +448,6 @@ function loadConfig(startDir) {
   return null;
 }
 
-function buildPingTool() {
-  return {
-    name: "ping",
-    description: "Basic ping tool exposed by the ctx bridge",
-    inputSchema: {
-      type: "object",
-      properties: {
-        text: {
-          type: "string",
-          description: "Optional text to echo back.",
-        },
-      },
-      required: [],
-    },
-  };
-}
-
 function detectGitBranch(workspace) {
   try {
     const out = execSync("git rev-parse --abbrev-ref HEAD", {