fix(launcher): exclude localhost from proxy in --remote-control (cnighswonger#257)

--remote-control set HTTPS_PROXY but no NO_PROXY, routing every client connection
(including to local HTTP/SSE-transport MCP servers on 127.0.0.1) at the cache-fix
proxy, which 404s anything but api.anthropic.com. stdio-transport MCPs were
unaffected. Fix: add 127.0.0.1,localhost,::1 to NO_PROXY/no_proxy in forward mode,
merging into any existing value. Reviewed by Codex (APPROVED).

Fixes a v4.3.0 --remote-control regression.

Author: vsits-proxy-builder[bot]

README.md

@@ -54,7 +54,9 @@ Or let the launcher do both steps for you with `--remote-control`:
 cache-fix-proxy --remote-control
 ```
 
-The `--remote-control` flag is the one-command equivalent of the manual wiring above: it starts the proxy in forward-proxy mode, waits for the CA, and launches `claude` pointed at `HTTPS_PROXY` with `NODE_EXTRA_CA_CERTS` set. Without the flag the launcher stays in reverse-proxy mode (sets `ANTHROPIC_BASE_URL`), unchanged. Two things worth knowing: Remote Control does a trusted-device enrollment on first connect that can need a few `/remote-control` retries (a Claude Code step that runs upstream, not a proxy failure); and enabling RC on an already-warm session costs a **single** prompt-cache rebuild (RC adds an `anthropic-beta` the cache keys on), so if you want RC, launching with `--remote-control` from the start avoids that one-time flip. `cache-fix-proxy --help` documents both.
+The `--remote-control` flag is the one-command equivalent of the manual wiring above: it starts the proxy in forward-proxy mode, waits for the CA, and launches `claude` pointed at `HTTPS_PROXY` with `NODE_EXTRA_CA_CERTS` set (and adds `127.0.0.1,localhost,::1` to `NO_PROXY` so local services — e.g. HTTP/SSE-transport MCP servers on localhost — bypass the proxy rather than being routed at it; any existing `NO_PROXY` is preserved). Without the flag the launcher stays in reverse-proxy mode (sets `ANTHROPIC_BASE_URL`), unchanged. Two things worth knowing: Remote Control does a trusted-device enrollment on first connect that can need a few `/remote-control` retries (a Claude Code step that runs upstream, not a proxy failure); and enabling RC on an already-warm session costs a **single** prompt-cache rebuild (RC adds an `anthropic-beta` the cache keys on), so if you want RC, launching with `--remote-control` from the start avoids that one-time flip. `cache-fix-proxy --help` documents both.
+
+> If you wire forward-proxy mode manually (setting `HTTPS_PROXY` yourself instead of using `--remote-control`), set `NO_PROXY=127.0.0.1,localhost,::1` as well, or local HTTP-transport MCP servers and other localhost services will be routed at the cache-fix proxy and fail. stdio-transport MCP servers are unaffected (they use pipes, not the network).
 
 How it works: the proxy also handles HTTP `CONNECT`. It MITMs **only** the upstream host (`api.anthropic.com`), terminating TLS with a locally-generated CA so it can run the same extension pipeline, and **blind-tunnels every other CONNECT** (mcp-proxy, telemetry, npm, ...) untouched. On first start it generates a CA under `$CLAUDE_CONFIG_DIR/cache-fix-ca/` (default `~/.claude/cache-fix-ca/`; override with `CACHE_FIX_CA_DIR`); the client must trust it via `NODE_EXTRA_CA_CERTS`. A WebSocket/Upgrade to the upstream host (e.g. `/voice`) is relayed to upstream as-is. Because base URL stays `api.anthropic.com`, all of `/api/oauth/*`, `/v1/agents`, Remote Control credential fetches, etc. pass through untouched and RC stays enabled.
 

bin/claude-via-proxy.mjs

@@ -72,7 +72,9 @@ async function dispatch() {
         "                         ANTHROPIC_BASE_URL, so Claude Code stays first-party\n" +
         "                         and Remote Control / mobile session visibility keeps\n" +
         "                         working (CC >= 2.1.196 disables it when\n" +
-        "                         ANTHROPIC_BASE_URL is set).\n" +
+        "                         ANTHROPIC_BASE_URL is set). Also adds localhost to\n" +
+        "                         NO_PROXY so local HTTP MCP servers / services bypass\n" +
+        "                         the proxy (any existing NO_PROXY is preserved).\n" +
         "\nEnvironment:\n" +
         "  CACHE_FIX_PROXY_PORT     Port for the proxy server\n" +
         "  CACHE_FIX_PROXY_UPSTREAM Upstream URL\n" +
@@ -210,6 +212,23 @@ if (remoteControl) {
   claudeEnv.HTTPS_PROXY = proxyUrl;
   claudeEnv.https_proxy = proxyUrl;
   claudeEnv.NODE_EXTRA_CA_CERTS = caPem;
+  // Exclude localhost from the proxy. Without this, HTTPS_PROXY routes EVERY
+  // connection claude makes — including to local services like HTTP/SSE-transport
+  // MCP servers (e.g. an MCP on 127.0.0.1) — at the cache-fix proxy, which only
+  // knows how to serve api.anthropic.com and 404s the rest. stdio-transport MCPs
+  // are unaffected (they're pipes, no network), which is why only network-transport
+  // local services break. Merge into any existing NO_PROXY rather than clobber it
+  // (a corporate env may already set one). Set both cases to cover libs that read
+  // either variable.
+  const NO_PROXY_LOCAL = "127.0.0.1,localhost,::1";
+  const mergeNoProxy = (existing) => {
+    const parts = (existing || "").split(",").map((s) => s.trim()).filter(Boolean);
+    for (const h of NO_PROXY_LOCAL.split(",")) if (!parts.includes(h)) parts.push(h);
+    return parts.join(",");
+  };
+  const merged = mergeNoProxy(claudeEnv.NO_PROXY || claudeEnv.no_proxy);
+  claudeEnv.NO_PROXY = merged;
+  claudeEnv.no_proxy = merged;
 } else {
   claudeEnv = {
     ...process.env,

test/proxy-wrapper.test.mjs

@@ -188,4 +188,107 @@ describe("launch wrapper (claude-via-proxy)", { concurrency: 1 }, () => {
       `NODE_EXTRA_CA_CERTS should be the CACHE_FIX_CA_DIR override (${join(caDir, "ca.pem")}), got: ${stdout}`,
     );
   });
+
+  it("--remote-control excludes localhost via NO_PROXY (so local HTTP MCP servers aren't misrouted)", async () => {
+    // Without NO_PROXY, HTTPS_PROXY routes every connection — including to local
+    // HTTP/SSE-transport MCP servers on 127.0.0.1 — at the cache-fix proxy, which
+    // 404s anything that isn't api.anthropic.com. The launcher must exclude
+    // localhost. The child prints both NO_PROXY and no_proxy.
+    const script =
+      'process.stdout.write("NP="+(process.env.NO_PROXY||"UNSET")+' +
+      '"|np="+(process.env.no_proxy||"UNSET")+"\\n")';
+    const wrapperProc = fork(WRAPPER_PATH, ["--remote-control", "--proxy-port", "0"], {
+      stdio: ["ignore", "pipe", "pipe", "ipc"],
+      env: cleanEnv({ CACHE_FIX_CLAUDE_CMD: `${NODE} -e ${script}` }),
+    });
+
+    let stdout = "";
+    let stderr = "";
+    wrapperProc.stdout.on("data", (c) => { stdout += c.toString(); });
+    wrapperProc.stderr.on("data", (c) => { stderr += c.toString(); });
+
+    const code = await new Promise((resolve) => {
+      wrapperProc.on("exit", (c) => resolve(c));
+      setTimeout(() => { wrapperProc.kill("SIGTERM"); resolve(null); }, 15000);
+    });
+
+    assert.equal(code, 0, `Expected exit 0, got ${code}. stderr: ${stderr}`);
+    // Both NO_PROXY and no_proxy must cover localhost.
+    for (const host of ["127.0.0.1", "localhost", "::1"]) {
+      assert.ok(stdout.includes(host), `NO_PROXY should include ${host}, got: ${stdout}`);
+    }
+    assert.match(stdout, /NP=\S*127\.0\.0\.1/, `NO_PROXY should be set in forward mode, got: ${stdout}`);
+    assert.match(stdout, /np=\S*127\.0\.0\.1/, `no_proxy should be set in forward mode, got: ${stdout}`);
+  });
+
+  it("--remote-control merges localhost into an existing NO_PROXY rather than clobbering it", async () => {
+    const script = 'process.stdout.write("NP="+(process.env.NO_PROXY||"UNSET")+"\\n")';
+    const wrapperProc = fork(WRAPPER_PATH, ["--remote-control", "--proxy-port", "0"], {
+      stdio: ["ignore", "pipe", "pipe", "ipc"],
+      env: cleanEnv({ CACHE_FIX_CLAUDE_CMD: `${NODE} -e ${script}`, NO_PROXY: "example.com" }),
+    });
+
+    let stdout = "";
+    let stderr = "";
+    wrapperProc.stdout.on("data", (c) => { stdout += c.toString(); });
+    wrapperProc.stderr.on("data", (c) => { stderr += c.toString(); });
+
+    const code = await new Promise((resolve) => {
+      wrapperProc.on("exit", (c) => resolve(c));
+      setTimeout(() => { wrapperProc.kill("SIGTERM"); resolve(null); }, 15000);
+    });
+
+    assert.equal(code, 0, `Expected exit 0, got ${code}. stderr: ${stderr}`);
+    assert.ok(stdout.includes("example.com"), `existing NO_PROXY entry should be preserved, got: ${stdout}`);
+    assert.ok(stdout.includes("127.0.0.1"), `localhost should be merged in, got: ${stdout}`);
+  });
+
+  it("--remote-control reads a lowercase-only no_proxy and preserves it", async () => {
+    // The existing value may be set under the lowercase name only; the merge
+    // must read either variant, not just NO_PROXY.
+    const script = 'process.stdout.write("NP="+(process.env.NO_PROXY||"UNSET")+"\\n")';
+    const wrapperProc = fork(WRAPPER_PATH, ["--remote-control", "--proxy-port", "0"], {
+      stdio: ["ignore", "pipe", "pipe", "ipc"],
+      env: cleanEnv({ CACHE_FIX_CLAUDE_CMD: `${NODE} -e ${script}`, no_proxy: "corp.internal" }),
+    });
+
+    let stdout = "";
+    let stderr = "";
+    wrapperProc.stdout.on("data", (c) => { stdout += c.toString(); });
+    wrapperProc.stderr.on("data", (c) => { stderr += c.toString(); });
+
+    const code = await new Promise((resolve) => {
+      wrapperProc.on("exit", (c) => resolve(c));
+      setTimeout(() => { wrapperProc.kill("SIGTERM"); resolve(null); }, 15000);
+    });
+
+    assert.equal(code, 0, `Expected exit 0, got ${code}. stderr: ${stderr}`);
+    assert.ok(stdout.includes("corp.internal"), `lowercase no_proxy entry should be preserved, got: ${stdout}`);
+    assert.ok(stdout.includes("127.0.0.1"), `localhost should be merged in, got: ${stdout}`);
+  });
+
+  it("--remote-control does not duplicate a localhost host already present in NO_PROXY", async () => {
+    const script = 'process.stdout.write("NP="+(process.env.NO_PROXY||"UNSET")+"\\n")';
+    const wrapperProc = fork(WRAPPER_PATH, ["--remote-control", "--proxy-port", "0"], {
+      stdio: ["ignore", "pipe", "pipe", "ipc"],
+      env: cleanEnv({ CACHE_FIX_CLAUDE_CMD: `${NODE} -e ${script}`, NO_PROXY: "127.0.0.1" }),
+    });
+
+    let stdout = "";
+    let stderr = "";
+    wrapperProc.stdout.on("data", (c) => { stdout += c.toString(); });
+    wrapperProc.stderr.on("data", (c) => { stderr += c.toString(); });
+
+    const code = await new Promise((resolve) => {
+      wrapperProc.on("exit", (c) => resolve(c));
+      setTimeout(() => { wrapperProc.kill("SIGTERM"); resolve(null); }, 15000);
+    });
+
+    assert.equal(code, 0, `Expected exit 0, got ${code}. stderr: ${stderr}`);
+    // 127.0.0.1 must appear exactly once, not duplicated, and localhost still added.
+    const np = (stdout.match(/NP=(\S*)/) || [])[1] || "";
+    const occurrences = np.split(",").filter((h) => h === "127.0.0.1").length;
+    assert.equal(occurrences, 1, `127.0.0.1 should appear exactly once, got NP=${np}`);
+    assert.ok(np.split(",").includes("localhost"), `localhost should be added, got NP=${np}`);
+  });
 });