@swimmingliu/autovpn 1.6.1 → 1.6.3

package/dist/pipeline/speedtest.js

@@ -71,6 +71,24 @@ 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 defaultNow() {
     return performance.now();
 }
@@ -84,26 +102,52 @@ async function fetchWithTimeout(fetchImpl, url, timeoutMs) {
         clearTimeout(timer);
     }
 }
-async function readResponseBytes(response, maxBytes) {
+async function withBodyTimeout(operation, timeoutMs) {
+    let timer;
+    try {
+        return await Promise.race([
+            operation(),
+            new Promise((_resolve, reject) => {
+                timer = setTimeout(() => reject(new Error(`response body timed out after ${timeoutMs}ms`)), timeoutMs);
+            })
+        ]);
+    }
+    finally {
+        if (timer) {
+            clearTimeout(timer);
+        }
+    }
+}
+async function readResponseBytes(response, maxBytes, timeoutMs) {
     if (response.body?.getReader) {
         const reader = response.body.getReader();
-        let total = 0;
+        let timedOut = false;
         try {
-            while (total < maxBytes) {
-                const { done, value } = await reader.read();
-                if (done) {
-                    break;
+            return await withBodyTimeout(async () => {
+                let total = 0;
+                while (total < maxBytes) {
+                    const { done, value } = await reader.read();
+                    if (done) {
+                        break;
+                    }
+                    total += Math.min(value.byteLength, maxBytes - total);
                 }
-                total += Math.min(value.byteLength, maxBytes - total);
-            }
+                return total;
+            }, timeoutMs);
+        }
+        catch (error) {
+            timedOut = error instanceof Error && error.message.includes('response body timed out');
+            throw error;
         }
         finally {
+            if (timedOut) {
+                await reader.cancel().catch(() => { });
+            }
             reader.releaseLock();
         }
-        return total;
     }
     if (response.arrayBuffer) {
-        return Math.min((await response.arrayBuffer()).byteLength, maxBytes);
+        return await withBodyTimeout(async () => Math.min((await response.arrayBuffer()).byteLength, maxBytes), timeoutMs);
     }
     return 0;
 }
@@ -301,26 +345,23 @@ async function probeLinksDirect(links, config, options) {
     }
     const now = options.now ?? defaultNow;
     const timeoutMs = Math.max(1, Number(config.timeout_seconds)) * 1000;
-    const results = [];
-    for (const link of links) {
+    return mapWithConcurrency(links, config.concurrency, async (link) => {
         const started = now();
         try {
             const response = await fetchWithTimeout(fetchImpl, config.probe_url, timeoutMs);
             const elapsed = Math.max(now() - started, 1);
             requireOkResponse(response, new Set([200, 204]));
-            results.push({ link, reachable: true, latency_ms: Math.max(Math.round(elapsed), 1), error: '' });
+            return { link, reachable: true, latency_ms: Math.max(Math.round(elapsed), 1), error: '' };
         }
         catch (error) {
-            results.push({ link, reachable: false, latency_ms: 0, error: error instanceof Error ? error.message : String(error) });
+            return { link, reachable: false, latency_ms: 0, error: error instanceof Error ? error.message : String(error) };
         }
-    }
-    return results;
+    });
 }
 async function probeLinksMihomo(links, config, runtimePath, options) {
     const openRuntime = options.openMihomoRuntime ?? defaultOpenMihomoRuntime;
     const probeDelay = options.probeMihomoProxyDelay ?? defaultProbeMihomoProxyDelay;
-    const results = [];
-    for (const link of links) {
+    return mapWithConcurrency(links, config.concurrency, async (link) => {
         let runtime;
         try {
             runtime = await openRuntime(link, {
@@ -329,16 +370,15 @@ async function probeLinksMihomo(links, config, runtimePath, options) {
                 env: options.env
             });
             const latencyMs = await probeDelay(runtime.controllerUrl, runtime.proxyName, config.probe_url, config.timeout_seconds);
-            results.push({ link, reachable: true, latency_ms: latencyMs, error: '' });
+            return { link, reachable: true, latency_ms: latencyMs, error: '' };
         }
         catch (error) {
-            results.push({ link, reachable: false, latency_ms: 0, error: error instanceof Error ? error.message : String(error) });
+            return { link, reachable: false, latency_ms: 0, error: error instanceof Error ? error.message : String(error) };
         }
         finally {
             await runtime?.close();
         }
-    }
-    return results;
+    });
 }
 async function testLinkDirect(link, config, options) {
     const fetchImpl = options.fetch ?? globalThis.fetch?.bind(globalThis);
@@ -354,7 +394,7 @@ async function testLinkDirect(link, config, options) {
         try {
             const response = await fetchWithTimeout(fetchImpl, url, timeoutMs);
             requireOkResponse(response, new Set([200]));
-            const total = await readResponseBytes(response, Math.max(1, Number(config.max_download_bytes)));
+            const total = await readResponseBytes(response, Math.max(1, Number(config.max_download_bytes)), timeoutMs);
             const elapsedSeconds = Math.max((now() - started) / 1000, 0.001);
             speedValues.push(total / elapsedSeconds / 1024 / 1024);
         }
@@ -440,7 +480,7 @@ async function speedtestInNode(input, options) {
     const config = normalizeSpeedTestConfig(input.config);
     const runtimePath = input.runtime_path ?? '';
     const requestedRuntime = String((options.env ?? process.env).AUTOVPN_SPEEDTEST_RUNTIME ?? '').trim().toLowerCase();
-    const useMihomoRuntime = requestedRuntime === 'mihomo';
+    const useMihomoRuntime = requestedRuntime !== 'direct';
     const probeLinks = options.probeLinks ?? ((links) => (useMihomoRuntime
         ? probeLinksMihomo(links, config, runtimePath, options)
         : probeLinksDirect(links, config, options)));
@@ -474,13 +514,10 @@ async function speedtestInNode(input, options) {
         latency_ms: probe.latency_ms,
         error: probe.error ?? ''
     }));
-    for (let index = 0; index < candidateLinks.length; index += 1) {
-        const result = await testLink(candidateLinks[index], config, { runtime_path: runtimePath });
+    const testedResults = await mapWithConcurrency(candidateLinks, config.concurrency, async (link) => (testLink(link, config, { runtime_path: runtimePath })), (result, _index, completed) => {
         if (result.reachable && result.latency_ms <= 0) {
             result.latency_ms = probeByLink.get(result.link)?.latency_ms ?? 0;
         }
-        results.push(result);
-        const completed = index + 1;
         options.progressCallback?.(`[speedtest] ${completed}/${candidateSet.size} reachable=${result.reachable} speed=${result.average_download_mb_s}MB/s`);
         emitEvent(options.eventCallback, 'speedtest_result', {
             completed,
@@ -492,15 +529,14 @@ async function speedtestInNode(input, options) {
             passed_threshold: result.reachable && result.average_download_mb_s >= config.min_download_mb_s,
             error: result.error ?? ''
         });
-    }
+    });
+    results.push(...testedResults);
     return results;
 }
 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.
@@ -561,7 +597,7 @@ export async function probeSpeedtestLinksInNode(input, options = {}) {
     const config = normalizeSpeedTestConfig(input.config);
     const runtimePath = input.runtime_path ?? '';
     const requestedRuntime = String((options.env ?? process.env).AUTOVPN_SPEEDTEST_RUNTIME ?? '').trim().toLowerCase();
-    const useMihomoRuntime = requestedRuntime === 'mihomo';
+    const useMihomoRuntime = requestedRuntime !== 'direct';
     const probeLinks = options.probeLinks ?? ((links) => (useMihomoRuntime
         ? probeLinksMihomo(links, config, runtimePath, options)
         : probeLinksDirect(links, config, options)));
@@ -571,7 +607,7 @@ export async function testSpeedtestLinkInNode(input, options = {}) {
     const config = normalizeSpeedTestConfig(input.config);
     const runtimePath = input.runtime_path ?? '';
     const requestedRuntime = String((options.env ?? process.env).AUTOVPN_SPEEDTEST_RUNTIME ?? '').trim().toLowerCase();
-    const useMihomoRuntime = requestedRuntime === 'mihomo';
+    const useMihomoRuntime = requestedRuntime !== 'direct';
     const testLink = options.testLink ?? ((link) => (useMihomoRuntime
         ? testLinkMihomo(link, config, runtimePath, options)
         : testLinkDirect(link, config, options)));

package/dist/runtime/managed-tools.js

@@ -3,6 +3,7 @@ import path from 'node:path';
 import { access, mkdir } from 'node:fs/promises';
 import { constants } from 'node:fs';
 import { resolveUserRuntimeRoot } from './paths.js';
+const DEFAULT_MANAGED_NPM_REGISTRY = 'https://registry.npmmirror.com';
 export class ManagedToolError extends Error {
     code;
     constructor(message, code = 'MANAGED_TOOL_ERROR') {
@@ -98,9 +99,12 @@ async function installManagedTool(packageName, version, installDir, runCommand)
     await mkdir(installDir, { recursive: true });
     let result;
     try {
-        result = await runCommand(['npm', 'install', '--no-save', '--no-audit', '--no-fund', `${packageName}@${version}`], {
+        result = await runCommand(['npm', '--prefix', installDir, 'install', '--no-save', '--no-audit', '--no-fund', `${packageName}@${version}`], {
             cwd: installDir,
-            env: { NPM_CONFIG_YES: 'true' }
+            env: {
+                NPM_CONFIG_YES: 'true',
+                NPM_CONFIG_REGISTRY: resolveManagedNpmRegistry()
+            }
         });
     }
     catch (error) {
@@ -110,6 +114,9 @@ async function installManagedTool(packageName, version, installDir, runCommand)
         throw new ManagedToolError(`npm install failed for ${packageName}@${version}: ${safeCommandMessage(result)}`, 'MANAGED_TOOL_INSTALL_FAILED');
     }
 }
+function resolveManagedNpmRegistry(env = process.env) {
+    return String(env.NPM_CONFIG_REGISTRY || env.npm_config_registry || DEFAULT_MANAGED_NPM_REGISTRY);
+}
 async function verifyToolVersion(binaryPath, cwd, runCommand, source) {
     let result;
     try {

package/dist/server/http.js

@@ -241,14 +241,17 @@ export async function createAutoVpnServer(options) {
     const originHost = options.host === '0.0.0.0' ? '127.0.0.1' : options.host;
     return {
         origin: `http://${originHost}:${port}`,
-        close: () => new Promise((resolve, reject) => {
-            server.close((error) => {
-                if (error) {
-                    reject(error);
-                    return;
-                }
-                resolve();
+        close: async () => {
+            await options.runtime.close?.();
+            await new Promise((resolve, reject) => {
+                server.close((error) => {
+                    if (error) {
+                        reject(error);
+                        return;
+                    }
+                    resolve();
+                });
             });
-        })
+        }
     };
 }

package/dist/server/runtime.js

@@ -136,6 +136,18 @@ function latestJob(projectRoot, env) {
         return undefined;
     }
 }
+function latestJobEvents(job, maxEvents = 1000) {
+    const eventLog = String(job?.event_log ?? '');
+    if (!eventLog || !fs.existsSync(eventLog))
+        return [];
+    try {
+        const lines = fs.readFileSync(eventLog, 'utf8').split(/\r?\n/).filter(Boolean);
+        return lines.slice(-maxEvents).map((line) => parseJsonLine(line)).filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+}
 function terminalRunStateFromLatestJob(job, nowMs, ttlMs) {
     const status = String(job?.status ?? '');
     if (status === 'running' || status === 'stopping')
@@ -163,6 +175,16 @@ function terminalRunStateFromArtifact(artifact, nowMs, ttlMs) {
         return undefined;
     return status;
 }
+function runStateFromJobStatus(job) {
+    const status = String(job?.status ?? '');
+    if (status === 'failed')
+        return 'failed';
+    if (status === 'success')
+        return 'success';
+    if (status === 'stopped')
+        return 'idle';
+    return undefined;
+}
 function jobsRoot(projectRoot, env) {
     return path.join(path.dirname(resolveProfilePath(projectRoot, env)), 'jobs');
 }
@@ -303,8 +325,11 @@ export function createServerRuntime(options) {
                     }
                 }
                 if (!cancelled && runState === 'running') {
-                    runState = 'success';
-                    publish({ type: 'server_state', run_state: runState });
+                    const reconciledState = runStateFromJobStatus(latestJob(options.projectRoot, options.env ?? process.env));
+                    if (reconciledState) {
+                        runState = reconciledState;
+                        publish({ type: 'server_state', run_state: runState });
+                    }
                 }
             }
             catch (error) {
@@ -344,12 +369,14 @@ export function createServerRuntime(options) {
             const artifact = normalizeLatestArtifact(options.projectRoot, options.env ?? process.env);
             restoreRunState(artifact);
             const retries = artifactList(options.projectRoot, options.env ?? process.env);
+            const job = latestJob(options.projectRoot, options.env ?? process.env);
             return {
                 profile: sanitizeProfileForServer(profilePayload(options.projectRoot, options.env)),
                 runState,
                 artifact,
                 retryArtifacts: Array.isArray(retries.items) ? retries.items : [],
-                deployment: (artifact?.deployment ?? {})
+                deployment: (artifact?.deployment ?? {}),
+                logEvents: latestJobEvents(job)
             };
         },
         async saveProfile(profile) {
@@ -436,6 +463,16 @@ export function createServerRuntime(options) {
         subscribe(handler) {
             subscribers.add(handler);
             return () => subscribers.delete(handler);
+        },
+        async close() {
+            unsubscribeLogs?.();
+            if (!activeJobId) {
+                const artifact = normalizeLatestArtifact(options.projectRoot, options.env ?? process.env);
+                restoreRunState(artifact);
+            }
+            if ((runState === 'running' || runState === 'stopping') && activeJobId) {
+                await this.stopRun?.();
+            }
         }
     };
 }

package/dist/web/renderer/app.js

@@ -111,9 +111,11 @@ const state = {
   logFilter: '全部',
   settingsDrawer: null,
   isDemo: false,
+  runtime: document.body.dataset.runtime === 'web' ? 'web' : 'electron',
   runState: 'idle',
   runResult: 'idle',
   logEntries: [],
+  extractDedupedFingerprints: new Set(),
   artifactDir: '',
   retryArtifacts: [],
   selectedRetryArtifactDir: '',
@@ -163,6 +165,7 @@ async function bootstrap() {
     ? await window.vpnAutomation.loadState()
     : { profile: await window.vpnAutomation.loadProfile() };
   hydrateInitialRuntimeState(loadedState);
+  hydrateHistoricalEvents(loadedState?.logEvents);
   touchUpdate();
   await refreshQrCode();
   if (!loadedState?.retryArtifacts) {
@@ -196,6 +199,19 @@ function hydrateInitialRuntimeState(loadedState = {}) {
   }
 }
 
+function hydrateHistoricalEvents(events = []) {
+  if (!Array.isArray(events) || events.length === 0) {
+    return;
+  }
+  const previousRunState = state.runState;
+  const previousRunResult = state.runResult;
+  for (const event of events) {
+    handlePipelineEvent(event, { historical: true });
+  }
+  state.runState = previousRunState;
+  state.runResult = previousRunState === 'idle' ? previousRunResult : previousRunState;
+}
+
 function bindActions() {
   document.addEventListener('click', handleDocumentClick);
   document.addEventListener('input', handleDocumentInput);
@@ -299,7 +315,7 @@ function runTone() {
   return 'neutral';
 }
 
-function handleDocumentClick(event) {
+async function handleDocumentClick(event) {
   const navButton = event.target.closest('[data-page-target]');
   if (navButton) {
     state.activePage = navButton.dataset.pageTarget;
@@ -422,7 +438,7 @@ function handleDocumentClick(event) {
   }
 
   if (event.target.closest('[data-drawer-save="save"]')) {
-    saveSettingsDrawer();
+    await saveSettingsDrawer();
   }
 }
 
@@ -548,6 +564,7 @@ function buildDeployDraft(deploy = {}) {
 function sanitizeDeployDraft(draft = {}) {
   const sanitizedDraft = structuredClone(draft);
   delete sanitizedDraft.__autoLinkedPagesProjectUrl;
+  sanitizedDraft.min_final_links = Math.max(0, Math.trunc(Number(sanitizedDraft.min_final_links ?? 10) || 0));
   return sanitizedDraft;
 }
 
@@ -932,6 +949,7 @@ async function runPipeline() {
   state.stageStatus = {};
   state.counts = {};
   state.sourceCounts = {};
+  state.extractDedupedFingerprints = new Set();
   state.logEntries = [];
   state.artifactDir = '';
   state.outputFiles = [];
@@ -981,6 +999,7 @@ async function retryStage() {
   state.stageStatus = {};
   state.counts = {};
   state.sourceCounts = {};
+  state.extractDedupedFingerprints = new Set();
   state.logEntries = [];
   state.artifactDir = '';
   state.outputFiles = [];
@@ -1131,7 +1150,8 @@ function finishRun(result = {}) {
   void hydrateRetryArtifacts();
 }
 
-function handlePipelineEvent(event) {
+function handlePipelineEvent(event, options = {}) {
+  const historical = Boolean(options.historical);
   if (event.type === 'server_state') {
     const nextRunState = String(event.run_state ?? '');
     if (['idle', 'running', 'stopping', 'failed', 'success'].includes(nextRunState)) {
@@ -1151,6 +1171,10 @@ function handlePipelineEvent(event) {
   }
 
   if (event.type === 'run_failed') {
+    if (historical) {
+      appendLog(`[run_failed] ${event.error ?? ''}`);
+      return;
+    }
     if (state.runState !== 'idle' || state.runResult !== 'failed') {
       finishRun({ ok: false, error: event.error });
     }
@@ -1196,16 +1220,34 @@ function handlePipelineEvent(event) {
     appendLog(`[summary] artifacts: ${event.artifact_dir}`);
     const runStatus = String(event.run_status ?? '');
     if (runStatus === 'failed') {
+      if (historical) {
+        state.runResult = 'failed';
+        touchUpdate();
+        renderAll();
+        return;
+      }
       finishRun({ ok: false, error: event.error });
       hydrateArtifactPreview();
       return;
     }
     if (runStatus === 'success') {
+      if (historical) {
+        state.runResult = 'success';
+        touchUpdate();
+        renderAll();
+        return;
+      }
       finishRun({ ok: true, code: 0 });
       hydrateArtifactPreview();
       return;
     }
     if (runStatus === 'stopped') {
+      if (historical) {
+        state.runResult = 'idle';
+        touchUpdate();
+        renderAll();
+        return;
+      }
       finishRun({ stopped: true });
       hydrateArtifactPreview();
       return;
@@ -1327,15 +1369,30 @@ 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);
+  if (Array.isArray(event.new_item_fingerprints)) {
+    for (const fingerprint of event.new_item_fingerprints) {
+      if (fingerprint) {
+        state.extractDedupedFingerprints.add(String(fingerprint));
+      }
+    }
+  }
   state.sourceCounts = {
     ...state.sourceCounts,
     [sourceName]: {
       ...previous,
-      raw_links: rawLinks
+      raw_links: rawLinks,
+      deduped_links: sourceDedupedLinks
     }
   };
   state.counts.raw_links = Object.values(state.sourceCounts)
     .reduce((total, item) => total + Number(item?.raw_links ?? 0), 0);
+  if (state.extractDedupedFingerprints.size > 0) {
+    state.counts.deduped_links = state.extractDedupedFingerprints.size;
+  } else {
+    state.counts.deduped_links = Object.values(state.sourceCounts)
+      .reduce((total, item) => total + Number(item?.deduped_links ?? 0), 0);
+  }
 }
 
 async function hydrateArtifactPreview() {
@@ -1362,6 +1419,7 @@ function hydrateArtifactState(result) {
   state.artifactDir = result.artifact_dir;
   state.counts = normalizeCounts(result.counts ?? {});
   state.sourceCounts = normalizeSourceCounts(result.source_counts ?? {});
+  state.extractDedupedFingerprints = new Set();
   state.outputFiles = result.outputFiles ?? [];
   state.nodeRows = result.nodeRows ?? [];
   state.retryContext = result.retry_context ?? {};

package/dist/web/renderer/i18n.js

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