@swimmingliu/autovpn 1.4.0

package/dist/pipeline/speedtest.js

@@ -0,0 +1,579 @@
+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")
+`;
+export function aggregateSpeedMeasurements(values) {
+    if (values.length === 0) {
+        return 0;
+    }
+    return Number((values.reduce((total, value) => total + value, 0) / values.length).toFixed(3));
+}
+export function normalizeSpeedTestConfig(config) {
+    return {
+        min_download_mb_s: Number(config.min_download_mb_s),
+        timeout_seconds: Number(config.timeout_seconds),
+        concurrency: Number(config.concurrency),
+        urls: config.urls ?? [],
+        probe_url: config.probe_url ?? 'https://www.gstatic.com/generate_204',
+        max_download_bytes: Number(config.max_download_bytes ?? 5_000_000),
+        startup_wait_seconds: Number(config.startup_wait_seconds ?? 1.0),
+        max_download_candidates: Number(config.max_download_candidates ?? 50)
+    };
+}
+export function selectSpeedtestCandidates(probes, limit) {
+    const reachable = probes
+        .filter((probe) => probe.reachable)
+        .sort((left, right) => {
+        const leftInvalidLatency = left.latency_ms <= 0 ? 1 : 0;
+        const rightInvalidLatency = right.latency_ms <= 0 ? 1 : 0;
+        if (leftInvalidLatency !== rightInvalidLatency) {
+            return leftInvalidLatency - rightInvalidLatency;
+        }
+        if (left.latency_ms !== right.latency_ms) {
+            return left.latency_ms - right.latency_ms;
+        }
+        if (left.link < right.link) {
+            return -1;
+        }
+        if (left.link > right.link) {
+            return 1;
+        }
+        return 0;
+    });
+    const links = reachable.map((probe) => probe.link);
+    if (limit <= 0) {
+        return links;
+    }
+    return links.slice(0, limit);
+}
+function emitEvent(callback, eventType, payload) {
+    if (callback) {
+        callback(eventType, payload);
+    }
+}
+function defaultNow() {
+    return performance.now();
+}
+async function fetchWithTimeout(fetchImpl, url, timeoutMs) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        return await fetchImpl(url, { signal: controller.signal });
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+async function readResponseBytes(response, maxBytes) {
+    if (response.body?.getReader) {
+        const reader = response.body.getReader();
+        let total = 0;
+        try {
+            while (total < maxBytes) {
+                const { done, value } = await reader.read();
+                if (done) {
+                    break;
+                }
+                total += Math.min(value.byteLength, maxBytes - total);
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+        return total;
+    }
+    if (response.arrayBuffer) {
+        return Math.min((await response.arrayBuffer()).byteLength, maxBytes);
+    }
+    return 0;
+}
+function requireOkResponse(response, allowedStatuses) {
+    const status = Number(response.status ?? 200);
+    if (response.ok === false || !allowedStatuses.has(status)) {
+        throw new Error(`unexpected status ${status}`);
+    }
+}
+function socketConnect(host, port, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const socket = net.createConnection({ host, port });
+        const timer = setTimeout(() => {
+            socket.destroy();
+            reject(new Error(`proxy connection timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+        socket.once('connect', () => {
+            clearTimeout(timer);
+            resolve(socket);
+        });
+        socket.once('error', (error) => {
+            clearTimeout(timer);
+            reject(error);
+        });
+    });
+}
+function splitHttpHeaders(buffer) {
+    const marker = buffer.indexOf('\r\n\r\n');
+    if (marker < 0) {
+        return undefined;
+    }
+    return {
+        head: buffer.subarray(0, marker).subarray(0),
+        body: buffer.subarray(marker + 4).subarray(0)
+    };
+}
+function parseHttpStatus(head) {
+    const firstLine = head.toString('latin1').split('\r\n')[0] ?? '';
+    const match = /^HTTP\/\d(?:\.\d)?\s+(\d+)/i.exec(firstLine);
+    if (!match) {
+        throw new Error(`invalid HTTP response: ${firstLine}`);
+    }
+    return Number(match[1]);
+}
+function readHttpBodyBytes(socket, maxBytes, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        let buffered = Buffer.alloc(0);
+        let headersParsed = false;
+        let total = 0;
+        const timer = setTimeout(() => {
+            cleanup();
+            socket.destroy();
+            reject(new Error(`proxy download timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+        const cleanup = () => {
+            clearTimeout(timer);
+            socket.off('data', onData);
+            socket.off('end', onEnd);
+            socket.off('error', onError);
+        };
+        const finish = (bytes) => {
+            cleanup();
+            socket.destroy();
+            resolve(bytes);
+        };
+        const onError = (error) => {
+            cleanup();
+            reject(error);
+        };
+        const onEnd = () => {
+            cleanup();
+            resolve(total);
+        };
+        const countBody = (chunk) => {
+            total += Math.min(chunk.byteLength, Math.max(maxBytes - total, 0));
+            if (total >= maxBytes) {
+                finish(maxBytes);
+            }
+        };
+        const onData = (chunk) => {
+            if (!headersParsed) {
+                buffered = Buffer.concat([buffered, chunk]);
+                const split = splitHttpHeaders(buffered);
+                if (!split) {
+                    return;
+                }
+                const status = parseHttpStatus(split.head);
+                if (status < 200 || status >= 300) {
+                    cleanup();
+                    socket.destroy();
+                    reject(new Error(`unexpected status ${status}`));
+                    return;
+                }
+                headersParsed = true;
+                if (split.body.byteLength > 0) {
+                    countBody(split.body);
+                }
+                return;
+            }
+            countBody(chunk);
+        };
+        socket.on('data', onData);
+        socket.once('end', onEnd);
+        socket.once('error', onError);
+    });
+}
+function readConnectResponse(socket, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        let buffered = Buffer.alloc(0);
+        const timer = setTimeout(() => {
+            cleanup();
+            socket.destroy();
+            reject(new Error(`proxy CONNECT timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+        const cleanup = () => {
+            clearTimeout(timer);
+            socket.off('data', onData);
+            socket.off('error', onError);
+        };
+        const onError = (error) => {
+            cleanup();
+            reject(error);
+        };
+        const onData = (chunk) => {
+            buffered = Buffer.concat([buffered, chunk]);
+            const split = splitHttpHeaders(buffered);
+            if (!split) {
+                return;
+            }
+            const status = parseHttpStatus(split.head);
+            cleanup();
+            if (status < 200 || status >= 300) {
+                socket.destroy();
+                reject(new Error(`proxy CONNECT failed with status ${status}`));
+                return;
+            }
+            resolve();
+        };
+        socket.on('data', onData);
+        socket.once('error', onError);
+    });
+}
+export async function downloadUrlViaHttpProxy(url, proxyUrl, maxBytes, timeoutSeconds) {
+    const target = new URL(url);
+    const proxy = new URL(proxyUrl);
+    const timeoutMs = Math.max(1, timeoutSeconds) * 1000;
+    const proxyPort = Number(proxy.port || 80);
+    const socket = await socketConnect(proxy.hostname, proxyPort, timeoutMs);
+    const requestPath = `${target.pathname || '/'}${target.search}`;
+    const targetPort = Number(target.port || (target.protocol === 'https:' ? 443 : 80));
+    if (target.protocol === 'http:') {
+        socket.write([
+            `GET ${target.toString()} HTTP/1.1`,
+            `Host: ${target.host}`,
+            'Connection: close',
+            '',
+            ''
+        ].join('\r\n'));
+        return await readHttpBodyBytes(socket, Math.max(1, maxBytes), timeoutMs);
+    }
+    if (target.protocol !== 'https:') {
+        socket.destroy();
+        throw new Error(`unsupported speedtest URL protocol: ${target.protocol}`);
+    }
+    socket.write([
+        `CONNECT ${target.hostname}:${targetPort} HTTP/1.1`,
+        `Host: ${target.hostname}:${targetPort}`,
+        'Connection: keep-alive',
+        '',
+        ''
+    ].join('\r\n'));
+    await readConnectResponse(socket, timeoutMs);
+    const secureSocket = tls.connect({
+        socket,
+        servername: target.hostname,
+        rejectUnauthorized: false
+    });
+    await new Promise((resolve, reject) => {
+        secureSocket.once('secureConnect', resolve);
+        secureSocket.once('error', reject);
+    });
+    secureSocket.write([
+        `GET ${requestPath} HTTP/1.1`,
+        `Host: ${target.host}`,
+        'Connection: close',
+        '',
+        ''
+    ].join('\r\n'));
+    return await readHttpBodyBytes(secureSocket, Math.max(1, maxBytes), timeoutMs);
+}
+async function probeLinksDirect(links, config, options) {
+    const fetchImpl = options.fetch ?? globalThis.fetch?.bind(globalThis);
+    if (!fetchImpl) {
+        throw new Error('Node speedtest backend requires fetch support');
+    }
+    const now = options.now ?? defaultNow;
+    const timeoutMs = Math.max(1, Number(config.timeout_seconds)) * 1000;
+    const results = [];
+    for (const link of links) {
+        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]));
+            results.push({ link, reachable: true, latency_ms: Math.max(Math.round(elapsed), 1), error: '' });
+        }
+        catch (error) {
+            results.push({ link, reachable: false, latency_ms: 0, error: error instanceof Error ? error.message : String(error) });
+        }
+    }
+    return results;
+}
+async function probeLinksMihomo(links, config, runtimePath, options) {
+    const openRuntime = options.openMihomoRuntime ?? defaultOpenMihomoRuntime;
+    const probeDelay = options.probeMihomoProxyDelay ?? defaultProbeMihomoProxyDelay;
+    const results = [];
+    for (const link of links) {
+        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);
+            results.push({ link, reachable: true, latency_ms: latencyMs, error: '' });
+        }
+        catch (error) {
+            results.push({ link, reachable: false, latency_ms: 0, error: error instanceof Error ? error.message : String(error) });
+        }
+        finally {
+            await runtime?.close();
+        }
+    }
+    return results;
+}
+async function testLinkDirect(link, config, options) {
+    const fetchImpl = options.fetch ?? globalThis.fetch?.bind(globalThis);
+    if (!fetchImpl) {
+        throw new Error('Node speedtest backend requires fetch support');
+    }
+    const now = options.now ?? defaultNow;
+    const timeoutMs = Math.max(1, Number(config.timeout_seconds)) * 1000;
+    const speedValues = [];
+    const failures = [];
+    for (const url of config.urls) {
+        const started = now();
+        try {
+            const response = await fetchWithTimeout(fetchImpl, url, timeoutMs);
+            requireOkResponse(response, new Set([200]));
+            const total = await readResponseBytes(response, Math.max(1, Number(config.max_download_bytes)));
+            const elapsedSeconds = Math.max((now() - started) / 1000, 0.001);
+            speedValues.push(total / elapsedSeconds / 1024 / 1024);
+        }
+        catch (error) {
+            failures.push(`${url}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    if (speedValues.length === 0) {
+        return {
+            link,
+            reachable: false,
+            average_download_mb_s: 0,
+            latency_ms: 0,
+            error: failures.join('; ') || 'all speed test urls failed'
+        };
+    }
+    return {
+        link,
+        reachable: true,
+        average_download_mb_s: aggregateSpeedMeasurements(speedValues),
+        latency_ms: 0,
+        error: failures.join('; ')
+    };
+}
+async function testLinkMihomo(link, config, runtimePath, options) {
+    const openRuntime = options.openMihomoRuntime ?? defaultOpenMihomoRuntime;
+    const downloadViaProxy = options.downloadUrlViaHttpProxy ?? downloadUrlViaHttpProxy;
+    let runtime;
+    try {
+        runtime = await openRuntime(link, {
+            runtimePath,
+            startupWaitSeconds: config.startup_wait_seconds,
+            env: options.env
+        });
+        const now = options.now ?? defaultNow;
+        const speedValues = [];
+        const failures = [];
+        for (const url of config.urls) {
+            const started = now();
+            try {
+                const total = await downloadViaProxy(url, runtime.proxies.http, Math.max(1, Number(config.max_download_bytes)), config.timeout_seconds);
+                const elapsedSeconds = Math.max((now() - started) / 1000, 0.001);
+                speedValues.push(total / elapsedSeconds / 1024 / 1024);
+            }
+            catch (error) {
+                failures.push(`${url}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        if (speedValues.length === 0) {
+            return {
+                link,
+                reachable: false,
+                average_download_mb_s: 0,
+                latency_ms: 0,
+                error: failures.join('; ') || 'all speed test urls failed'
+            };
+        }
+        return {
+            link,
+            reachable: true,
+            average_download_mb_s: aggregateSpeedMeasurements(speedValues),
+            latency_ms: 0,
+            error: failures.join('; ')
+        };
+    }
+    catch (error) {
+        return {
+            link,
+            reachable: false,
+            average_download_mb_s: 0,
+            latency_ms: 0,
+            error: error instanceof Error ? error.message : String(error)
+        };
+    }
+    finally {
+        await runtime?.close();
+    }
+}
+async function speedtestInNode(input, options) {
+    if (input.links.length === 0) {
+        return [];
+    }
+    const config = normalizeSpeedTestConfig(input.config);
+    const runtimePath = input.runtime_path ?? '';
+    const requestedRuntime = String((options.env ?? process.env).AUTOVPN_SPEEDTEST_RUNTIME ?? '').trim().toLowerCase();
+    const useMihomoRuntime = requestedRuntime === 'mihomo';
+    const probeLinks = options.probeLinks ?? ((links) => (useMihomoRuntime
+        ? probeLinksMihomo(links, config, runtimePath, options)
+        : probeLinksDirect(links, config, options)));
+    const testLink = options.testLink ?? ((link) => (useMihomoRuntime
+        ? testLinkMihomo(link, config, runtimePath, options)
+        : testLinkDirect(link, config, options)));
+    const runtimeCore = useMihomoRuntime || options.probeLinks || options.testLink ? 'mihomo' : 'direct';
+    options.progressCallback?.(`[speedtest] runtime_core=${runtimeCore} probe_url=${config.probe_url}`);
+    emitEvent(options.eventCallback, 'speedtest_runtime', {
+        runtime_core: runtimeCore,
+        probe_url: config.probe_url,
+        urls: [...config.urls]
+    });
+    const probes = await probeLinks(input.links, config, { runtime_path: runtimePath });
+    const candidateLinks = selectSpeedtestCandidates(probes, config.max_download_candidates);
+    const probeByLink = new Map(probes.map((probe) => [probe.link, probe]));
+    const candidateSet = new Set(candidateLinks);
+    const reachableCount = probes.filter((probe) => probe.reachable).length;
+    options.progressCallback?.(`[speedtest] selected ${candidateLinks.length}/${reachableCount} reachable links for full download test`);
+    emitEvent(options.eventCallback, 'speedtest_selected', {
+        total_links: input.links.length,
+        reachable_count: reachableCount,
+        candidate_count: candidateLinks.length
+    });
+    const results = probes
+        .filter((probe) => !probe.reachable)
+        .map((probe) => ({
+        link: probe.link,
+        reachable: false,
+        average_download_mb_s: 0,
+        latency_ms: probe.latency_ms,
+        error: probe.error ?? ''
+    }));
+    for (let index = 0; index < candidateLinks.length; index += 1) {
+        const result = await testLink(candidateLinks[index], config, { runtime_path: runtimePath });
+        if (result.reachable && result.latency_ms <= 0) {
+            result.latency_ms = probeByLink.get(result.link)?.latency_ms ?? 0;
+        }
+        results.push(result);
+        const completed = index + 1;
+        options.progressCallback?.(`[speedtest] ${completed}/${candidateSet.size} reachable=${result.reachable} speed=${result.average_download_mb_s}MB/s`);
+        emitEvent(options.eventCallback, 'speedtest_result', {
+            completed,
+            total: candidateSet.size,
+            link: result.link,
+            reachable: result.reachable,
+            average_download_mb_s: result.average_download_mb_s,
+            latency_ms: result.latency_ms,
+            passed_threshold: result.reachable && result.average_download_mb_s >= config.min_download_mb_s,
+            error: result.error ?? ''
+        });
+    }
+    return results;
+}
+export function selectPipelineStageBackend(stage, env = process.env) {
+    const stageKey = `AUTOVPN_STAGE_BACKEND_${stage.toUpperCase()}`;
+    const stageOverride = String(env[stageKey] ?? '').trim().toLowerCase();
+    const pipelineOverride = String(env.AUTOVPN_PIPELINE_BACKEND ?? '').trim().toLowerCase();
+    const selected = stageOverride || pipelineOverride || 'node';
+    return selected === 'python' ? 'python' : '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 = {}) {
+    const config = normalizeSpeedTestConfig(input.config);
+    const runtimePath = input.runtime_path ?? '';
+    const requestedRuntime = String((options.env ?? process.env).AUTOVPN_SPEEDTEST_RUNTIME ?? '').trim().toLowerCase();
+    const useMihomoRuntime = requestedRuntime === 'mihomo';
+    const probeLinks = options.probeLinks ?? ((links) => (useMihomoRuntime
+        ? probeLinksMihomo(links, config, runtimePath, options)
+        : probeLinksDirect(links, config, options)));
+    return probeLinks(input.links, config, { runtime_path: runtimePath });
+}
+export async function testSpeedtestLinkInNode(input, options = {}) {
+    const config = normalizeSpeedTestConfig(input.config);
+    const runtimePath = input.runtime_path ?? '';
+    const requestedRuntime = String((options.env ?? process.env).AUTOVPN_SPEEDTEST_RUNTIME ?? '').trim().toLowerCase();
+    const useMihomoRuntime = requestedRuntime === 'mihomo';
+    const testLink = options.testLink ?? ((link) => (useMihomoRuntime
+        ? testLinkMihomo(link, config, runtimePath, options)
+        : testLinkDirect(link, config, options)));
+    return testLink(input.link, config, { runtime_path: runtimePath });
+}

package/dist/runtime/env.js

@@ -0,0 +1,35 @@
+import fs from 'node:fs';
+import path from 'node:path';
+function parseDotEnv(text) {
+    const output = {};
+    for (const rawLine of text.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (!line || line.startsWith('#')) {
+            continue;
+        }
+        const equalsIndex = line.indexOf('=');
+        if (equalsIndex <= 0) {
+            continue;
+        }
+        const key = line.slice(0, equalsIndex).trim();
+        let value = line.slice(equalsIndex + 1).trim();
+        if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1);
+        }
+        output[key] = value;
+    }
+    return output;
+}
+export function loadProjectDotEnv(projectRoot) {
+    const envPath = path.join(projectRoot, '.env');
+    if (!fs.existsSync(envPath)) {
+        return {};
+    }
+    return parseDotEnv(fs.readFileSync(envPath, 'utf8'));
+}
+export function mergeProjectEnv(projectRoot, env = process.env) {
+    return {
+        ...loadProjectDotEnv(projectRoot),
+        ...env
+    };
+}

package/dist/runtime/paths.js

@@ -0,0 +1,66 @@
+import fs from 'node:fs';
+import path from 'node:path';
+export function resolveRuntimeRoot(candidate) {
+    const absolute = path.resolve(candidate || process.cwd());
+    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 parent = path.dirname(current);
+        if (parent === current) {
+            return resolved;
+        }
+        current = parent;
+    }
+}
+export function resolveProjectRoot(argv, cwd = process.cwd()) {
+    const value = readOptionValue(argv, '--project-root');
+    return resolveRuntimeRoot(value ? path.resolve(cwd, value) : cwd);
+}
+export function resolveProfilePath(projectRoot, env = process.env) {
+    const override = String(env.VPN_AUTOMATION_PROFILE_PATH ?? '').trim();
+    if (override) {
+        return path.resolve(override);
+    }
+    return path.join(resolveUserRuntimeRoot(env), 'profile.toml');
+}
+export function resolveArtifactsRoot(projectRoot, env = process.env) {
+    const override = String(env.VPN_AUTOMATION_ARTIFACTS_ROOT ?? '').trim();
+    if (override) {
+        return path.resolve(override);
+    }
+    return path.join(resolveUserRuntimeRoot(env), 'artifacts');
+}
+export function resolveUserRuntimeRoot(env = process.env) {
+    const override = String(env.VPN_AUTOMATION_RUNTIME_ROOT ?? '').trim();
+    if (override) {
+        return path.resolve(expandHomePath(override));
+    }
+    return path.join(osHomeDir(), '.auto-vpn');
+}
+function expandHomePath(value) {
+    if (value === '~') {
+        return osHomeDir();
+    }
+    if (value.startsWith(`~${path.sep}`)) {
+        return path.join(osHomeDir(), value.slice(2));
+    }
+    return value;
+}
+function osHomeDir() {
+    return process.env.HOME || process.env.USERPROFILE || '';
+}
+export function readOptionValue(argv, optionName) {
+    for (let index = 0; index < argv.length; index += 1) {
+        const value = argv[index];
+        if (value === optionName) {
+            return argv[index + 1];
+        }
+        if (value.startsWith(`${optionName}=`)) {
+            return value.slice(optionName.length + 1);
+        }
+    }
+    return undefined;
+}