@swimmingliu/autovpn 1.6.9 → 1.8.0

package/dist/pipeline/speedtest.js

@@ -1,6 +1,7 @@
 import net from 'node:net';
 import tls from 'node:tls';
 import { openMihomoRuntime as defaultOpenMihomoRuntime, probeMihomoProxyDelay as defaultProbeMihomoProxyDelay } from './proxy-runtime.js';
+import { retryTransientNetwork } from './network-retry.js';
 const PROBE_MAX_ATTEMPTS = 2;
 export function aggregateSpeedMeasurements(values) {
     if (values.length === 0) {
@@ -160,35 +161,8 @@ function requireOkResponse(response, allowedStatuses) {
         throw new Error(`unexpected status ${status}`);
     }
 }
-function isTransientProbeError(error) {
-    const message = error instanceof Error ? error.message : String(error);
-    const code = typeof error === 'object' && error !== null && 'code' in error
-        ? String(error.code ?? '')
-        : '';
-    const statusMatch = /(?:unexpected status|failed with status)\s+(\d{3})\b/i.exec(message);
-    if (statusMatch) {
-        const status = Number(statusMatch[1]);
-        return status >= 500 && status <= 599;
-    }
-    if (['AUTOVPN_INTERNAL_TIMEOUT', 'ECONNRESET', 'ETIMEDOUT', 'EPIPE', 'ECONNREFUSED', 'UND_ERR_CONNECT_TIMEOUT', 'UND_ERR_HEADERS_TIMEOUT', 'UND_ERR_BODY_TIMEOUT'].includes(code.toUpperCase())) {
-        return true;
-    }
-    return error instanceof TypeError && message.trim().toLowerCase() === 'fetch failed';
-}
 async function retryTransientProbe(operation) {
-    let lastError;
-    for (let attempt = 1; attempt <= PROBE_MAX_ATTEMPTS; attempt += 1) {
-        try {
-            return await operation();
-        }
-        catch (error) {
-            lastError = error;
-            if (attempt >= PROBE_MAX_ATTEMPTS || !isTransientProbeError(error)) {
-                throw error;
-            }
-        }
-    }
-    throw lastError;
+    return retryTransientNetwork(operation, { maxAttempts: PROBE_MAX_ATTEMPTS, delayMs: 0 });
 }
 function socketConnect(host, port, timeoutMs) {
     return new Promise((resolve, reject) => {
@@ -359,8 +333,14 @@ export async function downloadUrlViaHttpProxy(url, proxyUrl, maxBytes, timeoutSe
         rejectUnauthorized: false
     });
     await new Promise((resolve, reject) => {
-        secureSocket.once('secureConnect', resolve);
-        secureSocket.once('error', reject);
+        const timer = setTimeout(() => {
+            secureSocket.destroy();
+            const error = new Error(`TLS handshake timed out after ${timeoutMs}ms`);
+            error.code = 'AUTOVPN_INTERNAL_TIMEOUT';
+            reject(error);
+        }, timeoutMs);
+        secureSocket.once('secureConnect', () => { clearTimeout(timer); resolve(); });
+        secureSocket.once('error', (error) => { clearTimeout(timer); reject(error); });
     });
     secureSocket.write([
         `GET ${requestPath} HTTP/1.1`,
@@ -461,43 +441,44 @@ async function testLinkDirect(link, config, options) {
 async function testLinkMihomo(link, config, runtimePath, options) {
     const openRuntime = options.openMihomoRuntime ?? defaultOpenMihomoRuntime;
     const downloadViaProxy = options.downloadUrlViaHttpProxy ?? downloadUrlViaHttpProxy;
-    let runtime;
     try {
-        runtime = await openRuntime(link, {
-            runtimePath,
-            startupWaitSeconds: config.startup_wait_seconds,
-            env: options.env
-        });
-        const now = options.now ?? defaultNow;
-        const speedValues = [];
-        const failures = [];
-        for (const url of config.urls) {
-            const started = now();
+        return await retryTransientNetwork(async () => {
+            let runtime;
             try {
-                const total = await downloadViaProxy(url, runtime.proxies.http, Math.max(1, Number(config.max_download_bytes)), config.timeout_seconds);
-                const elapsedSeconds = Math.max((now() - started) / 1000, 0.001);
-                speedValues.push(total / elapsedSeconds / 1024 / 1024);
+                runtime = await openRuntime(link, {
+                    runtimePath,
+                    startupWaitSeconds: config.startup_wait_seconds,
+                    env: options.env
+                });
+                const now = options.now ?? defaultNow;
+                const speedValues = [];
+                const failures = [];
+                let lastFailure;
+                for (const url of config.urls) {
+                    try {
+                        const measurement = await retryTransientNetwork(async () => {
+                            const started = now();
+                            const total = await downloadViaProxy(url, runtime.proxies.http, Math.max(1, Number(config.max_download_bytes)), config.timeout_seconds);
+                            return { total, elapsedSeconds: Math.max((now() - started) / 1000, 0.001) };
+                        });
+                        speedValues.push(measurement.total / measurement.elapsedSeconds / 1024 / 1024);
+                    }
+                    catch (error) {
+                        lastFailure = error;
+                        failures.push(`${url}: ${error instanceof Error ? error.message : String(error)}`);
+                    }
+                }
+                if (speedValues.length === 0) {
+                    if (lastFailure)
+                        throw lastFailure;
+                    return { link, reachable: false, average_download_mb_s: 0, latency_ms: 0, error: failures.join('; ') || 'all speed test urls failed' };
+                }
+                return { link, reachable: true, average_download_mb_s: aggregateSpeedMeasurements(speedValues), latency_ms: 0, error: failures.join('; ') };
             }
-            catch (error) {
-                failures.push(`${url}: ${error instanceof Error ? error.message : String(error)}`);
+            finally {
+                await runtime?.close();
             }
-        }
-        if (speedValues.length === 0) {
-            return {
-                link,
-                reachable: false,
-                average_download_mb_s: 0,
-                latency_ms: 0,
-                error: failures.join('; ') || 'all speed test urls failed'
-            };
-        }
-        return {
-            link,
-            reachable: true,
-            average_download_mb_s: aggregateSpeedMeasurements(speedValues),
-            latency_ms: 0,
-            error: failures.join('; ')
-        };
+        });
     }
     catch (error) {
         return {
@@ -508,9 +489,6 @@ async function testLinkMihomo(link, config, runtimePath, options) {
             error: error instanceof Error ? error.message : String(error)
         };
     }
-    finally {
-        await runtime?.close();
-    }
 }
 async function speedtestInNode(input, options) {
     if (input.links.length === 0) {

package/dist/pipeline/streaming-coordinator.js

@@ -0,0 +1,154 @@
+export class AsyncPermitPool {
+    available;
+    waiters = [];
+    constructor(limit) {
+        if (!Number.isInteger(limit) || limit <= 0)
+            throw new RangeError('permit limit must be a positive integer');
+        this.available = limit;
+    }
+    async run(operation) {
+        await this.acquire();
+        try {
+            return await operation();
+        }
+        finally {
+            this.release();
+        }
+    }
+    async acquire() {
+        if (this.available > 0) {
+            this.available -= 1;
+            return;
+        }
+        await new Promise((resolve) => this.waiters.push(resolve));
+    }
+    release() {
+        const waiter = this.waiters.shift();
+        if (waiter)
+            waiter();
+        else
+            this.available += 1;
+    }
+}
+export class BoundedWorkerPool {
+    concurrency;
+    limit;
+    worker;
+    queue = [];
+    admissionWaiters = [];
+    drainWaiters = [];
+    active = 0;
+    closed = false;
+    failure;
+    failed = false;
+    constructor(options) {
+        if (!Number.isInteger(options.concurrency) || options.concurrency <= 0) {
+            throw new RangeError('concurrency must be a positive integer');
+        }
+        if (!Number.isInteger(options.capacity) || options.capacity < 0) {
+            throw new RangeError('capacity must be a non-negative integer');
+        }
+        this.concurrency = options.concurrency;
+        this.limit = options.concurrency + options.capacity;
+        this.worker = options.worker;
+    }
+    submit(item) {
+        if (this.failed) {
+            return Promise.reject(this.failure);
+        }
+        if (this.closed) {
+            return Promise.reject(new Error('worker pool is closed'));
+        }
+        if (this.active + this.queue.length < this.limit) {
+            this.accept(item);
+            return Promise.resolve();
+        }
+        return new Promise((resolve, reject) => {
+            this.admissionWaiters.push({ item, resolve, reject });
+        });
+    }
+    close() {
+        this.closed = true;
+        this.settleDrainWaitersIfIdle();
+    }
+    drain() {
+        if (this.isIdle()) {
+            return this.failed ? Promise.reject(this.failure) : Promise.resolve();
+        }
+        return new Promise((resolve, reject) => {
+            this.drainWaiters.push({ resolve, reject });
+        });
+    }
+    abort(error) {
+        if (!this.failed) {
+            this.failed = true;
+            this.failure = error;
+        }
+        this.closed = true;
+        this.queue.length = 0;
+        this.rejectAdmissionWaiters(this.failure);
+        this.settleDrainWaitersIfIdle();
+    }
+    accept(item) {
+        if (this.active < this.concurrency) {
+            this.start(item);
+        }
+        else {
+            this.queue.push(item);
+        }
+    }
+    start(item) {
+        this.active += 1;
+        Promise.resolve()
+            .then(() => this.worker(item))
+            .catch((error) => this.recordFailure(error))
+            .finally(() => {
+            this.active -= 1;
+            if (!this.failed) {
+                this.fillAvailableSlots();
+            }
+            this.settleDrainWaitersIfIdle();
+        });
+    }
+    fillAvailableSlots() {
+        while (this.active < this.concurrency && this.queue.length > 0) {
+            this.start(this.queue.shift());
+        }
+        while (this.active + this.queue.length < this.limit && this.admissionWaiters.length > 0) {
+            const admission = this.admissionWaiters.shift();
+            this.accept(admission.item);
+            admission.resolve();
+        }
+    }
+    recordFailure(error) {
+        if (this.failed) {
+            return;
+        }
+        this.failed = true;
+        this.failure = error;
+        this.closed = true;
+        this.queue.length = 0;
+        this.rejectAdmissionWaiters(error);
+    }
+    rejectAdmissionWaiters(error) {
+        for (const admission of this.admissionWaiters.splice(0)) {
+            admission.reject(error);
+        }
+    }
+    isIdle() {
+        return this.active === 0 && this.queue.length === 0;
+    }
+    settleDrainWaitersIfIdle() {
+        if (!this.isIdle()) {
+            return;
+        }
+        for (const waiter of this.drainWaiters.splice(0)) {
+            if (this.failed) {
+                waiter.reject(this.failure);
+            }
+            else {
+                waiter.resolve();
+            }
+        }
+    }
+}