@swimmingliu/autovpn 1.6.1 → 1.6.2

package/dist/pipeline/orchestrator.js

@@ -6,7 +6,7 @@ import { mergeProjectEnv } from '../runtime/env.js';
 import { resolveArtifactsRoot, resolveProfilePath } from '../runtime/paths.js';
 import { redactText } from '../runtime/redaction.js';
 import { fetchSourceLinksWithBackend } from './extract.js';
-import { dedupeVmessLinksWithBackend } from './dedupe.js';
+import { canonicalVmessKey, dedupeVmessLinksWithBackend, parseVmessLink } from './dedupe.js';
 import { normalizeSpeedTestConfig, probeSpeedtestLinksInNode, selectSpeedtestCandidates, speedtestLinksWithBackend, testSpeedtestLinkInNode } from './speedtest.js';
 import { checkLinkAvailabilityBatchWithBackend } from './availability.js';
 import { decorateLinkWithCountry, postprocessLinksWithBackend } from './postprocess.js';
@@ -69,6 +69,27 @@ async function readLines(filePath) {
     }
     return (await readFile(filePath, 'utf8')).split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
 }
+function speedtestFailureMessage(results, minDownloadMbS) {
+    const reachable = results.filter((result) => result.reachable);
+    if (reachable.length === 0) {
+        return 'No links passed speed test';
+    }
+    const bestSpeed = Math.max(...reachable.map((result) => Number(result.average_download_mb_s) || 0));
+    return `No links met minimum speed threshold ${minDownloadMbS}MB/s; best speed was ${bestSpeed}MB/s`;
+}
+function deployMinimumFinalLinks(profile) {
+    const raw = Number(profile.deploy?.min_final_links ?? 10);
+    if (!Number.isFinite(raw) || raw < 0) {
+        return 10;
+    }
+    return Math.trunc(raw);
+}
+function assertDeployMinimumFinalLinks(profile, finalLinks) {
+    const minimum = deployMinimumFinalLinks(profile);
+    if (minimum > 0 && finalLinks.length < minimum) {
+        throw new Error(`final node count ${finalLinks.length} is below deploy minimum ${minimum}`);
+    }
+}
 async function copyIfExists(source, destination) {
     if (!fs.existsSync(source)) {
         return;
@@ -140,6 +161,14 @@ function orderPreservingUnique(values) {
     }
     return result;
 }
+function streamingDedupeKey(link) {
+    try {
+        return canonicalVmessKey(parseVmessLink(link));
+    }
+    catch {
+        return link;
+    }
+}
 function defaultCountryFor(_link, _speedResult, _availabilityResult) {
     return 'US';
 }
@@ -264,6 +293,24 @@ async function forEachWithConcurrency(items, concurrency, mapper) {
         }
     }));
 }
+function createLimiter(concurrency) {
+    const limit = Math.max(1, Math.trunc(concurrency));
+    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();
@@ -341,9 +388,11 @@ export async function runNodePipeline(options, context = {}) {
     };
     const writeReport = () => writeJson(artifactDir, 'pipeline_report.json', summary);
     let activeStage;
-    const setStage = async (stage, status) => {
+    const setStage = async (stage, status, trackActive = true) => {
         summary.stage_status[stage] = status;
-        activeStage = status === 'running' ? stage : activeStage === stage ? undefined : activeStage;
+        if (trackActive) {
+            activeStage = status === 'running' ? stage : activeStage === stage ? undefined : activeStage;
+        }
         emit('stage', { stage, status });
         await writeReport();
     };
@@ -357,16 +406,126 @@ export async function runNodePipeline(options, context = {}) {
         await setStage('doctor', 'running');
         await setStage('doctor', 'success');
         const profile = await readProfile(projectRoot, env);
-        await setStage('extract', 'running');
         const sourcesToRun = enabledSources(profile);
+        const runtimePath = path.join(artifactDir, 'runtime');
+        const speedConfig = normalizeSpeedTestConfig(profile.speed_test);
+        const useStreamingStages = !context.stages?.speedtest || Boolean(context.stages.speedtestLink);
+        let rawLinks = [];
+        let dedupedLinks = [];
+        let speedResults = [];
+        let passedSpeedLinks = [];
+        let availabilityResults = [];
+        let availableLinks = [];
+        const streamedDeduped = new Set();
+        const speedTasks = [];
+        const availabilityTasks = [];
+        const limitSpeedtest = createLimiter(Number(speedConfig.concurrency ?? 1));
+        const limitAvailability = createLimiter(Number(speedConfig.concurrency ?? 1));
+        let speedCompleted = 0;
+        let availabilityCompleted = 0;
+        const runStreamingAvailability = (speedResult) => {
+            const task = limitAvailability(async () => {
+                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;
+                    if (context.stages?.availability) {
+                        emit('availability_link_result', {
+                            completed: availabilityCompleted,
+                            total: passedSpeedLinks.length,
+                            link: result.link,
+                            all_passed: result.all_passed,
+                            provider_results: result.provider_results
+                        });
+                    }
+                }
+            });
+            availabilityTasks.push(task);
+            task.catch(() => undefined);
+        };
+        const runStreamingSpeedtest = (link) => {
+            const task = limitSpeedtest(async () => {
+                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
+                    });
+                speedResults.push(result);
+                speedCompleted += 1;
+                const passed = result.reachable && result.average_download_mb_s >= speedConfig.min_download_mb_s;
+                emit('speedtest_result', {
+                    completed: speedCompleted,
+                    total: dedupedLinks.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}/${dedupedLinks.length} reachable=${result.reachable} speed=${result.average_download_mb_s}MB/s`
+                });
+                if (passed) {
+                    passedSpeedLinks.push(result.link);
+                    runStreamingAvailability(result);
+                }
+            });
+            speedTasks.push(task);
+            task.catch(() => undefined);
+        };
+        const onExtractedLinks = async (links) => {
+            for (const link of links) {
+                rawLinks.push(link);
+                const key = streamingDedupeKey(link);
+                if (streamedDeduped.has(key)) {
+                    continue;
+                }
+                streamedDeduped.add(key);
+                dedupedLinks.push(link);
+                runStreamingSpeedtest(link);
+            }
+        };
+        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();
+            const stream = useStreamingStages
+                ? {
+                    onLinks: async (links) => {
+                        for (const link of links) {
+                            streamedLinks.add(link);
+                        }
+                        await onExtractedLinks(links);
+                    }
+                }
+                : undefined;
             const result = context.stages?.extract
-                ? await context.stages.extract({ source_name: sourceName, source })
+                ? await context.stages.extract({ source_name: sourceName, source }, stream)
                 : await fetchSourceLinksWithBackend({ source_name: sourceName, source }, {
                     cwd: projectRoot,
                     env: runtimeStageEnv,
-                    eventCallback: (type, payload) => emit(type, payload)
+                    eventCallback: (type, payload) => emit(type, payload),
+                    linksCallback: stream?.onLinks
                 });
+            if (useStreamingStages && stream) {
+                const missingLinks = result.links.filter((link) => !streamedLinks.has(link));
+                if (missingLinks.length > 0) {
+                    await stream.onLinks(missingLinks);
+                }
+            }
             summary.source_counts[result.source_name] = {
                 raw_links: result.links.length,
                 successful_iterations: result.successful_iterations,
@@ -374,48 +533,82 @@ export async function runNodePipeline(options, context = {}) {
             };
             return result;
         }));
-        const rawLinks = extractResults.flatMap((result) => result.links);
+        if (!useStreamingStages) {
+            rawLinks = extractResults.flatMap((result) => result.links);
+        }
         if (sourcesToRun.length > 0 && rawLinks.length === 0 && extractResults.some((result) => result.requested_iterations > 0 || result.failed_iterations > 0)) {
             throw new Error('No links extracted from configured sources');
         }
         summary.counts.raw_links = rawLinks.length;
         await writeLines(artifactDir, 'vpn_node_raw.txt', rawLinks);
         await setStage('extract', 'success');
-        await setStage('dedupe', 'running');
-        const dedupedLinks = context.stages?.extract
-            ? orderPreservingUnique(rawLinks)
-            : await dedupeVmessLinksWithBackend(rawLinks, { cwd: projectRoot, env });
+        if (summary.stage_status.dedupe !== 'running') {
+            await setStage('dedupe', 'running');
+        }
+        dedupedLinks = useStreamingStages
+            ? dedupedLinks
+            : context.stages?.extract
+                ? orderPreservingUnique(rawLinks)
+                : await dedupeVmessLinksWithBackend(rawLinks, { cwd: projectRoot, env });
         summary.counts.deduped_links = dedupedLinks.length;
         await writeLines(artifactDir, 'vpn_node_deduped.txt', dedupedLinks);
-        await setStage('dedupe', 'success');
-        await setStage('speedtest', 'running');
-        const runtimePath = path.join(artifactDir, 'runtime');
-        const speedResults = context.stages?.speedtest
-            ? await context.stages.speedtest(dedupedLinks, profile.speed_test ?? {}, runtimePath)
-            : await speedtestLinksWithBackend({ links: dedupedLinks, config: profile.speed_test, runtime_path: runtimePath }, { cwd: projectRoot, env: runtimeStageEnv });
-        const passedSpeedLinks = speedResults
-            .filter((result) => result.reachable && result.average_download_mb_s >= Number(profile.speed_test?.min_download_mb_s ?? 0))
-            .map((result) => result.link);
+        await setStage('dedupe', 'success', !useStreamingStages);
+        if (summary.stage_status.speedtest !== 'running') {
+            await setStage('speedtest', 'running');
+        }
+        if (useStreamingStages) {
+            const requestedRuntime = String(runtimeStageEnv.AUTOVPN_SPEEDTEST_RUNTIME ?? '').trim().toLowerCase();
+            emit('speedtest_runtime', {
+                runtime_core: requestedRuntime === 'direct' ? 'direct' : 'mihomo',
+                probe_url: speedConfig.probe_url,
+                urls: [...speedConfig.urls]
+            });
+            emit('log', {
+                message: `[speedtest] runtime_core=${requestedRuntime === 'direct' ? 'direct' : 'mihomo'} probe_url=${speedConfig.probe_url}`
+            });
+            await Promise.all(speedTasks);
+            await Promise.all(availabilityTasks);
+        }
+        else {
+            speedResults = context.stages?.speedtest
+                ? await context.stages.speedtest(dedupedLinks, profile.speed_test ?? {}, runtimePath)
+                : await speedtestLinksWithBackend({ links: dedupedLinks, config: profile.speed_test, runtime_path: runtimePath }, {
+                    cwd: projectRoot,
+                    env: runtimeStageEnv,
+                    progressCallback: (message) => emit('log', { message }),
+                    eventCallback: (type, payload) => emit(type, payload)
+                });
+            passedSpeedLinks = speedResults
+                .filter((result) => result.reachable && result.average_download_mb_s >= Number(profile.speed_test?.min_download_mb_s ?? 0))
+                .map((result) => result.link);
+        }
         summary.counts.speedtest_links = passedSpeedLinks.length;
         await writeLines(artifactDir, 'vpn_node_speedtest.txt', passedSpeedLinks);
         await writeJson(artifactDir, 'vpn_node_speedtest_report.json', speedResults);
-        await setStage('speedtest', 'success');
-        await setStage('availability', 'running');
+        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('availability', 'running');
+        }
         const speedResultByLink = new Map(speedResults.map((result) => [result.link, result]));
         const candidateSpeedResults = passedSpeedLinks.map((link) => speedResultByLink.get(link)).filter((result) => Boolean(result));
-        const 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 });
-        const 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 });
+        availableLinks = availabilityResults.filter((result) => result.all_passed).map((result) => result.link);
         summary.counts.availability_links = availableLinks.length;
         await writeLines(artifactDir, 'vpn_node_availability.txt', availableLinks);
         await writeJson(artifactDir, 'vpn_node_availability_report.json', availabilityResults);
-        await setStage('availability', 'success');
+        await setStage('availability', 'success', !useStreamingStages);
         await setStage('postprocess', 'running');
         const countryLookup = context.stages?.countryLookup ?? defaultCountryFor;
         const availabilityByLink = new Map(availabilityResults.map((result) => [result.link, result]));
@@ -448,6 +641,7 @@ export async function runNodePipeline(options, context = {}) {
             await setStage('deploy', 'skipped');
         }
         else {
+            assertDeployMinimumFinalLinks(profile, postprocessed.links);
             await setStage('deploy', 'running');
             const deployment = context.stages?.deploy
                 ? await context.stages.deploy({ projectRoot, bundleDir, profile })
@@ -547,7 +741,12 @@ export async function retryNodePipelineStage(options, context = {}) {
             await setStage('speedtest', 'running');
             speedResults = context.stages?.speedtest
                 ? await context.stages.speedtest(dedupedLinks, profile.speed_test ?? {}, runtimePath)
-                : await speedtestLinksWithBackend({ links: dedupedLinks, config: profile.speed_test, runtime_path: runtimePath }, { cwd: projectRoot, env: runtimeStageEnv });
+                : await speedtestLinksWithBackend({ links: dedupedLinks, config: profile.speed_test, runtime_path: runtimePath }, {
+                    cwd: projectRoot,
+                    env: runtimeStageEnv,
+                    progressCallback: (message) => emit('log', { message }),
+                    eventCallback: (type, payload) => emit(type, payload)
+                });
             const passedSpeedLinks = speedResults
                 .filter((result) => result.reachable && result.average_download_mb_s >= Number(profile.speed_test?.min_download_mb_s ?? 0))
                 .map((result) => result.link);
@@ -557,9 +756,9 @@ export async function retryNodePipelineStage(options, context = {}) {
             if (passedSpeedLinks.length === 0) {
                 await setStage('speedtest', 'failed');
                 summary.run_status = 'failed';
-                summary.error = 'Error: No links passed speed test';
+                summary.error = `Error: ${speedtestFailureMessage(speedResults, Number(profile.speed_test?.min_download_mb_s ?? 0))}`;
                 await writeReport();
-                throw new Error('No links passed speed test');
+                throw new Error(speedtestFailureMessage(speedResults, Number(profile.speed_test?.min_download_mb_s ?? 0)));
             }
             speedResults = speedResults.filter((result) => passedSpeedLinks.includes(result.link));
             await setStage('speedtest', 'success');
@@ -662,6 +861,7 @@ 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');
             const deployment = context.stages?.deploy
                 ? await context.stages.deploy({ projectRoot, bundleDir, profile })
@@ -760,8 +960,8 @@ async function resumeNodeSpeedtest(options, context = {}) {
         const speedConfig = normalizeSpeedTestConfig(profile.speed_test);
         const requestedRuntime = String(env.AUTOVPN_SPEEDTEST_RUNTIME ?? '').trim().toLowerCase();
         const usingInjectedSpeedtestStages = Boolean(context.stages?.speedtestProbe && context.stages?.speedtestLink);
-        if (requestedRuntime !== 'mihomo' && !usingInjectedSpeedtestStages) {
-            throw new Error('Node resume speedtest requires AUTOVPN_SPEEDTEST_RUNTIME=mihomo');
+        if (requestedRuntime === 'direct' && !usingInjectedSpeedtestStages) {
+            throw new Error('Node resume speedtest cannot use AUTOVPN_SPEEDTEST_RUNTIME=direct');
         }
         const remainingProbeLinks = dedupedLinks.filter((link) => !probes.has(link));
         if (remainingProbeLinks.length > 0) {
@@ -826,9 +1026,9 @@ async function resumeNodeSpeedtest(options, context = {}) {
         if (fastResults.length === 0) {
             await setStage('speedtest', 'failed');
             summary.run_status = 'failed';
-            summary.error = 'Error: No links passed speed test';
+            summary.error = `Error: ${speedtestFailureMessage(orderedFullResults, speedConfig.min_download_mb_s)}`;
             await writeReport();
-            throw new Error('No links passed speed test');
+            throw new Error(speedtestFailureMessage(orderedFullResults, speedConfig.min_download_mb_s));
         }
         await setStage('speedtest', 'success');
         summary.run_status = 'success';
@@ -978,6 +1178,7 @@ export async function resumeNodePipeline(options, context = {}) {
             await setStage('verify', 'skipped');
         }
         else {
+            assertDeployMinimumFinalLinks(profile, postprocessed.links);
             await setStage('deploy', 'running');
             const deployment = context.stages?.deploy
                 ? await context.stages.deploy({ projectRoot, bundleDir, profile })

package/dist/pipeline/postprocess.js

@@ -150,11 +150,9 @@ export function runPostprocess(input) {
     };
 }
 export function selectPipelineStageBackend(stage, env = process.env) {
-    const stageKey = `AUTOVPN_STAGE_BACKEND_${stage.toUpperCase()}`;
-    const stageOverride = String(env[stageKey] ?? '').trim().toLowerCase();
-    const pipelineOverride = String(env.AUTOVPN_PIPELINE_BACKEND ?? '').trim().toLowerCase();
-    const selected = stageOverride || pipelineOverride || 'node';
-    return selected === 'python' ? 'python' : 'node';
+    void stage;
+    void env;
+    return 'node';
 }
 async function defaultResolvePythonCli(env) {
     // @ts-expect-error Phase 1 runner remains plain ESM JavaScript.

package/dist/pipeline/proxy-runtime.js

@@ -1,5 +1,5 @@
 import { spawn as defaultSpawn } from 'node:child_process';
-import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { mkdtemp, rm, stat, writeFile } from 'node:fs/promises';
 import net from 'node:net';
 import os from 'node:os';
 import path from 'node:path';
@@ -13,6 +13,7 @@ export const PROXY_ENV_KEYS = [
     'NO_PROXY',
     'no_proxy'
 ];
+const MIHOMO_DELAY_TIMEOUT_MAX_MS = 30_000;
 function padBase64(encoded) {
     return encoded + '='.repeat((4 - (encoded.length % 4)) % 4);
 }
@@ -99,7 +100,8 @@ export async function selectMihomoProxy(controllerUrl, proxyName, _timeoutSecond
 export async function probeMihomoProxyDelay(controllerUrl, proxyName, probeUrl, timeoutSeconds, options = {}) {
     const fetchImpl = requireFetch(options.fetch);
     const url = new URL(`${controllerUrl}/proxies/${encodeURIComponent(proxyName)}/delay`);
-    url.searchParams.set('timeout', String(Math.trunc(timeoutSeconds * 1000)));
+    const timeoutMs = Math.min(MIHOMO_DELAY_TIMEOUT_MAX_MS, Math.max(1, Math.trunc(timeoutSeconds * 1000)));
+    url.searchParams.set('timeout', String(timeoutMs));
     url.searchParams.set('url', probeUrl);
     const response = await fetchImpl(url.toString(), { method: 'GET' });
     requireOkResponse(response, 'mihomo proxy delay probe');
@@ -176,6 +178,27 @@ async function closeChildProcess(process) {
         process.kill('SIGTERM');
     });
 }
+async function resolveMihomoCommand(runtimePath) {
+    const candidate = String(runtimePath ?? '').trim();
+    if (!candidate) {
+        return 'mihomo';
+    }
+    try {
+        const info = await stat(candidate);
+        if (info.isFile()) {
+            return candidate;
+        }
+        if (info.isDirectory() && path.basename(candidate) === 'runtime') {
+            return 'mihomo';
+        }
+    }
+    catch {
+        if (path.basename(candidate) === 'runtime') {
+            return 'mihomo';
+        }
+    }
+    return candidate;
+}
 export async function openMihomoRuntime(link, options = {}) {
     const startupWaitSeconds = Number(options.startupWaitSeconds ?? 1);
     const mixedPort = Number.isInteger(options.mixedPort) && Number(options.mixedPort) > 0
@@ -191,10 +214,19 @@ export async function openMihomoRuntime(link, options = {}) {
     const tempDir = await mkdtemp(path.join(os.tmpdir(), 'autovpn-mihomo-'));
     const configPath = path.join(tempDir, 'config.json');
     await writeFile(configPath, JSON.stringify(config), 'utf8');
-    const child = (options.spawn ?? defaultSpawn)(options.runtimePath || 'mihomo', ['-f', configPath], {
+    const command = await resolveMihomoCommand(options.runtimePath);
+    const child = (options.spawn ?? defaultSpawn)(command, ['-f', configPath], {
         stdio: ['ignore', 'pipe', 'pipe'],
         env: stripProxyEnv(options.env ?? process.env)
     });
+    let rejectStartupError;
+    const startupError = new Promise((_resolve, reject) => {
+        rejectStartupError = reject;
+    });
+    const onStartupError = (error) => {
+        rejectStartupError?.(error);
+    };
+    child.once('error', onStartupError);
     let closed = false;
     const close = async () => {
         if (closed) {
@@ -206,11 +238,15 @@ export async function openMihomoRuntime(link, options = {}) {
     };
     try {
         const waitForPort = options.waitForPort ?? defaultWaitForPort;
-        await waitForPort(mixedPort, startupWaitSeconds + 4);
-        await waitForPort(controllerPort, startupWaitSeconds + 4);
-        await (options.selectProxy ?? ((url, name, timeoutSeconds) => selectMihomoProxy(url, name, timeoutSeconds)))(controllerUrl, proxyName, startupWaitSeconds + 4);
+        await Promise.race([waitForPort(mixedPort, startupWaitSeconds + 4), startupError]);
+        await Promise.race([waitForPort(controllerPort, startupWaitSeconds + 4), startupError]);
+        await Promise.race([(options.selectProxy ?? ((url, name, timeoutSeconds) => selectMihomoProxy(url, name, timeoutSeconds)))(controllerUrl, proxyName, startupWaitSeconds + 4), startupError]);
+        child.off('error', onStartupError);
+        child.on('error', () => { });
     }
     catch (error) {
+        child.off('error', onStartupError);
+        child.on('error', () => { });
         await close();
         throw error;
     }

package/dist/pipeline/render.js

@@ -28,11 +28,9 @@ export function runRender(input) {
     };
 }
 export function selectPipelineStageBackend(stage, env = process.env) {
-    const stageKey = `AUTOVPN_STAGE_BACKEND_${stage.toUpperCase()}`;
-    const stageOverride = String(env[stageKey] ?? '').trim().toLowerCase();
-    const pipelineOverride = String(env.AUTOVPN_PIPELINE_BACKEND ?? '').trim().toLowerCase();
-    const selected = stageOverride || pipelineOverride || 'node';
-    return selected === 'python' ? 'python' : 'node';
+    void stage;
+    void env;
+    return 'node';
 }
 async function defaultResolvePythonCli(env) {
     // @ts-expect-error Phase 1 runner remains plain ESM JavaScript.