feat: Replace agentkeepalive with native Node.js HTTP agents for proxy support (#788)

Hello 👋 

Here is a PR proposition to be able to use `apify` CLI in a sandboxed
environment (in my case, Claude code in the browser).

At the moment, we can't do `apify login` or `apify info` in such
environment, because the **apify-client** doesn't handle the proxy
configuration properly.
The commands are stuck.

Digging into it, I found out that the `agentkeepalive` module doesn't
support proxy (see
node-modules/agentkeepalive#22 (comment)
for instance).

I first attempted to use
[proxy-agents](https://github.com/TooTallNate/proxy-agents), but it
turns out the built-in agents can support both keepalive and proxies out
of the box.

So this PR removes `agentkeepalive` while maintaining the same
keep-alive functionality and adding proxy support capability.


### Test
To test it locally, I created a transparent proxy (we don't intercept
requests to avoid self-certificate issues):
```sh
mitmdump --listen-port 8000 --ignore-hosts '.*:*' --set dns_log=true
```

And in another terminal, I tested the Apify client with :
```sh
export HTTPS_PROXY=http://localhost:8000
export APIFY_TOKEN=[REPLACE_WITH_VALID_TOKEN]

node get-user-info.js  # See code below
```

```js
#!/usr/bin/env node

const { ApifyClient } = require('./dist/index.js');

async function main() {
    // Get token from environment variable
    const token = process.env.APIFY_TOKEN;

    if (!token) {
        console.error('Error: APIFY_TOKEN environment variable is not set');
        process.exit(1);
    }

    try {
        const client = new ApifyClient({ token });

        console.log('Fetching user information...\n');
        const userInfo = await client.user().get();

        console.log('User Information:');
        console.log(JSON.stringify(userInfo, null, 2));
    } catch (error) {
        console.error('Error fetching user information:');
        console.error(error.message);
        if (error.statusCode) {
            console.error(`Status Code: ${error.statusCode}`);
        }
        process.exit(1);
    }
}

main();
```

Author: tducret

package-lock.json

@@ -66,7 +66,6 @@
         "@apify/log": "^2.2.6",
         "@apify/utilities": "^2.23.2",
         "@crawlee/types": "^3.3.0",
-        "agentkeepalive": "^4.2.1",
         "ansi-colors": "^4.1.1",
         "async-retry": "^1.3.3",
         "axios": "^1.6.7",

package.json

@@ -31,6 +31,8 @@ export default defineConfig({
         externals: {
             'node:util': 'node:util',
             'node:zlib': 'node:zlib',
+            'node:http': 'node:http',
+            'node:https': 'node:https',
             crypto: 'node:crypto',
         },
     },

rsbuild.config.ts

@@ -1,6 +1,7 @@
+import http from 'node:http';
+import https from 'node:https';
 import os from 'node:os';
 
-import KeepAliveAgent from 'agentkeepalive';
 import type { RetryFunction } from 'async-retry';
 import retry from 'async-retry';
 import type { AxiosError, AxiosInstance, AxiosRequestConfig, AxiosResponse, InternalAxiosRequestConfig } from 'axios';
@@ -32,9 +33,9 @@ export class HttpClient {
 
     timeoutMillis: number;
 
-    httpAgent?: KeepAliveAgent;
+    httpAgent?: http.Agent;
 
-    httpsAgent?: KeepAliveAgent.HttpsAgent;
+    httpsAgent?: https.Agent;
 
     axios: AxiosInstance;
 
@@ -53,16 +54,37 @@ export class HttpClient {
 
         if (isNode()) {
             // We want to keep sockets alive for better performance.
-            // It's important to set the user's timeout also here and not only
-            // on the axios instance, because even though this timeout
-            // is for inactive sockets, sometimes the platform would take
-            // long to process requests and the socket would time-out
-            // while waiting for the response.
-            const agentOpts = {
+            // Enhanced agent configuration based on agentkeepalive best practices:
+            // - Nagle's algorithm disabled for lower latency
+            // - Free socket timeout to prevent socket leaks
+            // - LIFO scheduling to reuse recent sockets
+            // - Socket TTL for connection freshness
+            const agentOptions: http.AgentOptions & { scheduling?: 'lifo' | 'fifo' } = {
+                keepAlive: true,
+                // Timeout for inactive sockets
+                // Prevents socket leaks from idle connections
                 timeout: this.timeoutMillis,
+                // Keep alive timeout for free sockets (15 seconds)
+                // Node.js will close unused sockets after this period
+                keepAliveMsecs: 15_000,
+                // Maximum number of sockets per host
+                maxSockets: 256,
+                maxFreeSockets: 256,
+                // LIFO scheduling - reuse most recently used sockets for better performance
+                scheduling: 'lifo',
             };
-            this.httpAgent = new KeepAliveAgent(agentOpts);
-            this.httpsAgent = new KeepAliveAgent.HttpsAgent(agentOpts);
+
+            this.httpAgent = new http.Agent(agentOptions);
+            this.httpsAgent = new https.Agent(agentOptions);
+
+            // Disable Nagle's algorithm for lower latency
+            // This sends data immediately instead of buffering small packets
+            const setNoDelay = (socket: any) => {
+                socket.setNoDelay(true);
+            };
+
+            this.httpAgent.on('socket', setNoDelay);
+            this.httpsAgent.on('socket', setNoDelay);
         }
 
         this.axios = axios.create({