@jiangxiaoxu/lm-tools-bridge-proxy 0.1.18 → 0.1.19

package/README.md

@@ -15,15 +15,14 @@ The proxy uses the current working directory (`cwd`) to resolve the VS Code inst
 
 Codex does not pass `cwd` into `npx` MCP services, so the proxy requires an explicit workspace handshake before it forwards MCP requests.
 
-1. Call `lmTools/requestWorkspaceMCPServer` with `params.cwd`.
+1. Call `lmToolsBridgeProxy.requestWorkspaceMCPServer` with `params.cwd`.
 2. Wait for `ok: true` and a resolved target.
-3. Optionally call `lmTools/status` to confirm the target is still online.
 
-Until `lmTools/requestWorkspaceMCPServer` succeeds, the proxy rejects all MCP requests (including `roots/list`) with a workspace-not-ready error.
+Until `lmToolsBridgeProxy.requestWorkspaceMCPServer` succeeds, the proxy rejects all MCP requests (including `roots/list`) with a workspace-not-ready error.
 
 If the target MCP goes offline, the proxy marks itself disconnected and attempts auto-reconnect every second. `lmTools/status` returns `offlineDurationSec` to show how long it has been offline.
 
-When the proxy is not ready, it exposes a minimal MCP resource (`lm-tools-bridge-proxy://handshake`) via `resources/list` and also returns `lmTools/requestWorkspaceMCPServer` and `lmTools/status` from `tools/list` so clients can discover the exact method names.
+The proxy always exposes a minimal MCP resource (`lm-tools-bridge-proxy://handshake`) via `resources/list`, and it is pinned to the top of the list. It also returns `lmToolsBridgeProxy.requestWorkspaceMCPServer` from `tools/list` before handshake so clients can discover the exact method name.
 
 ## Logging
 

package/dist/index.js

@@ -41,8 +41,7 @@ var ERROR_NO_MATCH = -32004;
 var ERROR_WORKSPACE_NOT_SET = -32005;
 var ERROR_MCP_OFFLINE = -32006;
 var STARTUP_TIME = Date.now();
-var REQUEST_WORKSPACE_METHOD = "lmTools/requestWorkspaceMCPServer";
-var STATUS_METHOD = "lmTools/status";
+var REQUEST_WORKSPACE_METHOD = "lmToolsBridgeProxy.requestWorkspaceMCPServer";
 var TOOLS_LIST_METHOD = "tools/list";
 var TOOLS_CALL_METHOD = "tools/call";
 var INITIALIZE_METHOD = "initialize";
@@ -259,60 +258,137 @@ function getProxyVersion() {
   }
   return "unknown";
 }
+async function requestTargetJson(target, payload) {
+  return new Promise((resolve) => {
+    const body = JSON.stringify(payload);
+    const request = import_node_http.default.request(
+      {
+        hostname: target.host,
+        port: Number(target.port),
+        path: "/mcp",
+        method: "POST",
+        headers: {
+          Accept: "application/json",
+          "Content-Type": "application/json",
+          "Content-Length": Buffer.byteLength(body)
+        }
+      },
+      (response) => {
+        const chunks = [];
+        response.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
+        response.on("end", () => {
+          try {
+            const text = Buffer.concat(chunks).toString("utf8");
+            const parsed = JSON.parse(text);
+            resolve({ ok: true, data: parsed });
+          } catch {
+            resolve({ ok: false });
+          }
+        });
+      }
+    );
+    request.on("error", () => {
+      resolve({ ok: false });
+    });
+    request.write(body);
+    request.end();
+  });
+}
 function createStdioMessageHandler(targetGetter, targetRefresher, stateGetter) {
   return async (message) => {
     const state = stateGetter();
-    if (!state.workspaceMatched) {
-      if (message?.method === "resources/list") {
-        logDebug("resources.list.handshake", { id: message.id ?? null });
-        if (message.id === void 0 || message.id === null) {
-          return;
+    if (message?.method === "resources/read" && message?.params?.uri === HANDSHAKE_RESOURCE_URI) {
+      logDebug("resources.read.handshake", { id: message.id ?? null });
+      if (message.id === void 0 || message.id === null) {
+        return;
+      }
+      const statusResult = await buildStatusPayload();
+      const content = [
+        "This MCP proxy requires an explicit workspace handshake.",
+        "Call lmToolsBridgeProxy.requestWorkspaceMCPServer with params.cwd, wait for ok:true.",
+        "",
+        "Status snapshot:",
+        JSON.stringify(statusResult.payload, null, 2)
+      ].join("\n");
+      const resultPayload = {
+        jsonrpc: "2.0",
+        id: message.id,
+        result: {
+          contents: [
+            {
+              uri: HANDSHAKE_RESOURCE_URI,
+              mimeType: "text/plain",
+              text: content
+            }
+          ]
         }
-        const resultPayload = {
+      };
+      import_node_process.default.stdout.write(`${JSON.stringify(resultPayload)}
+`);
+      return;
+    }
+    if (message?.method === "resources/list") {
+      logDebug("resources.list.handshake", { id: message.id ?? null });
+      if (message.id === void 0 || message.id === null) {
+        return;
+      }
+      const proxyResource = {
+        uri: HANDSHAKE_RESOURCE_URI,
+        name: "MCP proxy handshake",
+        description: "Call lmToolsBridgeProxy.requestWorkspaceMCPServer with params.cwd before using MCP.",
+        mimeType: "text/plain"
+      };
+      if (!state.workspaceMatched) {
+        const resultPayload2 = {
           jsonrpc: "2.0",
           id: message.id,
           result: {
-            resources: [
-              {
-                uri: HANDSHAKE_RESOURCE_URI,
-                name: "MCP proxy handshake",
-                description: "Call lmTools/requestWorkspaceMCPServer with params.cwd before using MCP.",
-                mimeType: "text/plain"
-              }
-            ]
+            resources: [proxyResource]
           }
         };
-        import_node_process.default.stdout.write(`${JSON.stringify(resultPayload)}
+        import_node_process.default.stdout.write(`${JSON.stringify(resultPayload2)}
 `);
         return;
       }
-      if (message?.method === "resources/read" && message?.params?.uri === HANDSHAKE_RESOURCE_URI) {
-        logDebug("resources.read.handshake", { id: message.id ?? null });
-        if (message.id === void 0 || message.id === null) {
-          return;
-        }
-        const content = [
-          "This MCP proxy requires an explicit workspace handshake.",
-          "Call lmTools/requestWorkspaceMCPServer with params.cwd, wait for ok:true.",
-          "Then call lmTools/status to confirm online status."
-        ].join("\n");
-        const resultPayload = {
+      const target2 = targetGetter();
+      if (!target2) {
+        const resultPayload2 = {
           jsonrpc: "2.0",
           id: message.id,
           result: {
-            contents: [
-              {
-                uri: HANDSHAKE_RESOURCE_URI,
-                mimeType: "text/plain",
-                text: content
-              }
-            ]
+            resources: [proxyResource]
           }
         };
-        import_node_process.default.stdout.write(`${JSON.stringify(resultPayload)}
+        import_node_process.default.stdout.write(`${JSON.stringify(resultPayload2)}
 `);
         return;
       }
+      const remote = await requestTargetJson(target2, {
+        jsonrpc: "2.0",
+        id: message.id,
+        method: "resources/list",
+        params: message?.params ?? {}
+      });
+      const remoteResources = remote.ok && remote.data?.result?.resources ? remote.data.result.resources : [];
+      const merged = [
+        proxyResource,
+        ...remoteResources.filter((entry) => {
+          const uri = entry?.uri;
+          return uri !== HANDSHAKE_RESOURCE_URI;
+        })
+      ];
+      const resultPayload = {
+        jsonrpc: "2.0",
+        id: message.id,
+        result: {
+          resources: merged
+        }
+      };
+      import_node_process.default.stdout.write(`${JSON.stringify(resultPayload)}
+`);
+      return;
+    }
+    if (!state.workspaceMatched) {
       if (message.id === void 0 || message.id === null) {
         return;
       }
@@ -321,7 +397,7 @@ function createStdioMessageHandler(targetGetter, targetRefresher, stateGetter) {
         id: message.id,
         error: {
           code: state.workspaceSetExplicitly ? ERROR_NO_MATCH : ERROR_WORKSPACE_NOT_SET,
-          message: state.workspaceSetExplicitly ? "Workspace not matched. Call lmTools/requestWorkspaceMCPServer with params.cwd and wait for success." : "Workspace not set. Call lmTools/requestWorkspaceMCPServer with params.cwd before using MCP."
+          message: state.workspaceSetExplicitly ? "Workspace not matched. Call lmToolsBridgeProxy.requestWorkspaceMCPServer with params.cwd and wait for success." : "Workspace not set. Call lmToolsBridgeProxy.requestWorkspaceMCPServer with params.cwd before using MCP."
         }
       };
       if (message?.method === "roots/list") {
@@ -669,14 +745,6 @@ async function main() {
         },
         required: ["cwd"]
       }
-    },
-    {
-      name: STATUS_METHOD,
-      description: "Get proxy status and online state for the current target.",
-      inputSchema: {
-        type: "object",
-        properties: {}
-      }
     }
   ];
   const respondToolCall = (id, payload) => {
@@ -714,7 +782,7 @@ async function main() {
     import_node_process.default.stdout.write(`${JSON.stringify(resultPayload)}
 `);
   };
-  const buildStatusPayload = async () => {
+  const buildStatusPayload2 = async () => {
     let resolveResult;
     if (workspaceSetExplicitly && !workspaceMatched2) {
       const deadline = Date.now() + RESOLVE_RETRY_DELAY_MS;
@@ -908,31 +976,11 @@ async function main() {
         respondToolCall(message.id, result.payload);
         return;
       }
-      if (name === STATUS_METHOD) {
-        const statusResult = await buildStatusPayload();
-        respondToolCall(message.id, statusResult.payload);
-        return;
-      }
       if (!workspaceMatched2) {
         respondToolError(message.id, -32602, `Unknown tool: ${String(name)}`);
         return;
       }
     }
-    if (message?.method === STATUS_METHOD) {
-      logDebug("status.request", { id: message.id ?? null });
-      const statusResult = await buildStatusPayload();
-      logDebug("status.state", statusResult.debug);
-      if (message.id !== void 0 && message.id !== null) {
-        const resultPayload = {
-          jsonrpc: "2.0",
-          id: message.id,
-          result: statusResult.payload
-        };
-        import_node_process.default.stdout.write(`${JSON.stringify(resultPayload)}
-`);
-      }
-      return;
-    }
     if (message?.method === REQUEST_WORKSPACE_METHOD) {
       logDebug("requestWorkspaceMCPServer.request", { id: message.id ?? null, cwd: message?.params?.cwd ?? null });
       const result = await handleRequestWorkspace(message?.params?.cwd);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jiangxiaoxu/lm-tools-bridge-proxy",
-  "version": "0.1.18",
+  "version": "0.1.19",
   "description": "Stdio MCP proxy for LM Tools Bridge (Windows Named Pipe resolve).",
   "license": "MIT",
   "bin": {