Merge pull request #726 from Kherrisan/main

feat: add support for setting the global fetch proxy through HTTP_PROXY

tests/unit/cliproxy/binary-downloader-proxy.test.ts

@@ -68,6 +68,12 @@ describe('Binary Downloader Proxy Support', () => {
         process.env.ALL_PROXY = 'http://allproxy:8080';
         expect(getProxyUrl(true)).toBe('http://allproxy:8080');
       });
+
+      it('should skip invalid HTTP_PROXY and fall back to ALL_PROXY', () => {
+        process.env.HTTP_PROXY = 'not-a-valid-url';
+        process.env.ALL_PROXY = 'http://allproxy:8080';
+        expect(getProxyUrl(true)).toBe('http://allproxy:8080');
+      });
     });
 
     describe('HTTP requests', () => {
@@ -91,6 +97,12 @@ describe('Binary Downloader Proxy Support', () => {
         expect(getProxyUrl(false)).toBe('http://allproxy:8080');
       });
 
+      it('should skip invalid HTTP_PROXY and use ALL_PROXY for HTTP', () => {
+        process.env.HTTP_PROXY = 'not-a-valid-url';
+        process.env.ALL_PROXY = 'http://allproxy:8080';
+        expect(getProxyUrl(false)).toBe('http://allproxy:8080');
+      });
+
       it('should not use https_proxy for HTTP requests', () => {
         process.env.https_proxy = 'http://httpsproxy:8080';
         expect(getProxyUrl(false)).toBeUndefined();
@@ -251,6 +263,11 @@ describe('Binary Downloader Proxy Support', () => {
         expect(getProxyAgent('https://example.com')).toBe(false);
       });
 
+      it('should keep supporting socks proxy URLs for downloader traffic', () => {
+        process.env.https_proxy = 'socks5://proxy:1080';
+        expect(getProxyAgent('https://example.com')).not.toBe(false);
+      });
+
       it('should return false for invalid target URL', () => {
         process.env.https_proxy = 'http://proxy:8080';
         expect(getProxyAgent('not-a-url')).toBe(false);

tests/unit/utils/fetch-proxy-setup.test.ts

@@ -0,0 +1,198 @@
+import { afterEach, beforeEach, describe, expect, it } from 'bun:test';
+import * as http from 'node:http';
+import {
+  Agent,
+  Dispatcher,
+  ProxyAgent,
+  fetch,
+  getGlobalDispatcher,
+  setGlobalDispatcher,
+} from 'undici';
+import {
+  applyGlobalFetchProxy,
+  createGlobalFetchProxyDispatcher,
+} from '../../../src/utils/fetch-proxy-setup';
+
+const PROXY_ENV_KEYS = [
+  'http_proxy',
+  'HTTP_PROXY',
+  'https_proxy',
+  'HTTPS_PROXY',
+  'all_proxy',
+  'ALL_PROXY',
+  'no_proxy',
+  'NO_PROXY',
+] as const;
+
+describe('global fetch proxy setup', () => {
+  const originalEnv = new Map<string, string | undefined>();
+  const originalDispatcher = getGlobalDispatcher();
+
+  beforeEach(() => {
+    for (const key of PROXY_ENV_KEYS) {
+      originalEnv.set(key, process.env[key]);
+      delete process.env[key];
+    }
+    setGlobalDispatcher(originalDispatcher);
+  });
+
+  afterEach(() => {
+    setGlobalDispatcher(originalDispatcher);
+    for (const key of PROXY_ENV_KEYS) {
+      const value = originalEnv.get(key);
+      if (value === undefined) {
+        delete process.env[key];
+      } else {
+        process.env[key] = value;
+      }
+    }
+  });
+
+  async function captureDispatchRouting(
+    origin: string
+  ): Promise<{ directCalls: number; proxyCalls: number }> {
+    const dispatcher = createGlobalFetchProxyDispatcher();
+    if (!dispatcher) {
+      throw new Error('Expected proxy dispatcher to be configured');
+    }
+
+    let directCalls = 0;
+    let proxyCalls = 0;
+    const originalAgentDispatch = Agent.prototype.dispatch;
+    const originalProxyDispatch = ProxyAgent.prototype.dispatch;
+
+    Agent.prototype.dispatch = function mockAgentDispatch(
+      _options: Dispatcher.DispatchOptions,
+      _handler: Dispatcher.DispatchHandlers
+    ): boolean {
+      directCalls += 1;
+      return true;
+    };
+
+    ProxyAgent.prototype.dispatch = function mockProxyDispatch(
+      _options: Dispatcher.DispatchOptions,
+      _handler: Dispatcher.DispatchHandlers
+    ): boolean {
+      proxyCalls += 1;
+      return true;
+    };
+
+    try {
+      dispatcher.dispatch(
+        {
+          origin,
+          method: 'GET',
+          path: '/',
+        } as Dispatcher.DispatchOptions,
+        {} as Dispatcher.DispatchHandlers
+      );
+    } finally {
+      Agent.prototype.dispatch = originalAgentDispatch;
+      ProxyAgent.prototype.dispatch = originalProxyDispatch;
+    }
+
+    return { directCalls, proxyCalls };
+  }
+
+  it('does not fail when proxy configuration is invalid', () => {
+    process.env.HTTP_PROXY = 'not-a-valid-url';
+
+    expect(applyGlobalFetchProxy()).toEqual({
+      enabled: false,
+      error: 'Invalid URL',
+    });
+  });
+
+  it('rejects unsupported proxy protocols for global fetch setup', () => {
+    process.env.ALL_PROXY = 'socks5://proxy:1080';
+
+    expect(applyGlobalFetchProxy()).toEqual({
+      enabled: false,
+      error: 'Unsupported proxy protocol: socks5:',
+    });
+  });
+
+  it('rebinds globalThis.fetch to undici fetch when proxying is enabled', () => {
+    const originalFetch = globalThis.fetch;
+    process.env.HTTP_PROXY = 'http://proxy.example:8080';
+
+    try {
+      expect(applyGlobalFetchProxy()).toEqual({ enabled: true });
+      expect(globalThis.fetch).toBe(fetch);
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+  });
+
+  it('bypasses loopback fetches even when HTTP_PROXY is set', async () => {
+    process.env.HTTP_PROXY = 'http://127.0.0.1:9';
+
+    const server = http.createServer((_req, res) => {
+      res.writeHead(200, { 'content-type': 'text/plain' });
+      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('Failed to bind test server');
+    }
+
+    try {
+      expect(applyGlobalFetchProxy()).toEqual({ enabled: true });
+
+      const response = await fetch(`http://127.0.0.1:${address.port}/health`);
+      expect(response.status).toBe(200);
+      expect(await response.text()).toBe('ok');
+    } finally {
+      await new Promise<void>((resolve, reject) => {
+        server.close((error) => (error ? reject(error) : resolve()));
+      });
+    }
+  });
+
+  it('routes non-loopback HTTP requests through HTTP_PROXY', async () => {
+    process.env.HTTP_PROXY = 'http://proxy.example:8080';
+
+    const result = await captureDispatchRouting('http://example.com/quota');
+    expect(result).toEqual({ directCalls: 0, proxyCalls: 1 });
+  });
+
+  it('routes HTTPS requests through HTTPS_PROXY', async () => {
+    process.env.HTTPS_PROXY = 'http://proxy.example:8443';
+
+    const result = await captureDispatchRouting('https://example.com/secure');
+    expect(result).toEqual({ directCalls: 0, proxyCalls: 1 });
+  });
+
+  it('supports ALL_PROXY as a fetch proxy fallback', async () => {
+    process.env.ALL_PROXY = 'http://proxy.example:8080';
+
+    const result = await captureDispatchRouting('http://example.com/all-proxy');
+    expect(result).toEqual({ directCalls: 0, proxyCalls: 1 });
+  });
+
+  it('falls back to ALL_PROXY when HTTP_PROXY is invalid', async () => {
+    process.env.HTTP_PROXY = 'not-a-valid-url';
+    process.env.ALL_PROXY = 'http://proxy.example:8080';
+
+    const result = await captureDispatchRouting('http://example.com/fallback');
+    expect(result).toEqual({ directCalls: 0, proxyCalls: 1 });
+  });
+
+  it('falls back from invalid HTTPS_PROXY to HTTP_PROXY for HTTPS requests', async () => {
+    process.env.HTTPS_PROXY = 'not-a-valid-url';
+    process.env.HTTP_PROXY = 'http://proxy.example:8080';
+
+    const result = await captureDispatchRouting('https://example.com/fallback-secure');
+    expect(result).toEqual({ directCalls: 0, proxyCalls: 1 });
+  });
+
+  it('honors NO_PROXY on the fetch routing path', async () => {
+    process.env.HTTP_PROXY = 'http://proxy.example:8080';
+    process.env.NO_PROXY = 'example.com';
+
+    const result = await captureDispatchRouting('http://example.com/direct');
+    expect(result).toEqual({ directCalls: 1, proxyCalls: 0 });
+  });
+});

tests/unit/utils/proxy-env.test.ts

@@ -0,0 +1,96 @@
+import { afterEach, beforeEach, describe, expect, it } from 'bun:test';
+import { getProxyResolution, shouldBypassProxy } from '../../../src/utils/proxy-env';
+
+const PROXY_ENV_KEYS = [
+  'http_proxy',
+  'HTTP_PROXY',
+  'https_proxy',
+  'HTTPS_PROXY',
+  'all_proxy',
+  'ALL_PROXY',
+  'no_proxy',
+  'NO_PROXY',
+] as const;
+
+describe('proxy env helpers', () => {
+  const originalEnv = new Map<string, string | undefined>();
+
+  beforeEach(() => {
+    for (const key of PROXY_ENV_KEYS) {
+      originalEnv.set(key, process.env[key]);
+      delete process.env[key];
+    }
+  });
+
+  afterEach(() => {
+    for (const key of PROXY_ENV_KEYS) {
+      const value = originalEnv.get(key);
+      if (value === undefined) {
+        delete process.env[key];
+      } else {
+        process.env[key] = value;
+      }
+    }
+  });
+
+  describe('getProxyResolution', () => {
+    it('falls back from invalid HTTPS_PROXY to valid HTTP_PROXY for HTTPS requests', () => {
+      process.env.HTTPS_PROXY = 'not-a-valid-url';
+      process.env.HTTP_PROXY = 'http://http-proxy:8080';
+
+      expect(getProxyResolution(true, process.env, { allowedProtocols: ['http:', 'https:'] })).toEqual(
+        {
+          url: 'http://http-proxy:8080',
+        }
+      );
+    });
+
+    it('preserves socks proxy URLs when no protocol restriction is requested', () => {
+      process.env.https_proxy = 'socks5://proxy:1080';
+
+      expect(getProxyResolution(true)).toEqual({ url: 'socks5://proxy:1080' });
+    });
+
+    it('falls back from unsupported HTTPS_PROXY to valid ALL_PROXY when protocols are restricted', () => {
+      process.env.https_proxy = 'socks5://proxy:1080';
+      process.env.ALL_PROXY = 'http://all-proxy:8080';
+
+      expect(getProxyResolution(true, process.env, { allowedProtocols: ['http:', 'https:'] })).toEqual(
+        {
+          url: 'http://all-proxy:8080',
+        }
+      );
+    });
+
+    it('returns an error when only invalid proxy env values are configured for restricted protocols', () => {
+      process.env.https_proxy = 'socks5://proxy:1080';
+      process.env.HTTP_PROXY = 'not-a-valid-url';
+
+      expect(getProxyResolution(true, process.env, { allowedProtocols: ['http:', 'https:'] })).toEqual(
+        {
+          error: 'Unsupported proxy protocol: socks5:',
+        }
+      );
+    });
+  });
+
+  describe('shouldBypassProxy', () => {
+    it('automatically bypasses loopback hosts without NO_PROXY', () => {
+      expect(shouldBypassProxy('localhost')).toBe(true);
+      expect(shouldBypassProxy('api.localhost')).toBe(true);
+      expect(shouldBypassProxy('0.0.0.0')).toBe(true);
+      expect(shouldBypassProxy('127.0.0.2')).toBe(true);
+      expect(shouldBypassProxy('::1')).toBe(true);
+      expect(shouldBypassProxy('::ffff:127.0.0.1')).toBe(true);
+      expect(shouldBypassProxy('::ffff:7f00:1')).toBe(true);
+    });
+
+    it('supports wildcard NO_PROXY domain suffix patterns', () => {
+      process.env.NO_PROXY = '*.example.com';
+
+      expect(shouldBypassProxy('example.com')).toBe(true);
+      expect(shouldBypassProxy('api.example.com')).toBe(true);
+      expect(shouldBypassProxy('other.test')).toBe(false);
+    });
+  });
+});