@swimmingliu/autovpn 1.6.8 → 1.6.9

package/dist/pipeline/orchestrator.js

@@ -308,6 +308,24 @@ async function forEachWithConcurrency(items, concurrency, mapper) {
         throw firstError;
     }
 }
+function createLimiter(concurrency) {
+    const limit = Math.max(1, Math.trunc(Number(concurrency) || 1));
+    let active = 0;
+    const queue = [];
+    return async (task) => {
+        if (active >= limit) {
+            await new Promise((resolve) => queue.push(resolve));
+        }
+        active += 1;
+        try {
+            return await task();
+        }
+        finally {
+            active -= 1;
+            queue.shift()?.();
+        }
+    };
+}
 async function speedtestResumeStateFromEventLog(eventLog) {
     const probes = new Map();
     const fullResults = new Map();
@@ -414,6 +432,65 @@ export async function runNodePipeline(options, context = {}) {
         let availabilityResults = [];
         let availableLinks = [];
         const streamedDeduped = new Set();
+        const streamingAvailabilityTasks = [];
+        const limitAvailability = createLimiter(speedConfig.concurrency);
+        let availabilityCompleted = 0;
+        let availabilityStageStart;
+        let speedArtifactFlush = Promise.resolve();
+        let availabilityArtifactFlush = Promise.resolve();
+        const flushStreamingSpeedArtifacts = async (results, links) => {
+            const resultSnapshot = [...results];
+            const linkSnapshot = [...links];
+            speedArtifactFlush = speedArtifactFlush.catch(() => undefined).then(async () => {
+                await writeLines(artifactDir, 'vpn_node_speedtest.txt', linkSnapshot);
+                await writeJson(artifactDir, 'vpn_node_speedtest_report.json', resultSnapshot);
+            });
+            await speedArtifactFlush;
+        };
+        const flushStreamingAvailabilityArtifacts = async () => {
+            const resultSnapshot = [...availabilityResults];
+            const linkSnapshot = resultSnapshot.filter((result) => result.all_passed).map((result) => result.link);
+            availabilityArtifactFlush = availabilityArtifactFlush.catch(() => undefined).then(async () => {
+                await writeLines(artifactDir, 'vpn_node_availability.txt', linkSnapshot);
+                await writeJson(artifactDir, 'vpn_node_availability_report.json', resultSnapshot);
+            });
+            await availabilityArtifactFlush;
+        };
+        const ensureAvailabilityStageStarted = () => {
+            availabilityStageStart ??= setStage('availability', 'running', false);
+            return availabilityStageStart;
+        };
+        const runStreamingAvailability = (speedResult) => {
+            const task = limitAvailability(async () => {
+                await ensureAvailabilityStageStarted();
+                const results = context.stages?.availability
+                    ? await context.stages.availability([speedResult], profile.speed_test ?? {}, runtimePath, profile.availability_targets)
+                    : await checkLinkAvailabilityBatchWithBackend({
+                        results: [speedResult],
+                        config: profile.speed_test ?? {},
+                        runtime_path: runtimePath,
+                        targets: profile.availability_targets
+                    }, { cwd: projectRoot, env: runtimeStageEnv });
+                for (const result of results) {
+                    availabilityResults.push(result);
+                    availabilityCompleted += 1;
+                    await flushStreamingAvailabilityArtifacts();
+                    const statuses = Object.entries(result.provider_results)
+                        .map(([name, provider]) => `${name}=${provider.passed ? 'ok' : provider.reason}`)
+                        .join(' ');
+                    emit('log', { message: `[availability] ${availabilityCompleted}/${passedSpeedLinks.length} ${statuses}` });
+                    emit('availability_link_result', {
+                        completed: availabilityCompleted,
+                        total: passedSpeedLinks.length,
+                        link: result.link,
+                        all_passed: result.all_passed,
+                        provider_results: result.provider_results
+                    });
+                }
+            });
+            streamingAvailabilityTasks.push(task);
+            task.catch(() => undefined);
+        };
         const onExtractedLinks = async (links) => {
             for (const link of links) {
                 rawLinks.push(link);
@@ -428,8 +505,6 @@ export async function runNodePipeline(options, context = {}) {
         await setStage('extract', 'running');
         if (useStreamingStages) {
             await setStage('dedupe', 'running', false);
-            await setStage('speedtest', 'running', false);
-            await setStage('availability', 'running', false);
         }
         const extractResults = await Promise.all(sourcesToRun.map(async ([sourceName, source]) => {
             const streamedLinks = new Set();
@@ -501,19 +576,23 @@ export async function runNodePipeline(options, context = {}) {
                 ? await context.stages.speedtestProbe(dedupedLinks, profile.speed_test ?? {}, runtimePath)
                 : await probeSpeedtestLinksInNode({ links: dedupedLinks, config: profile.speed_test, runtime_path: runtimePath }, {
                     cwd: projectRoot,
-                    env: runtimeStageEnv
-                });
-            for (let index = 0; index < probes.length; index += 1) {
-                const result = probes[index];
-                emit('log', { message: `[speedtest:probe] ${index + 1}/${dedupedLinks.length} reachable=${result.reachable} latency=${result.latency_ms}ms` });
-                emit('speedtest_probe_result', {
-                    completed: index + 1,
-                    total: dedupedLinks.length,
-                    link: result.link,
-                    reachable: result.reachable,
-                    latency_ms: result.latency_ms,
-                    error: result.error ?? ''
+                    env: runtimeStageEnv,
+                    progressCallback: (message) => emit('log', { message }),
+                    eventCallback: (type, payload) => emit(type, payload)
                 });
+            if (context.stages?.speedtestProbe) {
+                for (let index = 0; index < probes.length; index += 1) {
+                    const result = probes[index];
+                    emit('log', { message: `[speedtest:probe] ${index + 1}/${dedupedLinks.length} reachable=${result.reachable} latency=${result.latency_ms}ms` });
+                    emit('speedtest_probe_result', {
+                        completed: index + 1,
+                        total: dedupedLinks.length,
+                        link: result.link,
+                        reachable: result.reachable,
+                        latency_ms: result.latency_ms,
+                        error: result.error ?? ''
+                    });
+                }
             }
             const candidateLinks = selectSpeedtestCandidates(probes, speedConfig.max_download_candidates);
             const reachableCount = probes.filter((probe) => probe.reachable).length;
@@ -537,33 +616,56 @@ export async function runNodePipeline(options, context = {}) {
                 }
             }
             let speedCompleted = 0;
-            await forEachWithConcurrency(candidateLinks, speedConfig.concurrency, async (link) => {
-                const result = context.stages?.speedtestLink
-                    ? await context.stages.speedtestLink(link, profile.speed_test ?? {}, runtimePath)
-                    : await testSpeedtestLinkInNode({ link, config: profile.speed_test, runtime_path: runtimePath }, {
-                        cwd: projectRoot,
-                        env: runtimeStageEnv
+            try {
+                await forEachWithConcurrency(candidateLinks, speedConfig.concurrency, async (link) => {
+                    const result = context.stages?.speedtestLink
+                        ? await context.stages.speedtestLink(link, profile.speed_test ?? {}, runtimePath)
+                        : await testSpeedtestLinkInNode({ link, config: profile.speed_test, runtime_path: runtimePath }, {
+                            cwd: projectRoot,
+                            env: runtimeStageEnv
+                        });
+                    if (result.reachable && result.latency_ms <= 0) {
+                        result.latency_ms = probeByLink.get(result.link)?.latency_ms ?? 0;
+                    }
+                    resultByLink.set(result.link, result);
+                    speedCompleted += 1;
+                    const passed = result.reachable && result.average_download_mb_s >= speedConfig.min_download_mb_s;
+                    emit('speedtest_result', {
+                        completed: speedCompleted,
+                        total: candidateLinks.length,
+                        link: result.link,
+                        reachable: result.reachable,
+                        average_download_mb_s: result.average_download_mb_s,
+                        latency_ms: result.latency_ms,
+                        passed_threshold: passed,
+                        error: result.error ?? ''
                     });
-                if (result.reachable && result.latency_ms <= 0) {
-                    result.latency_ms = probeByLink.get(result.link)?.latency_ms ?? 0;
-                }
-                resultByLink.set(result.link, result);
-                speedCompleted += 1;
-                const passed = result.reachable && result.average_download_mb_s >= speedConfig.min_download_mb_s;
-                emit('speedtest_result', {
-                    completed: speedCompleted,
-                    total: candidateLinks.length,
-                    link: result.link,
-                    reachable: result.reachable,
-                    average_download_mb_s: result.average_download_mb_s,
-                    latency_ms: result.latency_ms,
-                    passed_threshold: passed,
-                    error: result.error ?? ''
-                });
-                emit('log', {
-                    message: `[speedtest] ${speedCompleted}/${candidateLinks.length} reachable=${result.reachable} speed=${result.average_download_mb_s}MB/s`
+                    emit('log', {
+                        message: `[speedtest] ${speedCompleted}/${candidateLinks.length} reachable=${result.reachable} speed=${result.average_download_mb_s}MB/s`
+                    });
+                    const currentSpeedResults = [
+                        ...probes.filter((probe) => !probe.reachable).map((probe) => resultByLink.get(probe.link)),
+                        ...candidateLinks.map((candidate) => resultByLink.get(candidate)).filter((entry) => Boolean(entry))
+                    ];
+                    const currentPassedLinks = candidateLinks.filter((candidate) => {
+                        const entry = resultByLink.get(candidate);
+                        return Boolean(entry?.reachable && entry.average_download_mb_s >= speedConfig.min_download_mb_s);
+                    });
+                    summary.counts.speedtest_links = currentPassedLinks.length;
+                    await flushStreamingSpeedArtifacts(currentSpeedResults, currentPassedLinks);
+                    if (passed) {
+                        passedSpeedLinks.push(result.link);
+                        runStreamingAvailability(result);
+                    }
                 });
-            });
+            }
+            catch (error) {
+                await Promise.allSettled(streamingAvailabilityTasks);
+                if (summary.stage_status.availability === 'running') {
+                    await setStage('availability', 'failed', false);
+                }
+                throw error;
+            }
             speedResults = [
                 ...probes.filter((probe) => !probe.reachable).map((probe) => resultByLink.get(probe.link)),
                 ...candidateLinks.map((link) => resultByLink.get(link)).filter((result) => Boolean(result))
@@ -592,21 +694,40 @@ export async function runNodePipeline(options, context = {}) {
         if (dedupedLinks.length > 0 && passedSpeedLinks.length === 0) {
             throw new Error(speedtestFailureMessage(speedResults, Number(profile.speed_test?.min_download_mb_s ?? 0)));
         }
-        await setStage('speedtest', 'success', !useStreamingStages);
-        if (summary.stage_status.availability !== 'running') {
+        await setStage('speedtest', 'success');
+        if (useStreamingStages) {
+            try {
+                await Promise.all(streamingAvailabilityTasks);
+            }
+            catch (error) {
+                await setStage('availability', 'failed', false);
+                throw error;
+            }
+            const availabilityByLink = new Map(availabilityResults.map((result) => [result.link, result]));
+            availabilityResults = passedSpeedLinks.map((link) => availabilityByLink.get(link)).filter((result) => Boolean(result));
+        }
+        else if (summary.stage_status.availability !== 'running') {
             await setStage('availability', 'running');
         }
         const speedResultByLink = new Map(speedResults.map((result) => [result.link, result]));
         const candidateSpeedResults = passedSpeedLinks.map((link) => speedResultByLink.get(link)).filter((result) => Boolean(result));
-        availabilityResults = context.stages?.availability
-            ? await context.stages.availability(candidateSpeedResults, profile.speed_test ?? {}, runtimePath, profile.availability_targets)
-            : await checkLinkAvailabilityBatchWithBackend({
-                results: candidateSpeedResults,
-                config: profile.speed_test ?? {},
-                runtime_path: runtimePath,
-                targets: profile.availability_targets
-            }, { cwd: projectRoot, env: runtimeStageEnv });
-        availableLinks = availabilityResults.filter((result) => result.all_passed).map((result) => result.link);
+        availabilityResults = useStreamingStages
+            ? availabilityResults
+            : context.stages?.availability
+                ? await context.stages.availability(candidateSpeedResults, profile.speed_test ?? {}, runtimePath, profile.availability_targets)
+                : await checkLinkAvailabilityBatchWithBackend({
+                    results: candidateSpeedResults,
+                    config: profile.speed_test ?? {},
+                    runtime_path: runtimePath,
+                    targets: profile.availability_targets
+                }, {
+                    cwd: projectRoot,
+                    env: runtimeStageEnv,
+                    progressCallback: (message) => emit('log', { message }),
+                    eventCallback: (type, payload) => emit(type, payload)
+                });
+        const availabilityByLinkForOrder = new Map(availabilityResults.map((result) => [result.link, result]));
+        availableLinks = passedSpeedLinks.filter((link) => availabilityByLinkForOrder.get(link)?.all_passed);
         summary.counts.availability_links = availableLinks.length;
         await writeLines(artifactDir, 'vpn_node_availability.txt', availableLinks);
         await writeJson(artifactDir, 'vpn_node_availability_report.json', availabilityResults);
@@ -647,8 +768,8 @@ export async function runNodePipeline(options, context = {}) {
             await setStage('deploy', 'skipped');
         }
         else {
-            assertDeployMinimumFinalLinks(profile, postprocessed.links);
             await setStage('deploy', 'running');
+            assertDeployMinimumFinalLinks(profile, postprocessed.links);
             const deployment = context.stages?.deploy
                 ? await context.stages.deploy({ projectRoot, bundleDir, profile })
                 : await deployPagesWithBackend({ projectRoot, bundleDir, deploy: profile.deploy ?? {} }, { cwd: projectRoot, env });
@@ -869,8 +990,8 @@ export async function retryNodePipelineStage(options, context = {}) {
             if (!fs.existsSync(bundleDir)) {
                 throw new Error('No Pages bundle available to retry deploy');
             }
-            assertDeployMinimumFinalLinks(profile, finalLinks);
             await setStage('deploy', 'running');
+            assertDeployMinimumFinalLinks(profile, finalLinks);
             const deployment = context.stages?.deploy
                 ? await context.stages.deploy({ projectRoot, bundleDir, profile })
                 : await deployPagesWithBackend({ projectRoot, bundleDir, deploy: profile.deploy ?? {} }, { cwd: projectRoot, env });
@@ -1186,8 +1307,8 @@ export async function resumeNodePipeline(options, context = {}) {
             await setStage('verify', 'skipped');
         }
         else {
-            assertDeployMinimumFinalLinks(profile, postprocessed.links);
             await setStage('deploy', 'running');
+            assertDeployMinimumFinalLinks(profile, postprocessed.links);
             const deployment = context.stages?.deploy
                 ? await context.stages.deploy({ projectRoot, bundleDir, profile })
                 : await deployPagesWithBackend({ projectRoot, bundleDir, deploy: profile.deploy ?? {} }, { cwd: projectRoot, env });

package/dist/pipeline/speedtest.js

@@ -66,7 +66,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() {
@@ -367,7 +371,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 +391,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 +417,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);
@@ -587,10 +591,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/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.6.9',
   brandSubtitle: '概览、运行、结果、订阅、日志、设置统一管理',
   languageLabel: '',
   saveButton: '保存配置',

package/package.json

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