@swimmingliu/autovpn 1.6.2 → 1.6.4

package/dist/artifacts/list.js

@@ -8,6 +8,41 @@ function loadJson(filePath) {
     }
     return JSON.parse(fs.readFileSync(filePath, 'utf8'));
 }
+function countNonEmptyLines(filePath) {
+    if (!fs.existsSync(filePath) || !fs.statSync(filePath).isFile()) {
+        return undefined;
+    }
+    return fs.readFileSync(filePath, 'utf8')
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .length;
+}
+function positiveNumber(value) {
+    const numeric = Number(value);
+    return Number.isFinite(numeric) && numeric > 0 ? numeric : 0;
+}
+function restoreArtifactCounts(artifactDir, counts = {}) {
+    const restored = { ...counts };
+    const fileCounts = [
+        ['raw_links', 'vpn_node_raw.txt'],
+        ['deduped_links', 'vpn_node_deduped.txt'],
+        ['speedtest_links', 'vpn_node_speedtest.txt'],
+        ['availability_links', 'vpn_node_availability.txt'],
+        ['final_links', 'vpn_node_emoji.txt'],
+        ['postprocess_links', 'vpn_node_emoji.txt']
+    ];
+    for (const [countKey, fileName] of fileCounts) {
+        if (positiveNumber(restored[countKey]) > 0) {
+            continue;
+        }
+        const fileCount = countNonEmptyLines(path.join(artifactDir, fileName));
+        if (fileCount && fileCount > 0) {
+            restored[countKey] = fileCount;
+        }
+    }
+    return restored;
+}
 function latestArtifactDir(artifactsRoot) {
     if (!fs.existsSync(artifactsRoot)) {
         return '';
@@ -37,7 +72,7 @@ export function artifactLatest(projectRoot, env = process.env) {
         ...payload,
         run_status: report.run_status ?? '',
         stage_status: report.stage_status ?? {},
-        counts: report.counts ?? {},
+        counts: restoreArtifactCounts(latest, (report.counts ?? {})),
         source_counts: report.source_counts ?? {},
         deployment: safeDeployment((report.deployment ?? {})),
         error: redactText(String(report.error ?? ''))
@@ -88,7 +123,7 @@ export function artifactList(projectRoot, env = process.env) {
             artifact_name: path.basename(artifactDir),
             run_status: report.run_status ?? '',
             stage_status: stageStatus,
-            counts: report.counts ?? {},
+            counts: restoreArtifactCounts(artifactDir, (report.counts ?? {})),
             source_counts: report.source_counts ?? {},
             retry_context: report.retry_context ?? {},
             retryable_stages: retryableStages(artifactDir, stageStatus),

package/dist/doctor/checks.js

@@ -41,6 +41,21 @@ function commandPath(name, env, platform = process.platform) {
     }
     return '';
 }
+function firstExistingPath(candidates) {
+    return candidates.find((candidate) => candidate && fs.existsSync(candidate)) ?? '';
+}
+function mihomoInstallCandidates(env) {
+    const homeDir = String(env.HOME ?? env.USERPROFILE ?? '').trim();
+    return [
+        homeDir ? path.join(homeDir, 'clashctl', 'bin', 'mihomo') : '',
+        '/opt/homebrew/bin/mihomo',
+        '/usr/local/bin/mihomo',
+        '/usr/bin/mihomo'
+    ];
+}
+function mihomoPath(env) {
+    return commandPath('mihomo', env) || firstExistingPath(mihomoInstallCandidates(env));
+}
 function safeRun(command, env) {
     try {
         const { executable, args } = normalizeManagedToolCommandForSpawn(command);
@@ -98,7 +113,7 @@ function loadProfile(profilePath) {
 }
 function checkProxyRuntime(env) {
     const checks = [];
-    const mihomo = commandPath('mihomo', env);
+    const mihomo = mihomoPath(env);
     if (!mihomo) {
         checks.push(check('mihomo', 'fail', 'mihomo binary is missing'));
     }

package/dist/pipeline/orchestrator.js

@@ -423,6 +423,30 @@ export async function runNodePipeline(options, context = {}) {
         const limitAvailability = createLimiter(Number(speedConfig.concurrency ?? 1));
         let speedCompleted = 0;
         let availabilityCompleted = 0;
+        let speedArtifactFlush = Promise.resolve();
+        let availabilityArtifactFlush = Promise.resolve();
+        const flushStreamingSpeedArtifacts = async () => {
+            const resultSnapshot = [...speedResults];
+            const linkSnapshot = [...passedSpeedLinks];
+            speedArtifactFlush = speedArtifactFlush.catch(() => undefined).then(async () => {
+                summary.counts.speedtest_links = linkSnapshot.length;
+                await writeLines(artifactDir, 'vpn_node_speedtest.txt', linkSnapshot);
+                await writeJson(artifactDir, 'vpn_node_speedtest_report.json', resultSnapshot);
+                await writeReport();
+            });
+            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 () => {
+                summary.counts.availability_links = linkSnapshot.length;
+                await writeLines(artifactDir, 'vpn_node_availability.txt', linkSnapshot);
+                await writeJson(artifactDir, 'vpn_node_availability_report.json', resultSnapshot);
+                await writeReport();
+            });
+            await availabilityArtifactFlush;
+        };
         const runStreamingAvailability = (speedResult) => {
             const task = limitAvailability(async () => {
                 const results = context.stages?.availability
@@ -436,15 +460,14 @@ export async function runNodePipeline(options, context = {}) {
                 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
-                        });
-                    }
+                    await flushStreamingAvailabilityArtifacts();
+                    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);
@@ -476,8 +499,12 @@ export async function runNodePipeline(options, context = {}) {
                 });
                 if (passed) {
                     passedSpeedLinks.push(result.link);
+                    await flushStreamingSpeedArtifacts();
                     runStreamingAvailability(result);
                 }
+                else if (useStreamingStages) {
+                    await flushStreamingSpeedArtifacts();
+                }
             });
             speedTasks.push(task);
             task.catch(() => undefined);

package/dist/pipeline/proxy-runtime.js

@@ -178,10 +178,36 @@ async function closeChildProcess(process) {
         process.kill('SIGTERM');
     });
 }
-async function resolveMihomoCommand(runtimePath) {
+async function fileExists(candidate) {
+    try {
+        const info = await stat(candidate);
+        return info.isFile();
+    }
+    catch {
+        return false;
+    }
+}
+async function firstExistingFile(candidates) {
+    for (const candidate of candidates) {
+        if (candidate && await fileExists(candidate)) {
+            return candidate;
+        }
+    }
+    return '';
+}
+function mihomoInstallCandidates(env = process.env) {
+    const homeDir = String(env.HOME ?? env.USERPROFILE ?? '').trim();
+    return [
+        homeDir ? path.join(homeDir, 'clashctl', 'bin', 'mihomo') : '',
+        '/opt/homebrew/bin/mihomo',
+        '/usr/local/bin/mihomo',
+        '/usr/bin/mihomo'
+    ];
+}
+async function resolveMihomoCommand(runtimePath, env = process.env) {
     const candidate = String(runtimePath ?? '').trim();
     if (!candidate) {
-        return 'mihomo';
+        return await firstExistingFile(mihomoInstallCandidates(env)) || 'mihomo';
     }
     try {
         const info = await stat(candidate);
@@ -189,12 +215,12 @@ async function resolveMihomoCommand(runtimePath) {
             return candidate;
         }
         if (info.isDirectory() && path.basename(candidate) === 'runtime') {
-            return 'mihomo';
+            return await firstExistingFile(mihomoInstallCandidates(env)) || 'mihomo';
         }
     }
     catch {
         if (path.basename(candidate) === 'runtime') {
-            return 'mihomo';
+            return await firstExistingFile(mihomoInstallCandidates(env)) || 'mihomo';
         }
     }
     return candidate;
@@ -214,7 +240,7 @@ 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 command = await resolveMihomoCommand(options.runtimePath);
+    const command = await resolveMihomoCommand(options.runtimePath, options.env ?? process.env);
     const child = (options.spawn ?? defaultSpawn)(command, ['-f', configPath], {
         stdio: ['ignore', 'pipe', 'pipe'],
         env: stripProxyEnv(options.env ?? process.env)

package/dist/web/renderer/i18n.js

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

package/package.json

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