@swimmingliu/autovpn 1.5.4 → 1.6.0

package/dist/cli/main.js

@@ -207,7 +207,8 @@ export async function runCliShell(argv, options = {}) {
             const serverFactory = options.createServer ?? createAutoVpnServer;
             const runtime = createServerRuntime({
                 projectRoot: serveOptions.projectRoot,
-                env
+                env,
+                proxy: serveOptions.proxy
             });
             const server = await serverFactory({
                 ...serveOptions,
@@ -217,7 +218,13 @@ export async function runCliShell(argv, options = {}) {
             });
             io.writeStdout(`AutoVPN server listening on ${server.origin}\n`);
             if (serveOptions.auth.enabled) {
-                io.writeStdout(`Open ${server.origin}/?token=${encodeURIComponent(serveOptions.auth.token)}\n`);
+                if (serveOptions.auth.password) {
+                    io.writeStdout(`Open ${server.origin}/\n`);
+                    io.writeStdout(`Password: ${serveOptions.auth.password}\n`);
+                }
+                else {
+                    io.writeStdout(`Open ${server.origin}/?token=${encodeURIComponent(serveOptions.auth.token)}\n`);
+                }
             }
             else {
                 io.writeStderr('autovpn: warning: server authentication is disabled\n');

package/dist/cli/native-commands.js

@@ -160,6 +160,8 @@ export async function runNativeCommand(argv, context) {
                     resumeLatest: true,
                     skipDeploy: Boolean(sourceOptions.skip_deploy),
                     skipVerify: Boolean(sourceOptions.skip_verify),
+                    useProxy: Boolean(sourceOptions.use_proxy),
+                    proxyUrl: String(sourceOptions.proxy_url ?? ''),
                     outputFormat: outputFormat(argv)
                 }, jobOptions(context));
                 context.io.writeStdout(jsonLine(publicStartedPayload(job)));

package/dist/jobs/commands.js

@@ -45,6 +45,32 @@ function spawnDetached(command, args, job, options) {
         fs.closeSync(stderrFd);
     }
 }
+function markArtifactStopped(job) {
+    const artifactDir = String(job.artifact_dir ?? '');
+    if (!artifactDir) {
+        return;
+    }
+    const reportPath = path.join(artifactDir, 'pipeline_report.json');
+    if (!fs.existsSync(reportPath)) {
+        return;
+    }
+    try {
+        const report = JSON.parse(fs.readFileSync(reportPath, 'utf8'));
+        const stageStatus = { ...(report.stage_status ?? {}) };
+        for (const [stage, status] of Object.entries(stageStatus)) {
+            if (status === 'running') {
+                stageStatus[stage] = 'failed';
+            }
+        }
+        report.stage_status = stageStatus;
+        report.run_status = 'stopped';
+        report.error = report.error || 'Stopped by user';
+        fs.writeFileSync(reportPath, `${JSON.stringify(report, null, 2)}\n`, 'utf8');
+    }
+    catch {
+        // Best-effort cleanup so stopping a job never fails because its report is corrupt.
+    }
+}
 export async function startDetachedRun(command, options = {}) {
     const outputFormat = command.outputFormat ?? 'jsonl';
     const jobStore = createJobStore(command.projectRoot, options);
@@ -59,6 +85,8 @@ export async function startDetachedRun(command, options = {}) {
             resume_latest: Boolean(command.resumeLatest),
             skip_deploy: Boolean(command.skipDeploy),
             skip_verify: Boolean(command.skipVerify),
+            use_proxy: Boolean(command.useProxy),
+            proxy_url: command.proxyUrl ?? '',
             output_format: outputFormat
         }
     });
@@ -66,6 +94,12 @@ export async function startDetachedRun(command, options = {}) {
     pushFlag(runArgs, command.resumeLatest, '--resume-latest');
     pushFlag(runArgs, command.skipDeploy, '--skip-deploy');
     pushFlag(runArgs, command.skipVerify, '--skip-verify');
+    if (command.useProxy) {
+        runArgs.push('--proxy');
+        if (command.proxyUrl) {
+            runArgs.push(command.proxyUrl);
+        }
+    }
     job.command = [resolved.command, ...resolved.args, ...runArgs];
     const child = spawnDetached(resolved.command, [...resolved.args, ...runArgs], job, options);
     job.pid = Number(child.pid ?? 0);
@@ -148,6 +182,7 @@ export async function stopManagedJob(projectRoot, jobId, options = {}) {
         throw new Error(`refusing to stop pid ${pid}: command does not match AutoVPN job`);
     }
     await terminateProcessGroup(pid, options);
+    markArtifactStopped(job);
     job.status = 'stopped';
     job.finished_at = options.now?.() ?? new Date().toISOString().replace(/\.\d{3}Z$/, '+00:00');
     job.exit_code = 1;

package/dist/jobs/process.js

@@ -37,6 +37,9 @@ function defaultSignalProcess(target, signal, options) {
     }
     process.kill(target, signal);
 }
+function isNoSuchProcess(error) {
+    return error?.code === 'ESRCH';
+}
 function defaultSleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -54,22 +57,37 @@ export async function terminateProcessGroup(pid, options = {}) {
     const target = signalTarget(pid, platform);
     if (!isAlive(pid))
         return;
-    if (signalProcess) {
-        signalProcess(target, 'SIGTERM');
+    try {
+        if (signalProcess) {
+            signalProcess(target, 'SIGTERM');
+        }
+        else {
+            defaultSignalProcess(target, 'SIGTERM', options);
+        }
     }
-    else {
-        defaultSignalProcess(target, 'SIGTERM', options);
+    catch (error) {
+        if (isNoSuchProcess(error)) {
+            return;
+        }
+        throw error;
     }
     const deadline = Date.now() + timeoutMs;
     while (Date.now() < deadline && isAlive(pid)) {
         await sleep(100);
     }
     if (isAlive(pid)) {
-        if (signalProcess) {
-            signalProcess(target, 'SIGKILL');
+        try {
+            if (signalProcess) {
+                signalProcess(target, 'SIGKILL');
+            }
+            else {
+                defaultSignalProcess(target, 'SIGKILL', options);
+            }
         }
-        else {
-            defaultSignalProcess(target, 'SIGKILL', options);
+        catch (error) {
+            if (!isNoSuchProcess(error)) {
+                throw error;
+            }
         }
     }
 }

package/dist/jobs/read.js

@@ -55,6 +55,10 @@ function reconcileFromPipelineReport(job) {
         if (!['success', 'failed', 'stopped'].includes(runStatus)) {
             return undefined;
         }
+        const stageStatus = (report.stage_status ?? {});
+        if (Object.values(stageStatus).some((status) => String(status) === 'running')) {
+            return undefined;
+        }
         return {
             status: runStatus,
             finished_at: job.finished_at || nowIso(),

package/dist/pipeline/extract.js

@@ -142,10 +142,121 @@ async function fetchWithTimeout(fetchImpl, url, timeoutMs) {
         clearTimeout(timer);
     }
 }
+function isEnabled(value) {
+    return ['1', 'true', 'yes', 'on'].includes(String(value ?? '').trim().toLowerCase());
+}
+function resolveUpstreamProxyUrl(env) {
+    if (!isEnabled(env.VPN_AUTOMATION_USE_UPSTREAM_PROXY)) {
+        return '';
+    }
+    const value = String(env.VPN_AUTOMATION_UPSTREAM_PROXY ?? 'http://127.0.0.1:7897').trim();
+    return ['', 'off', 'none', 'false', '0'].includes(value.toLowerCase()) ? '' : value;
+}
+function isTlsFailure(error) {
+    const text = error instanceof Error
+        ? `${error.name}: ${error.message}`.toLowerCase()
+        : String(error).toLowerCase();
+    if (text.includes('ssl') || text.includes('tls') || text.includes('certificate')) {
+        return true;
+    }
+    const cause = error instanceof Error ? error.cause : undefined;
+    if (cause) {
+        return isTlsFailure(cause);
+    }
+    return false;
+}
+function defaultCurlFetch(url, proxyUrl, spawn = defaultSpawn) {
+    const args = [
+        '--fail',
+        '--silent',
+        '--show-error',
+        '--location',
+        '--max-time',
+        '20',
+        '--connect-timeout',
+        '10',
+        '--insecure',
+        '--http1.1',
+        '--config',
+        '-'
+    ];
+    if (proxyUrl) {
+        args.push('--proxy', proxyUrl);
+    }
+    else {
+        args.push('--noproxy', '*');
+    }
+    const child = spawn('curl', args, { 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) {
+                resolve(stdout);
+                return;
+            }
+            reject(new Error((stderr || stdout || 'curl TLS fallback failed').trim()));
+        });
+    });
+    child.stdin?.write(`url = ${JSON.stringify(url)}\n`);
+    child.stdin?.end();
+    return completion;
+}
+function emitExtractEvent(options, type, payload) {
+    options.eventCallback?.(type, payload);
+}
+async function fetchSourceText(input, url, attempt, fetchImpl, options, upstreamProxy) {
+    try {
+        const response = await fetchWithTimeout(fetchImpl, url, 20_000);
+        if (response.ok === false || Number(response.status ?? 200) >= 400) {
+            throw new Error(`HTTP ${Number(response.status ?? 0)}`);
+        }
+        const text = await response.text();
+        emitExtractEvent(options, 'extract_request_result', {
+            source_name: input.source_name,
+            iteration: attempt,
+            success: true,
+            via: 'direct'
+        });
+        return { text, via: 'direct' };
+    }
+    catch (error) {
+        const shouldRetry = Boolean(upstreamProxy) || isTlsFailure(error);
+        emitExtractEvent(options, 'extract_request_result', {
+            source_name: input.source_name,
+            iteration: attempt,
+            success: false,
+            via: 'direct',
+            error: error instanceof Error ? `${error.constructor.name}: ${error.message}` : String(error),
+            will_retry: shouldRetry
+        });
+        if (!shouldRetry) {
+            throw error;
+        }
+        const curlFetch = options.curlFetch ?? ((targetUrl, proxyUrl) => defaultCurlFetch(targetUrl, proxyUrl, options.spawn));
+        const text = await curlFetch(url, upstreamProxy);
+        const via = upstreamProxy ? 'upstream_proxy_curl_tls_fallback' : 'direct_curl_tls_fallback';
+        emitExtractEvent(options, 'extract_request_result', {
+            source_name: input.source_name,
+            iteration: attempt,
+            success: true,
+            via
+        });
+        return { text, via };
+    }
+}
 async function fetchSourceLinksInNode(input, options) {
     const source = input.source;
     const maxIterations = Math.max(0, Math.trunc(numberOrDefault(source.max_iterations, 0)));
-    const minIterations = Math.max(0, Math.trunc(numberOrDefault(source.min_iterations, 0)));
+    const configuredMinIterations = Math.max(0, Math.trunc(numberOrDefault(source.min_iterations, 0)));
+    const minIterations = configuredMinIterations > maxIterations ? 0 : configuredMinIterations;
     const plateauLimit = Math.max(1, Math.trunc(numberOrDefault(source.plateau_limit, 1)));
     const failureLimit = Math.max(1, Math.trunc(numberOrDefault(source.failure_limit, 1)));
     const maxRuntimeSeconds = Math.max(0, numberOrDefault(source.max_runtime_seconds, 0));
@@ -169,6 +280,13 @@ async function fetchSourceLinksInNode(input, options) {
     let successes = 0;
     let failures = 0;
     const startedAt = Date.now();
+    const upstreamProxy = resolveUpstreamProxyUrl(options.env ?? process.env);
+    emitExtractEvent(options, 'extract_source_started', {
+        source_name: input.source_name,
+        requested_iterations: maxIterations,
+        min_iterations: minIterations,
+        resume_from_iteration: startIteration
+    });
     for (let iteration = startIteration - 1; iteration < maxIterations; iteration += 1) {
         const attempt = iteration + 1;
         if (maxRuntimeSeconds > 0 && attempt > minIterations && (Date.now() - startedAt) / 1000 >= maxRuntimeSeconds) {
@@ -176,11 +294,25 @@ async function fetchSourceLinksInNode(input, options) {
         }
         try {
             const url = buildRuntimeSourceUrl(source, iteration);
-            const response = await fetchWithTimeout(fetchImpl, url, 20_000);
-            if (response.ok === false || Number(response.status ?? 200) >= 400) {
-                throw new Error(`HTTP ${Number(response.status ?? 0)}`);
+            const response = await fetchSourceText(input, url, attempt, fetchImpl, options, upstreamProxy);
+            let plaintext = '';
+            try {
+                plaintext = decryptPayload(response.text.trim(), source.key);
+                emitExtractEvent(options, 'extract_decrypt_result', {
+                    source_name: input.source_name,
+                    iteration: attempt,
+                    success: true
+                });
+            }
+            catch (decryptError) {
+                emitExtractEvent(options, 'extract_decrypt_result', {
+                    source_name: input.source_name,
+                    iteration: attempt,
+                    success: false,
+                    error: decryptError instanceof Error ? `${decryptError.constructor.name}: ${decryptError.message}` : String(decryptError)
+                });
+                throw decryptError;
             }
-            const plaintext = decryptPayload((await response.text()).trim(), source.key);
             const extracted = extractLinksFromPlaintext(input.source_name, plaintext);
             successes += 1;
             failures = 0;
@@ -193,6 +325,14 @@ async function fetchSourceLinksInNode(input, options) {
                 links.push(link);
                 newItems += 1;
             }
+            emitExtractEvent(options, 'extract_iteration', {
+                source_name: input.source_name,
+                iteration: attempt,
+                requested_iterations: maxIterations,
+                new_items: newItems,
+                extracted_links: extracted.length,
+                total_links: links.length
+            });
             plateau = newItems === 0 ? plateau + 1 : 0;
             if (plateau >= plateauLimit && attempt >= minIterations) {
                 break;
@@ -200,7 +340,7 @@ async function fetchSourceLinksInNode(input, options) {
         }
         catch (error) {
             failures += 1;
-            if (failures >= failureLimit && attempt >= minIterations) {
+            if (failures >= failureLimit) {
                 break;
             }
             if (attempt >= maxIterations) {
@@ -208,6 +348,13 @@ async function fetchSourceLinksInNode(input, options) {
             }
         }
     }
+    emitExtractEvent(options, 'extract_source_completed', {
+        source_name: input.source_name,
+        requested_iterations: maxIterations,
+        successful_iterations: successes,
+        failed_iterations: failures,
+        raw_links: links.length
+    });
     return {
         source_name: input.source_name,
         requested_iterations: maxIterations,

package/dist/pipeline/orchestrator.js

@@ -169,7 +169,7 @@ async function seedRetryArtifact(sourceArtifactDir, retryArtifactDir, stage, ret
         source_counts: { ...(sourceReport.source_counts ?? {}) },
         deployment: { ...(sourceReport.deployment ?? {}) },
         retry_context: retryContext,
-        run_status: 'success',
+        run_status: 'running',
         error: ''
     };
     await copyIfExists(path.join(sourceArtifactDir, 'vpn_node_raw.txt'), path.join(retryArtifactDir, 'vpn_node_raw.txt'));
@@ -205,7 +205,9 @@ function pipelineSummaryFromReport(artifactDir, report) {
         source_counts: { ...(report.source_counts ?? {}) },
         deployment: { ...(report.deployment ?? {}) },
         retry_context: { ...(report.retry_context ?? {}) },
-        run_status: String(report.run_status ?? 'success') === 'failed' ? 'failed' : 'success',
+        run_status: ['running', 'success', 'failed', 'stopped'].includes(String(report.run_status ?? ''))
+            ? String(report.run_status)
+            : 'running',
         error: String(report.error ?? '')
     };
 }
@@ -328,7 +330,7 @@ export async function runNodePipeline(options, context = {}) {
         source_counts: {},
         deployment: {},
         retry_context: {},
-        run_status: 'success',
+        run_status: 'running',
         error: ''
     };
     const emit = (type, payload = {}) => {
@@ -356,19 +358,26 @@ export async function runNodePipeline(options, context = {}) {
         await setStage('doctor', 'success');
         const profile = await readProfile(projectRoot, env);
         await setStage('extract', 'running');
-        const extractResults = [];
-        for (const [sourceName, source] of enabledSources(profile)) {
+        const sourcesToRun = enabledSources(profile);
+        const extractResults = await Promise.all(sourcesToRun.map(async ([sourceName, source]) => {
             const result = context.stages?.extract
                 ? await context.stages.extract({ source_name: sourceName, source })
-                : await fetchSourceLinksWithBackend({ source_name: sourceName, source }, { cwd: projectRoot, env: runtimeStageEnv });
-            extractResults.push(result);
+                : await fetchSourceLinksWithBackend({ source_name: sourceName, source }, {
+                    cwd: projectRoot,
+                    env: runtimeStageEnv,
+                    eventCallback: (type, payload) => emit(type, payload)
+                });
             summary.source_counts[result.source_name] = {
                 raw_links: result.links.length,
                 successful_iterations: result.successful_iterations,
                 failed_iterations: result.failed_iterations
             };
-        }
+            return result;
+        }));
         const rawLinks = extractResults.flatMap((result) => result.links);
+        if (sourcesToRun.length > 0 && rawLinks.length === 0 && extractResults.some((result) => result.requested_iterations > 0 || result.failed_iterations > 0)) {
+            throw new Error('No links extracted from configured sources');
+        }
         summary.counts.raw_links = rawLinks.length;
         await writeLines(artifactDir, 'vpn_node_raw.txt', rawLinks);
         await setStage('extract', 'success');
@@ -478,6 +487,7 @@ export async function runNodePipeline(options, context = {}) {
         emit('run_failed', { error: summary.error });
         throw error;
     }
+    summary.run_status = 'success';
     await writeReport();
     emit('summary', summary);
     return summary;

package/dist/server/http.js

@@ -1,43 +1,38 @@
 import http from 'node:http';
+import crypto from 'node:crypto';
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import { fileURLToPath, URL } from 'node:url';
 import QRCode from 'qrcode';
 import { renderWebAdapterScript } from './web-adapter.js';
 import { redactText } from '../runtime/redaction.js';
-const SENSITIVE_KEYS = new Set([
-    'key',
-    'token',
-    'api_token',
-    'cloudflare_api_token',
-    'cloudflare_global_key',
-    'subscription_url',
-    'verify_subscription_url',
-    'secret_query',
-    'pages_secret_admin',
-    'share_project_sub_value'
+const LABELED_SECRET_KEYS = new Map([
+    ['cloudflare_api_token', '<Cloudflare Token>'],
+    ['cloudflare_global_key', '<Cloudflare Token>'],
+    ['pages_secret_admin', '<Pages Secret ADMIN>']
 ]);
-function redactPayload(value, parentKey = '') {
+function redactPayload(value, parentKey = '', mode = 'full') {
     if (typeof value === 'string') {
-        if (SENSITIVE_KEYS.has(parentKey.toLowerCase())) {
-            return value ? '<redacted>' : '';
+        const label = LABELED_SECRET_KEYS.get(parentKey.toLowerCase());
+        if (label) {
+            return value ? label : '';
         }
-        return redactText(value);
+        return mode === 'config' ? value : redactText(value);
     }
     if (value === null || ['number', 'boolean'].includes(typeof value)) {
         return value;
     }
     if (Array.isArray(value)) {
-        return value.map((item) => redactPayload(item, parentKey));
+        return value.map((item) => redactPayload(item, parentKey, mode));
     }
     if (typeof value === 'object') {
-        return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, redactPayload(item, key)]));
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, redactPayload(item, key, mode)]));
     }
     return null;
 }
-function writeJson(response, statusCode, payload) {
+function writeJson(response, statusCode, payload, mode = 'full') {
     response.writeHead(statusCode, { 'Content-Type': 'application/json; charset=utf-8' });
-    response.end(JSON.stringify(redactPayload(payload)));
+    response.end(JSON.stringify(redactPayload(payload, '', mode)));
 }
 function contentType(filePath) {
     if (filePath.endsWith('.html'))
@@ -56,13 +51,16 @@ function rendererRoot() {
     return path.resolve(fileURLToPath(new URL('../web/renderer', import.meta.url)));
 }
 async function writeStaticFile(response, statusCode, filePath, body) {
+    const payload = body ?? await fs.readFile(filePath);
     response.writeHead(statusCode, { 'Content-Type': contentType(filePath) });
-    response.end(body ?? await fs.readFile(filePath));
+    response.end(payload);
 }
 async function serveRendererIndex(response) {
     const indexPath = path.join(rendererRoot(), 'index.html');
     const html = await fs.readFile(indexPath, 'utf8');
-    const injected = html.replace('<script type="module" src="./app.js"></script>', '<script src="/web-adapter.js"></script>\n    <script type="module" src="./app.js"></script>');
+    const injected = html
+        .replace('<body data-page="dashboard">', '<body data-page="dashboard" data-runtime="web">')
+        .replace('<script type="module" src="./app.js"></script>', '<script src="/web-adapter.js"></script>\n    <script type="module" src="./app.js"></script>');
     await writeStaticFile(response, 200, indexPath, injected);
 }
 async function serveRendererAsset(url, response) {
@@ -70,10 +68,6 @@ async function serveRendererAsset(url, response) {
         await serveRendererIndex(response);
         return true;
     }
-    if (url.pathname === '/web-adapter.js') {
-        await writeStaticFile(response, 200, 'web-adapter.js', renderWebAdapterScript());
-        return true;
-    }
     const decodedPath = decodeURIComponent(url.pathname.replace(/^\/+/, ''));
     if (!decodedPath || decodedPath.includes('..') || path.isAbsolute(decodedPath)) {
         return false;
@@ -91,15 +85,23 @@ async function serveRendererAsset(url, response) {
         return false;
     }
 }
+function timingSafeEqualText(left, right) {
+    const leftBuffer = Buffer.from(left);
+    const rightBuffer = Buffer.from(right);
+    return leftBuffer.length === rightBuffer.length && crypto.timingSafeEqual(leftBuffer, rightBuffer);
+}
 function isAuthorized(request, url, auth) {
     if (!auth.enabled) {
         return true;
     }
     const authorization = request.headers.authorization ?? '';
-    if (authorization === `Bearer ${auth.token}`) {
+    if (authorization.startsWith('Bearer ') && timingSafeEqualText(authorization.slice(7), auth.token)) {
         return true;
     }
-    return url.searchParams.get('token') === auth.token;
+    return timingSafeEqualText(url.searchParams.get('token') ?? '', auth.token);
+}
+function clientIp(request) {
+    return request.socket.remoteAddress || 'unknown';
 }
 async function readJsonBody(request) {
     const chunks = [];
@@ -120,13 +122,47 @@ async function readJsonBody(request) {
     return typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed) ? parsed : {};
 }
 export async function createAutoVpnServer(options) {
+    const authFailures = new Map();
     const server = http.createServer(async (request, response) => {
         const url = new URL(request.url ?? '/', `http://${request.headers.host ?? `${options.host}:${options.port}`}`);
-        if (url.pathname.startsWith('/api/') && !isAuthorized(request, url, options.auth)) {
-            writeJson(response, 401, { ok: false, error: 'unauthorized' });
+        const ip = clientIp(request);
+        const authState = authFailures.get(ip);
+        if (authState?.banned) {
+            writeJson(response, 403, { ok: false, error: 'ip_banned' });
             return;
         }
         try {
+            if (request.method === 'POST' && url.pathname === '/api/auth/login') {
+                const password = String((await readJsonBody(request)).password ?? '');
+                if (!options.auth.enabled || !options.auth.password || timingSafeEqualText(password, options.auth.password)) {
+                    authFailures.delete(ip);
+                    writeJson(response, 200, { ok: true, token: options.auth.token });
+                    return;
+                }
+                const nextFailures = (authState?.failures ?? 0) + 1;
+                if (nextFailures >= options.auth.maxAttempts) {
+                    authFailures.set(ip, { failures: nextFailures, banned: true });
+                    writeJson(response, 403, { ok: false, error: 'ip_banned' });
+                    return;
+                }
+                authFailures.set(ip, { failures: nextFailures, banned: false });
+                writeJson(response, 401, {
+                    ok: false,
+                    error: 'invalid_password',
+                    attemptsRemaining: options.auth.maxAttempts - nextFailures
+                });
+                return;
+            }
+            if (request.method === 'GET' && url.pathname === '/web-adapter.js') {
+                await writeStaticFile(response, 200, 'web-adapter.js', renderWebAdapterScript({
+                    passwordEnabled: Boolean(options.auth.enabled && options.auth.password)
+                }));
+                return;
+            }
+            if (url.pathname.startsWith('/api/') && !isAuthorized(request, url, options.auth)) {
+                writeJson(response, 401, { ok: false, error: 'unauthorized' });
+                return;
+            }
             if (request.method === 'GET' && url.pathname === '/api/health') {
                 writeJson(response, 200, {
                     status: 'ok',
@@ -137,12 +173,12 @@ export async function createAutoVpnServer(options) {
                 return;
             }
             if (request.method === 'GET' && url.pathname === '/api/state') {
-                writeJson(response, 200, await options.runtime.loadState());
+                writeJson(response, 200, await options.runtime.loadState(), 'config');
                 return;
             }
             if (request.method === 'POST' && url.pathname === '/api/profile') {
                 const body = await readJsonBody(request);
-                writeJson(response, 200, await options.runtime.saveProfile?.(body) ?? { ok: false, error: 'profile_save_unavailable' });
+                writeJson(response, 200, await options.runtime.saveProfile?.(body) ?? { ok: false, error: 'profile_save_unavailable' }, 'config');
                 return;
             }
             if (request.method === 'POST' && url.pathname === '/api/qr') {

package/dist/server/options.js

@@ -11,6 +11,23 @@ function isLoopbackHost(host) {
 function defaultRandomToken() {
     return crypto.randomBytes(18).toString('base64url');
 }
+function defaultRandomPassword() {
+    return crypto.randomBytes(9).toString('base64url');
+}
+const DEFAULT_PROXY_URL = 'http://127.0.0.1:7897';
+function optionalFlagValue(argv, flag) {
+    for (let index = 0; index < argv.length; index += 1) {
+        const value = argv[index];
+        if (value.startsWith(`${flag}=`)) {
+            return value.slice(flag.length + 1);
+        }
+        if (value === flag) {
+            const next = argv[index + 1] ?? '';
+            return next && !next.startsWith('--') ? next : '';
+        }
+    }
+    return '';
+}
 export function parseServeOptions(argv, context) {
     const host = readOptionValue(argv, '--host') ?? context.env.AUTOVPN_SERVER_HOST ?? '127.0.0.1';
     const portText = readOptionValue(argv, '--port') ?? context.env.AUTOVPN_SERVER_PORT ?? '8765';
@@ -19,16 +36,33 @@ export function parseServeOptions(argv, context) {
         throw new CliUsageError('serve --port must be an integer from 1 to 65535');
     }
     const token = readOptionValue(argv, '--token') ?? context.env.AUTOVPN_SERVER_TOKEN ?? '';
+    const password = readOptionValue(argv, '--password')
+        ?? context.env.AUTOVPN_SERVER_PASSWORD
+        ?? (context.randomPassword ?? defaultRandomPassword)();
+    const maxAttemptsText = readOptionValue(argv, '--max-auth-attempts') ?? context.env.AUTOVPN_SERVER_MAX_AUTH_ATTEMPTS ?? '5';
+    const maxAttempts = Number(maxAttemptsText);
+    if (!Number.isInteger(maxAttempts) || maxAttempts < 1 || maxAttempts > 100) {
+        throw new CliUsageError('serve --max-auth-attempts must be an integer from 1 to 100');
+    }
     const noAuth = hasFlag(argv, '--no-auth');
-    if (!isLoopbackHost(host) && !token && !noAuth) {
-        throw new CliUsageError('serve requires --token or --no-auth when binding to non-loopback host');
+    if (!isLoopbackHost(host) && !token && !password && !noAuth) {
+        throw new CliUsageError('serve requires --token, --password, or --no-auth when binding to non-loopback host');
     }
     return {
         host,
         port,
         projectRoot: path.resolve(resolveProjectRoot(argv, context.cwd)),
+        proxy: {
+            enabled: hasFlag(argv, '--proxy') || argv.some((value) => value.startsWith('--proxy=')),
+            url: optionalFlagValue(argv, '--proxy') || DEFAULT_PROXY_URL
+        },
         auth: noAuth
-            ? { enabled: false, token: '' }
-            : { enabled: true, token: token || (context.randomToken ?? defaultRandomToken)() }
+            ? { enabled: false, token: '', password: '', maxAttempts }
+            : {
+                enabled: true,
+                token: token || (context.randomToken ?? defaultRandomToken)(),
+                password,
+                maxAttempts
+            }
     };
 }

package/dist/server/runtime.js

@@ -6,26 +6,19 @@ import { followLog as defaultFollowLog } from '../jobs/logs.js';
 const DEPLOY_SECRET_KEYS = new Set([
     'cloudflare_api_token',
     'cloudflare_global_key',
-    'pages_secret_admin',
-    'subscription_url',
-    'verify_subscription_url',
-    'secret_query',
-    'share_project_sub_value'
+    'pages_secret_admin'
 ]);
-function redactIfSet(value) {
-    return String(value ?? '').trim() ? '<redacted>' : '';
+function redactedLabel(key) {
+    return key === 'pages_secret_admin' ? '<Pages Secret ADMIN>' : '<Cloudflare Token>';
+}
+function redactIfSet(key, value) {
+    return String(value ?? '').trim() ? redactedLabel(key) : '';
 }
 export function sanitizeProfileForServer(profile) {
     const safe = structuredClone(profile ?? {});
-    for (const source of Object.values((safe.sources ?? {}))) {
-        if (source && typeof source === 'object') {
-            source.url = redactIfSet(source.url);
-            source.key = redactIfSet(source.key);
-        }
-    }
     for (const [key, value] of Object.entries((safe.deploy ?? {}))) {
         if (DEPLOY_SECRET_KEYS.has(key)) {
-            safe.deploy[key] = redactIfSet(value);
+            safe.deploy[key] = redactIfSet(key, value);
         }
     }
     return safe;
@@ -46,7 +39,7 @@ function preserveRedactedSecrets(incoming, current) {
     const deploy = (merged.deploy ?? {});
     const currentDeploy = (current.deploy ?? {});
     for (const key of DEPLOY_SECRET_KEYS) {
-        if (deploy[key] === '<redacted>') {
+        if (deploy[key] === '<redacted>' || deploy[key] === redactedLabel(key)) {
             deploy[key] = currentDeploy[key] ?? '';
         }
     }
@@ -77,6 +70,35 @@ function parseJsonLine(line) {
         return { type: 'log', message: trimmed };
     }
 }
+function eventRunState(event) {
+    if (event.type === 'run_failed') {
+        return 'failed';
+    }
+    if (event.type === 'summary') {
+        const status = String(event.run_status ?? '');
+        if (status === 'failed') {
+            return 'failed';
+        }
+        if (status === 'success') {
+            return 'success';
+        }
+        if (status === 'stopped') {
+            return 'idle';
+        }
+    }
+    return undefined;
+}
+function runEnv(options) {
+    if (!options.proxy?.enabled) {
+        return options.env;
+    }
+    const proxyUrl = String(options.proxy.url ?? '').trim() || 'http://127.0.0.1:7897';
+    return {
+        ...(options.env ?? process.env),
+        VPN_AUTOMATION_USE_UPSTREAM_PROXY: '1',
+        VPN_AUTOMATION_UPSTREAM_PROXY: proxyUrl
+    };
+}
 export function createServerRuntime(options) {
     let runState = 'idle';
     let activeJobId = '';
@@ -106,11 +128,15 @@ export function createServerRuntime(options) {
                     for (const line of String(chunk).split(/\r?\n/)) {
                         const event = parseJsonLine(line);
                         if (event) {
+                            const nextRunState = eventRunState(event);
+                            if (nextRunState) {
+                                runState = nextRunState;
+                            }
                             publish(event);
                         }
                     }
                 }
-                if (!cancelled && runState !== 'stopping') {
+                if (!cancelled && runState === 'running') {
                     runState = 'success';
                     publish({ type: 'server_state', run_state: runState });
                 }
@@ -148,16 +174,25 @@ export function createServerRuntime(options) {
                 return { ok: false, error: 'run_already_active' };
             }
             runState = 'running';
-            const job = await startDetachedRun({
-                projectRoot: options.projectRoot,
-                skipDeploy: Boolean(runOptions.skipDeploy),
-                skipVerify: Boolean(runOptions.skipVerify),
-                resumeLatest: Boolean(runOptions.resumeLatest),
-                outputFormat: 'jsonl'
-            }, {
-                env: options.env,
-                cwd: options.projectRoot
-            });
+            let job;
+            try {
+                job = await startDetachedRun({
+                    projectRoot: options.projectRoot,
+                    skipDeploy: Boolean(runOptions.skipDeploy),
+                    skipVerify: Boolean(runOptions.skipVerify),
+                    resumeLatest: Boolean(runOptions.resumeLatest),
+                    outputFormat: 'jsonl'
+                }, {
+                    env: runEnv(options),
+                    cwd: options.projectRoot
+                });
+            }
+            catch (error) {
+                runState = 'failed';
+                activeJobId = '';
+                publish({ type: 'server_state', run_state: runState });
+                throw error;
+            }
             activeJobId = String(job.job_id ?? '');
             followJob(activeJobId);
             return { ok: true, runId: activeJobId, job_id: activeJobId, status: job.status ?? 'running' };
@@ -178,7 +213,7 @@ export function createServerRuntime(options) {
                 stage,
                 outputFormat: 'jsonl'
             }, {
-                env: options.env,
+                env: runEnv(options),
                 cwd: options.projectRoot
             });
             activeJobId = String(job.job_id ?? '');
@@ -187,15 +222,25 @@ export function createServerRuntime(options) {
         },
         async stopRun() {
             if (runState !== 'running' || !activeJobId) {
-                return { ok: true, requested: false };
+                return { ok: true, requested: false, run_state: runState };
             }
             runState = 'stopping';
             publish({ type: 'server_state', run_state: runState });
-            const stopped = await stopManagedJob(options.projectRoot, activeJobId, { env: options.env });
-            unsubscribeLogs?.();
-            runState = 'idle';
-            publish({ type: 'server_state', run_state: 'idle' });
-            return { ok: true, requested: true, job_id: stopped.job_id ?? activeJobId, status: stopped.status ?? 'stopped' };
+            const jobId = activeJobId;
+            try {
+                const stopped = await stopManagedJob(options.projectRoot, jobId, { env: options.env });
+                unsubscribeLogs?.();
+                runState = 'idle';
+                activeJobId = '';
+                publish({ type: 'server_state', run_state: 'idle' });
+                return { ok: true, requested: true, job_id: stopped.job_id ?? jobId, status: stopped.status ?? 'stopped', stopped: true };
+            }
+            catch (error) {
+                unsubscribeLogs?.();
+                runState = 'failed';
+                publish({ type: 'server_state', run_state: 'failed' });
+                return { ok: false, requested: true, run_state: 'failed', error: error instanceof Error ? error.message : String(error) };
+            }
         },
         subscribe(handler) {
             subscribers.add(handler);

package/dist/server/web-adapter.js

@@ -1,8 +1,9 @@
-export function renderWebAdapterScript() {
+export function renderWebAdapterScript(options = {}) {
     return `
 (() => {
+  const passwordEnabled = ${JSON.stringify(Boolean(options.passwordEnabled))};
   const params = new URLSearchParams(window.location.search);
-  const token = params.get('token') || window.localStorage.getItem('autovpn.server.token') || '';
+  let token = params.get('token') || window.localStorage.getItem('autovpn.server.token') || '';
   if (token) {
     window.localStorage.setItem('autovpn.server.token', token);
   }
@@ -14,12 +15,129 @@ export function renderWebAdapterScript() {
     return url.pathname + url.search;
   }
 
-  async function request(path, options = {}) {
-    const headers = { ...(options.headers || {}) };
+  function ensureLoginStyles() {
+    if (document.getElementById('autovpn-server-login-style')) return;
+    const style = document.createElement('style');
+    style.id = 'autovpn-server-login-style';
+    style.textContent = [
+      '.server-login-page{position:fixed;inset:0;z-index:9999;display:grid;place-items:center;padding:28px;background:radial-gradient(circle at top left,rgba(91,92,226,.08),transparent 24%),linear-gradient(180deg,#fbfcff 0%,var(--bg,#f5f7ff) 100%);font-family:Inter,"SF Pro Display","PingFang SC","Microsoft YaHei",system-ui,sans-serif;color:var(--text,#1e2746);}',
+      '.server-login-panel{width:min(440px,calc(100vw - 40px));display:grid;gap:22px;padding:30px;border:1px solid var(--border,#dfe5f5);border-radius:20px;background:rgba(255,255,255,.96);box-shadow:var(--shadow,0 20px 44px rgba(29,39,71,.1));}',
+      '.server-login-brand{display:flex;align-items:center;gap:14px;}',
+      '.server-login-logo{width:54px;height:54px;object-fit:contain;border-radius:18px;}',
+      '.server-login-title{margin:0;font-size:28px;font-weight:850;letter-spacing:0;}',
+      '.server-login-copy{margin:5px 0 0;color:var(--text-soft,#6d7794);line-height:1.5;}',
+      '.server-login-form{display:grid;gap:14px;}',
+      '.server-login-form input{width:100%;min-height:48px;border:1px solid var(--border,#dfe5f5);border-radius:14px;background:#fff;color:var(--text,#1e2746);padding:0 14px;outline:none;}',
+      '.server-login-form input:focus{border-color:rgba(91,92,226,.45);box-shadow:0 0 0 4px rgba(91,92,226,.12);}',
+      '.server-login-form button{min-height:48px;border:0;border-radius:14px;background:var(--accent,#5b5ce2);color:#fff;font-weight:800;cursor:pointer;box-shadow:0 12px 28px rgba(91,92,226,.22);}',
+      '.server-login-form button:disabled{background:var(--border-strong,#cfd7ef);box-shadow:none;cursor:not-allowed;}',
+      '.server-login-error{min-height:22px;margin:0;color:var(--danger,#f05b69);font-weight:700;}'
+    ].join('');
+    document.head.append(style);
+  }
+
+  function loginMessage(payload) {
+    if (payload?.error === 'ip_banned') return '密码错误次数过多，此 IP 已被封禁。';
+    if (payload?.error === 'invalid_password') {
+      const remaining = Number(payload.attemptsRemaining ?? 0);
+      return '密码错误，剩余 ' + remaining + ' 次尝试。';
+    }
+    return '登录失败，请重试。';
+  }
+
+  function showLoginPage(message = '', banned = false) {
+    ensureLoginStyles();
+    let root = document.querySelector('[data-server-login]');
+    if (!root) {
+      root = document.createElement('section');
+      root.className = 'server-login-page';
+      root.setAttribute('data-server-login', '');
+      root.innerHTML = [
+        '<div class="server-login-panel">',
+        '<div class="server-login-brand">',
+        '<img class="server-login-logo" src="./assets/vpn-auto-logo-v2-minimal.svg" alt="" aria-hidden="true" />',
+        '<div>',
+        '<h1 class="server-login-title">AutoVPN</h1>',
+        '<p class="server-login-copy">输入 serve 启动时打印的密码继续访问。</p>',
+        '</div>',
+        '</div>',
+        '<form class="server-login-form" data-server-login-form>',
+        '<input data-server-password type="password" autocomplete="current-password" placeholder="密码" />',
+        '<button data-server-login-submit type="submit">登录</button>',
+        '<p class="server-login-error" data-server-login-error aria-live="polite"></p>',
+        '</form>',
+        '</div>'
+      ].join('');
+      document.body.append(root);
+    }
+    const error = root.querySelector('[data-server-login-error]');
+    const submit = root.querySelector('[data-server-login-submit]');
+    const input = root.querySelector('[data-server-password]');
+    if (error) error.textContent = message;
+    if (submit) submit.disabled = Boolean(banned);
+    if (input) {
+      input.disabled = Boolean(banned);
+      if (!banned) input.focus();
+    }
+    return root;
+  }
+
+  function hideLoginPage() {
+    document.querySelector('[data-server-login]')?.remove();
+  }
+
+  async function submitPassword(password) {
+    const response = await fetch('/api/auth/login', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ password })
+    });
+    const payload = await response.json().catch(() => ({}));
+    if (!response.ok || !payload.token) {
+      return { ok: false, status: response.status, payload };
+    }
+    token = String(payload.token);
+    window.localStorage.setItem('autovpn.server.token', token);
+    hideLoginPage();
+    return { ok: true, token };
+  }
+
+  function loginWithPassword(message = '') {
+    return new Promise((resolve, reject) => {
+      const root = showLoginPage(message);
+      const form = root.querySelector('[data-server-login-form]');
+      const input = root.querySelector('[data-server-password]');
+      form.onsubmit = async (event) => {
+        event.preventDefault();
+        const result = await submitPassword(input?.value || '');
+        if (result.ok) {
+          resolve(result.token);
+          return;
+        }
+        const banned = result.payload?.error === 'ip_banned' || result.status === 403;
+        showLoginPage(loginMessage(result.payload), banned);
+        if (banned) {
+          reject(new Error('ip_banned'));
+        }
+      };
+    });
+  }
+
+  async function request(path, requestOptions = {}) {
+    if (passwordEnabled && !token) {
+      await loginWithPassword();
+    }
+    const headers = { ...(requestOptions.headers || {}) };
     if (token) headers.Authorization = 'Bearer ' + token;
-    if (options.body && !headers['Content-Type']) headers['Content-Type'] = 'application/json';
-    const response = await fetch(path, { ...options, headers });
+    if (requestOptions.body && !headers['Content-Type']) headers['Content-Type'] = 'application/json';
+    const response = await fetch(path, { ...requestOptions, headers });
     const payload = await response.json().catch(() => ({}));
+    if (response.status === 401 && passwordEnabled) {
+      window.localStorage.removeItem('autovpn.server.token');
+      token = '';
+      await loginWithPassword('登录已过期，请重新输入密码。');
+      return request(path, requestOptions);
+    }
     if (!response.ok) {
       throw new Error(payload.error || 'request_failed');
     }

package/dist/web/renderer/app.js

@@ -1037,12 +1037,29 @@ async function stopPipeline() {
   renderAll();
   appendLog(messages.pipelineStopping);
 
-  const result = await window.vpnAutomation.stopPipeline();
-  if (!result?.ok) {
-    state.runState = 'running';
-    touchUpdate();
-    renderAll();
-    appendLog(messages.stopUnavailable);
+  try {
+    const result = await window.vpnAutomation.stopPipeline();
+    if (!result?.ok) {
+      finishRun({ ok: false, error: result?.error || messages.stopUnavailable });
+      return;
+    }
+    if (result.requested === false) {
+      if (result.run_state === 'failed') {
+        finishRun({ ok: false, error: result.error || messages.stopUnavailable });
+      } else {
+        state.runState = 'idle';
+        state.runStartedAt = null;
+        touchUpdate();
+        renderAll();
+        appendLog(messages.stopUnavailable);
+      }
+      return;
+    }
+    if (result.stopped || result.status === 'stopped') {
+      finishRun({ stopped: true });
+    }
+  } catch (error) {
+    finishRun({ ok: false, error: error.message });
   }
 }
 
@@ -1081,6 +1098,31 @@ function finishRun(result = {}) {
 }
 
 function handlePipelineEvent(event) {
+  if (event.type === 'server_state') {
+    const nextRunState = String(event.run_state ?? '');
+    if (['idle', 'running', 'stopping', 'failed', 'success'].includes(nextRunState)) {
+      state.runState = nextRunState === 'success' ? 'idle' : nextRunState;
+      if (['idle', 'failed', 'success'].includes(nextRunState)) {
+        state.runStartedAt = null;
+      }
+      if (nextRunState === 'failed') {
+        state.runResult = 'failed';
+      } else if (nextRunState === 'success') {
+        state.runResult = 'success';
+      }
+      touchUpdate();
+      renderAll();
+    }
+    return;
+  }
+
+  if (event.type === 'run_failed') {
+    if (state.runState !== 'idle' || state.runResult !== 'failed') {
+      finishRun({ ok: false, error: event.error });
+    }
+    return;
+  }
+
   if (event.type === 'log') {
     appendLog(event.message);
     return;
@@ -1117,18 +1159,76 @@ function handlePipelineEvent(event) {
     }
     state.artifactDir = event.artifact_dir ?? '';
     state.selectedRetryArtifactDir = state.artifactDir || state.selectedRetryArtifactDir;
+    appendLog(`[summary] artifacts: ${event.artifact_dir}`);
+    const runStatus = String(event.run_status ?? '');
+    if (runStatus === 'failed') {
+      finishRun({ ok: false, error: event.error });
+      hydrateArtifactPreview();
+      return;
+    }
+    if (runStatus === 'success') {
+      finishRun({ ok: true, code: 0 });
+      hydrateArtifactPreview();
+      return;
+    }
+    if (runStatus === 'stopped') {
+      finishRun({ stopped: true });
+      hydrateArtifactPreview();
+      return;
+    }
     touchUpdate();
     renderAll();
-    appendLog(`[summary] artifacts: ${event.artifact_dir}`);
     hydrateArtifactPreview();
     void hydrateRetryArtifacts();
     return;
   }
 
+  if (event.type === 'extract_source_started') {
+    appendLog(`[extract] ${event.source_name} 开始提取，最多 ${event.requested_iterations ?? 0} 次，最少 ${event.min_iterations ?? 0} 次`, {
+      kind: 'stage',
+      stage: 'extract',
+      level: 'info'
+    });
+    return;
+  }
+
+  if (event.type === 'extract_request_result') {
+    const status = event.success ? '成功' : '失败';
+    const retry = event.will_retry ? '，将重试' : '';
+    appendLog(`[extract] ${event.source_name} #${event.iteration} ${event.via} ${status}${retry}`, {
+      kind: 'stage',
+      stage: 'extract',
+      level: event.success ? 'info' : 'warning'
+    });
+    return;
+  }
+
+  if (event.type === 'extract_decrypt_result' && !event.success) {
+    appendLog(`[extract] ${event.source_name} #${event.iteration} 解密失败`, {
+      kind: 'stage',
+      stage: 'extract',
+      level: 'error'
+    });
+    return;
+  }
+
+  if (event.type === 'extract_source_completed') {
+    updateExtractMetrics({ source_name: event.source_name, total_links: event.raw_links });
+    appendLog(`[extract] ${event.source_name} 完成，成功 ${event.successful_iterations ?? 0} 次，失败 ${event.failed_iterations ?? 0} 次，原始节点 ${event.raw_links ?? 0} 个`, {
+      kind: 'stage',
+      stage: 'extract',
+      level: 'info'
+    });
+    return;
+  }
+
   if (event.type === 'extract_iteration') {
     updateExtractMetrics(event);
-    touchUpdate();
-    renderRuntimeOnly({ chrome: false });
+    appendLog(`[extract] ${event.source_name} #${event.iteration ?? 0} 新增 ${event.new_items ?? 0} 个，本次解析 ${event.extracted_links ?? 0} 个，累计 ${event.total_links ?? 0} 个`, {
+      kind: 'stage',
+      stage: 'extract',
+      level: 'info'
+    });
     return;
   }
 

package/dist/web/renderer/i18n.js

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

package/dist/web/renderer/styles.css

@@ -94,6 +94,10 @@ textarea:focus {
   min-height: 0;
 }
 
+body[data-runtime="web"] .app-frame {
+  grid-template-rows: minmax(0, 1fr);
+}
+
 .window-titlebar {
   -webkit-app-region: drag;
   user-select: none;
@@ -102,6 +106,10 @@ textarea:focus {
   backdrop-filter: blur(16px);
 }
 
+body[data-runtime="web"] .window-titlebar {
+  display: none;
+}
+
 .app-content-shell {
   min-height: 0;
   overflow: hidden;

package/dist/web/renderer/views.js

@@ -1005,6 +1005,7 @@ export function applySourceIterationDraft(sources = {}, draft = {}) {
       {
         ...source,
         max_iterations: maxIterations,
+        min_iterations: Math.min(coercePositiveInteger(source.min_iterations, 0), maxIterations),
         area_min: Math.min(areaMin, areaMax),
         area_max: Math.max(areaMin, areaMax)
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swimmingliu/autovpn",
-  "version": "1.5.4",
+  "version": "1.6.0",
   "description": "npm wrapper for the AutoVPN headless CLI",
   "type": "module",
   "repository": {