@swimmingliu/autovpn 1.6.8 → 1.7.0

package/README.md

@@ -65,6 +65,11 @@ autovpn run --project-root . --output jsonl
 
 Runtime notes:
 
+- Each run writes `artifact_dir/run.db`. This SQLite database is the authoritative local record for run state, node identity, stage results, and resume checkpoints. The `.txt` and `.json` files in the artifact directory are compatibility exports; do not use them as the source of truth for an in-progress run.
+- Pipeline mode sends each newly discovered unique node from the extract callback to a reachability probe. Only reachable nodes receive the full speed measurement, and only nodes that pass the configured speed threshold proceed to availability checks. Dedupe, probe/speedtest, and availability can be active while extraction is still running, so their displayed totals can increase during the run.
+- The streaming queues use bounded concurrency and backpressure. A slow speed or availability worker therefore limits queued work instead of allowing unbounded memory growth.
+- `resume pipeline`, `resume speedtest`, `run --resume-latest`, and `retry-stage` continue from the SQLite checkpoints. Existing legacy artifact directories can be imported on resume; subsequent state is recorded in `run.db` while compatibility exports remain available.
+- Pipeline mode does not apply the legacy global `max_download_candidates` ranking gate before availability. If that field remains in a profile, it only applies when the speed module is run independently in its legacy ranked-candidate mode.
 - Detached job management runs in Node for `run --detach`, `jobs resume --detach`, and `jobs retry --detach`; detached run/resume/retry workers also use the Node CLI worker.
 - Non-detached `retry-stage` runs through the Node backend for retryable artifact stages from `speedtest` through `verify`; non-detached `resume pipeline`, `resume speedtest`, and `run --resume-latest` continue existing sessions through the Node backend.
 - Add `--skip-deploy --skip-verify` when you want an offline Node pipeline check.

package/dist/backend/node-backend.js

@@ -1,9 +1,8 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { createRequire } from 'node:module';
 import { resumeNodePipeline, retryNodePipelineStage, runNodePipeline } from '../pipeline/orchestrator.js';
 import { resolveArtifactsRoot } from '../runtime/paths.js';
-const require = createRequire(import.meta.url);
+import { readLatestStageStatuses, readRunStatus } from '../pipeline/run-store.js';
 function unsupported(method) {
     return new Error(`Node backend ${method} is not available in this execution path`);
 }
@@ -12,7 +11,6 @@ function latestIncompleteRunArtifact(projectRoot, env) {
     if (!fs.existsSync(artifactsRoot)) {
         return undefined;
     }
-    const { DatabaseSync } = require('node:sqlite');
     const candidates = fs.readdirSync(artifactsRoot, { withFileTypes: true })
         .filter((entry) => entry.isDirectory())
         .map((entry) => {
@@ -23,27 +21,14 @@ function latestIncompleteRunArtifact(projectRoot, env) {
         .filter((candidate) => fs.existsSync(candidate.dbPath))
         .sort((left, right) => fs.statSync(right.artifactDir).mtimeMs - fs.statSync(left.artifactDir).mtimeMs);
     for (const candidate of candidates) {
-        let db;
-        try {
-            db = new DatabaseSync(candidate.dbPath);
-            const runRow = db.prepare('SELECT status FROM runs ORDER BY run_id DESC LIMIT 1').get();
-            const runStatus = String(runRow?.status ?? '').trim();
-            if (['success', 'failed', 'stopped'].includes(runStatus)) {
-                continue;
-            }
-            const stageRows = db.prepare('SELECT stage_name, status FROM stage_events ORDER BY rowid ASC').all();
-            const stageStatus = new Map(stageRows.map((row) => [String(row.stage_name ?? ''), String(row.status ?? '')]));
-            if (stageStatus.get('verify') === 'success') {
-                continue;
-            }
-            return candidate.artifactDir;
-        }
-        catch {
+        const runStatus = readRunStatus(candidate.dbPath);
+        if (!runStatus || ['success', 'failed', 'stopped', 'cancelled'].includes(runStatus)) {
             continue;
         }
-        finally {
-            db?.close();
-        }
+        const stageStatus = readLatestStageStatuses(candidate.dbPath);
+        if (stageStatus.verify === 'success')
+            continue;
+        return candidate.artifactDir;
     }
     return undefined;
 }

package/dist/jobs/commands.js

@@ -1,5 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import { RunStore, readRunStatus } from '../pipeline/run-store.js';
 import { randomBytes } from 'node:crypto';
 import { spawn as defaultSpawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
@@ -45,18 +46,47 @@ function spawnDetached(command, args, job, options) {
 function markArtifactStopped(job) {
     const artifactDir = String(job.artifact_dir ?? '');
     if (!artifactDir) {
-        return;
+        return undefined;
     }
     const reportPath = path.join(artifactDir, 'pipeline_report.json');
-    if (!fs.existsSync(reportPath)) {
-        return;
+    const dbPath = path.join(artifactDir, 'run.db');
+    let authoritativeStatus;
+    if (fs.existsSync(dbPath)) {
+        let runStore;
+        try {
+            runStore = RunStore.open(dbPath);
+            if (!runStore.stopForResume('Stopped by user'))
+                authoritativeStatus = readRunStatus(dbPath);
+        }
+        catch {
+            // The compatibility report remains the fallback when SQLite is corrupt or locked.
+        }
+        finally {
+            try {
+                runStore?.close();
+            }
+            catch { /* best effort */ }
+        }
+    }
+    if (authoritativeStatus) {
+        if (fs.existsSync(reportPath)) {
+            try {
+                const report = JSON.parse(fs.readFileSync(reportPath, 'utf8'));
+                report.run_status = authoritativeStatus;
+                fs.writeFileSync(reportPath, `${JSON.stringify(report, null, 2)}\n`, 'utf8');
+            }
+            catch { /* SQLite remains authoritative */ }
+        }
+        return authoritativeStatus;
     }
+    if (!fs.existsSync(reportPath))
+        return 'stopped';
     try {
         const report = JSON.parse(fs.readFileSync(reportPath, 'utf8'));
         const stageStatus = { ...(report.stage_status ?? {}) };
         for (const [stage, status] of Object.entries(stageStatus)) {
             if (status === 'running') {
-                stageStatus[stage] = 'failed';
+                stageStatus[stage] = 'stopped';
             }
         }
         report.stage_status = stageStatus;
@@ -67,6 +97,7 @@ function markArtifactStopped(job) {
     catch {
         // Best-effort cleanup so stopping a job never fails because its report is corrupt.
     }
+    return 'stopped';
 }
 export async function startDetachedRun(command, options = {}) {
     const outputFormat = command.outputFormat ?? 'jsonl';
@@ -184,10 +215,10 @@ export async function stopManagedJob(projectRoot, jobId, options = {}) {
         throw new Error(`refusing to stop pid ${pid}: command does not match AutoVPN job`);
     }
     await terminateProcessGroup(pid, options);
-    markArtifactStopped(job);
-    job.status = 'stopped';
+    const artifactStatus = markArtifactStopped(job);
+    job.status = artifactStatus === 'success' || artifactStatus === 'failed' ? artifactStatus : 'stopped';
     job.finished_at = options.now?.() ?? new Date().toISOString().replace(/\.\d{3}Z$/, '+00:00');
-    job.exit_code = 1;
+    job.exit_code = job.status === 'success' ? 0 : 1;
     job.signal = 'SIGTERM';
     return store.writeJob(job);
 }

package/dist/jobs/read.js

@@ -1,8 +1,8 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { createRequire } from 'node:module';
 import { resolveProfilePath, readOptionValue } from '../runtime/paths.js';
 import { redactText } from '../runtime/redaction.js';
+import { readRunStatus } from '../pipeline/run-store.js';
 function jobsRoot(projectRoot, env = process.env) {
     return path.join(path.dirname(resolveProfilePath(projectRoot, env)), 'jobs');
 }
@@ -79,29 +79,16 @@ function reconcileFromRunDb(job) {
     if (!fs.existsSync(runDbPath)) {
         return undefined;
     }
-    try {
-        const require = createRequire(import.meta.url);
-        const sqlite = require('node:sqlite');
-        const db = new sqlite.DatabaseSync(runDbPath);
-        try {
-            const row = db.prepare('SELECT status FROM runs ORDER BY run_id DESC LIMIT 1').get();
-            const runStatus = String(row?.status ?? '');
-            if (!['success', 'failed', 'stopped'].includes(runStatus)) {
-                return undefined;
-            }
-            return {
-                status: runStatus,
-                finished_at: job.finished_at || nowIso(),
-                exit_code: runStatus === 'success' ? 0 : 1
-            };
-        }
-        finally {
-            db.close();
-        }
-    }
-    catch {
+    const storedStatus = readRunStatus(runDbPath);
+    const runStatus = storedStatus === 'cancelled' ? 'stopped' : storedStatus;
+    if (!runStatus || !['success', 'failed', 'stopped'].includes(runStatus)) {
         return undefined;
     }
+    return {
+        status: runStatus,
+        finished_at: job.finished_at || nowIso(),
+        exit_code: runStatus === 'success' ? 0 : 1
+    };
 }
 function writeJob(job) {
     const jobFile = String(job.job_file ?? '');

package/dist/pipeline/availability.js

@@ -2,6 +2,7 @@ import http from 'node:http';
 import net from 'node:net';
 import tls from 'node:tls';
 import { openMihomoRuntime as defaultOpenMihomoRuntime } from './proxy-runtime.js';
+import { isTransientNetworkError, retryTransientNetwork } from './network-retry.js';
 const PROVIDER_TARGETS = [
     { name: 'gemini', url: 'https://gemini.google.com', allowed_hosts: ['gemini.google.com'], negative_phrases: [] },
     { name: 'chatgpt_ios', url: 'https://ios.chat.openai.com/', allowed_hosts: ['ios.chat.openai.com'], negative_phrases: [] },
@@ -615,44 +616,45 @@ export async function fetchUrlViaHttpProxy(url, proxyUrl, timeoutSeconds) {
 async function checkLinkAvailabilityMihomo(speedResult, config, options) {
     const openRuntime = options.openMihomoRuntime ?? defaultOpenMihomoRuntime;
     const fetchViaProxy = options.fetchUrlViaHttpProxy ?? fetchUrlViaHttpProxy;
-    let runtime;
-    try {
-        runtime = await openRuntime(speedResult.link, {
-            runtimePath: options.runtimePath,
-            startupWaitSeconds: numberOrDefault(config.startup_wait_seconds, 1),
-            env: options.env
-        });
-        const providerResults = {};
-        const timeoutSeconds = Math.max(1, numberOrDefault(config.timeout_seconds, 20));
-        for (const target of options.targets) {
-            try {
-                const response = await fetchViaProxy(target.url, runtime.proxies.http, timeoutSeconds);
-                providerResults[target.name] = evaluateProviderResponse(target, {
-                    final_url: response.final_url,
-                    status_code: response.status_code,
-                    title: extractTitle(response.body),
-                    body: response.body
-                });
-            }
-            catch (error) {
-                providerResults[target.name] = {
-                    provider: target.name,
-                    passed: false,
-                    reason: 'runtime_error',
-                    status_code: 0,
-                    final_url: target.url,
-                    matched_phrase: error instanceof Error ? error.message : String(error)
-                };
+    return retryTransientNetwork(async () => {
+        let runtime;
+        try {
+            runtime = await openRuntime(speedResult.link, {
+                runtimePath: options.runtimePath,
+                startupWaitSeconds: numberOrDefault(config.startup_wait_seconds, 1),
+                env: options.env
+            });
+            const providerResults = {};
+            const timeoutSeconds = Math.max(1, numberOrDefault(config.timeout_seconds, 20));
+            for (const target of options.targets) {
+                try {
+                    const response = await retryTransientNetwork(() => fetchViaProxy(target.url, runtime.proxies.http, timeoutSeconds));
+                    providerResults[target.name] = evaluateProviderResponse(target, {
+                        final_url: response.final_url,
+                        status_code: response.status_code,
+                        title: extractTitle(response.body),
+                        body: response.body
+                    });
+                }
+                catch (error) {
+                    if (isTransientNetworkError(error))
+                        throw error;
+                    providerResults[target.name] = {
+                        provider: target.name,
+                        passed: false,
+                        reason: 'runtime_error',
+                        status_code: 0,
+                        final_url: target.url,
+                        matched_phrase: error instanceof Error ? error.message : String(error)
+                    };
+                }
             }
+            return { speed_result: speedResult, provider_results: providerResults };
         }
-        return {
-            speed_result: speedResult,
-            provider_results: providerResults
-        };
-    }
-    finally {
-        await runtime?.close();
-    }
+        finally {
+            await runtime?.close();
+        }
+    });
 }
 async function checkBatchInNode(input, options) {
     if (input.results.length === 0) {

package/dist/pipeline/network-retry.js

@@ -0,0 +1,54 @@
+const DEFAULT_MAX_ATTEMPTS = 2;
+const DEFAULT_RETRY_DELAY_MS = 100;
+export function isTransientNetworkError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const code = typeof error === 'object' && error !== null && 'code' in error
+        ? String(error.code ?? '').toUpperCase()
+        : '';
+    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',
+        'EAI_AGAIN',
+        'ENETUNREACH',
+        'EHOSTUNREACH',
+        'UND_ERR_CONNECT_TIMEOUT',
+        'UND_ERR_HEADERS_TIMEOUT',
+        'UND_ERR_BODY_TIMEOUT'
+    ].includes(code)) {
+        return true;
+    }
+    if (error instanceof TypeError && message.trim().toLowerCase() === 'fetch failed') {
+        return true;
+    }
+    return /(?:connection|connect|download|response body|tls handshake).*timed out/i.test(message)
+        || /socket hang up|network is unreachable|temporary failure/i.test(message);
+}
+export async function retryTransientNetwork(operation, options = {}) {
+    const maxAttempts = Math.max(1, Math.trunc(options.maxAttempts ?? DEFAULT_MAX_ATTEMPTS));
+    const delayMs = Math.max(0, Math.trunc(options.delayMs ?? DEFAULT_RETRY_DELAY_MS));
+    const sleep = options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+    let lastError;
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+        try {
+            return await operation();
+        }
+        catch (error) {
+            lastError = error;
+            if (attempt >= maxAttempts || !isTransientNetworkError(error)) {
+                throw error;
+            }
+            if (delayMs > 0) {
+                await sleep(delayMs * attempt);
+            }
+        }
+    }
+    throw lastError;
+}