@swimmingliu/autovpn 1.6.5 → 1.6.7

package/dist/pipeline/speedtest.js

@@ -1,27 +1,7 @@
-import path from 'node:path';
-import { spawn as defaultSpawn } from 'node:child_process';
 import net from 'node:net';
 import tls from 'node:tls';
-import { mergeProjectEnv } from '../runtime/env.js';
 import { openMihomoRuntime as defaultOpenMihomoRuntime, probeMihomoProxyDelay as defaultProbeMihomoProxyDelay } from './proxy-runtime.js';
-const PYTHON_SPEEDTEST_HELPER = `
-import json
-import sys
-from vpn_automation.config.models import SpeedTestConfig
-from vpn_automation.pipeline.speedtest import speedtest_links
-
-payload = json.load(sys.stdin)
-output = [
-    item.__dict__
-    for item in speedtest_links(
-        payload.get("links", []),
-        SpeedTestConfig(**payload["config"]),
-        runtime_path=payload.get("runtime_path", ""),
-    )
-]
-json.dump(output, sys.stdout, ensure_ascii=False)
-sys.stdout.write("\\n")
-`;
+const PROBE_MAX_ATTEMPTS = 2;
 export function aggregateSpeedMeasurements(values) {
     if (values.length === 0) {
         return 0;
@@ -94,9 +74,27 @@ function defaultNow() {
 }
 async function fetchWithTimeout(fetchImpl, url, timeoutMs) {
     const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    let internallyTimedOut = false;
+    const timer = setTimeout(() => {
+        internallyTimedOut = true;
+        controller.abort();
+    }, timeoutMs);
     try {
-        return await fetchImpl(url, { signal: controller.signal });
+        const response = await fetchImpl(url, { signal: controller.signal });
+        if (internallyTimedOut) {
+            const error = new Error(`request timed out after ${timeoutMs}ms`);
+            error.code = 'AUTOVPN_INTERNAL_TIMEOUT';
+            throw error;
+        }
+        return response;
+    }
+    catch (error) {
+        if (internallyTimedOut && !(error instanceof Error && error.code === 'AUTOVPN_INTERNAL_TIMEOUT')) {
+            const timeoutError = new Error(`request timed out after ${timeoutMs}ms`, { cause: error });
+            timeoutError.code = 'AUTOVPN_INTERNAL_TIMEOUT';
+            throw timeoutError;
+        }
+        throw error;
     }
     finally {
         clearTimeout(timer);
@@ -122,6 +120,7 @@ async function readResponseBytes(response, maxBytes, timeoutMs) {
     if (response.body?.getReader) {
         const reader = response.body.getReader();
         let timedOut = false;
+        let reachedCap = false;
         try {
             return await withBodyTimeout(async () => {
                 let total = 0;
@@ -131,6 +130,9 @@ async function readResponseBytes(response, maxBytes, timeoutMs) {
                         break;
                     }
                     total += Math.min(value.byteLength, maxBytes - total);
+                    if (total >= maxBytes) {
+                        reachedCap = true;
+                    }
                 }
                 return total;
             }, timeoutMs);
@@ -140,16 +142,13 @@ async function readResponseBytes(response, maxBytes, timeoutMs) {
             throw error;
         }
         finally {
-            if (timedOut) {
+            if (timedOut || reachedCap) {
                 await reader.cancel().catch(() => { });
             }
             reader.releaseLock();
         }
     }
-    if (response.arrayBuffer) {
-        return await withBodyTimeout(async () => Math.min((await response.arrayBuffer()).byteLength, maxBytes), timeoutMs);
-    }
-    return 0;
+    throw new Error('streaming response body required for bounded speed test downloads');
 }
 function requireOkResponse(response, allowedStatuses) {
     const status = Number(response.status ?? 200);
@@ -157,6 +156,36 @@ function requireOkResponse(response, allowedStatuses) {
         throw new Error(`unexpected status ${status}`);
     }
 }
+function isTransientProbeError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const code = typeof error === 'object' && error !== null && 'code' in error
+        ? String(error.code ?? '')
+        : '';
+    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', 'UND_ERR_CONNECT_TIMEOUT', 'UND_ERR_HEADERS_TIMEOUT', 'UND_ERR_BODY_TIMEOUT'].includes(code.toUpperCase())) {
+        return true;
+    }
+    return error instanceof TypeError && message.trim().toLowerCase() === 'fetch failed';
+}
+async function retryTransientProbe(operation) {
+    let lastError;
+    for (let attempt = 1; attempt <= PROBE_MAX_ATTEMPTS; attempt += 1) {
+        try {
+            return await operation();
+        }
+        catch (error) {
+            lastError = error;
+            if (attempt >= PROBE_MAX_ATTEMPTS || !isTransientProbeError(error)) {
+                throw error;
+            }
+        }
+    }
+    throw lastError;
+}
 function socketConnect(host, port, timeoutMs) {
     return new Promise((resolve, reject) => {
         const socket = net.createConnection({ host, port });
@@ -346,12 +375,14 @@ async function probeLinksDirect(links, config, options) {
     const now = options.now ?? defaultNow;
     const timeoutMs = Math.max(1, Number(config.timeout_seconds)) * 1000;
     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]));
-            return { link, reachable: true, latency_ms: Math.max(Math.round(elapsed), 1), error: '' };
+            return await retryTransientProbe(async () => {
+                const started = now();
+                const response = await fetchWithTimeout(fetchImpl, config.probe_url, timeoutMs);
+                const elapsed = Math.max(now() - started, 1);
+                requireOkResponse(response, new Set([200, 204]));
+                return { link, reachable: true, latency_ms: Math.max(Math.round(elapsed), 1), error: '' };
+            });
         }
         catch (error) {
             return { link, reachable: false, latency_ms: 0, error: error instanceof Error ? error.message : String(error) };
@@ -362,22 +393,26 @@ async function probeLinksMihomo(links, config, runtimePath, options) {
     const openRuntime = options.openMihomoRuntime ?? defaultOpenMihomoRuntime;
     const probeDelay = options.probeMihomoProxyDelay ?? defaultProbeMihomoProxyDelay;
     return mapWithConcurrency(links, config.concurrency, async (link) => {
-        let runtime;
         try {
-            runtime = await openRuntime(link, {
-                runtimePath,
-                startupWaitSeconds: config.startup_wait_seconds,
-                env: options.env
+            return await retryTransientProbe(async () => {
+                let runtime;
+                try {
+                    runtime = await openRuntime(link, {
+                        runtimePath,
+                        startupWaitSeconds: config.startup_wait_seconds,
+                        env: options.env
+                    });
+                    const latencyMs = await probeDelay(runtime.controllerUrl, runtime.proxyName, config.probe_url, config.timeout_seconds);
+                    return { link, reachable: true, latency_ms: latencyMs, error: '' };
+                }
+                finally {
+                    await runtime?.close();
+                }
             });
-            const latencyMs = await probeDelay(runtime.controllerUrl, runtime.proxyName, config.probe_url, config.timeout_seconds);
-            return { link, reachable: true, latency_ms: latencyMs, error: '' };
         }
         catch (error) {
             return { link, reachable: false, latency_ms: 0, error: error instanceof Error ? error.message : String(error) };
         }
-        finally {
-            await runtime?.close();
-        }
     });
 }
 async function testLinkDirect(link, config, options) {
@@ -495,6 +530,17 @@ async function speedtestInNode(input, options) {
         urls: [...config.urls]
     });
     const probes = await probeLinks(input.links, config, { runtime_path: runtimePath });
+    for (let index = 0; index < probes.length; index += 1) {
+        const probe = probes[index];
+        emitEvent(options.eventCallback, 'speedtest_probe_result', {
+            completed: index + 1,
+            total: input.links.length,
+            link: probe.link,
+            reachable: probe.reachable,
+            latency_ms: probe.latency_ms,
+            error: probe.error ?? ''
+        });
+    }
     const candidateLinks = selectSpeedtestCandidates(probes, config.max_download_candidates);
     const probeByLink = new Map(probes.map((probe) => [probe.link, probe]));
     const candidateSet = new Set(candidateLinks);
@@ -533,64 +579,7 @@ async function speedtestInNode(input, options) {
     results.push(...testedResults);
     return results;
 }
-export function selectPipelineStageBackend(stage, env = process.env) {
-    void stage;
-    void env;
-    return 'node';
-}
-async function defaultResolvePythonCli(env) {
-    // @ts-expect-error Phase 1 runner remains plain ESM JavaScript.
-    const runner = await import('../../lib/runner.mjs');
-    return runner.resolveOrInstallPythonCli({ env });
-}
-function pythonCommandFor(resolved) {
-    const command = resolved.command;
-    const name = path.basename(command).toLowerCase();
-    if (['autovpn', 'autovpn.exe'].includes(name)) {
-        const executable = process.platform === 'win32' ? 'python.exe' : 'python';
-        return path.join(path.dirname(command), executable);
-    }
-    return process.platform === 'win32' ? 'python.exe' : 'python3';
-}
-async function speedtestWithPython(input, options) {
-    const env = mergeProjectEnv(options.cwd ?? process.cwd(), options.env ?? process.env);
-    const resolved = options.resolvePythonCli ? await options.resolvePythonCli() : await defaultResolvePythonCli(env);
-    const child = (options.spawn ?? defaultSpawn)(pythonCommandFor(resolved), ['-c', PYTHON_SPEEDTEST_HELPER], {
-        cwd: options.cwd ?? process.cwd(),
-        env,
-        stdio: ['pipe', 'pipe', 'pipe']
-    });
-    let stdout = '';
-    let stderr = '';
-    child.stdout?.on('data', (chunk) => {
-        stdout += String(chunk);
-    });
-    child.stderr?.on('data', (chunk) => {
-        stderr += String(chunk);
-    });
-    const completion = new Promise((resolve, reject) => {
-        child.on('error', reject);
-        child.on('close', (code) => {
-            if (code !== 0) {
-                reject(new Error(`Python speedtest backend failed with exit code ${code}: ${stderr.trim()}`));
-                return;
-            }
-            try {
-                resolve(JSON.parse(stdout));
-            }
-            catch (error) {
-                reject(new Error(`Python speedtest backend returned invalid JSON: ${error instanceof Error ? error.message : String(error)}`));
-            }
-        });
-    });
-    child.stdin?.write(JSON.stringify(input));
-    child.stdin?.end();
-    return completion;
-}
 export async function speedtestLinksWithBackend(input, options = {}) {
-    if (selectPipelineStageBackend('speedtest', options.env ?? process.env) === 'python') {
-        return options.pythonSpeedtest ? options.pythonSpeedtest(input) : speedtestWithPython(input, options);
-    }
     return speedtestInNode(input, options);
 }
 export async function probeSpeedtestLinksInNode(input, options = {}) {

package/dist/runtime/paths.js

@@ -5,8 +5,17 @@ export function resolveRuntimeRoot(candidate) {
     const resolved = fs.existsSync(absolute) ? fs.realpathSync(absolute) : absolute;
     let current = fs.existsSync(resolved) && fs.statSync(resolved).isFile() ? path.dirname(resolved) : resolved;
     while (true) {
-        if (fs.existsSync(path.join(current, 'pyproject.toml'))) {
-            return current;
+        const packagePath = path.join(current, 'package.json');
+        if (fs.existsSync(packagePath)) {
+            try {
+                const manifest = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+                if (manifest.name === 'vpn-subscription-automation') {
+                    return current;
+                }
+            }
+            catch {
+                // Continue walking when an unrelated package manifest is invalid.
+            }
         }
         const parent = path.dirname(current);
         if (parent === current) {

package/dist/runtime/templates.js

@@ -0,0 +1,37 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const packagedWorkerTemplatePath = fileURLToPath(new URL('../templates/vmess_node.js', import.meta.url));
+const packagedShareWorkerTemplatePath = fileURLToPath(new URL('../templates/share-worker/vpn.js', import.meta.url));
+function expandHomePath(candidate, env) {
+    if (candidate === '~') {
+        return env.HOME || candidate;
+    }
+    if (candidate.startsWith('~/')) {
+        return env.HOME ? path.join(env.HOME, candidate.slice(2)) : candidate;
+    }
+    return candidate;
+}
+function firstExistingPath(candidates, message) {
+    const uniqueCandidates = [...new Set(candidates.filter(Boolean).map((candidate) => path.resolve(candidate)))];
+    const resolved = uniqueCandidates.find((candidate) => fs.existsSync(candidate));
+    if (resolved) {
+        return resolved;
+    }
+    throw new Error(`${message}; checked: ${uniqueCandidates.join(', ')}`);
+}
+export function resolveWorkerTemplatePath(projectRoot) {
+    return firstExistingPath([
+        path.join(projectRoot, 'templates', 'vmess_node.js'),
+        packagedWorkerTemplatePath
+    ], 'Worker template is missing');
+}
+export function resolveShareWorkerTemplatePath(projectRoot, env = process.env) {
+    return firstExistingPath([
+        expandHomePath(String(env.VPN_AUTOMATION_SHARE_WORKER_PATH ?? '').trim(), env),
+        path.join(projectRoot, 'electron', 'runtime', 'share-worker', 'vpn.js'),
+        path.join(projectRoot, 'templates', 'share-worker', 'vpn.js'),
+        packagedShareWorkerTemplatePath,
+        path.join(path.dirname(projectRoot), 'cloudflarevpn', 'edgetunnel', 'vpn.js')
+    ], 'Share Worker template is missing');
+}