@swimmingliu/autovpn 1.6.1 → 1.6.2

package/dist/backend/node-backend.js

@@ -5,7 +5,7 @@ import { resumeNodePipeline, retryNodePipelineStage, runNodePipeline } from '../
 import { resolveArtifactsRoot } from '../runtime/paths.js';
 const require = createRequire(import.meta.url);
 function unsupported(method) {
-    return new Error(`Node backend ${method} is not available yet; use AUTOVPN_BACKEND=python`);
+    return new Error(`Node backend ${method} is not available in this execution path`);
 }
 function latestIncompleteRunArtifact(projectRoot, env) {
     const artifactsRoot = resolveArtifactsRoot(projectRoot, env);

package/dist/backend/select-backend.js

@@ -1,9 +1,8 @@
 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);
+        throw new Error('AUTOVPN_BACKEND=python is no longer supported; AutoVPN now runs on the NodeJS engine');
     }
     if (backend && backend !== 'node') {
         throw new Error(`Unsupported AUTOVPN_BACKEND: ${backend}`);

package/dist/cli/main.js

@@ -35,6 +35,10 @@ async function defaultReadStdin() {
 function isEnabled(value) {
     return ['1', 'true', 'yes', 'on'].includes(String(value ?? '').trim().toLowerCase());
 }
+function wantsDeprecatedPythonShell(env) {
+    return String(env.AUTOVPN_CLI_SHELL ?? '').trim().toLowerCase() === 'python'
+        || String(env.AUTOVPN_BACKEND ?? '').trim().toLowerCase() === 'python';
+}
 async function resolvePackageVersion(options) {
     if (options.packageVersion) {
         return options.packageVersion;
@@ -86,6 +90,20 @@ function resolveResumeSessionDir(job) {
     }
     return '';
 }
+async function waitForServeShutdown(server) {
+    let closing;
+    const closeOnce = () => {
+        closing ??= server.close();
+        return closing;
+    };
+    await new Promise((resolve) => {
+        const shutdown = () => {
+            void closeOnce().finally(resolve);
+        };
+        process.once('SIGINT', shutdown);
+        process.once('SIGTERM', shutdown);
+    });
+}
 async function runForegroundPipeline(argv, backend, io, cwd) {
     if (backend.kind !== 'node') {
         return undefined;
@@ -183,8 +201,9 @@ export async function runCliShell(argv, options = {}) {
     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 (wantsDeprecatedPythonShell(env)) {
+        io.writeStderr('autovpn: Python backend is no longer supported; AutoVPN now runs on the NodeJS engine\n');
+        return 2;
     }
     if (isEnabled(env.AUTOVPN_WRAPPER_PROBE) && argv.length === 1 && argv[0] === '--version') {
         return 42;
@@ -233,27 +252,17 @@ export async function runCliShell(argv, options = {}) {
                 await server.close();
                 return 0;
             }
-            await new Promise(() => { });
+            await waitForServeShutdown(server);
             return 0;
         }
-        let pythonFallbackBackend;
-        const runExplicitPythonFallback = (fallbackArgv) => {
-            pythonFallbackBackend ??= createBackend({
-                env: { ...env, AUTOVPN_BACKEND: 'python' },
-                cwd,
-                runForwarder
-            });
-            return pythonFallbackBackend.executeCli(fallbackArgv);
-        };
         if (isPipelineProxyCommand(normalizedArgv)) {
-            return runExplicitPythonFallback(normalizedArgv);
+            throw new Error('--proxy is now handled by serve and Node runtime proxy settings; Python proxy mode is no longer supported');
         }
         const nativeResult = await runNativeCommand(normalizedArgv, {
             cwd,
             env,
             io,
             readStdin: options.readStdin ?? defaultReadStdin,
-            pythonFallback: runExplicitPythonFallback,
             spawn: options.spawn,
             now: options.now,
             jobId: options.jobId,

package/dist/cli/native-commands.js

@@ -8,12 +8,18 @@ import { publicStartedPayload, startDetachedResume, startDetachedRetry, startDet
 import { followLog } from '../jobs/logs.js';
 import { latestJobId, listJobs, loadJob, publicJobPayload, singleActiveJobId, tailLog } from '../jobs/read.js';
 import { readOptionValue, resolveProjectRoot } from '../runtime/paths.js';
-function wantsPython(env, key) {
-    return String(env[key] ?? '').trim().toLowerCase() === 'python';
-}
 function jsonLine(payload) {
     return `${JSON.stringify(payload)}\n`;
 }
+function renderDoctorHuman(payload) {
+    const checks = Array.isArray(payload.checks) ? payload.checks : [];
+    const lines = [`doctor: ${payload.ok ? 'ok' : 'failed'}`];
+    for (const item of checks) {
+        const check = item;
+        lines.push(`[${String(check.status ?? 'unknown')}] ${String(check.name ?? 'check')}: ${String(check.message ?? '')}`);
+    }
+    return `${lines.join('\n')}\n`;
+}
 function positionalAfter(argv, start) {
     for (let index = start; index < argv.length; index += 1) {
         const value = argv[index];
@@ -66,17 +72,13 @@ export async function runNativeCommand(argv, context) {
     const projectRoot = resolveProjectRoot(argv, context.cwd);
     const command = argv[0];
     if (command === 'doctor') {
-        if (wantsPython(context.env, 'AUTOVPN_DOCTOR_BACKEND'))
-            return context.pythonFallback(argv);
-        if (readOptionValue(argv, '--output') !== 'json')
-            return undefined;
         const result = await runDoctor(projectRoot, argv, context.env);
-        context.io.writeStdout(jsonLine(result.payload));
+        context.io.writeStdout(readOptionValue(argv, '--output') === 'json'
+            ? jsonLine(result.payload)
+            : renderDoctorHuman(result.payload));
         return result.code;
     }
     if (command === 'profile') {
-        if (wantsPython(context.env, 'AUTOVPN_PROFILE_BACKEND'))
-            return context.pythonFallback(argv);
         if (argv[1] === 'show') {
             context.io.writeStdout(jsonLine(profilePayload(projectRoot, context.env)));
             return 0;
@@ -92,8 +94,6 @@ export async function runNativeCommand(argv, context) {
         }
     }
     if (command === 'artifacts') {
-        if (wantsPython(context.env, 'AUTOVPN_ARTIFACTS_BACKEND'))
-            return context.pythonFallback(argv);
         const subcommand = argv[1];
         if (subcommand === 'latest') {
             context.io.writeStdout(jsonLine(artifactLatest(projectRoot, context.env)));

package/dist/jobs/commands.js

@@ -5,23 +5,12 @@ import { fileURLToPath } from 'node:url';
 import { publicJobPayload } from './read.js';
 import { createJobStore } from './store.js';
 import { processMatchesJob as defaultProcessMatchesJob, terminateProcessGroup } from './process.js';
-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 defaultResolveNodeCli() {
     const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
     return { command: process.execPath, args: [path.join(packageRoot, 'bin', 'autovpn.mjs')] };
 }
-function wantsNodeWorker(env) {
-    return String(env.AUTOVPN_BACKEND ?? '').trim().toLowerCase() !== 'python';
-}
-async function resolveDetachedWorker(env, options) {
-    if (wantsNodeWorker(env)) {
-        return defaultResolveNodeCli();
-    }
-    return options.resolvePythonCli ? await options.resolvePythonCli() : await defaultResolvePythonCli(env);
+async function resolveDetachedWorker(_env, _options) {
+    return defaultResolveNodeCli();
 }
 function pushFlag(argv, enabled, flag) {
     if (enabled)
@@ -117,7 +106,7 @@ export async function startDetachedResume(command, options = {}) {
         options: { source_job_id: command.sourceJobId, session_dir: command.sessionDir, output_format: outputFormat },
         resumeFrom: command.sessionDir
     });
-    const pythonArgs = [
+    const resumeArgs = [
         'resume',
         'pipeline',
         '--project-root',
@@ -131,8 +120,8 @@ export async function startDetachedResume(command, options = {}) {
         '--human-log',
         String(job.human_log)
     ];
-    job.command = [resolved.command, ...resolved.args, ...pythonArgs];
-    const child = spawnDetached(resolved.command, [...resolved.args, ...pythonArgs], job, options);
+    job.command = [resolved.command, ...resolved.args, ...resumeArgs];
+    const child = spawnDetached(resolved.command, [...resolved.args, ...resumeArgs], job, options);
     job.pid = Number(child.pid ?? 0);
     job.pgid = Number(child.pid ?? 0);
     return jobStore.writeJob(job);
@@ -149,7 +138,7 @@ export async function startDetachedRetry(command, options = {}) {
         options: { artifact_dir: command.artifactDir, stage: command.stage, output_format: outputFormat },
         retry
     });
-    const pythonArgs = [
+    const retryArgs = [
         'retry-stage',
         '--project-root',
         command.projectRoot,
@@ -164,8 +153,8 @@ export async function startDetachedRetry(command, options = {}) {
         '--human-log',
         String(job.human_log)
     ];
-    job.command = [resolved.command, ...resolved.args, ...pythonArgs];
-    const child = spawnDetached(resolved.command, [...resolved.args, ...pythonArgs], job, options);
+    job.command = [resolved.command, ...resolved.args, ...retryArgs];
+    const child = spawnDetached(resolved.command, [...resolved.args, ...retryArgs], job, options);
     job.pid = Number(child.pid ?? 0);
     job.pgid = Number(child.pid ?? 0);
     return jobStore.writeJob(job);

package/dist/pipeline/availability.js

@@ -199,6 +199,24 @@ function emitEvent(callback, eventType, payload) {
         callback(eventType, payload);
     }
 }
+async function mapWithConcurrency(items, concurrency, worker, onComplete) {
+    const limit = Math.max(1, Math.trunc(Number(concurrency) || 1));
+    const results = new Array(items.length);
+    let nextIndex = 0;
+    let completed = 0;
+    async function runWorker() {
+        while (nextIndex < items.length) {
+            const index = nextIndex;
+            nextIndex += 1;
+            const result = await worker(items[index], index);
+            results[index] = result;
+            completed += 1;
+            onComplete?.(result, index, completed);
+        }
+    }
+    await Promise.all(Array.from({ length: Math.min(limit, items.length) }, () => runWorker()));
+    return results;
+}
 function numberOrDefault(value, fallback) {
     const parsed = Number(value);
     return Number.isFinite(parsed) ? parsed : fallback;
@@ -584,9 +602,7 @@ async function checkBatchInNode(input, options) {
             runtimePath: input.runtime_path ?? ''
         })
         : checkLinkAvailabilityDirect(speedResult, config, { targets, fetch: options.fetch })));
-    const output = [];
-    for (let index = 0; index < input.results.length; index += 1) {
-        const speedResult = input.results[index];
+    return mapWithConcurrency(input.results, numberOrDefault(input.config.concurrency, 1), async (speedResult) => {
         let availability;
         try {
             availability = availabilityResultToDict(await checkLinkAvailability(speedResult, input.config, {
@@ -597,8 +613,8 @@ async function checkBatchInNode(input, options) {
         catch (error) {
             availability = buildRuntimeErrorResult(speedResult, error instanceof Error ? error.message : String(error), targets);
         }
-        output.push(availability);
-        const completed = index + 1;
+        return availability;
+    }, (availability, _index, completed) => {
         if (options.progressCallback) {
             const statuses = Object.entries(availability.provider_results)
                 .map(([name, provider]) => `${name}=${provider.passed ? 'ok' : provider.reason}`)
@@ -612,15 +628,12 @@ async function checkBatchInNode(input, options) {
             all_passed: availability.all_passed,
             provider_results: availability.provider_results
         });
-    }
-    return output;
+    });
 }
 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';
+    void stage;
+    void env;
+    return 'node';
 }
 async function defaultResolvePythonCli(env) {
     // @ts-expect-error Phase 1 runner remains plain ESM JavaScript.

package/dist/pipeline/dedupe.js

@@ -41,11 +41,9 @@ export function dedupeVmessLinks(links) {
     return result;
 }
 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';
+    void stage;
+    void env;
+    return 'node';
 }
 async function defaultResolvePythonCli(env) {
     // @ts-expect-error Phase 1 runner remains plain ESM JavaScript.

package/dist/pipeline/deploy.js

@@ -720,11 +720,9 @@ export async function cleanupBlockedPagesProjects(deploy, deployment, client) {
     return { cleanup_deleted: deletedAny, cleanup_errors: errors };
 }
 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';
+    void stage;
+    void env;
+    return 'node';
 }
 async function defaultResolvePythonCli(env) {
     // @ts-expect-error Phase 1 runner remains plain ESM JavaScript.

package/dist/pipeline/extract.js

@@ -65,6 +65,27 @@ function generateVmessLink(payload) {
     const encoded = Buffer.from(json, 'utf8').toString('base64').replaceAll('+', '-').replaceAll('/', '_');
     return `vmess://${encoded}`;
 }
+function linkFingerprint(link) {
+    try {
+        const encoded = String(link).replace(/^vmess:\/\//, '');
+        const padded = encoded + '='.repeat((4 - (encoded.length % 4)) % 4);
+        const payload = JSON.parse(Buffer.from(padded, 'base64url').toString('utf8'));
+        const canonical = JSON.stringify([
+            payload.add ?? '',
+            payload.port ?? '',
+            payload.id ?? '',
+            payload.net ?? '',
+            payload.host ?? '',
+            payload.path ?? '',
+            payload.tls ?? '',
+            payload.sni ?? ''
+        ].map((value) => String(value)));
+        return crypto.createHash('sha256').update(canonical).digest('hex');
+    }
+    catch {
+        return crypto.createHash('sha256').update(String(link)).digest('hex');
+    }
+}
 function payloadFromOutboundConfig(psName, jsonText) {
     const config = JSON.parse(jsonText);
     const outbound = (config.outbounds ?? []).find((item) => item.protocol === 'vmess');
@@ -108,11 +129,9 @@ export function extractLinksFromPlaintext(sourceName, plaintext) {
     return [generateVmessLink(payloadFromOutboundConfig(psName, jsonText))];
 }
 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';
+    void stage;
+    void env;
+    return 'node';
 }
 async function defaultResolvePythonCli(env) {
     // @ts-expect-error Phase 1 runner remains plain ESM JavaScript.
@@ -257,7 +276,7 @@ async function fetchSourceLinksInNode(input, options) {
     const maxIterations = Math.max(0, Math.trunc(numberOrDefault(source.max_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 plateauLimit = Math.max(1, Math.trunc(numberOrDefault(source.plateau_limit, 20)));
     const failureLimit = Math.max(1, Math.trunc(numberOrDefault(source.failure_limit, 1)));
     const maxRuntimeSeconds = Math.max(0, numberOrDefault(source.max_runtime_seconds, 0));
     const startIteration = Math.max(1, Math.trunc(numberOrDefault(source.resume_from_iteration, 1)));
@@ -317,13 +336,17 @@ async function fetchSourceLinksInNode(input, options) {
             successes += 1;
             failures = 0;
             let newItems = 0;
+            const newLinks = [];
+            const newItemFingerprints = [];
             for (const link of extracted) {
                 if (seen.has(link)) {
                     continue;
                 }
                 seen.add(link);
                 links.push(link);
+                newLinks.push(link);
                 newItems += 1;
+                newItemFingerprints.push(linkFingerprint(link));
             }
             emitExtractEvent(options, 'extract_iteration', {
                 source_name: input.source_name,
@@ -331,8 +354,13 @@ async function fetchSourceLinksInNode(input, options) {
                 requested_iterations: maxIterations,
                 new_items: newItems,
                 extracted_links: extracted.length,
-                total_links: links.length
+                total_links: links.length,
+                deduped_links: links.length,
+                new_item_fingerprints: newItemFingerprints
             });
+            if (newItems > 0) {
+                await options.linksCallback?.(newLinks);
+            }
             plateau = newItems === 0 ? plateau + 1 : 0;
             if (plateau >= plateauLimit && attempt >= minIterations) {
                 break;

package/dist/pipeline/obfuscate.js

@@ -140,11 +140,9 @@ export function buildWorkerArtifacts(renderedSource, configInput = {}, secretQue
     };
 }
 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';
+    void stage;
+    void env;
+    return 'node';
 }
 async function defaultResolvePythonCli(env) {
     // @ts-expect-error Phase 1 runner remains plain ESM JavaScript.