@swimmingliu/autovpn 1.6.8 → 1.7.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) {
@@ -66,7 +67,11 @@ async function mapWithConcurrency(items, concurrency, worker, onComplete) {
             onComplete?.(result, index, completed);
         }
     }
-    await Promise.all(Array.from({ length: Math.min(limit, items.length) }, () => runWorker()));
+    const workers = await Promise.allSettled(Array.from({ length: Math.min(limit, items.length) }, () => runWorker()));
+    const failed = workers.find((result) => result.status === 'rejected');
+    if (failed) {
+        throw failed.reason;
+    }
     return results;
 }
 function defaultNow() {
@@ -156,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) => {
@@ -355,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`,
@@ -367,7 +351,7 @@ export async function downloadUrlViaHttpProxy(url, proxyUrl, maxBytes, timeoutSe
     ].join('\r\n'));
     return await readHttpBodyBytes(secureSocket, Math.max(1, maxBytes), timeoutMs);
 }
-async function probeLinksDirect(links, config, options) {
+async function probeLinksDirect(links, config, options, onComplete) {
     const fetchImpl = options.fetch ?? globalThis.fetch?.bind(globalThis);
     if (!fetchImpl) {
         throw new Error('Node speedtest backend requires fetch support');
@@ -387,9 +371,9 @@ async function probeLinksDirect(links, config, options) {
         catch (error) {
             return { link, reachable: false, latency_ms: 0, error: error instanceof Error ? error.message : String(error) };
         }
-    });
+    }, (result, _index, completed) => onComplete?.(result, completed));
 }
-async function probeLinksMihomo(links, config, runtimePath, options) {
+async function probeLinksMihomo(links, config, runtimePath, options, onComplete) {
     const openRuntime = options.openMihomoRuntime ?? defaultOpenMihomoRuntime;
     const probeDelay = options.probeMihomoProxyDelay ?? defaultProbeMihomoProxyDelay;
     return mapWithConcurrency(links, config.concurrency, async (link) => {
@@ -413,7 +397,7 @@ async function probeLinksMihomo(links, config, runtimePath, options) {
         catch (error) {
             return { link, reachable: false, latency_ms: 0, error: error instanceof Error ? error.message : String(error) };
         }
-    });
+    }, (result, _index, completed) => onComplete?.(result, completed));
 }
 async function testLinkDirect(link, config, options) {
     const fetchImpl = options.fetch ?? globalThis.fetch?.bind(globalThis);
@@ -457,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 {
@@ -504,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) {
@@ -587,10 +569,25 @@ export async function probeSpeedtestLinksInNode(input, options = {}) {
     const runtimePath = input.runtime_path ?? '';
     const requestedRuntime = String((options.env ?? process.env).AUTOVPN_SPEEDTEST_RUNTIME ?? '').trim().toLowerCase();
     const useMihomoRuntime = requestedRuntime !== 'direct';
-    const probeLinks = options.probeLinks ?? ((links) => (useMihomoRuntime
-        ? probeLinksMihomo(links, config, runtimePath, options)
-        : probeLinksDirect(links, config, options)));
-    return probeLinks(input.links, config, { runtime_path: runtimePath });
+    const emitProbe = (result, completed) => {
+        options.progressCallback?.(`[speedtest:probe] ${completed}/${input.links.length} reachable=${result.reachable} latency=${result.latency_ms}ms`);
+        emitEvent(options.eventCallback, 'speedtest_probe_result', {
+            completed,
+            total: input.links.length,
+            link: result.link,
+            reachable: result.reachable,
+            latency_ms: result.latency_ms,
+            error: result.error ?? ''
+        });
+    };
+    if (options.probeLinks) {
+        const results = await options.probeLinks(input.links, config, { runtime_path: runtimePath });
+        results.forEach((result, index) => emitProbe(result, index + 1));
+        return results;
+    }
+    return useMihomoRuntime
+        ? probeLinksMihomo(input.links, config, runtimePath, options, emitProbe)
+        : probeLinksDirect(input.links, config, options, emitProbe);
 }
 export async function testSpeedtestLinkInNode(input, options = {}) {
     const config = normalizeSpeedTestConfig(input.config);

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();
+            }
+        }
+    }
+}

package/dist/web/renderer/app.js

@@ -1187,7 +1187,7 @@ function handlePipelineEvent(event, options = {}) {
   }
 
   if (event.type === 'stage') {
-    state.stageStatus[event.stage] = event.status;
+    state.stageStatus[event.stage] = normalizeStageStatus(event.status);
     appendLog(`[stage] ${event.stage} ${event.status}`, {
       kind: 'stage',
       stage: event.stage,
@@ -1199,7 +1199,7 @@ function handlePipelineEvent(event, options = {}) {
   }
 
   if (event.type === 'summary') {
-    state.stageStatus = event.stage_status ?? {};
+    state.stageStatus = normalizeStageStatuses(event.stage_status);
     state.counts = normalizeCounts(event.counts ?? {});
     state.sourceCounts = normalizeSourceCounts(event.source_counts ?? state.sourceCounts);
     state.retryContext = event.retry_context ?? state.retryContext ?? {};
@@ -1332,12 +1332,38 @@ function handlePipelineEvent(event, options = {}) {
   }
 
   if (event.type === 'run_started') {
-    state.artifactDir = event.artifact_dir ?? '';
+    const nextArtifactDir = String(event.artifact_dir ?? '');
+    if (nextArtifactDir !== state.artifactDir) {
+      resetRunScopedProgress();
+      state.runState = 'running';
+      state.runResult = 'running';
+      state.runStartedAt = Date.now();
+    }
+    state.artifactDir = nextArtifactDir;
     touchUpdate();
     renderAll();
   }
 }
 
+function normalizeStageStatus(status) {
+  return status === 'skipped' ? '已跳过' : status;
+}
+
+function normalizeStageStatuses(stageStatuses = {}) {
+  return Object.fromEntries(
+    Object.entries(stageStatuses ?? {}).map(([stage, status]) => [stage, normalizeStageStatus(status)])
+  );
+}
+
+function resetRunScopedProgress() {
+  state.stageStatus = {};
+  state.counts = {};
+  state.sourceCounts = {};
+  state.extractDedupedFingerprints = new Set();
+  state.outputFiles = [];
+  state.nodeRows = [];
+}
+
 function normalizeCounts(counts) {
   return {
     ...counts,
@@ -1368,8 +1394,16 @@ function updateExtractMetrics(event) {
   }
 
   const previous = state.sourceCounts[sourceName] ?? {};
-  const rawLinks = Number(event.total_links ?? previous.raw_links ?? 0);
-  const sourceDedupedLinks = Number(event.deduped_links ?? previous.deduped_links ?? rawLinks);
+  const previousRawLinks = validNonNegativeNumber(previous.raw_links) ?? 0;
+  const previousDedupedLinks = validNonNegativeNumber(previous.deduped_links) ?? 0;
+  const rawLinks = Math.max(previousRawLinks, validNonNegativeNumber(event.total_links) ?? previousRawLinks);
+  const eventDedupedLinks = event.deduped_links == null
+    ? rawLinks
+    : validNonNegativeNumber(event.deduped_links) ?? previousDedupedLinks;
+  const sourceDedupedLinks = Math.max(
+    previousDedupedLinks,
+    eventDedupedLinks
+  );
   if (Array.isArray(event.new_item_fingerprints)) {
     for (const fingerprint of event.new_item_fingerprints) {
       if (fingerprint) {
@@ -1395,6 +1429,11 @@ function updateExtractMetrics(event) {
   }
 }
 
+function validNonNegativeNumber(value) {
+  const number = Number(value);
+  return Number.isFinite(number) && number >= 0 ? number : null;
+}
+
 async function hydrateArtifactPreview() {
   if (!state.artifactDir || !window.vpnAutomation?.previewArtifact) {
     state.outputFiles = [];
@@ -1430,7 +1469,7 @@ function hydrateArtifactState(result) {
     state.runResult = 'failed';
   }
   if (result.stage_status) {
-    state.stageStatus = result.stage_status;
+    state.stageStatus = normalizeStageStatuses(result.stage_status);
   }
 }
 

package/dist/web/renderer/i18n.js

@@ -5,7 +5,7 @@ const ZH_MESSAGES = {
   locale: 'zh-CN',
   appTitle: 'AutoVPN',
   sidebarTitle: 'AutoVPN',
-  sidebarVersion: 'v.1.6.8',
+  sidebarVersion: 'v.1.7.0',
   brandSubtitle: '概览、运行、结果、订阅、日志、设置统一管理',
   languageLabel: '',
   saveButton: '保存配置',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swimmingliu/autovpn",
-  "version": "1.6.8",
+  "version": "1.7.0",
   "description": "npm wrapper for the AutoVPN headless CLI",
   "type": "module",
   "repository": {