@esankhan3/code-search-mcp 1.0.5 → 1.1.0

package/dist/transports/remote-proxy.js

@@ -1,15 +1,32 @@
-import { Server } from "@modelcontextprotocol/server";
+import { Server, ProtocolError, ProtocolErrorCode } from "@modelcontextprotocol/server";
 import { StdioServerTransport } from "@modelcontextprotocol/server/stdio";
+import { PACKAGE_VERSION } from "../core/version.js";
+import { getComponentLogger } from "../observability/logger.js";
+const log = getComponentLogger("code-search-mcp");
+function parseSseMessages(text) {
+  const messages = [];
+  for (const event of text.split(/\r?\n\r?\n/)) {
+    const data = event.split(/\r?\n/).filter((line) => line.startsWith("data:")).map((line) => line.slice(5).replace(/^ /, "")).join("\n");
+    if (!data) continue;
+    try {
+      messages.push(JSON.parse(data));
+    } catch {
+    }
+  }
+  return messages;
+}
 class RemoteConnection {
   serverUrl;
   apiKey;
-  sessionId = null;
+  nextId = 1;
   constructor(config) {
     this.serverUrl = config.serverUrl.replace(/\/$/, "");
     this.apiKey = config.apiKey;
   }
-  /** Send a JSON-RPC request to the remote MCP server */
-  async request(method, params = {}, id = 1, _retried = false) {
+  /** Send one request; resolve with its `result`, or throw a ProtocolError
+   *  carrying the remote's JSON-RPC error / the HTTP failure. */
+  async request(method, params = {}) {
+    const id = this.nextId++;
     const headers = {
       "Content-Type": "application/json",
       "Accept": "application/json, text/event-stream"
@@ -17,54 +34,35 @@ class RemoteConnection {
     if (this.apiKey) {
       headers["Authorization"] = `Bearer ${this.apiKey}`;
     }
-    if (this.sessionId) {
-      headers["mcp-session-id"] = this.sessionId;
+    let response;
+    try {
+      response = await fetch(`${this.serverUrl}/mcp`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({ jsonrpc: "2.0", id, method, params })
+      });
+    } catch (err) {
+      throw new ProtocolError(ProtocolErrorCode.InternalError, `Remote server unreachable: ${err instanceof Error ? err.message : String(err)}`);
     }
-    const body = JSON.stringify({
-      jsonrpc: "2.0",
-      id,
-      method,
-      params
-    });
-    const response = await fetch(`${this.serverUrl}/mcp`, {
-      method: "POST",
-      headers,
-      body
-    });
     if (!response.ok) {
-      if ((response.status === 404 || response.status === 400) && this.sessionId && method !== "initialize" && !_retried) {
-        this.sessionId = null;
-        await this.initialize();
-        return this.request(method, params, id, true);
-      }
       const errBody = await response.text().catch(() => "");
-      throw new Error(`Remote server error (${response.status}): ${errBody.slice(0, 300)}`);
-    }
-    const newSessionId = response.headers.get("mcp-session-id");
-    if (newSessionId) {
-      this.sessionId = newSessionId;
+      throw new ProtocolError(ProtocolErrorCode.InternalError, `Remote server error (${response.status}): ${errBody.slice(0, 300)}`);
     }
     const contentType = response.headers.get("content-type") ?? "";
-    if (contentType.includes("text/event-stream")) {
-      const text = await response.text();
-      for (const line of text.split("\n")) {
-        if (line.startsWith("data: ")) {
-          try {
-            return JSON.parse(line.slice(6));
-          } catch {
-          }
-        }
-      }
-      throw new Error("No valid JSON in SSE response");
+    const messages = contentType.includes("text/event-stream") ? parseSseMessages(await response.text()) : [await response.json()];
+    const reply = messages.find((m) => typeof m === "object" && m !== null && m.id === id && ("result" in m || "error" in m));
+    if (!reply) {
+      throw new ProtocolError(ProtocolErrorCode.InternalError, `Remote server sent no response for ${method} (id ${id})`);
     }
-    return response.json();
+    if (reply.error) throw new ProtocolError(reply.error.code, reply.error.message, reply.error.data);
+    return reply.result;
   }
-  /** Initialize the remote session */
+  /** MCP handshake — used at startup as a reachability / credentials check. */
   async initialize() {
     return this.request("initialize", {
       protocolVersion: "2024-11-05",
       capabilities: {},
-      clientInfo: { name: "code-search-mcp-proxy", version: "1.0.0" }
+      clientInfo: { name: "code-search-mcp-proxy", version: PACKAGE_VERSION }
     });
   }
   /** Check remote server health */
@@ -78,74 +76,37 @@ async function startRemoteProxy(config) {
   const remote = new RemoteConnection(config);
   try {
     const health = await remote.health();
-    console.error(`[code-search-mcp] Connected to remote server at ${config.serverUrl}`);
-    console.error(`[code-search-mcp] Remote status: ${health.status}, project: ${health.project ?? "unknown"}, index: ${health.indexReady ? "ready" : "not ready"}`);
+    log.info(`Connected to remote server at ${config.serverUrl}`);
+    log.info(`Remote status: ${health.status}, project: ${health.project ?? "unknown"}, index: ${health.indexReady ? "ready" : "not ready"}`);
   } catch (err) {
-    console.error(`[code-search-mcp] WARNING: Could not reach remote server at ${config.serverUrl}: ${err.message}`);
-    console.error(`[code-search-mcp] Proxy will start anyway \u2014 requests will fail until server is available.`);
+    log.warn(`WARNING: Could not reach remote server at ${config.serverUrl}: ${err.message}`);
+    log.warn(`Proxy will start anyway \u2014 requests will fail until server is available.`);
   }
   try {
     await remote.initialize();
-    console.error(`[code-search-mcp] Remote session established`);
+    log.info(`Remote MCP handshake ok`);
   } catch (err) {
-    console.error(`[code-search-mcp] WARNING: Session init failed: ${err.message}. Will retry on first request.`);
+    log.warn(`WARNING: Remote MCP handshake failed: ${err.message}. Requests will fail until this is fixed (check --api-key / CODE_SEARCH_API_KEY).`);
   }
   const server = new Server(
-    { name: "code-search-mcp", version: "1.0.0" },
+    { name: "code-search-mcp", version: PACKAGE_VERSION },
     { capabilities: { tools: {}, resources: {} } }
   );
-  server.setRequestHandler("tools/list", async () => {
-    try {
-      const response = await remote.request("tools/list");
-      return response.result ?? { tools: [] };
-    } catch (err) {
-      console.error(`[proxy] Failed to list tools: ${err.message}`);
-      return { tools: [] };
-    }
-  });
-  server.setRequestHandler("tools/call", async (request) => {
-    try {
-      const response = await remote.request("tools/call", {
-        name: request.params.name,
-        arguments: request.params.arguments ?? {}
-      });
-      return response.result ?? {
-        content: [{ type: "text", text: "No response from remote server" }],
-        isError: true
-      };
-    } catch (err) {
-      return {
-        content: [{ type: "text", text: `Remote server error: ${err.message}` }],
-        isError: true
-      };
-    }
-  });
-  server.setRequestHandler("resources/list", async () => {
-    try {
-      const response = await remote.request("resources/list");
-      return response.result ?? { resources: [] };
-    } catch {
-      return { resources: [] };
-    }
-  });
-  server.setRequestHandler("resources/read", async (request) => {
-    try {
-      const response = await remote.request("resources/read", {
-        uri: request.params.uri
-      });
-      return response.result ?? {
-        contents: [{ uri: request.params.uri, text: "Not available" }]
-      };
-    } catch (err) {
-      return {
-        contents: [{ uri: request.params.uri, text: `Error: ${err.message}` }]
-      };
-    }
-  });
+  server.setRequestHandler("tools/list", async () => remote.request("tools/list"));
+  server.setRequestHandler("tools/call", async (request) => remote.request("tools/call", {
+    name: request.params.name,
+    arguments: request.params.arguments ?? {}
+  }));
+  server.setRequestHandler("resources/list", async () => remote.request("resources/list"));
+  server.setRequestHandler("resources/templates/list", async () => remote.request("resources/templates/list"));
+  server.setRequestHandler("resources/read", async (request) => remote.request("resources/read", {
+    uri: request.params.uri
+  }));
   const transport = new StdioServerTransport();
   await server.connect(transport);
-  console.error(`[code-search-mcp] Proxy running (stdio \u2192 ${config.serverUrl})`);
+  log.info(`Proxy running (stdio \u2192 ${config.serverUrl})`);
 }
 export {
+  parseSseMessages,
   startRemoteProxy
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@esankhan3/code-search-mcp",
-  "version": "1.0.5",
+  "version": "1.1.0",
   "description": "MCP server for multi-repo code search \u2014 GitHub org or local path, zero config",
   "type": "module",
   "license": "MIT",