recker 1.0.79 → 1.0.80-next.70ea84d

package/dist/testing/index.js

@@ -1,12 +1,2 @@
 export { MockClient, MockTransport, createMockClient, installGlobalMock, uninstallGlobalMock, MockAgent, } from './mock.js';
-export { MockUDPServer, createMockUDPServer, } from './mock-udp-server.js';
-export { MockHlsServer, createMockHlsVod, createMockHlsLive, createMockHlsMultiQuality, } from './mock-hls-server.js';
-export { MockWebSocketServer, createMockWebSocketServer, } from './mock-websocket-server.js';
-export { MockSSEServer, createMockSSEServer, } from './mock-sse-server.js';
-export { MockHttpServer, createMockHttpServer, createWebhookServer, } from './mock-http-server.js';
-export { MockDnsServer, } from './mock-dns-server.js';
-export { MockWhoisServer, } from './mock-whois-server.js';
-export { MockTelnetServer, } from './mock-telnet-server.js';
-export { MockFtpServer, } from './mock-ftp-server.js';
-export { MockProxyServer, createForwardProxy, createInterceptProxy, } from './mock-proxy-server.js';
-export { generateCertificate, generateCA, getDefaultCA, } from './proxy-certs.js';
+export * from 'raffel/testing';

package/dist/transport/curl.d.ts

@@ -1,4 +1,8 @@
-import { Transport, ReckerRequest, ReckerResponse } from '../types/index.js';
+import { Transport, ReckerRequest, ReckerResponse, ProxyOptions } from '../types/index.js';
 export declare class CurlTransport implements Transport {
+    private proxyList;
+    private proxyIndex;
+    constructor(proxy?: ProxyOptions | string | (ProxyOptions | string)[]);
+    private getNextProxy;
     dispatch(req: ReckerRequest): Promise<ReckerResponse>;
 }

package/dist/transport/curl.js

@@ -2,7 +2,136 @@ import { spawn } from 'node:child_process';
 import { HttpResponse } from '../core/response.js';
 import { NetworkError } from '../core/errors.js';
 import { getCurlPath, hasImpersonate } from '../utils/binary-manager.js';
+const TIMING_MARKER = '__RECKER_TIMING__';
+function parseCurlTimingValue(value) {
+    if (!value)
+        return undefined;
+    const parsed = Number.parseFloat(value);
+    if (Number.isNaN(parsed))
+        return undefined;
+    return Math.round(parsed * 1000);
+}
+function parseCurlTimings(payload) {
+    if (!payload)
+        return {};
+    const pairs = payload.split(/\s+/).filter(Boolean);
+    const values = {};
+    for (const pair of pairs) {
+        const idx = pair.indexOf('=');
+        if (idx <= 0)
+            continue;
+        const key = pair.slice(0, idx);
+        const value = pair.slice(idx + 1);
+        switch (key) {
+            case 'dns':
+                values.dns = parseCurlTimingValue(value);
+                break;
+            case 'tcp':
+                values.tcp = parseCurlTimingValue(value);
+                break;
+            case 'tls':
+                values.tls = parseCurlTimingValue(value);
+                break;
+            case 'ttfb':
+                values.ttfb = parseCurlTimingValue(value);
+                break;
+            case 'download':
+                values.download = parseCurlTimingValue(value);
+                break;
+            case 'total':
+                values.total = parseCurlTimingValue(value);
+                break;
+            default:
+                break;
+        }
+    }
+    if (values.download === undefined && values.total !== undefined && values.ttfb !== undefined) {
+        values.download = Math.max(0, values.total - values.ttfb);
+    }
+    return values;
+}
+function parseCurlOutput(responseText) {
+    const markerMatch = responseText.match(/(?:\r?\n)__RECKER_TIMING__(.*)$/);
+    let timingText;
+    let bodyAndHeaders = responseText;
+    if (markerMatch && markerMatch.index !== undefined) {
+        const index = markerMatch.index;
+        timingText = markerMatch[1]?.trim();
+        bodyAndHeaders = responseText.slice(0, index);
+    }
+    const splitModes = [
+        { sep: '\r\n\r\n', sepLen: 4 },
+        { sep: '\n\n', sepLen: 2 },
+    ];
+    let foundHeaderBlock;
+    let bodyText = '';
+    for (const mode of splitModes) {
+        let cursor = 0;
+        let lastBlockStart = -1;
+        let lastBlockEnd = -1;
+        while (cursor < bodyAndHeaders.length) {
+            const start = bodyAndHeaders.indexOf('HTTP/', cursor);
+            if (start < 0)
+                break;
+            const headerEnd = bodyAndHeaders.indexOf(mode.sep, start);
+            if (headerEnd < 0)
+                break;
+            lastBlockStart = start;
+            lastBlockEnd = headerEnd + mode.sepLen;
+            cursor = lastBlockEnd;
+        }
+        if (lastBlockStart >= 0 && lastBlockEnd >= 0) {
+            foundHeaderBlock = bodyAndHeaders.slice(lastBlockStart, lastBlockEnd - mode.sepLen);
+            bodyText = bodyAndHeaders.slice(lastBlockEnd);
+            break;
+        }
+    }
+    if (foundHeaderBlock === undefined) {
+        return {
+            statusLine: 'HTTP/1.1 200 OK',
+            headersText: '',
+            bodyText: bodyAndHeaders,
+            timings: timingText ? parseCurlTimings(timingText) : undefined,
+        };
+    }
+    const lines = foundHeaderBlock.split(/\r?\n/);
+    const statusLine = lines[0]?.trim() || 'HTTP/1.1 200 OK';
+    const headersText = lines.slice(1).filter((line) => line.trim().length > 0).join('\r\n');
+    return {
+        statusLine,
+        headersText,
+        bodyText,
+        timings: timingText ? parseCurlTimings(timingText) : undefined,
+    };
+}
+let resolvedCommand = null;
+async function getCommand() {
+    if (resolvedCommand !== null)
+        return resolvedCommand;
+    if (process.env.RECKER_CURL_BIN) {
+        resolvedCommand = process.env.RECKER_CURL_BIN;
+    }
+    else if (await hasImpersonate()) {
+        resolvedCommand = getCurlPath();
+    }
+    else {
+        resolvedCommand = 'curl';
+    }
+    return resolvedCommand;
+}
 export class CurlTransport {
+    proxyList;
+    proxyIndex = 0;
+    constructor(proxy) {
+        this.proxyList = proxy ? (Array.isArray(proxy) ? proxy : [proxy]) : [];
+    }
+    getNextProxy() {
+        if (this.proxyList.length === 0)
+            return undefined;
+        const slot = this.proxyList[this.proxyIndex % this.proxyList.length];
+        this.proxyIndex++;
+        return slot;
+    }
     async dispatch(req) {
         return new Promise(async (resolve, reject) => {
             const args = [
@@ -10,24 +139,44 @@ export class CurlTransport {
                 req.url,
                 '-i',
                 '-s',
+                '-L',
                 '--compressed',
-                '--no-keepalive'
+                '--no-keepalive',
+                '--write-out',
+                `\\n${TIMING_MARKER} dns=%{time_namelookup} tcp=%{time_connect} tls=%{time_appconnect} ttfb=%{time_starttransfer} total=%{time_total}`,
             ];
+            const proxy = this.getNextProxy();
+            if (proxy) {
+                const proxyUrl = typeof proxy === 'string' ? proxy : proxy.url;
+                const proxyType = typeof proxy === 'object' && proxy.type
+                    ? proxy.type
+                    : new URL(proxyUrl).protocol.replace(':', '');
+                if (proxyType === 'socks5h') {
+                    args.push('--socks5-hostname', proxyUrl.replace(/^socks5h:\/\//, ''));
+                }
+                else if (proxyType === 'socks5' || proxyType === 'socks') {
+                    args.push('--socks5', proxyUrl.replace(/^socks5?:\/\//, ''));
+                }
+                else if (proxyType === 'socks4a') {
+                    args.push('--socks4a', proxyUrl.replace(/^socks4a:\/\//, ''));
+                }
+                else if (proxyType === 'socks4') {
+                    args.push('--socks4', proxyUrl.replace(/^socks4:\/\//, ''));
+                }
+                else {
+                    args.push('--proxy', proxyUrl);
+                    if (typeof proxy === 'object' && proxy.auth) {
+                        args.push('--proxy-user', `${proxy.auth.username}:${proxy.auth.password}`);
+                    }
+                }
+            }
             req.headers.forEach((val, key) => {
                 args.push('-H', `${key}: ${val}`);
             });
             if (req.body && typeof req.body === 'string') {
                 args.push('-d', req.body);
             }
-            let command = process.env.RECKER_CURL_BIN;
-            if (!command) {
-                if (await hasImpersonate()) {
-                    command = getCurlPath();
-                }
-                else {
-                    command = 'curl';
-                }
-            }
+            const command = await getCommand();
             const child = spawn(command, args);
             const stdoutChunks = [];
             const stderrChunks = [];
@@ -39,46 +188,43 @@ export class CurlTransport {
             child.on('close', (code) => {
                 if (code !== 0) {
                     const stderr = Buffer.concat(stderrChunks).toString();
-                    reject(new NetworkError(`Curl exited with code ${code}: ${stderr}`, 'ERR_CURL_EXIT', req));
-                    return;
-                }
-                const fullOutput = Buffer.concat(stdoutChunks);
-                let headerEndIndex = fullOutput.indexOf('\r\n\r\n');
-                let offset = 4;
-                if (headerEndIndex === -1) {
-                    headerEndIndex = fullOutput.indexOf('\n\n');
-                    offset = 2;
-                }
-                if (headerEndIndex !== -1) {
-                    const firstLine = fullOutput.subarray(0, Math.min(20, headerEndIndex)).toString();
-                    if (firstLine.startsWith('HTTP/1.1 100') || firstLine.startsWith('HTTP/2 100')) {
-                        const nextStart = headerEndIndex + offset;
-                        const secondSplit = fullOutput.indexOf('\r\n\r\n', nextStart);
-                        if (secondSplit !== -1) {
-                            headerEndIndex = secondSplit;
-                            offset = 4;
+                    const parsed = parseCurlOutput(Buffer.concat(stdoutChunks).toString());
+                    if (parsed.bodyText.length > 0) {
+                        try {
+                            const parsedHeaders = new Headers();
+                            for (const line of parsed.headersText.split(/\r?\n/)) {
+                                const colon = line.indexOf(':');
+                                if (colon > 0) {
+                                    const key = line.substring(0, colon).trim();
+                                    const val = line.substring(colon + 1).trim();
+                                    parsedHeaders.append(key, val);
+                                }
+                            }
+                            const statusMatch = parsed.statusLine.match(/HTTP\/[^ ]+ (\d+)(?:\s+(.*))?/);
+                            const status = statusMatch ? Number.parseInt(statusMatch[1], 10) : 0;
+                            const statusText = statusMatch ? statusMatch[2] || '' : '';
+                            const nativeResponse = new Response(parsed.bodyText, {
+                                status: Number.isFinite(status) && status > 0 ? status : 0,
+                                statusText,
+                                headers: parsedHeaders,
+                            });
+                            resolve(new HttpResponse(nativeResponse, {
+                                timings: parsed.timings,
+                                connection: { protocol: 'curl' },
+                            }));
+                        }
+                        catch {
+                            reject(new NetworkError(`Curl exited with code ${code}: ${stderr}`, 'ERR_CURL_EXIT', req));
                         }
+                        return;
                     }
-                }
-                if (headerEndIndex === -1) {
-                    const nativeResponse = new Response(fullOutput, { status: 200, statusText: 'OK' });
-                    resolve(new HttpResponse(nativeResponse, { connection: { protocol: 'curl' } }));
+                    reject(new NetworkError(`Curl exited with code ${code}: ${stderr}`, 'ERR_CURL_EXIT', req));
                     return;
                 }
-                const headerBlock = fullOutput.subarray(0, headerEndIndex).toString();
-                const bodyBlock = fullOutput.subarray(headerEndIndex + offset);
-                const headerLines = headerBlock.split(/\r?\n/);
-                const statusLine = headerLines[0];
-                let status = 200;
-                let statusText = 'OK';
-                const statusMatch = statusLine.match(/HTTP\/[\d\.]+ (\d+) ?(.*)/);
-                if (statusMatch) {
-                    status = parseInt(statusMatch[1], 10);
-                    statusText = statusMatch[2] || '';
-                }
+                const fullOutput = Buffer.concat(stdoutChunks);
+                const { statusLine, headersText, bodyText, timings } = parseCurlOutput(fullOutput.toString());
                 const headers = new Headers();
-                for (let i = 1; i < headerLines.length; i++) {
-                    const line = headerLines[i];
+                for (const line of headersText.split(/\r?\n/)) {
                     const colon = line.indexOf(':');
                     if (colon > 0) {
                         const key = line.substring(0, colon).trim();
@@ -86,14 +232,25 @@ export class CurlTransport {
                         headers.append(key, val);
                     }
                 }
-                const nativeResponse = new Response(bodyBlock, {
-                    status,
+                const statusMatch = statusLine.match(/HTTP\/[^ ]+ (\d+)(?:\s+(.*))?/);
+                const status = statusMatch ? Number.parseInt(statusMatch[1], 10) : 200;
+                const statusText = statusMatch ? statusMatch[2] || '' : 'OK';
+                const nativeResponse = new Response(bodyText, {
+                    status: Number.isFinite(status) && status >= 0 ? status : 200,
                     statusText,
-                    headers
+                    headers,
                 });
+                const responseTimings = timings && Object.keys(timings).length > 0 ? {
+                    dns: timings.dns,
+                    tcp: timings.tcp,
+                    tls: timings.tls ? (timings.ttfb !== undefined ? timings.tls : timings.tls) : undefined,
+                    firstByte: timings.ttfb,
+                    content: timings.download,
+                    total: timings.total,
+                } : {};
                 resolve(new HttpResponse(nativeResponse, {
-                    timings: {},
-                    connection: { protocol: 'curl' }
+                    timings: responseTimings,
+                    connection: { protocol: 'curl' },
                 }));
             });
         });

package/dist/transport/undici.d.ts

@@ -6,7 +6,7 @@ interface UndiciTransportOptions {
     headersTimeout?: number;
     bodyTimeout?: number;
     maxRedirections?: number;
-    proxy?: ProxyOptions | string;
+    proxy?: ProxyOptions | string | (ProxyOptions | string)[];
     http2?: HTTP2Options;
     dns?: DNSOptions;
     agent?: AgentManager;
@@ -26,10 +26,10 @@ interface UndiciTransportOptions {
 export declare class UndiciTransport implements Transport {
     private baseUrl;
     private options;
-    private proxyAgent?;
+    private proxySlots;
+    private proxyIndex;
     private dnsAgent?;
     private agentManager?;
-    private proxyBypassList?;
     private tlsOptions?;
     private socketClient?;
     private observability;
@@ -39,6 +39,7 @@ export declare class UndiciTransport implements Transport {
     private recordProtocolFailure;
     shouldUseHttp2(url: string): boolean;
     getProtocolCache(): ProtocolCache | undefined;
+    private resolveDispatcher;
     dispatch(req: ReckerRequest): Promise<ReckerResponse>;
     private dispatchFast;
 }

package/dist/transport/undici.js

@@ -214,10 +214,10 @@ function mapTimeoutOptions(requestTimeout, transportDefaults) {
 export class UndiciTransport {
     baseUrl;
     options;
-    proxyAgent;
+    proxySlots = [];
+    proxyIndex = 0;
     dnsAgent;
     agentManager;
-    proxyBypassList;
     tlsOptions;
     socketClient;
     observability;
@@ -234,39 +234,19 @@ export class UndiciTransport {
             this.protocolCache = options.protocolCache;
         }
         if (options.proxy) {
-            const proxyConfig = typeof options.proxy === 'string'
-                ? { url: options.proxy }
-                : options.proxy;
-            const proxyUrl = new URL(proxyConfig.url);
-            const proxyType = proxyConfig.type || detectProxyType(proxyUrl.protocol);
-            if (proxyType?.startsWith('socks')) {
-                throw new NetworkError(`SOCKS proxy (${proxyType}) is not supported. Use an HTTP/HTTPS proxy or a SOCKS-to-HTTP bridge.`, 'ERR_UNSUPPORTED_PROXY_TYPE');
-            }
-            const proxyAuth = proxyConfig.auth
-                ? `${proxyConfig.auth.username}:${proxyConfig.auth.password}`
-                : undefined;
-            const finalProxyUrl = proxyAuth
-                ? proxyConfig.url.replace('://', `://${proxyAuth}@`)
-                : proxyConfig.url;
-            this.proxyBypassList = proxyConfig.bypass;
-            const proxyAgentOptions = {
-                uri: finalProxyUrl,
-                headers: proxyConfig.headers,
-                token: proxyConfig.token,
-                proxyTunnel: proxyConfig.tunnel,
-                requestTls: mapTlsOptions(proxyConfig.requestTls ?? options.tls),
-                proxyTls: mapTlsOptions(proxyConfig.proxyTls),
-            };
-            if (proxyConfig.connectTimeout) {
-                proxyAgentOptions.connectTimeout = proxyConfig.connectTimeout;
-            }
-            if (proxyConfig.http2) {
-                if (!proxyAgentOptions.requestTls) {
-                    proxyAgentOptions.requestTls = {};
+            const proxyList = Array.isArray(options.proxy) ? options.proxy : [options.proxy];
+            for (const proxyItem of proxyList) {
+                const config = typeof proxyItem === 'string' ? { url: proxyItem } : proxyItem;
+                const proxyUrl = new URL(config.url);
+                const proxyType = config.type || detectProxyType(proxyUrl.protocol) || 'http';
+                if (proxyType.startsWith('socks')) {
+                    this.proxySlots.push({ config, proxyType, bypass: config.bypass });
+                }
+                else {
+                    const agent = buildHttpProxyAgent(config, options.tls);
+                    this.proxySlots.push({ config, proxyType, bypass: config.bypass, agent });
                 }
-                proxyAgentOptions.requestTls.ALPNProtocols = ['h2', 'http/1.1'];
             }
-            this.proxyAgent = new ProxyAgent(proxyAgentOptions);
         }
         this.agentManager = options.agent;
         if (options.dns && !this.agentManager) {
@@ -320,6 +300,30 @@ export class UndiciTransport {
     getProtocolCache() {
         return this.protocolCache;
     }
+    async resolveDispatcher(url, explicit) {
+        if (explicit)
+            return explicit;
+        if (this.socketClient)
+            return this.socketClient;
+        if (this.proxySlots.length > 0) {
+            const slot = this.proxySlots[this.proxyIndex % this.proxySlots.length];
+            this.proxyIndex++;
+            if (!shouldBypassProxy(url, slot.bypass)) {
+                if (slot.agent)
+                    return slot.agent;
+                if (!slot.socksAgentPromise) {
+                    slot.socksAgentPromise = buildSocksAgent(slot.config);
+                }
+                slot.agent = await slot.socksAgentPromise;
+                return slot.agent;
+            }
+        }
+        if (this.agentManager)
+            return this.agentManager.getAgentForUrl(url);
+        if (this.dnsAgent)
+            return this.dnsAgent;
+        return undefined;
+    }
     async dispatch(req) {
         const headers = Object.fromEntries(req.headers);
         const contentLengthHeader = headers['content-length'];
@@ -406,14 +410,7 @@ export class UndiciTransport {
                     }, timeouts.totalTimeout);
                 }
                 while (true) {
-                    const dispatcher = this.socketClient || determineDispatcher({
-                        explicit: req._dispatcher,
-                        proxyAgent: this.proxyAgent,
-                        agentManager: this.agentManager,
-                        dnsAgent: this.dnsAgent,
-                        url: currentUrl,
-                        bypass: this.proxyBypassList
-                    });
+                    const dispatcher = await this.resolveDispatcher(currentUrl, req._dispatcher);
                     const bodyWithProgress = redirectCount === 0
                         ? wrapUploadBody(currentBody, req.onUploadProgress, uploadTotal)
                         : currentBody;
@@ -708,14 +705,7 @@ export class UndiciTransport {
                 }, timeouts.totalTimeout);
             }
             while (true) {
-                const dispatcher = this.socketClient || determineDispatcher({
-                    explicit: req._dispatcher,
-                    proxyAgent: this.proxyAgent,
-                    agentManager: this.agentManager,
-                    dnsAgent: this.dnsAgent,
-                    url: currentUrl,
-                    bypass: this.proxyBypassList
-                });
+                const dispatcher = await this.resolveDispatcher(currentUrl, req._dispatcher);
                 const bodyWithProgress = redirectCount === 0
                     ? wrapUploadBody(currentBody, req.onUploadProgress, uploadTotal)
                     : currentBody;
@@ -941,6 +931,88 @@ function mapTlsOptions(options) {
     }
     return tls;
 }
+function buildHttpProxyAgent(config, globalTls) {
+    const proxyAuth = config.auth
+        ? `${config.auth.username}:${config.auth.password}`
+        : undefined;
+    const finalProxyUrl = proxyAuth
+        ? config.url.replace('://', `://${proxyAuth}@`)
+        : config.url;
+    const proxyAgentOptions = {
+        uri: finalProxyUrl,
+        headers: config.headers,
+        token: config.token,
+        proxyTunnel: config.tunnel,
+        requestTls: mapTlsOptions(config.requestTls ?? globalTls),
+        proxyTls: mapTlsOptions(config.proxyTls),
+    };
+    if (config.connectTimeout) {
+        proxyAgentOptions.connectTimeout = config.connectTimeout;
+    }
+    if (config.http2) {
+        if (!proxyAgentOptions.requestTls)
+            proxyAgentOptions.requestTls = {};
+        proxyAgentOptions.requestTls.ALPNProtocols = ['h2', 'http/1.1'];
+    }
+    return new ProxyAgent(proxyAgentOptions);
+}
+async function buildSocksAgent(config) {
+    let SocksClient;
+    try {
+        ({ SocksClient } = await import('socks'));
+    }
+    catch {
+        throw new NetworkError('SOCKS proxy support requires the "socks" package. Install it with: npm install socks', 'ERR_SOCKS_NOT_INSTALLED');
+    }
+    const proxyUrl = new URL(config.url);
+    const proxyHost = proxyUrl.hostname;
+    const proxyPort = parseInt(proxyUrl.port) || 1080;
+    const socksType = (config.type === 'socks4' || config.type === 'socks4a') ? 4 : 5;
+    const username = proxyUrl.username ? decodeURIComponent(proxyUrl.username) : config.auth?.username;
+    const password = proxyUrl.password ? decodeURIComponent(proxyUrl.password) : config.auth?.password;
+    return new Agent({
+        connect: async (options, callback) => {
+            try {
+                const { connect: tlsConnect } = await import('tls');
+                const destHost = options.hostname;
+                const destPort = Number(options.port) || (options.servername ? 443 : 80);
+                const { socket } = await SocksClient.createConnection({
+                    proxy: {
+                        host: proxyHost,
+                        port: proxyPort,
+                        type: socksType,
+                        ...(username && { userId: username }),
+                        ...(password && { password }),
+                    },
+                    command: 'connect',
+                    destination: { host: destHost, port: destPort },
+                });
+                if (options.protocol === 'https:' || destPort === 443) {
+                    const tlsOpts = {
+                        socket,
+                        servername: options.servername || destHost,
+                        rejectUnauthorized: options.rejectUnauthorized ?? true,
+                    };
+                    if (options.ca)
+                        tlsOpts.ca = options.ca;
+                    if (options.cert)
+                        tlsOpts.cert = options.cert;
+                    if (options.key)
+                        tlsOpts.key = options.key;
+                    const tlsSocket = tlsConnect(tlsOpts);
+                    tlsSocket.once('secureConnect', () => callback(null, tlsSocket));
+                    tlsSocket.once('error', (err) => callback(err, null));
+                }
+                else {
+                    callback(null, socket);
+                }
+            }
+            catch (err) {
+                callback(err, null);
+            }
+        },
+    });
+}
 function determineDispatcher(params) {
     if (params.explicit)
         return params.explicit;
@@ -968,6 +1040,8 @@ function detectProxyType(protocol) {
         case 'socks5':
         case 'socks':
             return 'socks5';
+        case 'socks5h':
+            return 'socks5h';
         default:
             return undefined;
     }

package/dist/types/index.d.ts

@@ -214,7 +214,13 @@ export interface CacheStorage {
     delete(key: string): Promise<void>;
 }
 export type CacheStrategy = 'cache-first' | 'network-only' | 'network-first' | 'stale-while-revalidate' | 'revalidate' | 'rfc-compliant';
-export type Plugin = (client: any) => void;
+export interface PluginClient {
+    beforeRequest(fn: (req: ReckerRequest) => ReckerRequest | void | Promise<ReckerRequest | void>): void;
+    afterResponse(fn: (req: ReckerRequest, res: ReckerResponse) => ReckerResponse | void | Promise<ReckerResponse | void>): void;
+    onError(fn: (error: Error, req: ReckerRequest) => ReckerResponse | void | Promise<ReckerResponse | void>): void;
+    use(middleware: Middleware): void;
+}
+export type Plugin = (client: PluginClient) => void;
 export type HookFunction<T = void> = (req: ReckerRequest, extra?: any) => T | Promise<T>;
 export interface Hooks {
     beforeRequest?: Array<(req: ReckerRequest) => ReckerRequest | void | Promise<ReckerRequest | void>>;
@@ -289,7 +295,7 @@ export interface Http2FlowControlInfo {
 }
 export interface ProxyOptions {
     url: string;
-    type?: 'http' | 'https' | 'socks4' | 'socks4a' | 'socks5';
+    type?: 'http' | 'https' | 'socks4' | 'socks4a' | 'socks5' | 'socks5h';
     auth?: {
         username: string;
         password: string;
@@ -388,7 +394,7 @@ export interface ClientOptions {
     pagination?: PaginationConfig;
     debug?: boolean;
     logger?: import('./logger.js').Logger;
-    proxy?: ProxyOptions | string;
+    proxy?: ProxyOptions | string | (ProxyOptions | string)[];
     tls?: TLSOptions;
     dns?: DNSOptions;
     xsrf?: boolean | XSRFOptions;

package/dist/utils/binary-manager.js

@@ -1,4 +1,4 @@
-import { promises as fs } from 'node:fs';
+import { promises as fs, constants } from 'node:fs';
 import { join } from 'node:path';
 import { homedir, platform, arch } from 'node:os';
 import { spawn } from 'node:child_process';
@@ -14,13 +14,36 @@ export function getCurlPath() {
     return join(BIN_DIR, getCurlBinName());
 }
 export async function hasImpersonate() {
+    const binaryPath = process.env.RECKER_CURL_BIN || getCurlPath();
     try {
-        await fs.access(getCurlPath());
-        return true;
+        await fs.access(binaryPath, constants.X_OK);
     }
     catch {
         return false;
     }
+    return new Promise((resolve) => {
+        let settled = false;
+        const child = spawn(binaryPath, ['--version']);
+        const settle = (ok) => {
+            if (!settled) {
+                settled = true;
+                resolve(ok);
+            }
+        };
+        child.on('error', () => settle(false));
+        child.on('close', (code) => {
+            settle(code === 0);
+        });
+        const timeout = setTimeout(() => {
+            if (child.exitCode === null) {
+                child.kill();
+            }
+            settle(false);
+        }, 2_000);
+        child.on('close', () => {
+            clearTimeout(timeout);
+        });
+    });
 }
 function getDownloadUrl() {
     const p = platform();