fix(core): respect NO_PROXY in global fetch dispatcher

Author: cocosheng-g

packages/core/src/utils/fetch.test.ts

@@ -10,16 +10,16 @@ import * as dnsPromises from 'node:dns/promises';
 import type { LookupAddress, LookupAllOptions } from 'node:dns';
 import ipaddr from 'ipaddr.js';
 
-const { setGlobalDispatcher, Agent, ProxyAgent } = vi.hoisted(() => ({
+const { setGlobalDispatcher, Agent, EnvHttpProxyAgent } = vi.hoisted(() => ({
   setGlobalDispatcher: vi.fn(),
   Agent: vi.fn(),
-  ProxyAgent: vi.fn(),
+  EnvHttpProxyAgent: vi.fn(),
 }));
 
 vi.mock('undici', () => ({
   setGlobalDispatcher,
   Agent,
-  ProxyAgent,
+  EnvHttpProxyAgent,
 }));
 
 vi.mock('node:dns/promises', () => ({
@@ -54,6 +54,7 @@ describe('fetch utils', () => {
       }
       return [{ address: '93.184.216.34', family: 4 }];
     });
+    vi.unstubAllEnvs();
   });
 
   afterEach(() => {
@@ -237,17 +238,36 @@ describe('fetch utils', () => {
   });
 
   describe('setGlobalProxy', () => {
-    it('should configure ProxyAgent with experiment flag timeout', () => {
+    it('should configure EnvHttpProxyAgent with experiment flag timeout and noProxy', () => {
       const proxyUrl = 'http://proxy.example.com';
+      const noProxyValue = 'localhost,127.0.0.1';
+      vi.stubEnv('NO_PROXY', noProxyValue);
+
       updateGlobalFetchTimeouts(45773134);
       setGlobalProxy(proxyUrl);
 
-      expect(ProxyAgent).toHaveBeenCalledWith({
-        uri: proxyUrl,
+      expect(EnvHttpProxyAgent).toHaveBeenCalledWith({
+        httpProxy: proxyUrl,
+        httpsProxy: proxyUrl,
+        noProxy: noProxyValue,
         headersTimeout: 45773134,
         bodyTimeout: 300000,
       });
       expect(setGlobalDispatcher).toHaveBeenCalled();
     });
+
+    it('should fall back to no_proxy if NO_PROXY is not set', () => {
+      const proxyUrl = 'http://proxy.example.com';
+      const noProxyValue = 'localhost,127.0.0.1';
+      vi.stubEnv('no_proxy', noProxyValue);
+
+      setGlobalProxy(proxyUrl);
+
+      expect(EnvHttpProxyAgent).toHaveBeenCalledWith(
+        expect.objectContaining({
+          noProxy: noProxyValue,
+        }),
+      );
+    });
   });
 });

packages/core/src/utils/fetch.ts

@@ -6,7 +6,7 @@
 
 import { getErrorMessage, isAbortError } from './errors.js';
 import { URL } from 'node:url';
-import { Agent, ProxyAgent, setGlobalDispatcher } from 'undici';
+import { Agent, EnvHttpProxyAgent, setGlobalDispatcher } from 'undici';
 import ipaddr from 'ipaddr.js';
 import { lookup } from 'node:dns/promises';
 
@@ -169,11 +169,14 @@ export async function isPrivateIpAsync(url: string): Promise<boolean> {
 }
 
 /**
- * Creates an undici ProxyAgent that incorporates safe DNS lookup.
+ * Creates an undici EnvHttpProxyAgent that incorporates safe DNS lookup.
  */
-export function createSafeProxyAgent(proxyUrl: string): ProxyAgent {
-  return new ProxyAgent({
-    uri: proxyUrl,
+export function createSafeProxyAgent(proxyUrl: string): EnvHttpProxyAgent {
+  const noProxy = process.env['NO_PROXY'] || process.env['no_proxy'];
+  return new EnvHttpProxyAgent({
+    httpProxy: proxyUrl,
+    httpsProxy: proxyUrl,
+    noProxy,
   });
 }
 
@@ -221,9 +224,12 @@ export async function fetchWithTimeout(
 
 export function setGlobalProxy(proxy: string) {
   currentProxy = proxy;
+  const noProxy = process.env['NO_PROXY'] || process.env['no_proxy'];
   setGlobalDispatcher(
-    new ProxyAgent({
-      uri: proxy,
+    new EnvHttpProxyAgent({
+      httpProxy: proxy,
+      httpsProxy: proxy,
+      noProxy,
       headersTimeout: defaultHeadersTimeout,
       bodyTimeout: defaultBodyTimeout,
     }),

packages/core/src/utils/proxy_bypass.test.ts

@@ -0,0 +1,98 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import {
+  EnvHttpProxyAgent,
+  setGlobalDispatcher,
+  getGlobalDispatcher,
+} from 'undici';
+import {
+  setGlobalProxy,
+  fetchWithTimeout,
+  createSafeProxyAgent,
+} from './fetch.js';
+
+describe('Proxy Bypass Integration', () => {
+  const originalDispatcher = getGlobalDispatcher();
+
+  beforeEach(() => {
+    vi.unstubAllEnvs();
+  });
+
+  afterEach(() => {
+    setGlobalDispatcher(originalDispatcher);
+    vi.unstubAllEnvs();
+  });
+
+  it('should bypass proxy for localhost when NO_PROXY is set', async () => {
+    // We use a dummy proxy that will fail if any request is sent to it.
+    const dummyProxy = 'http://1.2.3.4:5678';
+
+    // Set a dummy proxy and NO_PROXY for localhost
+    vi.stubEnv('NO_PROXY', 'localhost');
+
+    // This will set the global dispatcher to a new EnvHttpProxyAgent
+    setGlobalProxy(dummyProxy);
+
+    // We expect fetch to localhost to bypass the proxy.
+    // Since we don't have a real localhost server running in this unit test,
+    // we can't easily do a REAL fetch, but we can verify the dispatcher's behavior.
+
+    const dispatcher = getGlobalDispatcher();
+    expect(dispatcher).toBeInstanceOf(EnvHttpProxyAgent);
+
+    // To do a real integration test, we would need a local server.
+    // Let's start a small http server.
+
+    const http = await import('node:http');
+    const server = http.createServer((req, res) => {
+      res.end('ok');
+    });
+
+    await new Promise<void>((resolve) =>
+      server.listen(0, '127.0.0.1', () => resolve()),
+    );
+    const address = server.address();
+    if (!address || typeof address === 'string') {
+      throw new Error('Server address not found');
+    }
+    const port = address.port;
+    const url = `http://127.0.0.1:${port}`;
+
+    try {
+      // We need NO_PROXY to include 127.0.0.1 (or use localhost and fetch localhost)
+      vi.stubEnv('NO_PROXY', `127.0.0.1,localhost`);
+      setGlobalProxy(dummyProxy);
+
+      // If bypass works, this succeeds. If it tries to use the dummy proxy, it fails/times out.
+      const response = await fetchWithTimeout(url, 1000);
+      expect(await response.text()).toBe('ok');
+    } finally {
+      server.close();
+    }
+  });
+
+  it('should USE proxy for other domains when NO_PROXY is set to localhost', async () => {
+    const dummyProxy = 'http://1.2.3.4:5678';
+    vi.stubEnv('NO_PROXY', 'localhost');
+    setGlobalProxy(dummyProxy);
+
+    // Fetching a public domain should try to use the proxy and fail (since the proxy is dummy).
+    // We expect it to time out or fail with a connection error.
+    await expect(fetchWithTimeout('http://example.com', 500)).rejects.toThrow();
+  });
+
+  it('createSafeProxyAgent should return a proxy agent that respects NO_PROXY', () => {
+    const proxyUrl = 'http://proxy.example.com';
+    const noProxyValue = 'localhost,127.0.0.1';
+    vi.stubEnv('NO_PROXY', noProxyValue);
+
+    const agent = createSafeProxyAgent(proxyUrl);
+    expect(agent).toBeInstanceOf(EnvHttpProxyAgent);
+    // Since we can't easily inspect internal state, this is mostly a type and presence check.
+  });
+});