@swimmingliu/autovpn 1.4.0

package/dist/backend/python-backend.js

@@ -0,0 +1,242 @@
+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/dist/backend/select-backend.js

@@ -0,0 +1,12 @@
+import { NodeBackend } from './node-backend.js';
+import { PythonBackend } from './python-backend.js';
+export function selectBackend(options = {}) {
+    const backend = String(options.env?.AUTOVPN_BACKEND ?? '').trim().toLowerCase();
+    if (backend === 'python') {
+        return new PythonBackend(options);
+    }
+    if (backend && backend !== 'node') {
+        throw new Error(`Unsupported AUTOVPN_BACKEND: ${backend}`);
+    }
+    return new NodeBackend(options);
+}

package/dist/backend/types.js

@@ -0,0 +1 @@
+export {};

package/dist/cli/commands/index.js

@@ -0,0 +1,143 @@
+import { CliUsageError } from '../errors.js';
+import { readOptionValue } from '../global-options.js';
+const TOP_LEVEL_COMMANDS = new Set([
+    'profile',
+    'doctor',
+    'artifacts',
+    'run',
+    'retry-stage',
+    'resume',
+    'jobs',
+    'status',
+    'logs',
+    'stop'
+]);
+const JOBS_SUBCOMMANDS = new Set(['list', 'status', 'logs', 'stop', 'resume', 'retry']);
+const RESUME_SUBCOMMANDS = new Set(['pipeline', 'speedtest']);
+const PROFILE_SUBCOMMANDS = new Set(['show', 'save', 'summary']);
+const ARTIFACT_SUBCOMMANDS = new Set(['latest', 'list', 'preview']);
+function validateChoice(commandLabel, optionName, value, choices) {
+    if (value === undefined || choices.includes(value)) {
+        return;
+    }
+    throw new CliUsageError(`${commandLabel} ${optionName} must be one of: ${choices.join(', ')}`);
+}
+function requireOption(commandLabel, argv, optionName) {
+    const value = readOptionValue(argv, optionName);
+    if (value === undefined || value === '') {
+        throw new CliUsageError(`${commandLabel} requires ${optionName}`);
+    }
+    return value;
+}
+function findJobsSubcommand(argv) {
+    for (let index = 1; index < argv.length; index += 1) {
+        const value = argv[index];
+        if (value === '--project-root') {
+            index += 1;
+            continue;
+        }
+        if (value.startsWith('--project-root=')) {
+            continue;
+        }
+        if (JOBS_SUBCOMMANDS.has(value)) {
+            return value;
+        }
+        if (!value.startsWith('-')) {
+            return value;
+        }
+    }
+    return '';
+}
+function findSubcommand(argv, choices) {
+    for (let index = 1; index < argv.length; index += 1) {
+        const value = argv[index];
+        if (value === '--project-root' || value === '--format' || value === '--tail' || value === '--output' || value === '--artifact-dir' || value === '--stage') {
+            index += 1;
+            continue;
+        }
+        if (value.startsWith('--project-root=')) {
+            continue;
+        }
+        if (choices.has(value)) {
+            return value;
+        }
+        if (!value.startsWith('-')) {
+            return value;
+        }
+    }
+    return '';
+}
+export function validateCommand(argv) {
+    const command = argv[0];
+    if (!command) {
+        throw new CliUsageError('missing command');
+    }
+    if (command.startsWith('-')) {
+        throw new CliUsageError(`unknown option: ${command}`);
+    }
+    if (!TOP_LEVEL_COMMANDS.has(command)) {
+        throw new CliUsageError(`unknown command: ${command}`);
+    }
+    if (command === 'doctor') {
+        validateChoice('doctor', '--output', readOptionValue(argv, '--output'), ['human', 'json']);
+        return;
+    }
+    if (command === 'profile') {
+        const subcommand = argv[1] ?? '';
+        if (!PROFILE_SUBCOMMANDS.has(subcommand)) {
+            throw new CliUsageError('profile subcommand must be one of: show, save, summary');
+        }
+        return;
+    }
+    if (command === 'artifacts') {
+        const subcommand = argv[1] ?? '';
+        if (!ARTIFACT_SUBCOMMANDS.has(subcommand)) {
+            throw new CliUsageError('artifacts subcommand must be one of: latest, list, preview');
+        }
+        if (subcommand === 'preview' && !findSubcommand(argv.slice(argv.indexOf(subcommand)), new Set())) {
+            throw new CliUsageError('artifacts preview requires artifact_dir');
+        }
+        return;
+    }
+    if (command === 'run' || command === 'retry-stage' || command === 'resume') {
+        validateChoice(command, '--output', readOptionValue(argv, '--output'), ['jsonl', 'human']);
+        if (command === 'retry-stage') {
+            requireOption('retry-stage', argv, '--artifact-dir');
+            requireOption('retry-stage', argv, '--stage');
+        }
+        if (command === 'resume') {
+            const subcommand = argv[1] ?? '';
+            if (!RESUME_SUBCOMMANDS.has(subcommand)) {
+                throw new CliUsageError('resume subcommand must be one of: pipeline, speedtest');
+            }
+            requireOption('resume', argv, '--session');
+        }
+        return;
+    }
+    if (command === 'logs') {
+        validateChoice('logs', '--format', readOptionValue(argv, '--format'), ['human', 'jsonl']);
+        return;
+    }
+    if (command === 'jobs') {
+        const subcommand = findJobsSubcommand(argv);
+        if (!JOBS_SUBCOMMANDS.has(subcommand)) {
+            throw new CliUsageError('jobs subcommand must be one of: list, status, logs, stop, resume, retry');
+        }
+        if (['status', 'logs', 'stop', 'resume'].includes(subcommand)) {
+            const value = findSubcommand(argv.slice(argv.indexOf(subcommand)), new Set());
+            if (!value) {
+                throw new CliUsageError(`jobs ${subcommand} requires job_id`);
+            }
+        }
+        if (subcommand === 'logs') {
+            validateChoice('jobs logs', '--format', readOptionValue(argv, '--format'), ['human', 'jsonl']);
+        }
+        if (subcommand === 'resume' || subcommand === 'retry') {
+            validateChoice(`jobs ${subcommand}`, '--output', readOptionValue(argv, '--output'), ['jsonl', 'human']);
+        }
+        if (subcommand === 'retry') {
+            requireOption('jobs retry', argv, '--artifact-dir');
+            requireOption('jobs retry', argv, '--stage');
+        }
+    }
+}

package/dist/cli/errors.js

@@ -0,0 +1,7 @@
+export class CliUsageError extends Error {
+    exitCode = 2;
+    constructor(message) {
+        super(message);
+        this.name = 'CliUsageError';
+    }
+}

package/dist/cli/global-options.js

@@ -0,0 +1,29 @@
+import path from 'node:path';
+export function normalizeProjectRootArgs(argv, cwd = process.cwd()) {
+    const normalized = [...argv];
+    for (let index = 0; index < normalized.length; index += 1) {
+        const value = normalized[index];
+        if (value === '--project-root' && index + 1 < normalized.length) {
+            normalized[index + 1] = path.resolve(cwd, normalized[index + 1]);
+            index += 1;
+            continue;
+        }
+        if (value.startsWith('--project-root=')) {
+            const [, projectRoot] = value.split('=', 2);
+            normalized[index] = `--project-root=${path.resolve(cwd, projectRoot)}`;
+        }
+    }
+    return normalized;
+}
+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;
+}

package/dist/cli/main.js

@@ -0,0 +1,231 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { validateCommand } from './commands/index.js';
+import { CliUsageError } from './errors.js';
+import { normalizeProjectRootArgs } from './global-options.js';
+import { runNativeCommand } from './native-commands.js';
+import { defaultIo, renderHelp } from './output.js';
+import { selectBackend } from '../backend/select-backend.js';
+import { loadJob } from '../jobs/read.js';
+import { readOptionValue, resolveProjectRoot } from '../runtime/paths.js';
+import { redactText } from '../runtime/redaction.js';
+async function defaultReadPackageVersion() {
+    // @ts-expect-error The Phase 1 runner is plain ESM JavaScript.
+    const runner = await import('../../lib/runner.mjs');
+    return String(runner.readPackageVersion());
+}
+function defaultCreateBackend(options) {
+    return selectBackend(options);
+}
+async function defaultRunForwarder(argv, options) {
+    // @ts-expect-error The Phase 1 runner is plain ESM JavaScript.
+    const runner = await import('../../lib/runner.mjs');
+    return Number(await runner.runForwarder(argv, options));
+}
+async function defaultReadStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+    }
+    return Buffer.concat(chunks).toString('utf8');
+}
+function isEnabled(value) {
+    return ['1', 'true', 'yes', 'on'].includes(String(value ?? '').trim().toLowerCase());
+}
+async function resolvePackageVersion(options) {
+    if (options.packageVersion) {
+        return options.packageVersion;
+    }
+    if (options.readPackageVersion) {
+        return String(await options.readPackageVersion());
+    }
+    return defaultReadPackageVersion();
+}
+function hasFlag(argv, flag) {
+    return argv.includes(flag);
+}
+function eventOutputFormat(argv) {
+    return readOptionValue(argv, '--output') === 'human' ? 'human' : 'jsonl';
+}
+function positionalAfter(argv, start) {
+    for (let index = start; index < argv.length; index += 1) {
+        const value = argv[index];
+        if (value === '--project-root' || value === '--format' || value === '--tail' || value === '--output' || value === '--artifact-dir' || value === '--stage') {
+            index += 1;
+            continue;
+        }
+        if (value.startsWith('--')) {
+            continue;
+        }
+        return value;
+    }
+    return '';
+}
+function resolveResumeSessionDir(job) {
+    const candidates = [
+        String(job.resume_from ?? ''),
+        String((job.options ?? {}).session_dir ?? ''),
+        String(job.session_dir ?? '')
+    ];
+    for (const candidate of candidates) {
+        if (candidate && fs.existsSync(path.join(candidate, 'session.json'))) {
+            return candidate;
+        }
+    }
+    return '';
+}
+async function runForegroundPipeline(argv, backend, io, cwd) {
+    if (backend.kind !== 'node') {
+        return undefined;
+    }
+    const output = eventOutputFormat(argv);
+    let events;
+    if (argv[0] === 'run' && !hasFlag(argv, '--detach') && typeof backend.run === 'function') {
+        events = backend.run({
+            projectRoot: resolveProjectRoot(argv, cwd),
+            skipDeploy: hasFlag(argv, '--skip-deploy'),
+            skipVerify: hasFlag(argv, '--skip-verify'),
+            resumeLatest: hasFlag(argv, '--resume-latest'),
+            output,
+            eventLog: readOptionValue(argv, '--event-log'),
+            humanLog: readOptionValue(argv, '--human-log')
+        });
+    }
+    else if (argv[0] === 'retry-stage' && typeof backend.retryStage === 'function') {
+        events = backend.retryStage({
+            projectRoot: resolveProjectRoot(argv, cwd),
+            artifactDir: readOptionValue(argv, '--artifact-dir') ?? '',
+            stage: readOptionValue(argv, '--stage') ?? '',
+            output,
+            eventLog: readOptionValue(argv, '--event-log'),
+            humanLog: readOptionValue(argv, '--human-log')
+        });
+    }
+    else if (argv[0] === 'resume' && typeof backend.resume === 'function') {
+        events = backend.resume({
+            projectRoot: resolveProjectRoot(argv, cwd),
+            mode: argv[1] === 'speedtest' ? 'speedtest' : 'pipeline',
+            session: readOptionValue(argv, '--session') ?? '',
+            output,
+            eventLog: readOptionValue(argv, '--event-log'),
+            humanLog: readOptionValue(argv, '--human-log')
+        });
+    }
+    else if (argv[0] === 'jobs' && argv[1] === 'retry' && !hasFlag(argv, '--detach') && typeof backend.retryStage === 'function') {
+        events = backend.retryStage({
+            projectRoot: resolveProjectRoot(argv, cwd),
+            artifactDir: path.resolve(cwd, readOptionValue(argv, '--artifact-dir') ?? ''),
+            stage: readOptionValue(argv, '--stage') ?? '',
+            output
+        });
+    }
+    else if (argv[0] === 'jobs' && argv[1] === 'resume' && !hasFlag(argv, '--detach')) {
+        const projectRoot = resolveProjectRoot(argv, cwd);
+        const sourceJob = loadJob(projectRoot, positionalAfter(argv, 2));
+        const sessionDir = resolveResumeSessionDir(sourceJob);
+        if (!sessionDir && String(sourceJob.kind ?? '') === 'run' && typeof backend.run === 'function') {
+            const sourceOptions = sourceJob.options ?? {};
+            events = backend.run({
+                projectRoot,
+                resumeLatest: true,
+                skipDeploy: Boolean(sourceOptions.skip_deploy),
+                skipVerify: Boolean(sourceOptions.skip_verify),
+                output
+            });
+        }
+        else if (sessionDir && typeof backend.resume === 'function') {
+            events = backend.resume({
+                projectRoot,
+                mode: 'pipeline',
+                session: sessionDir,
+                output
+            });
+        }
+        else if (!sessionDir) {
+            throw new Error('cannot resume job without session.json');
+        }
+    }
+    if (!events) {
+        return undefined;
+    }
+    for await (const event of events) {
+        const backendEvent = event;
+        if (output === 'human') {
+            if (backendEvent.type === 'log' && typeof backendEvent.message === 'string') {
+                io.writeStdout(`${backendEvent.message}\n`);
+            }
+            else if (backendEvent.type === 'stage') {
+                io.writeStdout(`[${String(backendEvent.stage ?? '')}] ${String(backendEvent.status ?? '')}\n`);
+            }
+            else if (backendEvent.type === 'summary') {
+                io.writeStdout(`summary: ${String(backendEvent.run_status ?? '')} ${String(backendEvent.artifact_dir ?? '')}\n`);
+            }
+            continue;
+        }
+        io.writeStdout(`${JSON.stringify(backendEvent)}\n`);
+    }
+    return 0;
+}
+export async function runCliShell(argv, options = {}) {
+    const env = options.env ?? process.env;
+    const io = options.io ?? defaultIo();
+    const runForwarder = options.runForwarder ?? defaultRunForwarder;
+    const cwd = options.cwd ?? process.cwd();
+    if (env.AUTOVPN_CLI_SHELL === 'python') {
+        return runForwarder(argv, { env, cwd });
+    }
+    if (isEnabled(env.AUTOVPN_WRAPPER_PROBE) && argv.length === 1 && argv[0] === '--version') {
+        return 42;
+    }
+    if (argv[0] === '--help' || argv[0] === '-h') {
+        io.writeStdout(renderHelp());
+        return 0;
+    }
+    if (argv[0] === '--version') {
+        io.writeStdout(`autovpn ${await resolvePackageVersion(options)}\n`);
+        return 0;
+    }
+    try {
+        const normalizedArgv = normalizeProjectRootArgs(argv, cwd);
+        validateCommand(normalizedArgv);
+        const createBackend = options.createBackend ?? defaultCreateBackend;
+        const backend = createBackend({ env, cwd, runForwarder });
+        let pythonFallbackBackend;
+        const runExplicitPythonFallback = (fallbackArgv) => {
+            pythonFallbackBackend ??= createBackend({
+                env: { ...env, AUTOVPN_BACKEND: 'python' },
+                cwd,
+                runForwarder
+            });
+            return pythonFallbackBackend.executeCli(fallbackArgv);
+        };
+        const nativeResult = await runNativeCommand(normalizedArgv, {
+            cwd,
+            env,
+            io,
+            readStdin: options.readStdin ?? defaultReadStdin,
+            pythonFallback: runExplicitPythonFallback,
+            spawn: options.spawn,
+            now: options.now,
+            jobId: options.jobId,
+            sleep: options.sleep
+        });
+        if (nativeResult !== undefined) {
+            return nativeResult;
+        }
+        const foregroundResult = await runForegroundPipeline(normalizedArgv, backend, io, cwd);
+        if (foregroundResult !== undefined) {
+            return foregroundResult;
+        }
+        return await backend.executeCli(normalizedArgv);
+    }
+    catch (error) {
+        if (error instanceof CliUsageError) {
+            io.writeStderr(`autovpn: ${error.message}\n`);
+            return error.exitCode;
+        }
+        const message = redactText(error instanceof Error ? error.message : String(error));
+        io.writeStderr(`autovpn npm wrapper error: ${message}\n`);
+        return 1;
+    }
+}