@swimmingliu/autovpn 2.0.2 → 2.1.0

package/dist/pipeline/availability.js

@@ -1,7 +1,9 @@
 import http from 'node:http';
-import net from 'node:net';
+import https from 'node:https';
 import tls from 'node:tls';
 import { openMihomoRuntime as defaultOpenMihomoRuntime } from './proxy-runtime.js';
+import { mapWithCompletion } from './concurrency.js';
+import { HTTP_HEAD_LIMIT_BYTES, connectProxySocket, httpStatusLine, parseProxyEndpoint, safeParseHttpStatus, splitHttpResponseHead } from './http-transport.js';
 import { isTransientNetworkError, retryTransientNetwork } from './network-retry.js';
 const PROVIDER_TARGETS = [
     { name: 'gemini', url: 'https://gemini.google.com', allowed_hosts: ['gemini.google.com'], negative_phrases: [] },
@@ -265,24 +267,6 @@ function emitEvent(callback, eventType, payload) {
         callback(eventType, payload);
     }
 }
-async function mapWithConcurrency(items, concurrency, worker, onComplete) {
-    const limit = Math.max(1, Math.trunc(Number(concurrency) || 1));
-    const results = new Array(items.length);
-    let nextIndex = 0;
-    let completed = 0;
-    async function runWorker() {
-        while (nextIndex < items.length) {
-            const index = nextIndex;
-            nextIndex += 1;
-            const result = await worker(items[index], index);
-            results[index] = result;
-            completed += 1;
-            onComplete?.(result, index, completed);
-        }
-    }
-    await Promise.all(Array.from({ length: Math.min(limit, items.length) }, () => runWorker()));
-    return results;
-}
 function numberOrDefault(value, fallback) {
     const parsed = Number(value);
     return Number.isFinite(parsed) ? parsed : fallback;
@@ -334,41 +318,6 @@ async function checkLinkAvailabilityDirect(speedResult, config, options) {
         provider_results: providerResults
     };
 }
-function socketConnect(host, port, timeoutMs) {
-    return new Promise((resolve, reject) => {
-        const socket = net.createConnection({ host, port });
-        const timer = setTimeout(() => {
-            socket.destroy();
-            reject(new Error(`proxy connection timed out after ${timeoutMs}ms`));
-        }, timeoutMs);
-        socket.once('connect', () => {
-            clearTimeout(timer);
-            resolve(socket);
-        });
-        socket.once('error', (error) => {
-            clearTimeout(timer);
-            reject(error);
-        });
-    });
-}
-function splitHttpHeaders(buffer) {
-    const marker = buffer.indexOf('\r\n\r\n');
-    if (marker < 0) {
-        return undefined;
-    }
-    return {
-        head: buffer.subarray(0, marker),
-        body: buffer.subarray(marker + 4)
-    };
-}
-function parseHttpStatus(head) {
-    const firstLine = head.toString('latin1').split('\r\n')[0] ?? '';
-    const match = /^HTTP\/\d(?:\.\d)?\s+(\d+)/i.exec(firstLine);
-    if (!match) {
-        throw new Error(`invalid HTTP response: ${firstLine}`);
-    }
-    return Number(match[1]);
-}
 function parseHttpHeaders(head) {
     const headers = {};
     for (const line of head.toString('latin1').split('\r\n').slice(1)) {
@@ -404,13 +353,24 @@ function redirectTarget(current, response) {
 }
 function fetchHttpUrlViaHttpProxy(target, proxy, timeoutMs) {
     return new Promise((resolve, reject) => {
-        const request = http.request({
-            hostname: proxy.hostname,
-            port: Number(proxy.port || 80),
+        let settled = false;
+        const settle = (action) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            action();
+        };
+        const endpoint = parseProxyEndpoint(proxy);
+        const requestModule = endpoint.protocol === 'https:' ? https : http;
+        const request = requestModule.request({
+            hostname: endpoint.hostname,
+            port: endpoint.port,
             method: 'GET',
             path: target.toString(),
             headers: {
                 Host: target.host,
+                ...(endpoint.authorization ? { 'Proxy-Authorization': endpoint.authorization } : {}),
                 Connection: 'close'
             },
             agent: false,
@@ -419,21 +379,47 @@ function fetchHttpUrlViaHttpProxy(target, proxy, timeoutMs) {
             const chunks = [];
             response.on('data', (chunk) => chunks.push(chunk));
             response.once('end', () => {
-                resolve({
+                settle(() => resolve({
                     final_url: target.toString(),
                     status_code: Number(response.statusCode ?? 0),
                     body: Buffer.concat(chunks).toString('utf8'),
                     headers: response.headers
-                });
+                }));
+                // `agent: false` + Connection: close, but destroy explicitly so a
+                // keep-alive-capable agent can never retain the socket.
+                request.destroy();
+            });
+            // A response that errors mid-body used to abort the process; surface it as
+            // a per-target failure and tear the request down instead.
+            response.once('error', (error) => {
+                settle(() => reject(error));
+                request.destroy();
+            });
+            response.once('aborted', () => {
+                settle(() => reject(new Error('proxy response aborted before the body was received')));
+                request.destroy();
             });
         });
         request.once('timeout', () => {
             request.destroy(new Error(`proxy fetch timed out after ${timeoutMs}ms`));
         });
-        request.once('error', reject);
+        request.once('error', (error) => {
+            settle(() => reject(error));
+        });
         request.end();
     });
 }
+function destroyQuietly(socket) {
+    if (!socket || socket.destroyed) {
+        return;
+    }
+    try {
+        socket.destroy();
+    }
+    catch {
+        // already torn down
+    }
+}
 function readHttpResponse(socket, timeoutMs) {
     return new Promise((resolve, reject) => {
         let buffered = Buffer.alloc(0);
@@ -441,46 +427,68 @@ function readHttpResponse(socket, timeoutMs) {
         let status = 0;
         let headers = {};
         const chunks = [];
-        const timer = setTimeout(() => {
-            cleanup();
-            socket.destroy();
-            reject(new Error(`proxy fetch timed out after ${timeoutMs}ms`));
-        }, timeoutMs);
+        let settled = false;
         const cleanup = () => {
             clearTimeout(timer);
             socket.off('data', onData);
             socket.off('end', onEnd);
             socket.off('error', onError);
         };
-        const onError = (error) => {
+        const settle = (action) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
             cleanup();
-            reject(error);
+            destroyQuietly(socket);
+            action();
         };
-        const onEnd = () => {
-            cleanup();
+        const fail = (error) => settle(() => reject(error));
+        const timer = setTimeout(() => fail(new Error(`proxy fetch timed out after ${timeoutMs}ms`)), timeoutMs);
+        function onError(error) {
+            fail(error);
+        }
+        function onEnd() {
             if (!headersParsed) {
-                reject(new Error('proxy response ended before HTTP headers were received'));
+                fail(new Error('proxy response ended before HTTP headers were received'));
                 return;
             }
-            resolve({ status, headers, body: Buffer.concat(chunks).toString('utf8') });
-        };
-        const onData = (chunk) => {
-            if (!headersParsed) {
-                buffered = Buffer.concat([buffered, chunk]);
-                const split = splitHttpHeaders(buffered);
-                if (!split) {
+            settle(() => resolve({ status, headers, body: Buffer.concat(chunks).toString('utf8') }));
+        }
+        function onData(chunk) {
+            if (settled) {
+                return;
+            }
+            try {
+                if (!headersParsed) {
+                    buffered = Buffer.concat([buffered, chunk]);
+                    const split = splitHttpResponseHead(buffered);
+                    if (!split) {
+                        if (buffered.byteLength > HTTP_HEAD_LIMIT_BYTES) {
+                            fail(new Error(`invalid HTTP response: ${httpStatusLine(buffered)}`));
+                        }
+                        return;
+                    }
+                    const parsed = safeParseHttpStatus(split.head);
+                    if (parsed === null) {
+                        fail(new Error(`invalid HTTP response: ${httpStatusLine(split.head)}`));
+                        return;
+                    }
+                    status = parsed;
+                    headers = parseHttpHeaders(split.head);
+                    headersParsed = true;
+                    buffered = Buffer.alloc(0);
+                    if (split.body.byteLength > 0) {
+                        chunks.push(split.body);
+                    }
                     return;
                 }
-                status = parseHttpStatus(split.head);
-                headers = parseHttpHeaders(split.head);
-                headersParsed = true;
-                if (split.body.byteLength > 0) {
-                    chunks.push(split.body);
-                }
-                return;
+                chunks.push(chunk);
             }
-            chunks.push(chunk);
-        };
+            catch (error) {
+                fail(error instanceof Error ? error : new Error(String(error)));
+            }
+        }
         socket.on('data', onData);
         socket.once('end', onEnd);
         socket.once('error', onError);
@@ -489,59 +497,88 @@ function readHttpResponse(socket, timeoutMs) {
 function readConnectResponse(socket, timeoutMs) {
     return new Promise((resolve, reject) => {
         let buffered = Buffer.alloc(0);
-        const timer = setTimeout(() => {
-            cleanup();
-            socket.destroy();
-            reject(new Error(`proxy CONNECT timed out after ${timeoutMs}ms`));
-        }, timeoutMs);
+        let settled = false;
         const cleanup = () => {
             clearTimeout(timer);
             socket.off('data', onData);
+            socket.off('end', onEnd);
             socket.off('error', onError);
         };
-        const onError = (error) => {
+        const fail = (error) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
             cleanup();
+            destroyQuietly(socket);
             reject(error);
         };
-        const onData = (chunk) => {
+        const timer = setTimeout(() => fail(new Error(`proxy CONNECT timed out after ${timeoutMs}ms`)), timeoutMs);
+        function onError(error) {
+            fail(error);
+        }
+        function onEnd() {
+            fail(new Error('proxy CONNECT response ended before HTTP headers were received'));
+        }
+        function onData(chunk) {
+            if (settled) {
+                return;
+            }
             buffered = Buffer.concat([buffered, chunk]);
-            const split = splitHttpHeaders(buffered);
+            const split = splitHttpResponseHead(buffered);
             if (!split) {
+                if (buffered.byteLength > HTTP_HEAD_LIMIT_BYTES) {
+                    fail(new Error(`invalid HTTP response: ${httpStatusLine(buffered)}`));
+                }
+                return;
+            }
+            const status = safeParseHttpStatus(split.head);
+            if (status === null) {
+                fail(new Error(`invalid HTTP response: ${httpStatusLine(split.head)}`));
                 return;
             }
-            const status = parseHttpStatus(split.head);
-            cleanup();
             if (status < 200 || status >= 300) {
-                socket.destroy();
-                reject(new Error(`proxy CONNECT failed with status ${status}`));
+                fail(new Error(`proxy CONNECT failed with status ${status}`));
                 return;
             }
+            settled = true;
+            cleanup();
             resolve();
-        };
+        }
         socket.on('data', onData);
+        socket.once('end', onEnd);
         socket.once('error', onError);
     });
 }
 function waitForSecureConnect(socket, timeoutMs) {
     return new Promise((resolve, reject) => {
-        const timer = setTimeout(() => {
-            cleanup();
-            socket.destroy();
-            reject(new Error(`proxy TLS handshake timed out after ${timeoutMs}ms`));
-        }, timeoutMs);
+        let settled = false;
         const cleanup = () => {
             clearTimeout(timer);
             socket.off('secureConnect', onSecureConnect);
             socket.off('error', onError);
         };
-        const onSecureConnect = () => {
-            cleanup();
-            resolve();
-        };
-        const onError = (error) => {
+        const fail = (error) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
             cleanup();
+            destroyQuietly(socket);
             reject(error);
         };
+        const timer = setTimeout(() => fail(new Error(`proxy TLS handshake timed out after ${timeoutMs}ms`)), timeoutMs);
+        function onSecureConnect() {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            cleanup();
+            resolve();
+        }
+        function onError(error) {
+            fail(error);
+        }
         socket.once('secureConnect', onSecureConnect);
         socket.once('error', onError);
     });
@@ -565,49 +602,63 @@ async function fetchUrlViaHttpProxyTarget(target, proxy, timeoutMs, redirectsRem
     if (target.protocol !== 'https:') {
         throw new Error(`unsupported availability URL protocol: ${target.protocol}`);
     }
-    const proxyPort = Number(proxy.port || 80);
-    const socket = await socketConnect(proxy.hostname, proxyPort, timeoutMs);
+    const endpoint = parseProxyEndpoint(proxy);
     const targetPort = Number(target.port || 443);
-    socket.write([
-        `CONNECT ${target.hostname}:${targetPort} HTTP/1.1`,
-        `Host: ${target.hostname}:${targetPort}`,
-        'Connection: keep-alive',
-        '',
-        ''
-    ].join('\r\n'));
-    await readConnectResponse(socket, timeoutMs);
-    const secureSocket = tls.connect({
-        socket,
-        servername: target.hostname,
-        rejectUnauthorized: true
-    });
-    await waitForSecureConnect(secureSocket, timeoutMs);
-    secureSocket.write([
-        `GET ${target.pathname || '/'}${target.search} HTTP/1.1`,
-        `Host: ${target.host}`,
-        'Connection: close',
-        '',
-        ''
-    ].join('\r\n'));
-    const response = await readHttpResponse(secureSocket, timeoutMs);
-    const proxiedResponse = {
-        final_url: target.toString(),
-        status_code: response.status,
-        body: response.body,
-        headers: response.headers
-    };
-    const next = redirectTarget(target, proxiedResponse);
-    if (next) {
-        if (redirectsRemaining <= 0) {
-            throw new Error(`too many redirects while fetching ${target.toString()}`);
+    const proxyAuthorization = endpoint.authorization ? [`Proxy-Authorization: ${endpoint.authorization}`] : [];
+    const socket = await connectProxySocket(endpoint, timeoutMs);
+    let secureSocket;
+    try {
+        socket.write([
+            `CONNECT ${target.hostname}:${targetPort} HTTP/1.1`,
+            `Host: ${target.hostname}:${targetPort}`,
+            ...proxyAuthorization,
+            'Connection: keep-alive',
+            '',
+            ''
+        ].join('\r\n'));
+        await readConnectResponse(socket, timeoutMs);
+        secureSocket = tls.connect({
+            socket,
+            servername: target.hostname,
+            rejectUnauthorized: true
+        });
+        // Destroying a TLSSocket after the request-scoped listeners are removed
+        // must not surface as an uncaught 'error'.
+        secureSocket.on('error', () => { });
+        await waitForSecureConnect(secureSocket, timeoutMs);
+        secureSocket.write([
+            `GET ${target.pathname || '/'}${target.search} HTTP/1.1`,
+            `Host: ${target.host}`,
+            'Connection: close',
+            '',
+            ''
+        ].join('\r\n'));
+        const response = await readHttpResponse(secureSocket, timeoutMs);
+        const proxiedResponse = {
+            final_url: target.toString(),
+            status_code: response.status,
+            body: response.body,
+            headers: response.headers
+        };
+        const next = redirectTarget(target, proxiedResponse);
+        if (next) {
+            if (redirectsRemaining <= 0) {
+                throw new Error(`too many redirects while fetching ${target.toString()}`);
+            }
+            return await fetchUrlViaHttpProxyTarget(next, proxy, timeoutMs, redirectsRemaining - 1);
         }
-        return fetchUrlViaHttpProxyTarget(next, proxy, timeoutMs, redirectsRemaining - 1);
+        return {
+            final_url: target.toString(),
+            status_code: response.status,
+            body: response.body
+        };
+    }
+    finally {
+        // Every terminal branch (success, redirect, parse failure, timeout) must
+        // release both handles; destroy() is idempotent so the readers can too.
+        destroyQuietly(secureSocket);
+        destroyQuietly(socket);
     }
-    return {
-        final_url: target.toString(),
-        status_code: response.status,
-        body: response.body
-    };
 }
 export async function fetchUrlViaHttpProxy(url, proxyUrl, timeoutSeconds) {
     const timeoutMs = Math.max(1, timeoutSeconds) * 1000;
@@ -670,7 +721,7 @@ async function checkBatchInNode(input, options) {
             runtimePath: input.runtime_path ?? ''
         })
         : checkLinkAvailabilityDirect(speedResult, config, { targets, fetch: options.fetch })));
-    return mapWithConcurrency(input.results, numberOrDefault(input.config.concurrency, 1), async (speedResult) => {
+    return mapWithCompletion(input.results, numberOrDefault(input.config.concurrency, 1), async (speedResult) => {
         let availability;
         try {
             availability = availabilityResultToDict(await checkLinkAvailability(speedResult, input.config, {

package/dist/pipeline/concurrency.js

@@ -0,0 +1,68 @@
+/**
+ * Bounded fan-out over a fixed work list.
+ *
+ * Three stages used to carry their own copy of this loop (speed test,
+ * availability probe, credential rounds). They drifted: one swallowed worker
+ * errors, one lost input order, none capped a non-finite limit. One definition
+ * keeps the contract the same everywhere:
+ *
+ *   - results keep input order, so a caller can zip them back onto its items;
+ *   - at most `limit` workers are in flight, and `limit` is clamped to >= 1;
+ *   - a worker rejection propagates, but the workers already in flight are
+ *     awaited first so no promise is left running after the call returns.
+ */
+export async function mapWithConcurrency(items, limit, worker) {
+    if (items.length === 0)
+        return [];
+    const width = Math.max(1, Math.min(items.length, Math.trunc(Number(limit)) || 1));
+    const results = new Array(items.length);
+    let cursor = 0;
+    let failed = false;
+    let failure;
+    const runners = Array.from({ length: width }, async () => {
+        while (!failed) {
+            const index = cursor;
+            cursor += 1;
+            if (index >= items.length)
+                return;
+            try {
+                results[index] = await worker(items[index], index);
+            }
+            catch (error) {
+                if (!failed) {
+                    failed = true;
+                    failure = error;
+                }
+                return;
+            }
+        }
+    });
+    await Promise.all(runners);
+    if (failed)
+        throw failure;
+    return results;
+}
+/** Clamp a user-supplied concurrency knob into a sane range. */
+export function resolveConcurrency(value, fallback, max = 16) {
+    const parsed = Math.trunc(Number(value));
+    if (!Number.isFinite(parsed) || parsed < 1)
+        return Math.max(1, Math.min(max, Math.trunc(fallback)));
+    return Math.max(1, Math.min(max, parsed));
+}
+/**
+ * `mapWithConcurrency` plus a progress counter, for a stage that reports
+ * "N of M done" while it works. The callback runs after the result is
+ * recorded, so `completed` counts settled items, not started ones.
+ */
+export async function mapWithCompletion(items, concurrency, worker, onComplete) {
+    if (!onComplete) {
+        return mapWithConcurrency(items, concurrency, worker);
+    }
+    let completed = 0;
+    return mapWithConcurrency(items, concurrency, async (item, index) => {
+        const result = await worker(item, index);
+        completed += 1;
+        onComplete(result, index, completed);
+        return result;
+    });
+}