@swimmingliu/autovpn 1.6.6 → 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/web/renderer/i18n.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swimmingliu/autovpn",
-  "version": "1.6.6",
+  "version": "1.6.7",
   "description": "npm wrapper for the AutoVPN headless CLI",
   "type": "module",
   "repository": {
@@ -14,16 +14,15 @@
   "files": [
     "bin/",
     "dist/",
-    "lib/",
     "README.md"
   ],
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json && node scripts/copy-web-assets.mjs",
+    "build": "node -e \"require('fs').rmSync('dist', { recursive: true, force: true })\" && tsc -p tsconfig.json && node scripts/copy-web-assets.mjs",
     "prepack": "npm run build",
-    "test": "npm run build && node --test test/*.test.mjs test/doctor/*.test.mjs test/parity/*.test.mjs test/jobs/*.test.mjs test/pipeline/*.test.mjs test/runtime/*.test.mjs test/server/*.test.mjs"
+    "test": "npm run build && node --test test/*.test.mjs test/doctor/*.test.mjs test/jobs/*.test.mjs test/pipeline/*.test.mjs test/runtime/*.test.mjs test/server/*.test.mjs"
   },
   "engines": {
     "node": ">=22.5.0"

package/dist/backend/python-backend.js

@@ -1,242 +0,0 @@
-import { spawn as defaultSpawn } from 'node:child_process';
-import { parseEventLine } from '../events/schema.js';
-import { mergeProjectEnv } from '../runtime/env.js';
-function pushOption(argv, name, value) {
-    if (value !== undefined && value !== '') {
-        argv.push(name, String(value));
-    }
-}
-function runArgs(options) {
-    const argv = ['run', '--project-root', options.projectRoot, '--output', options.output ?? 'jsonl'];
-    if (options.resumeLatest)
-        argv.push('--resume-latest');
-    if (options.skipDeploy)
-        argv.push('--skip-deploy');
-    if (options.skipVerify)
-        argv.push('--skip-verify');
-    pushOption(argv, '--event-log', options.eventLog);
-    pushOption(argv, '--human-log', options.humanLog);
-    return argv;
-}
-function retryArgs(options) {
-    const argv = [
-        'retry-stage',
-        '--project-root',
-        options.projectRoot,
-        '--artifact-dir',
-        options.artifactDir,
-        '--stage',
-        options.stage,
-        '--output',
-        options.output ?? 'jsonl'
-    ];
-    pushOption(argv, '--event-log', options.eventLog);
-    pushOption(argv, '--human-log', options.humanLog);
-    return argv;
-}
-function resumeArgs(options) {
-    const argv = [
-        'resume',
-        options.mode,
-        '--project-root',
-        options.projectRoot,
-        '--session',
-        options.session,
-        '--output',
-        options.output ?? 'jsonl'
-    ];
-    pushOption(argv, '--event-log', options.eventLog);
-    pushOption(argv, '--human-log', options.humanLog);
-    return argv;
-}
-async function* splitLines(stream) {
-    const queue = [];
-    let ended = false;
-    let pendingResolve;
-    let buffer = '';
-    stream.on('data', (chunk) => {
-        buffer += String(chunk);
-        const parts = buffer.split(/\r?\n/);
-        buffer = parts.pop() ?? '';
-        queue.push(...parts.filter((line) => line.trim()));
-        pendingResolve?.();
-        pendingResolve = undefined;
-    });
-    stream.on('end', () => {
-        if (buffer.trim())
-            queue.push(buffer);
-        ended = true;
-        pendingResolve?.();
-        pendingResolve = undefined;
-    });
-    while (!ended || queue.length) {
-        if (!queue.length) {
-            await new Promise((resolve) => {
-                pendingResolve = resolve;
-            });
-            continue;
-        }
-        yield queue.shift();
-    }
-}
-function waitForClose(child) {
-    return new Promise((resolve, reject) => {
-        child.once('error', reject);
-        child.once('close', (code, signal) => {
-            resolve({ code, signal });
-        });
-    });
-}
-function errorSummary(stderr) {
-    const summary = stderr.trim().split(/\r?\n/).filter(Boolean).slice(-3).join('\n');
-    return summary ? `: ${summary}` : '';
-}
-function parseJsonPayload(stdout) {
-    const line = stdout.split(/\r?\n/).find((candidate) => candidate.trim());
-    if (!line) {
-        throw new Error('Python backend returned empty JSON payload');
-    }
-    const payload = JSON.parse(line);
-    if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
-        throw new Error('Python backend JSON payload must be an object');
-    }
-    return payload;
-}
-function projectRootFromArgv(argv) {
-    const index = argv.indexOf('--project-root');
-    if (index >= 0 && argv[index + 1]) {
-        return argv[index + 1];
-    }
-    const inline = argv.find((item) => item.startsWith('--project-root='));
-    if (inline) {
-        return inline.slice('--project-root='.length) || undefined;
-    }
-    return undefined;
-}
-export class PythonBackend {
-    kind = 'python';
-    env;
-    cwd;
-    runForwarder;
-    resolvePythonCli;
-    spawn;
-    constructor(options = {}) {
-        this.env = options.env ?? process.env;
-        this.cwd = options.cwd ?? process.cwd();
-        this.runForwarder = options.runForwarder;
-        this.resolvePythonCli = options.resolvePythonCli;
-        this.spawn = options.spawn ?? defaultSpawn;
-    }
-    async executeCli(argv) {
-        const env = this.envForArgv(argv);
-        const forwarderOptions = { env, cwd: this.cwd };
-        if (this.runForwarder) {
-            return this.runForwarder(argv, forwarderOptions);
-        }
-        // @ts-expect-error Phase 1 runner remains plain ESM JavaScript.
-        const runner = await import('../../lib/runner.mjs');
-        return Number(await runner.runForwarder(argv, forwarderOptions));
-    }
-    run(options) {
-        return this.streamEvents(runArgs(options));
-    }
-    retryStage(options) {
-        return this.streamEvents(retryArgs(options));
-    }
-    resume(options) {
-        return this.streamEvents(resumeArgs(options));
-    }
-    async startDetached(options) {
-        const argv = runArgs(options);
-        argv.push('--detach');
-        argv.push('--json');
-        return this.captureJson(argv);
-    }
-    async stopJob(jobId, options = {}) {
-        const argv = jobId === 'latest'
-            ? ['stop']
-            : ['jobs', 'stop', jobId];
-        pushOption(argv, '--project-root', options.projectRoot);
-        pushOption(argv, '--timeout', options.timeout);
-        return this.captureJson(argv);
-    }
-    async readJob(jobId, options = {}) {
-        const argv = jobId === 'latest'
-            ? ['status', '--json']
-            : ['jobs', 'status', jobId, '--json'];
-        pushOption(argv, '--project-root', options.projectRoot);
-        return this.captureJson(argv);
-    }
-    async *readLogs(options) {
-        const argv = options.jobId
-            ? ['jobs', 'logs', options.jobId, '--project-root', options.projectRoot]
-            : ['logs', '--project-root', options.projectRoot];
-        if (options.format)
-            argv.push('--format', options.format);
-        pushOption(argv, '--tail', options.tail);
-        if (options.follow)
-            argv.push('--follow');
-        yield* this.streamLines(argv);
-    }
-    async *streamEvents(argv) {
-        for await (const line of this.streamLines(argv)) {
-            yield parseEventLine(line);
-        }
-    }
-    async *streamLines(argv) {
-        const env = this.envForArgv(argv);
-        const resolved = this.resolvePythonCli ? this.resolvePythonCli() : await this.defaultResolvePythonCli(env);
-        const child = this.spawn(resolved.command, [...resolved.args, ...argv], {
-            cwd: this.cwd,
-            env,
-            stdio: ['ignore', 'pipe', 'pipe']
-        });
-        let stderr = '';
-        child.stderr?.on('data', (chunk) => {
-            stderr += String(chunk);
-        });
-        const closePromise = waitForClose(child);
-        const stdout = child.stdout;
-        if (!stdout) {
-            throw new Error('Python backend did not expose stdout for event streaming');
-        }
-        for await (const line of splitLines(stdout)) {
-            yield line;
-        }
-        const { code, signal } = await closePromise;
-        if (code !== 0) {
-            throw new Error(`Python backend exited with ${signal ? `signal ${signal}` : `code ${code}`}${errorSummary(stderr)}`);
-        }
-    }
-    async captureJson(argv) {
-        const env = this.envForArgv(argv);
-        const resolved = this.resolvePythonCli ? this.resolvePythonCli() : await this.defaultResolvePythonCli(env);
-        const child = this.spawn(resolved.command, [...resolved.args, ...argv], {
-            cwd: this.cwd,
-            env,
-            stdio: ['ignore', 'pipe', 'pipe']
-        });
-        let stdout = '';
-        let stderr = '';
-        child.stdout?.on('data', (chunk) => {
-            stdout += String(chunk);
-        });
-        child.stderr?.on('data', (chunk) => {
-            stderr += String(chunk);
-        });
-        const { code, signal } = await waitForClose(child);
-        if (code !== 0) {
-            throw new Error(`Python backend exited with ${signal ? `signal ${signal}` : `code ${code}`}${errorSummary(stderr)}`);
-        }
-        return parseJsonPayload(stdout);
-    }
-    envForArgv(argv) {
-        const projectRoot = projectRootFromArgv(argv);
-        return projectRoot ? mergeProjectEnv(projectRoot, this.env) : this.env;
-    }
-    async defaultResolvePythonCli(env = this.env) {
-        // @ts-expect-error Phase 1 runner remains plain ESM JavaScript.
-        const runner = await import('../../lib/runner.mjs');
-        return runner.resolveOrInstallPythonCli({ env });
-    }
-}

package/lib/cache.mjs

@@ -1,14 +0,0 @@
-import os from 'node:os';
-import path from 'node:path';
-
-export function getCacheDir(env = process.env) {
-  const override = String(env.AUTOVPN_CACHE_DIR ?? '').trim();
-  if (override) {
-    return override;
-  }
-  return path.join(os.homedir(), '.cache', 'autovpn', 'npm-wrapper');
-}
-
-export function pythonBinName(platform = process.platform) {
-  return platform === 'win32' ? 'Scripts' : 'bin';
-}

package/lib/errors.mjs

@@ -1,11 +0,0 @@
-export class WrapperError extends Error {
-  constructor(message, options = {}) {
-    super(message);
-    this.name = 'WrapperError';
-    this.cause = options.cause;
-  }
-}
-
-export function isEnabled(value) {
-  return ['1', 'true', 'yes', 'on'].includes(String(value ?? '').trim().toLowerCase());
-}

package/lib/install-python-cli.mjs

@@ -1,63 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { spawnSync as defaultSpawnSync } from 'node:child_process';
-
-import { getCacheDir, pythonBinName } from './cache.mjs';
-import { isEnabled, WrapperError } from './errors.mjs';
-
-export function buildPipInstallArgs({ env = process.env, packageVersion }) {
-  const packageSpec = String(env.AUTOVPN_WHEEL_URL ?? '').trim()
-    || `${String(env.AUTOVPN_PYTHON_PACKAGE ?? 'vpn-subscription-automation').trim()}==${packageVersion}`;
-  const args = ['-m', 'pip', 'install'];
-  if (env.AUTOVPN_PIP_INDEX_URL) {
-    args.push('--index-url', String(env.AUTOVPN_PIP_INDEX_URL));
-  }
-  if (env.AUTOVPN_PIP_EXTRA_INDEX_URL) {
-    args.push('--extra-index-url', String(env.AUTOVPN_PIP_EXTRA_INDEX_URL));
-  }
-  args.push(packageSpec);
-  return args;
-}
-
-export function installPythonCli({
-  env = process.env,
-  packageVersion,
-  spawnSync = defaultSpawnSync,
-  cacheDir = getCacheDir(env),
-  platform = process.platform
-} = {}) {
-  if (isEnabled(env.AUTOVPN_NO_INSTALL)) {
-    throw new WrapperError('No compatible Python autovpn CLI found and AUTOVPN_NO_INSTALL is enabled.');
-  }
-  if (!packageVersion) {
-    throw new WrapperError('Cannot install Python AutoVPN backend without an npm package version.');
-  }
-
-  const venvDir = path.join(cacheDir, `python-${packageVersion}`);
-  const executable = platform === 'win32' ? 'autovpn.exe' : 'autovpn';
-  const cliPath = path.join(venvDir, pythonBinName(platform), executable);
-  const forceInstall = isEnabled(env.AUTOVPN_FORCE_INSTALL);
-
-  if (!forceInstall && fs.existsSync(cliPath)) {
-    return { command: cliPath, args: [], source: 'managed-venv' };
-  }
-
-  fs.mkdirSync(cacheDir, { recursive: true });
-  const pythonCommand = String(env.PYTHON ?? env.PYTHON3 ?? 'python3');
-  const venvResult = spawnSync(pythonCommand, ['-m', 'venv', venvDir], { stdio: 'inherit', env });
-  if (venvResult.status !== 0) {
-    throw new WrapperError(`Failed to create AutoVPN Python backend venv with ${pythonCommand}.`);
-  }
-
-  const pythonPath = path.join(venvDir, pythonBinName(platform), platform === 'win32' ? 'python.exe' : 'python');
-  const installResult = spawnSync(pythonPath, buildPipInstallArgs({ env, packageVersion }), { stdio: 'inherit', env });
-  if (installResult.status !== 0) {
-    throw new WrapperError('Failed to install AutoVPN Python backend into the wrapper-managed venv.');
-  }
-
-  if (!fs.existsSync(cliPath)) {
-    throw new WrapperError(`Installed Python backend did not provide autovpn at ${cliPath}.`);
-  }
-
-  return { command: cliPath, args: [], source: 'managed-venv' };
-}