@jiangxiaoxu/lm-tools-bridge-proxy 0.1.0 → 0.1.2

package/README.md

@@ -11,9 +11,19 @@ args = ["-y", "@jiangxiaoxu/lm-tools-bridge-proxy"]
 
 The proxy uses the current working directory (`cwd`) to resolve the VS Code instance.
 
+## Logging
+
+Set `LM_TOOLS_BRIDGE_PROXY_LOG` to a file path to enable log output. If unset, the proxy emits no logs.
+
+## Resolve test
+
+```
+node ./scripts/resolve-test.mjs --cwd <workspace-path>
+```
+
 ## Development
 
 ```
 npm install
 npm run build
-```
+```

package/dist/index.js

@@ -27,10 +27,15 @@ var import_node_http = __toESM(require("node:http"));
 var import_node_process = __toESM(require("node:process"));
 var import_node_crypto = __toESM(require("node:crypto"));
 var import_node_os = __toESM(require("node:os"));
+var import_node_fs = __toESM(require("node:fs"));
 var MANAGER_TIMEOUT_MS = 1500;
-var RESOLVE_RETRIES = 5;
-var RESOLVE_RETRY_DELAY_MS = 1e3;
-var TARGET_HOST_HEADER = "x-mcp-target";
+var RESOLVE_RETRIES = 10;
+var RESOLVE_RETRY_DELAY_MS = 500;
+var STARTUP_GRACE_MS = 5e3;
+var LOG_ENV = "LM_TOOLS_BRIDGE_PROXY_LOG";
+var ERROR_MANAGER_UNREACHABLE = -32003;
+var ERROR_NO_MATCH = -32004;
+var STARTUP_TIME = Date.now();
 function getUserSeed() {
   return import_node_process.default.env.USERNAME ?? import_node_process.default.env.USERPROFILE ?? import_node_os.default.userInfo().username ?? "default-user";
 }
@@ -43,15 +48,42 @@ async function delay(ms) {
     setTimeout(resolve, ms);
   });
 }
-async function resolveTarget(cwd) {
-  for (let attempt = 0; attempt < RESOLVE_RETRIES; attempt += 1) {
+async function resolveTargetWithDeadline(cwd, deadlineMs) {
+  let sawNoMatch = false;
+  let sawUnreachable = false;
+  while (Date.now() < deadlineMs) {
     const result = await managerRequest("POST", "/resolve", { cwd });
     if (result.ok && result.data && result.data.match) {
-      return result.data.match;
+      return { target: result.data.match, errorKind: void 0 };
+    }
+    if (result.errorKind === "no_match") {
+      sawNoMatch = true;
+    } else if (result.errorKind === "unreachable") {
+      sawUnreachable = true;
     }
-    await delay(RESOLVE_RETRY_DELAY_MS);
+    const remaining = deadlineMs - Date.now();
+    if (remaining <= 0) {
+      break;
+    }
+    await delay(Math.min(RESOLVE_RETRY_DELAY_MS, remaining));
+  }
+  if (sawNoMatch) {
+    return { target: void 0, errorKind: "no_match" };
   }
-  return void 0;
+  if (sawUnreachable) {
+    return { target: void 0, errorKind: "unreachable" };
+  }
+  return { target: void 0, errorKind: "unreachable" };
+}
+async function resolveTarget(cwd) {
+  const deadline = Date.now() + RESOLVE_RETRIES * RESOLVE_RETRY_DELAY_MS;
+  return resolveTargetWithDeadline(cwd, deadline);
+}
+function isSameTarget(left, right) {
+  if (!left || !right) {
+    return false;
+  }
+  return left.host === right.host && left.port === right.port;
 }
 async function managerRequest(method, requestPath, body) {
   return new Promise((resolve) => {
@@ -71,6 +103,10 @@ async function managerRequest(method, requestPath, body) {
         response.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
         response.on("end", () => {
           const status = response.statusCode ?? 500;
+          if (status === 404) {
+            resolve({ ok: false, status, errorKind: "no_match" });
+            return;
+          }
           if (chunks.length === 0) {
             resolve({ ok: status >= 200 && status < 300, status });
             return;
@@ -90,7 +126,7 @@ async function managerRequest(method, requestPath, body) {
     }, MANAGER_TIMEOUT_MS);
     request.on("error", () => {
       clearTimeout(timeout);
-      resolve({ ok: false });
+      resolve({ ok: false, errorKind: "unreachable" });
     });
     request.on("close", () => {
       clearTimeout(timeout);
@@ -101,68 +137,151 @@ async function managerRequest(method, requestPath, body) {
     request.end();
   });
 }
-function createStdioMessageHandler(target) {
-  const targetUrl = new URL(`http://${target.host}:${target.port}/mcp`);
-  return (message) => {
+function getLogPath() {
+  return import_node_process.default.env[LOG_ENV];
+}
+function appendLog(message) {
+  const logPath = getLogPath();
+  if (!logPath) {
+    return;
+  }
+  try {
+    import_node_fs.default.appendFileSync(logPath, `${message}
+`, { encoding: "utf8" });
+  } catch {
+  }
+}
+function createStdioMessageHandler(targetGetter, targetRefresher) {
+  return async (message) => {
     const payload = JSON.stringify(message);
-    const request = import_node_http.default.request(
-      {
-        hostname: targetUrl.hostname,
-        port: Number(targetUrl.port),
-        path: targetUrl.pathname,
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "Content-Length": Buffer.byteLength(payload),
-          [TARGET_HOST_HEADER]: `${target.host}:${target.port}`
+    let target = targetGetter();
+    if (!target) {
+      const now2 = Date.now();
+      const graceDeadline2 = STARTUP_TIME + STARTUP_GRACE_MS;
+      const refreshResult2 = await targetRefresher(now2 < graceDeadline2 ? graceDeadline2 : void 0);
+      target = refreshResult2?.target;
+      if (!target) {
+        appendLog("No target resolved for MCP proxy.");
+        if (message.id === void 0 || message.id === null) {
+          return;
         }
-      },
-      (response) => {
-        const chunks = [];
-        response.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
-        response.on("end", () => {
-          const text = Buffer.concat(chunks).toString("utf8");
-          if (text.length > 0) {
-            import_node_process.default.stdout.write(`${text}
+        const errorKind = refreshResult2?.errorKind ?? "unreachable";
+        const errorPayload2 = {
+          jsonrpc: "2.0",
+          id: message.id,
+          error: {
+            code: errorKind === "no_match" ? ERROR_NO_MATCH : ERROR_MANAGER_UNREACHABLE,
+            message: errorKind === "no_match" ? "No matching VS Code instance for current workspace." : "Manager unreachable."
+          }
+        };
+        import_node_process.default.stdout.write(`${JSON.stringify(errorPayload2)}
 `);
+        return;
+      }
+    }
+    const attemptSend = async (sendTarget) => {
+      return new Promise((resolve) => {
+        const targetUrl = new URL(`http://${sendTarget.host}:${sendTarget.port}/mcp`);
+        const request = import_node_http.default.request(
+          {
+            hostname: targetUrl.hostname,
+            port: Number(targetUrl.port),
+            path: targetUrl.pathname,
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              "Content-Length": Buffer.byteLength(payload)
+            }
+          },
+          (response) => {
+            const chunks = [];
+            response.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
+            response.on("end", () => {
+              const text = Buffer.concat(chunks).toString("utf8");
+              if (text.length > 0) {
+                import_node_process.default.stdout.write(`${text}
+`);
+              }
+              resolve({ ok: true });
+            });
           }
+        );
+        request.on("error", (error) => {
+          resolve({ ok: false, error });
         });
+        request.write(payload);
+        request.end();
+      });
+    };
+    const firstAttempt = await attemptSend(target);
+    if (firstAttempt.ok) {
+      return;
+    }
+    appendLog(`MCP proxy request failed: ${String(firstAttempt.error)}`);
+    const now = Date.now();
+    const graceDeadline = STARTUP_TIME + STARTUP_GRACE_MS;
+    const refreshResult = await targetRefresher(now < graceDeadline ? graceDeadline : void 0);
+    const refreshed = refreshResult?.target;
+    if (!refreshed || isSameTarget(target, refreshed)) {
+      const errorKind = refreshResult?.errorKind ?? "unreachable";
+      if (message.id === void 0 || message.id === null) {
+        return;
       }
-    );
-    request.on("error", (error) => {
-      const errorPayload = {
+      const errorPayload2 = {
         jsonrpc: "2.0",
-        id: message.id ?? null,
+        id: message.id,
         error: {
-          code: -32e3,
-          message: `MCP proxy request failed: ${String(error)}`
+          code: errorKind === "no_match" ? ERROR_NO_MATCH : ERROR_MANAGER_UNREACHABLE,
+          message: errorKind === "no_match" ? "No matching VS Code instance for current workspace." : "Manager unreachable."
         }
       };
-      import_node_process.default.stdout.write(`${JSON.stringify(errorPayload)}
+      import_node_process.default.stdout.write(`${JSON.stringify(errorPayload2)}
 `);
-    });
-    request.write(payload);
-    request.end();
-  };
-}
-async function main() {
-  const cwd = import_node_process.default.cwd();
-  const target = await resolveTarget(cwd);
-  if (!target) {
+      return;
+    }
+    const retryAttempt = await attemptSend(refreshed);
+    if (retryAttempt.ok) {
+      return;
+    }
+    appendLog(`MCP proxy retry failed: ${String(retryAttempt.error)}`);
+    if (message.id === void 0 || message.id === null) {
+      return;
+    }
     const errorPayload = {
       jsonrpc: "2.0",
-      id: null,
+      id: message.id,
       error: {
-        code: -32001,
-        message: `No VS Code instance registered for cwd: ${cwd}`
+        code: ERROR_MANAGER_UNREACHABLE,
+        message: "Manager unreachable."
       }
     };
     import_node_process.default.stdout.write(`${JSON.stringify(errorPayload)}
 `);
-    import_node_process.default.exit(1);
-    return;
+  };
+}
+async function main() {
+  const cwd = import_node_process.default.cwd();
+  let currentTargetResult = await resolveTarget(cwd);
+  let currentTarget = currentTargetResult.target;
+  if (!currentTarget) {
+    appendLog(`No VS Code instance registered for cwd: ${cwd}`);
   }
-  const handler = createStdioMessageHandler(target);
+  let resolveInFlight;
+  const refreshTarget = async (deadlineMs) => {
+    if (resolveInFlight) {
+      return resolveInFlight;
+    }
+    const resolver = deadlineMs ? resolveTargetWithDeadline(cwd, deadlineMs) : resolveTarget(cwd);
+    resolveInFlight = resolver.finally(() => {
+      resolveInFlight = void 0;
+    });
+    const resolved = await resolveInFlight;
+    if (resolved?.target) {
+      currentTarget = resolved.target;
+    }
+    return resolved;
+  };
+  const handler = createStdioMessageHandler(() => currentTarget, refreshTarget);
   let buffer = "";
   import_node_process.default.stdin.setEncoding("utf8");
   import_node_process.default.stdin.on("data", (chunk) => {
@@ -174,8 +293,9 @@ async function main() {
       if (line.length > 0) {
         try {
           const message = JSON.parse(line);
-          handler(message);
+          void handler(message);
         } catch {
+          appendLog("Invalid JSON received by MCP proxy.");
           const errorPayload = {
             jsonrpc: "2.0",
             id: null,
@@ -196,6 +316,7 @@ async function main() {
   });
 }
 main().catch((error) => {
+  appendLog(`MCP proxy startup failed: ${String(error)}`);
   const errorPayload = {
     jsonrpc: "2.0",
     id: null,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jiangxiaoxu/lm-tools-bridge-proxy",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Stdio MCP proxy for LM Tools Bridge (Windows Named Pipe resolve).",
   "license": "MIT",
   "bin": {
@@ -23,4 +23,4 @@
     "esbuild": "^0.27.2",
     "typescript": "^5.4.5"
   }
-}
+}