Fix stale proxy connections: disable HTTP agent keepAlive, reduce withPage timeout to 60s

Author: nihalwashere

src/browser-session.ts

@@ -26,12 +26,17 @@ import { randomUUID } from "crypto";
 import { mkdtempSync, rmSync } from "fs";
 import { join } from "path";
 import { tmpdir } from "os";
-import { anonymizeProxy, closeAnonymizedProxy } from "proxy-chain";
+import type { Server as ProxyChainServer } from "proxy-chain";
 import { FingerprintGenerator } from "fingerprint-generator";
 import { FingerprintInjector } from "fingerprint-injector";
 import { createProxyUrl } from "./proxy/config";
 import { createLogger } from "./utils/logger";
-import { findChromePath, buildChromeArgs, CHROME_LAUNCH_TIMEOUT_MS } from "./browser/shared";
+import {
+  findChromePath,
+  buildChromeArgs,
+  createProxyTunnel,
+  CHROME_LAUNCH_TIMEOUT_MS,
+} from "./browser/shared";
 import type { BrowserSession, BrowserSessionInternalOptions } from "./browser-types";
 
 const logger = createLogger("browser-session");
@@ -62,17 +67,16 @@ export async function createBrowserSession(
   const proxyConfig = options.proxy ?? options.resolveProxy?.(options.proxyTier);
   const proxyUrl = proxyConfig ? createProxyUrl(proxyConfig) : undefined;
 
-  // proxy-chain handles auth transparently (no TLS breakage, no "Not Secure")
-  let anonymizedUrl: string | undefined;
+  // proxy-chain tunnel with keepAlive disabled (see createProxyTunnel)
+  let proxyChainServer: ProxyChainServer | null = null;
   let chromeProxyArg: string | undefined;
 
   if (proxyUrl) {
-    anonymizedUrl = await anonymizeProxy(proxyUrl);
-    chromeProxyArg = anonymizedUrl;
+    const tunnel = await createProxyTunnel(proxyUrl);
+    proxyChainServer = tunnel.server;
+    chromeProxyArg = tunnel.url;
     if (verbose) {
-      logger.info(
-        `Proxy anonymized: ${proxyUrl.replace(/\/\/[^@]+@/, "//***@")} -> ${anonymizedUrl}`
-      );
+      logger.info(`Proxy tunnel: ${proxyUrl.replace(/\/\/[^@]+@/, "//***@")} -> ${tunnel.url}`);
     }
   }
 
@@ -158,8 +162,8 @@ export async function createBrowserSession(
     } catch {
       /* ignore */
     }
-    if (anonymizedUrl) {
-      await closeAnonymizedProxy(anonymizedUrl, true).catch(() => {});
+    if (proxyChainServer) {
+      await proxyChainServer.close(true).catch(() => {});
     }
     try {
       rmSync(userDataDir, { recursive: true, force: true });
@@ -272,9 +276,9 @@ export async function createBrowserSession(
       internalPwBrowser = null;
     }
 
-    // Stop proxy-chain anonymized proxy
-    if (anonymizedUrl) {
-      await closeAnonymizedProxy(anonymizedUrl, true).catch(() => {});
+    // Stop proxy-chain server
+    if (proxyChainServer) {
+      await proxyChainServer.close(true).catch(() => {});
     }
 
     // Clean up temp profile directory (delayed so Chrome can release locks)

src/browser/playwright-pool.ts

@@ -24,12 +24,17 @@ import { mkdtempSync, rmSync } from "fs";
 import { join } from "path";
 import { tmpdir } from "os";
 import pLimit from "p-limit";
-import { anonymizeProxy, closeAnonymizedProxy } from "proxy-chain";
+import type { Server as ProxyChainServer } from "proxy-chain";
 import { FingerprintGenerator, type BrowserFingerprintWithHeaders } from "fingerprint-generator";
 import { FingerprintInjector } from "fingerprint-injector";
 import { createLogger, type Logger } from "../utils/logger.js";
 import type { ProxyHealthTracker } from "../proxy/health-tracker.js";
-import { findChromePath, buildChromeArgs, CHROME_LAUNCH_TIMEOUT_MS } from "./shared.js";
+import {
+  findChromePath,
+  buildChromeArgs,
+  createProxyTunnel,
+  CHROME_LAUNCH_TIMEOUT_MS,
+} from "./shared.js";
 
 // Lazy-loaded Playwright types — we import dynamically to avoid hard dep at parse time.
 type PlaywrightBrowser = import("playwright-core").Browser;
@@ -99,7 +104,7 @@ export class ChromeInstance {
   private chromeProcess: ChildProcess | null = null;
   private pwBrowser: PlaywrightBrowser | null = null;
   private pwContext: PlaywrightBrowserContext | null = null;
-  private anonymizedProxyUrl: string | null = null;
+  private proxyChainServer: ProxyChainServer | null = null;
   private userDataDir: string | null = null;
   private wsEndpoint: string | null = null;
   private fingerprint: BrowserFingerprintWithHeaders["fingerprint"] | null = null;
@@ -159,7 +164,7 @@ export class ChromeInstance {
    * at most maxTabs calls run concurrently. A hard timeout guarantees the
    * slot is always released, even if fn hangs (proxy stall, DNS hang, etc.).
    */
-  async withPage<T>(fn: (page: PlaywrightPage) => Promise<T>, timeoutMs = 90_000): Promise<T> {
+  async withPage<T>(fn: (page: PlaywrightPage) => Promise<T>, timeoutMs = 60_000): Promise<T> {
     if (this.state === "closed" || this.state === "retired") {
       throw new Error(`ChromeInstance: cannot withPage on ${this.state} browser`);
     }
@@ -285,12 +290,13 @@ export class ChromeInstance {
     try {
       this.logger.debug({ proxy: redactProxy(this.proxyUrl) }, "launching Chrome");
 
-      // Set up proxy via proxy-chain (handles auth transparently, preserves TLS)
+      // Set up proxy tunnel with keepAlive disabled (see createProxyTunnel).
       let chromeProxyArg: string | undefined;
 
       if (this.proxyUrl) {
-        this.anonymizedProxyUrl = await anonymizeProxy(this.proxyUrl);
-        chromeProxyArg = this.anonymizedProxyUrl;
+        const tunnel = await createProxyTunnel(this.proxyUrl);
+        this.proxyChainServer = tunnel.server;
+        chromeProxyArg = tunnel.url;
       }
 
       // Generate fingerprint once per ChromeInstance (cached across relaunches)
@@ -461,10 +467,10 @@ export class ChromeInstance {
       this.chromeProcess = null;
     }
 
-    // Stop proxy-chain anonymized proxy
-    if (this.anonymizedProxyUrl) {
-      await closeAnonymizedProxy(this.anonymizedProxyUrl, true).catch(() => {});
-      this.anonymizedProxyUrl = null;
+    // Stop proxy-chain server
+    if (this.proxyChainServer) {
+      await this.proxyChainServer.close(true).catch(() => {});
+      this.proxyChainServer = null;
     }
 
     // Remove temp profile

src/browser/shared.ts

@@ -141,3 +141,44 @@ export function buildChromeArgs(opts: ChromeArgsOptions): string[] {
 }
 
 export const CHROME_LAUNCH_TIMEOUT_MS = 15_000;
+
+// ─── Proxy tunnel with no connection pooling ─────────────────────
+
+import http from "http";
+import { Server as ProxyChainServer } from "proxy-chain";
+
+/**
+ * Create a local proxy server that forwards to an upstream proxy
+ * WITHOUT connection pooling.
+ *
+ * Node 19+ changed http.globalAgent to keepAlive: true by default.
+ * proxy-chain's anonymizeProxy() passes agent: undefined to http.request(),
+ * which falls back to globalAgent, which pools TCP connections to the
+ * upstream proxy. Those pooled connections go stale after idle periods
+ * (upstream drops them via NAT/firewall timeout), causing Chrome requests
+ * to hang on dead sockets.
+ *
+ * This function creates a Server with an explicit http.Agent({ keepAlive: false })
+ * so every CONNECT to the upstream gets a fresh TCP connection.
+ *
+ * @returns { url, close } - the local proxy URL and a cleanup function
+ */
+export async function createProxyTunnel(
+  upstreamProxyUrl: string
+): Promise<{ url: string; server: ProxyChainServer }> {
+  const agent = new http.Agent({ keepAlive: false });
+  const server = new ProxyChainServer({
+    port: 0,
+    host: "127.0.0.1",
+    prepareRequestFunction: () => ({
+      requestAuthentication: false,
+      upstreamProxyUrl,
+      httpAgent: agent,
+    }),
+  });
+  await server.listen();
+  return {
+    url: `http://127.0.0.1:${server.port}`,
+    server,
+  };
+}