PR #50650: fix(infra/net): use EnvHttpProxyAgent when proxy env vars are configured

• Repository: openclaw/openclaw
• Author: kkav004
• State: open | merged: False
• Link: https://github.com/openclaw/openclaw/pull/50650

Description (problem / solution / changelog)

Problem

When HTTPS_PROXY / HTTP_PROXY environment variables are set, web_fetch (and other tools using fetchWithSsrFGuard without an explicit dispatcherPolicy.mode) fail with fetch failed or getaddrinfo EAI_AGAIN. The pinned dispatcher connects directly to the DNS-resolved IP, bypassing the proxy entirely.

This breaks OpenClaw in:

• OpenShell/NemoClaw sandboxes — DNS is blocked in the network namespace, and direct outbound TCP is only routable through the proxy
• Docker containers with proxy-only network access
• Corporate networks requiring proxy for all HTTPS traffic

The TRUSTED_ENV_PROXY mode (#45248) works correctly but requires explicit opt-in. The default STRICT mode always uses createPinnedDispatcher in direct mode, which bypasses the proxy.

Fix

Two files changed.

src/infra/net/fetch-guard.ts — When hasEnvHttpProxyConfigured() returns true and the caller hasn't already specified a dispatcherPolicy.mode or allowed private networks, use createPinnedDispatcher with mode: "env-proxy" instead of the default direct mode:

+import { hasEnvHttpProxyConfigured, hasProxyEnvConfigured } from "./proxy-env.js";
-import { hasProxyEnvConfigured } from "./proxy-env.js";

       } else if (params.pinDns !== false) {
-        dispatcher = createPinnedDispatcher(pinned, params.dispatcherPolicy, params.policy);
+        const protocol = parsedUrl.protocol === "http:" ? "http" : "https";
+        const useEnvProxy =
+          hasEnvHttpProxyConfigured(protocol) &&
+          !params.dispatcherPolicy?.mode &&
+          !params.policy?.allowPrivateNetwork &&
+          !params.policy?.dangerouslyAllowPrivateNetwork;
+        const dispatcherPolicy: PinnedDispatcherPolicy | undefined = useEnvProxy
+          ? Object.assign({}, params.dispatcherPolicy, { mode: "env-proxy" as const })
+          : params.dispatcherPolicy;
+        dispatcher = createPinnedDispatcher(pinned, dispatcherPolicy, params.policy);
       }

src/infra/net/fetch-guard.ssrf.test.ts — Updated test expectations to reflect that STRICT mode now uses EnvHttpProxyAgent (via pinned env-proxy dispatcher) when proxy env vars are configured:

-  it("ignores env proxy by default to preserve DNS-pinned destination binding", async () => {
+  it("routes through env proxy in strict mode via pinned env-proxy dispatcher", async () => {
     await runProxyModeDispatcherTest({
       mode: GUARDED_FETCH_MODE.STRICT,
-      expectEnvProxy: false,
+      expectEnvProxy: true,
     });
   });

-  it("uses env proxy only when dangerous proxy bypass is explicitly enabled", async () => {
+  it("routes through env proxy when trusted proxy mode is explicitly enabled", async () => {

What's preserved:

• DNS pinning — createPinnedDispatcher threads the pinned lookup into EnvHttpProxyAgent via connect: withPinnedLookup() in its existing env-proxy mode
• SSRF validation — resolvePinnedHostnameWithPolicy() still runs before the dispatcher is created
• Explicit dispatcher policies — callers with mode: "explicit-proxy" (Telegram media), mode: "direct" (fallback recovery), or any other mode are not overridden
• Private/local network access — callers with allowPrivateNetwork or dangerouslyAllowPrivateNetwork stay on the direct pinned path (BlueBubbles, remote memory over LAN)
• TRUSTED_ENV_PROXY — unchanged, remains the explicit opt-in for unpinned proxy routing
• Protocol-aware detection — uses hasEnvHttpProxyConfigured(protocol) so http:// URLs only trigger env-proxy when HTTP_PROXY is set
• No proxy configured — falls through to existing direct mode behavior

How I found this

Deploying NemoClaw (NVIDIA's OpenClaw wrapper) inside an OpenShell sandbox. The sandbox has NODE_USE_ENV_PROXY=1, HTTPS_PROXY, and NODE_EXTRA_CA_CERTS configured — raw fetch() works natively. But web_fetch fails because the SSRF guard's pinned dispatcher in direct mode bypasses the proxy.

The env-proxy mode already existed in createPinnedDispatcher (in ssrf.ts) and correctly threads DNS pinning through EnvHttpProxyAgent. This PR just activates it when proxy env vars are detected and the caller hasn't opted out.

Testing

• All 14 tests in fetch-guard.ssrf.test.ts pass locally
• pnpm check passes locally (format, types, lint, all boundary checks)
• Verified web_fetch works for google.com, httpbin.org, bbc.com, api.github.com in an OpenShell sandbox
• SSRF validation still blocks private/reserved IPs
• Slack API, Jira API, and Codex inference unaffected
• No proxy configured → existing direct mode (unchanged)
• Callers with explicit dispatcherPolicy.mode → not overridden
• Callers with allowPrivateNetwork / dangerouslyAllowPrivateNetwork → direct pinned path preserved

Fixes

• #47598 — web_fetch doesn't work behind HTTP proxy
• #49948 — web_fetch fails when HTTPS proxy is enabled
• #32947 — web_fetch always fails even for example.com
• #46306 — web_fetch fails behind proxy with getaddrinfo EAI_AGAIN

Changed files

• src/infra/net/fetch-guard.ssrf.test.ts (modified, +3/-3)
• src/infra/net/fetch-guard.ts (modified, +16/-2)