@swimmingliu/autovpn 1.6.9 → 1.8.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/country-codes.js

@@ -0,0 +1,12 @@
+const ISO_ALPHA_2_CODES = new Set(`
+AD AE AF AG AI AL AM AO AQ AR AS AT AU AW AX AZ BA BB BD BE BF BG BH BI BJ BL BM BN BO BQ BR BS BT BV BW BY BZ
+CA CC CD CF CG CH CI CK CL CM CN CO CR CU CV CW CX CY CZ DE DJ DK DM DO DZ EC EE EG EH ER ES ET FI FJ FK FM FO FR
+GA GB GD GE GF GG GH GI GL GM GN GP GQ GR GS GT GU GW GY HK HM HN HR HT HU ID IE IL IM IN IO IQ IR IS IT JE JM JO JP
+KE KG KH KI KM KN KP KR KW KY KZ LA LB LC LI LK LR LS LT LU LV LY MA MC MD ME MF MG MH MK ML MM MN MO MP MQ MR MS MT
+MU MV MW MX MY MZ NA NC NE NF NG NI NL NO NP NR NU NZ OM PA PE PF PG PH PK PL PM PN PR PS PT PW PY QA RE RO RS RU RW
+SA SB SC SD SE SG SH SI SJ SK SL SM SN SO SR SS ST SV SX SY SZ TC TD TF TG TH TJ TK TL TM TN TO TR TT TV TW TZ UA UG
+UM US UY UZ VA VC VE VG VI VN VU WF WS YE YT ZA ZM ZW
+`.trim().split(/\s+/));
+export function isIsoAlpha2CountryCode(value) {
+    return typeof value === 'string' && ISO_ALPHA_2_CODES.has(value.trim().toUpperCase());
+}

package/dist/pipeline/geoip.js

@@ -0,0 +1,232 @@
+import { isIP } from 'node:net';
+import { lookup as dnsLookup } from 'node:dns/promises';
+import { isIsoAlpha2CountryCode } from './country-codes.js';
+function countryCode(value) {
+    const normalized = typeof value === 'string' ? value.trim().toUpperCase() : '';
+    return isIsoAlpha2CountryCode(normalized) ? normalized : null;
+}
+function retryAfterMilliseconds(value, now, maximum) {
+    if (!value)
+        return 0;
+    const seconds = Number(value);
+    const delay = Number.isFinite(seconds)
+        ? seconds * 1000
+        : Date.parse(value) - now;
+    return Number.isFinite(delay) && delay > 0 ? Math.min(delay, maximum) : 0;
+}
+function ipv4Number(address) {
+    const octets = address.split('.').map(Number);
+    if (octets.length !== 4 || octets.some((octet) => !Number.isInteger(octet) || octet < 0 || octet > 255))
+        return null;
+    return (((octets[0] * 256 + octets[1]) * 256 + octets[2]) * 256 + octets[3]) >>> 0;
+}
+function ipv4InCidr(value, base, prefix) {
+    const baseValue = ipv4Number(base);
+    const size = 2 ** (32 - prefix);
+    return Math.floor(value / size) === Math.floor(baseValue / size);
+}
+function isRejectedIpv4(value) {
+    return [
+        ['0.0.0.0', 8], ['10.0.0.0', 8], ['100.64.0.0', 10], ['127.0.0.0', 8],
+        ['169.254.0.0', 16], ['172.16.0.0', 12], ['192.0.0.0', 24], ['192.0.2.0', 24], ['192.88.99.0', 24],
+        ['192.168.0.0', 16], ['198.18.0.0', 15], ['198.51.100.0', 24], ['203.0.113.0', 24],
+        ['224.0.0.0', 4], ['240.0.0.0', 4]
+    ].some(([base, prefix]) => ipv4InCidr(value, base, prefix));
+}
+function ipv6Number(address) {
+    const pieces = address.toLowerCase().split('::');
+    if (pieces.length > 2)
+        return null;
+    const parseSide = (side) => {
+        if (!side)
+            return [];
+        const groups = side.split(':');
+        const last = groups.at(-1) ?? '';
+        if (last.includes('.')) {
+            const mapped = ipv4Number(last);
+            if (mapped === null)
+                return null;
+            groups.splice(-1, 1, ((mapped >>> 16) & 0xffff).toString(16), (mapped & 0xffff).toString(16));
+        }
+        const parsed = groups.map((group) => /^[0-9a-f]{1,4}$/.test(group) ? Number.parseInt(group, 16) : -1);
+        return parsed.some((group) => group < 0) ? null : parsed;
+    };
+    const left = parseSide(pieces[0]);
+    const right = parseSide(pieces[1] ?? '');
+    if (!left || !right)
+        return null;
+    const missing = 8 - left.length - right.length;
+    if ((pieces.length === 1 && missing !== 0) || (pieces.length === 2 && missing < 1))
+        return null;
+    const groups = [...left, ...Array(missing).fill(0), ...right];
+    return groups.reduce((value, group) => (value << 16n) | BigInt(group), 0n);
+}
+function canonicalIpv6(value) {
+    const groups = Array.from({ length: 8 }, (_, index) => Number((value >> BigInt((7 - index) * 16)) & 0xffffn));
+    let bestStart = -1;
+    let bestLength = 0;
+    for (let index = 0; index < groups.length;) {
+        if (groups[index] !== 0) {
+            index += 1;
+            continue;
+        }
+        let end = index;
+        while (end < groups.length && groups[end] === 0)
+            end += 1;
+        if (end - index > bestLength) {
+            bestStart = index;
+            bestLength = end - index;
+        }
+        index = end;
+    }
+    const hex = groups.map((group) => group.toString(16));
+    if (bestLength < 2)
+        return hex.join(':');
+    const before = hex.slice(0, bestStart).join(':');
+    const after = hex.slice(bestStart + bestLength).join(':');
+    return `${before}::${after}`;
+}
+function normalizeGlobalAddress(address) {
+    if (isIP(address) === 4) {
+        const value = ipv4Number(address);
+        return value !== null && !isRejectedIpv4(value) ? address : null;
+    }
+    const value = ipv6Number(address);
+    if (value === null)
+        return null;
+    if ((value >> 32n) === 0xffffn) {
+        const mapped = Number(value & 0xffffffffn) >>> 0;
+        if (isRejectedIpv4(mapped))
+            return null;
+        return `${mapped >>> 24}.${(mapped >>> 16) & 255}.${(mapped >>> 8) & 255}.${mapped & 255}`;
+    }
+    const globalUnicast = value >= 0x20000000000000000000000000000000n && value <= 0x3fffffffffffffffffffffffffffffffn;
+    const ietfProtocolAssignments = value >= 0x20010000000000000000000000000000n && value <= 0x200101ffffffffffffffffffffffffffn;
+    const documentation = value >= 0x20010db8000000000000000000000000n && value <= 0x20010db8ffffffffffffffffffffffffn;
+    const extendedDocumentation = value >= 0x3fff0000000000000000000000000000n && value <= 0x3fff0fffffffffffffffffffffffffffn;
+    return globalUnicast && !ietfProtocolAssignments && !documentation && !extendedDocumentation ? canonicalIpv6(value) : null;
+}
+export function createGeoIpLookup(options = {}) {
+    const fetchFn = options.fetch ?? globalThis.fetch;
+    const resolve = options.resolve ?? ((hostname) => dnsLookup(hostname, { all: true, verbatim: true }));
+    const now = options.now ?? Date.now;
+    const sleep = options.sleep ?? ((milliseconds) => new Promise((done) => globalThis.setTimeout(done, milliseconds)));
+    const setTimer = options.setTimeout ?? ((callback, milliseconds) => globalThis.setTimeout(callback, milliseconds));
+    const clearTimer = options.clearTimeout ?? ((handle) => globalThis.clearTimeout(handle));
+    const timeoutMs = options.timeoutMs ?? 3000;
+    const successTtlMs = options.successTtlMs ?? 24 * 60 * 60 * 1000;
+    const negativeTtlMs = options.negativeTtlMs ?? 60 * 1000;
+    const maxRetryAfterMs = options.maxRetryAfterMs ?? 2000;
+    const providerConcurrency = Math.max(1, Math.floor(options.providerConcurrency ?? 4));
+    const primaryUrl = options.primaryUrl ?? ((ip) => `https://ipwho.is/${encodeURIComponent(ip)}`);
+    const fallbackUrl = options.fallbackUrl ?? ((ip) => `https://ipapi.co/${encodeURIComponent(ip)}/json/`);
+    const cache = new Map();
+    const pending = new Map();
+    const providerWaiters = [];
+    let activeProviderRequests = 0;
+    let providerCooldownUntil = 0;
+    async function acquireProviderSlot() {
+        if (activeProviderRequests >= providerConcurrency) {
+            await new Promise((resolve) => providerWaiters.push(resolve));
+        }
+        else {
+            activeProviderRequests += 1;
+        }
+        return () => {
+            const next = providerWaiters.shift();
+            if (next)
+                next();
+            else
+                activeProviderRequests -= 1;
+        };
+    }
+    async function request(url, provider) {
+        try {
+            const parsed = new URL(url);
+            const expectedHost = provider === 'primary' ? 'ipwho.is' : 'ipapi.co';
+            if (parsed.protocol !== 'https:' || parsed.hostname !== expectedHost || parsed.port || parsed.username || parsed.password) {
+                return { country: null, retryAfterMs: 0 };
+            }
+        }
+        catch {
+            return { country: null, retryAfterMs: 0 };
+        }
+        const release = await acquireProviderSlot();
+        const cooldownMs = providerCooldownUntil - now();
+        if (cooldownMs > 0)
+            await sleep(cooldownMs);
+        const controller = new AbortController();
+        const timer = setTimer(() => controller.abort(), timeoutMs);
+        try {
+            const response = await fetchFn(url, { signal: controller.signal, headers: { accept: 'application/json' } });
+            const retryAfterMs = response.status === 429
+                ? retryAfterMilliseconds(response.headers.get('retry-after'), now(), maxRetryAfterMs)
+                : 0;
+            if (retryAfterMs > 0)
+                providerCooldownUntil = Math.max(providerCooldownUntil, now() + retryAfterMs);
+            if (!response.ok)
+                return { country: null, retryAfterMs };
+            const payload = await response.json();
+            if (provider === 'primary' && payload.success !== true)
+                return { country: null, retryAfterMs: 0 };
+            if (provider === 'fallback' && payload.error === true)
+                return { country: null, retryAfterMs: 0 };
+            return { country: countryCode(payload.country_code), retryAfterMs: 0 };
+        }
+        catch {
+            return { country: null, retryAfterMs: 0 };
+        }
+        finally {
+            clearTimer(timer);
+            release();
+        }
+    }
+    async function lookupIp(ip) {
+        const cached = cache.get(ip);
+        if (cached && cached.expiresAt > now())
+            return cached;
+        const existing = pending.get(ip);
+        if (existing)
+            return existing;
+        const operation = (async () => {
+            const primary = await request(primaryUrl(ip), 'primary');
+            if (primary.country)
+                return { country: primary.country, detected: true };
+            const fallback = await request(fallbackUrl(ip), 'fallback');
+            return fallback.country
+                ? { country: fallback.country, detected: true }
+                : { country: 'US', detected: false };
+        })();
+        pending.set(ip, operation);
+        try {
+            const result = await operation;
+            cache.set(ip, { ...result, expiresAt: now() + (result.detected ? successTtlMs : negativeTtlMs) });
+            return result;
+        }
+        finally {
+            pending.delete(ip);
+        }
+    }
+    return async (rawAddress) => {
+        const address = String(rawAddress ?? '').trim();
+        if (!address)
+            return 'US';
+        try {
+            const results = isIP(address) ? [{ address, family: isIP(address) }] : await resolve(address);
+            const seen = new Set();
+            for (const result of results) {
+                const globalAddress = normalizeGlobalAddress(result.address);
+                if (!globalAddress || seen.has(globalAddress))
+                    continue;
+                seen.add(globalAddress);
+                const resultCountry = await lookupIp(globalAddress);
+                if (resultCountry.detected)
+                    return resultCountry.country;
+            }
+            return 'US';
+        }
+        catch {
+            return 'US';
+        }
+    };
+}

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;
+}