@swimmingliu/autovpn 1.6.5 → 1.6.7

package/README.md

@@ -1,6 +1,7 @@
 # AutoVPN CLI
 
-Node-first npm CLI for AutoVPN headless and Agent workflows.
+Node.js npm CLI for AutoVPN headless and Agent workflows. Node.js `>=22.5.0`
+is required.
 
 ## Usage
 
@@ -53,78 +54,30 @@ terminator for internet-facing deployments.
 
 ## Runtime Shape
 
-The CLI is currently Node-first with explicit Python rollback:
+The CLI owns command parsing, profiles, artifacts, detached jobs, pipeline
+execution, Cloudflare deployment, verification, and the server Web UI.
 
-- Node.js handles `--help`, `--version`, argument validation, `doctor --output json`, `profile summary --json`, `artifacts latest/list/preview`, `status --json`, `logs`, read-only `jobs` commands, and detached job management.
-- Node is the default backend for pipeline actions. Detached run/resume/retry workers spawn the Node CLI worker.
-- Plain Cloudflare Pages deploy, primary blocked-project fallback, share-project `SUB` sync, share-project fallback, custom-domain binding, custom-domain DNS upsert, and verify are Node-native. Python backend and stage fallback remain available for rollback.
-
-Node-orchestrated foreground run:
+Foreground run:
 
 ```bash
 autovpn run --project-root . --output jsonl
 ```
 
-Current Node backend notes:
+Runtime notes:
 
 - Detached job management runs in Node for `run --detach`, `jobs resume --detach`, and `jobs retry --detach`; detached run/resume/retry workers also use the Node CLI worker.
 - Non-detached `retry-stage` runs through the Node backend for retryable artifact stages from `speedtest` through `verify`; non-detached `resume pipeline`, `resume speedtest`, and `run --resume-latest` continue existing sessions through the Node backend.
 - Add `--skip-deploy --skip-verify` when you want an offline Node pipeline check.
 - Plain Node foreground deploy/verify runs use Node for Wrangler deploy, primary blocked-project fallback, share-project sync/fallback, custom-domain binding, custom-domain DNS upsert, and verify.
-- Deploy and verify can be rolled back with `AUTOVPN_STAGE_BACKEND_DEPLOY=python` and `AUTOVPN_STAGE_BACKEND_VERIFY=python`.
-- `AUTOVPN_NO_PYTHON=1` disables implicit Python backend resolution and default Python runtime stage fallback. Use it as a v3 readiness gate. Empty offline runs now complete in Node. Speedtest and availability use the per-node Mihomo runtime by default so candidate measurements and provider checks traverse each candidate node. Set `AUTOVPN_SPEEDTEST_RUNTIME=direct` or `AUTOVPN_AVAILABILITY_RUNTIME=direct` only for direct-host diagnostic checks.
+- Empty offline runs complete without requiring an external language runtime. Speedtest and availability use the per-node Mihomo runtime by default so candidate measurements and provider checks traverse each candidate node. Set `AUTOVPN_SPEEDTEST_RUNTIME=direct` or `AUTOVPN_AVAILABILITY_RUNTIME=direct` only for direct-host diagnostic checks.
 - Project `.env` is loaded before resolving profile and artifact paths. Explicit process environment values still win over `.env`.
 - `autovpn serve` is Node-native and exposes the browser UI plus `/api/health`,
   `/api/state`, `/api/runs`, `/api/runs/current/stop`, and `/api/events`.
 
-Fallback flags for migrated commands:
-
-```bash
-AUTOVPN_CLI_SHELL=python autovpn <args>
-AUTOVPN_BACKEND=python autovpn run --project-root . --output jsonl
-AUTOVPN_DOCTOR_BACKEND=python autovpn doctor --output json
-AUTOVPN_PROFILE_BACKEND=python autovpn profile summary --json
-AUTOVPN_ARTIFACTS_BACKEND=python autovpn artifacts latest
-```
-
-Job state, logs, stop, detached run, detached resume, and detached retry commands are Node-owned in v3 and intentionally ignore the old `AUTOVPN_JOBS_BACKEND` rollback flag.
-
-## Python Backend Resolution
-
-When a command still needs Python, the wrapper resolves the backend in this order:
-
-1. `AUTOVPN_PYTHON_CLI`
-2. PATH `autovpn`, accepted only when `autovpn --version` matches this npm package version
-3. wrapper-managed Python virtual environment under `AUTOVPN_CACHE_DIR` or the user cache
-
-For Python-backed commands, the wrapper forwards argv, stdin, stdout, stderr, and exit code.
-
 ## Environment
 
-- `AUTOVPN_CACHE_DIR`
-- `AUTOVPN_WHEEL_URL`
-- `AUTOVPN_PYTHON_PACKAGE`
-- `AUTOVPN_PIP_INDEX_URL`
-- `AUTOVPN_PIP_EXTRA_INDEX_URL`
 - `AUTOVPN_NO_INSTALL`
 - `AUTOVPN_FORCE_INSTALL`
-- `AUTOVPN_ALLOW_VERSION_MISMATCH`
-- `AUTOVPN_PYTHON_CLI`
-- `AUTOVPN_CLI_SHELL`
-- `AUTOVPN_BACKEND`
-- `AUTOVPN_PIPELINE_BACKEND`
-- `AUTOVPN_STAGE_BACKEND_EXTRACT`
-- `AUTOVPN_STAGE_BACKEND_DEDUPE`
-- `AUTOVPN_STAGE_BACKEND_SPEEDTEST`
-- `AUTOVPN_STAGE_BACKEND_AVAILABILITY`
-- `AUTOVPN_STAGE_BACKEND_POSTPROCESS`
-- `AUTOVPN_STAGE_BACKEND_RENDER`
-- `AUTOVPN_STAGE_BACKEND_OBFUSCATE`
-- `AUTOVPN_STAGE_BACKEND_DEPLOY`
-- `AUTOVPN_STAGE_BACKEND_VERIFY`
-- `AUTOVPN_DOCTOR_BACKEND`
-- `AUTOVPN_PROFILE_BACKEND`
-- `AUTOVPN_ARTIFACTS_BACKEND`
 - `AUTOVPN_SERVER_HOST`
 - `AUTOVPN_SERVER_PORT`
 - `AUTOVPN_SERVER_TOKEN`

package/dist/backend/select-backend.js

@@ -1,9 +1,6 @@
 import { NodeBackend } from './node-backend.js';
 export function selectBackend(options = {}) {
     const backend = String(options.env?.AUTOVPN_BACKEND ?? '').trim().toLowerCase();
-    if (backend === 'python') {
-        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/commands/index.js

@@ -79,6 +79,10 @@ export function validateCommand(argv) {
     if (!TOP_LEVEL_COMMANDS.has(command)) {
         throw new CliUsageError(`unknown command: ${command}`);
     }
+    const internalJobToken = readOptionValue(argv, '--internal-job-token');
+    if (internalJobToken !== undefined && !/^[a-f0-9]{64}$/i.test(internalJobToken)) {
+        throw new CliUsageError('invalid internal job token');
+    }
     if (command === 'doctor') {
         validateChoice('doctor', '--output', readOptionValue(argv, '--output'), ['human', 'json']);
         return;

package/dist/cli/main.js

@@ -1,5 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { validateCommand } from './commands/index.js';
 import { CliUsageError } from './errors.js';
 import { normalizeProjectRootArgs } from './global-options.js';
@@ -13,18 +14,13 @@ import { createAutoVpnServer } from '../server/http.js';
 import { parseServeOptions } from '../server/options.js';
 import { createServerRuntime } from '../server/runtime.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());
+    const packagePath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..', 'package.json');
+    const manifest = JSON.parse(await fs.promises.readFile(packagePath, 'utf8'));
+    return String(manifest.version ?? '');
 }
 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) {
@@ -32,13 +28,6 @@ async function defaultReadStdin() {
     }
     return Buffer.concat(chunks).toString('utf8');
 }
-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;
@@ -199,15 +188,7 @@ async function runForegroundPipeline(argv, backend, io, cwd) {
 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 (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;
-    }
     if (argv[0] === '--help' || argv[0] === '-h') {
         io.writeStdout(renderHelp());
         return 0;
@@ -220,7 +201,7 @@ export async function runCliShell(argv, options = {}) {
         const normalizedArgv = normalizeProjectRootArgs(argv, cwd);
         validateCommand(normalizedArgv);
         const createBackend = options.createBackend ?? defaultCreateBackend;
-        const backend = createBackend({ env, cwd, runForwarder });
+        const backend = createBackend({ env, cwd });
         if (normalizedArgv[0] === 'serve') {
             const serveOptions = parseServeOptions(normalizedArgv, { cwd, env });
             const serverFactory = options.createServer ?? createAutoVpnServer;
@@ -256,7 +237,7 @@ export async function runCliShell(argv, options = {}) {
             return 0;
         }
         if (isPipelineProxyCommand(normalizedArgv)) {
-            throw new Error('--proxy is now handled by serve and Node runtime proxy settings; Python proxy mode is no longer supported');
+            throw new Error('--proxy is handled by serve and Node runtime proxy settings');
         }
         const nativeResult = await runNativeCommand(normalizedArgv, {
             cwd,
@@ -266,6 +247,7 @@ export async function runCliShell(argv, options = {}) {
             spawn: options.spawn,
             now: options.now,
             jobId: options.jobId,
+            jobToken: options.jobToken,
             sleep: options.sleep
         });
         if (nativeResult !== undefined) {

package/dist/cli/native-commands.js

@@ -47,6 +47,7 @@ function jobOptions(context) {
         spawn: context.spawn,
         now: context.now,
         jobId: context.jobId,
+        jobToken: context.jobToken,
         sleep: context.sleep
     };
 }

package/dist/doctor/checks.js

@@ -5,6 +5,7 @@ import { spawnSync } from 'node:child_process';
 import { parse } from '@iarna/toml';
 import { profileSummary } from '../config/profile.js';
 import { resolveArtifactsRoot, resolveProfilePath } from '../runtime/paths.js';
+import { resolveShareWorkerTemplatePath, resolveWorkerTemplatePath } from '../runtime/templates.js';
 import { normalizeManagedToolCommandForSpawn, resolveManagedNpmTool } from '../runtime/managed-tools.js';
 const JAVASCRIPT_OBFUSCATOR_VERSION = '5.4.3';
 const WRANGLER_VERSION = '4.106.0';
@@ -201,13 +202,27 @@ export async function runDoctor(projectRoot, argv, env = process.env, options =
     const configuredSources = sourceValues.filter((source) => source.enabled && source.url === 'set' && source.key === 'set');
     const nodeToolChecks = await checkNodeTools(projectRoot, env, options);
     const cloudflareChecks = await checkCloudflare(summary, deploy, env, projectRoot, options);
+    let workerTemplatePath = '';
+    let shareWorkerTemplatePath = '';
+    try {
+        workerTemplatePath = resolveWorkerTemplatePath(projectRoot);
+    }
+    catch {
+        workerTemplatePath = '';
+    }
+    try {
+        shareWorkerTemplatePath = resolveShareWorkerTemplatePath(projectRoot, env);
+    }
+    catch {
+        shareWorkerTemplatePath = '';
+    }
     const checks = [
         check('node_version', 'pass', `Node ${process.versions.node}`, { required: '>=20' }),
         check('project_root', 'pass', 'Project root resolved', { path: projectRoot }),
         check('profile_path', pathWritable(profilePath) ? 'pass' : 'fail', pathWritable(profilePath) ? 'Profile is readable and writable' : 'Profile path is not writable', { profile_path: profilePath, exists: fs.existsSync(profilePath) }),
         check('artifacts_root', pathWritable(artifactsRoot) ? 'pass' : 'fail', pathWritable(artifactsRoot) ? 'Artifacts root is writable' : 'Artifacts root is not writable', { path: artifactsRoot }),
-        check('worker_template', fs.existsSync(path.join(projectRoot, 'templates', 'vmess_node.js')) ? 'pass' : 'fail', fs.existsSync(path.join(projectRoot, 'templates', 'vmess_node.js')) ? 'Worker template exists' : 'Worker template is missing', { path: path.join(projectRoot, 'templates', 'vmess_node.js') }),
-        check('share_worker_template', fs.existsSync(path.join(projectRoot, 'templates', 'share-worker', 'vpn.js')) ? 'pass' : 'warn', fs.existsSync(path.join(projectRoot, 'templates', 'share-worker', 'vpn.js')) ? 'Share worker template exists' : 'Share worker template is missing', { path: path.join(projectRoot, 'templates', 'share-worker', 'vpn.js') }),
+        check('worker_template', workerTemplatePath ? 'pass' : 'fail', workerTemplatePath ? 'Worker template exists' : 'Worker template is missing', { path: workerTemplatePath || path.join(projectRoot, 'templates', 'vmess_node.js') }),
+        check('share_worker_template', shareWorkerTemplatePath ? 'pass' : 'warn', shareWorkerTemplatePath ? 'Share worker template exists' : 'Share worker template is missing', { path: shareWorkerTemplatePath || path.join(projectRoot, 'templates', 'share-worker', 'vpn.js') }),
         configuredSources.length
             ? check('sources', 'pass', 'At least one enabled source is configured', { configured_count: configuredSources.length })
             : check('sources', 'warn', 'No enabled source has both URL and key configured', { configured_count: 0, key_state: 'missing' }),

package/dist/jobs/commands.js

@@ -1,5 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import { randomBytes } from 'node:crypto';
 import { spawn as defaultSpawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { publicJobPayload } from './read.js';
@@ -16,6 +17,13 @@ function pushFlag(argv, enabled, flag) {
     if (enabled)
         argv.push(flag);
 }
+function createJobToken(options) {
+    const token = options.jobToken?.() ?? randomBytes(32).toString('hex');
+    if (!/^[a-f0-9]{64}$/i.test(token)) {
+        throw new Error('internal job token must be 64 hexadecimal characters');
+    }
+    return token.toLowerCase();
+}
 function spawnDetached(command, args, job, options) {
     const stdoutFd = fs.openSync(String(job.stdout_log), 'a');
     const stderrFd = fs.openSync(String(job.stderr_log), 'a');
@@ -79,6 +87,7 @@ export async function startDetachedRun(command, options = {}) {
             output_format: outputFormat
         }
     });
+    runArgs.push('--internal-job-token', createJobToken(options));
     runArgs.push('--event-log', String(job.event_log), '--human-log', String(job.human_log));
     pushFlag(runArgs, command.resumeLatest, '--resume-latest');
     pushFlag(runArgs, command.skipDeploy, '--skip-deploy');
@@ -115,6 +124,8 @@ export async function startDetachedResume(command, options = {}) {
         command.sessionDir,
         '--output',
         outputFormat,
+        '--internal-job-token',
+        createJobToken(options),
         '--event-log',
         String(job.event_log),
         '--human-log',
@@ -148,6 +159,8 @@ export async function startDetachedRetry(command, options = {}) {
         command.stage,
         '--output',
         outputFormat,
+        '--internal-job-token',
+        createJobToken(options),
         '--event-log',
         String(job.event_log),
         '--human-log',

package/dist/jobs/process.js

@@ -1,22 +1,104 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { spawnSync as defaultSpawnSync } from 'node:child_process';
-export function processMatchesJob(pid, command) {
-    const cmdlinePath = path.join('/proc', String(pid), 'cmdline');
-    if (!fs.existsSync(cmdlinePath)) {
-        return true;
+function resolvedArg(value) {
+    if (!path.isAbsolute(value)) {
+        return value;
     }
     try {
-        const cmdline = fs.readFileSync(cmdlinePath).toString('utf8').replaceAll('\0', ' ');
-        const markers = ['vpn_automation.backend'];
-        if (command.length > 0) {
-            markers.push(path.basename(String(command[0])));
-        }
-        return markers.some((marker) => marker.length > 0 && cmdline.includes(marker));
+        return fs.realpathSync(value);
     }
     catch {
+        return path.resolve(value);
+    }
+}
+function jobIdentity(command) {
+    const expected = command.map(String);
+    const tokenIndex = expected.indexOf('--internal-job-token');
+    const projectRootIndex = expected.indexOf('--project-root');
+    const token = expected[tokenIndex + 1] ?? '';
+    if (expected.length < 7
+        || path.basename(expected[1] ?? '') !== 'autovpn.mjs'
+        || projectRootIndex < 3
+        || !expected[projectRootIndex + 1]
+        || tokenIndex < 3
+        || !/^[a-f0-9]{64}$/i.test(token)) {
+        return undefined;
+    }
+    return {
+        executable: resolvedArg(expected[0]),
+        entry: resolvedArg(expected[1]),
+        projectRoot: resolvedArg(expected[projectRootIndex + 1]),
+        token: token.toLowerCase()
+    };
+}
+function escaped(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function commandTextMatchesJob(commandLine, command) {
+    const identity = jobIdentity(command);
+    if (!identity || !commandLine.trim()) {
+        return false;
+    }
+    const tokenPattern = new RegExp(`(?:^|[\\s"'])${escaped(identity.token)}(?:$|[\\s"'])`, 'i');
+    const normalized = commandLine.replaceAll('\\', '/');
+    const projectRootIndex = command.indexOf('--project-root');
+    const containsPath = (value) => [value, resolvedArg(value)]
+        .map((candidate) => candidate.replaceAll('\\', '/'))
+        .some((candidate) => normalized.includes(candidate));
+    return tokenPattern.test(commandLine)
+        && containsPath(command[1])
+        && containsPath(command[projectRootIndex + 1])
+        && containsPath(command[0]);
+}
+export function cmdlineMatchesJob(cmdline, command) {
+    const actual = cmdline.toString('utf8').split('\0').filter((value) => value.length > 0);
+    const expected = command.map(String);
+    const identity = jobIdentity(expected);
+    if (!identity || actual.length !== expected.length) {
+        return false;
+    }
+    if (path.basename(expected[1]) !== 'autovpn.mjs' || path.basename(actual[1]) !== 'autovpn.mjs') {
+        return false;
+    }
+    const projectRootIndex = expected.indexOf('--project-root');
+    return expected.every((value, index) => {
+        if (index <= 1 || index === projectRootIndex + 1) {
+            return resolvedArg(actual[index]) === resolvedArg(value);
+        }
+        return actual[index] === value;
+    });
+}
+export function processMatchesJob(pid, command, options = {}) {
+    const platform = options.platform ?? process.platform;
+    if (!jobIdentity(command)) {
+        return false;
+    }
+    const cmdlinePath = path.join('/proc', String(pid), 'cmdline');
+    if (platform === 'linux') {
+        if (!fs.existsSync(cmdlinePath)) {
+            return false;
+        }
+        try {
+            return cmdlineMatchesJob(fs.readFileSync(cmdlinePath), command);
+        }
+        catch {
+            return false;
+        }
+    }
+    const spawnSync = options.spawnSync ?? defaultSpawnSync;
+    const lookup = platform === 'win32'
+        ? spawnSync('powershell.exe', [
+            '-NoProfile',
+            '-NonInteractive',
+            '-Command',
+            `(Get-CimInstance Win32_Process -Filter "ProcessId = ${pid}").CommandLine`
+        ], { encoding: 'utf8', windowsHide: true })
+        : spawnSync('ps', ['-ww', '-p', String(pid), '-o', 'command='], { encoding: 'utf8' });
+    if (lookup.status !== 0 || typeof lookup.stdout !== 'string') {
         return false;
     }
+    return commandTextMatchesJob(lookup.stdout, command);
 }
 function defaultIsAlive(pid) {
     if (pid <= 0)

package/dist/pipeline/availability.js

@@ -1,9 +1,6 @@
-import path from 'node:path';
-import { spawn as defaultSpawn } from 'node:child_process';
 import http from 'node:http';
 import net from 'node:net';
 import tls from 'node:tls';
-import { mergeProjectEnv } from '../runtime/env.js';
 import { openMihomoRuntime as defaultOpenMihomoRuntime } from './proxy-runtime.js';
 const PROVIDER_TARGETS = [
     { name: 'gemini', url: 'https://gemini.google.com', allowed_hosts: ['gemini.google.com'], negative_phrases: [] },
@@ -20,42 +17,6 @@ const CHALLENGE_PHRASES = [
 const GEMINI_REGION_MARKERS = [',2,1,200,"', ',2,1,200,\\"'];
 const CLAUDE_BLOCKED_CODES = new Set(['AF', 'BY', 'CN', 'CU', 'HK', 'IR', 'KP', 'MO', 'RU', 'SY']);
 const GEMINI_BLOCKED_CODES = new Set(['CHN', 'RUS', 'BLR', 'CUB', 'IRN', 'PRK', 'SYR', 'HKG', 'MAC']);
-const PYTHON_AVAILABILITY_HELPER = `
-import json
-import sys
-from vpn_automation.config.models import AvailabilityTargetConfig, SpeedTestConfig
-from vpn_automation.pipeline.availability import ProviderTarget, check_link_availability_batch
-from vpn_automation.pipeline.speedtest import SpeedTestResult
-
-payload = json.load(sys.stdin)
-config = SpeedTestConfig(**payload["config"])
-results = [SpeedTestResult(**item) for item in payload.get("results", [])]
-raw_targets = payload.get("targets", None)
-targets = None
-if isinstance(raw_targets, list):
-    targets = tuple(
-        ProviderTarget(
-            name=str(item["name"]),
-            url=str(item["url"]),
-            allowed_hosts=tuple(item.get("allowed_hosts") or []),
-            negative_phrases=tuple(item.get("negative_phrases") or []),
-        )
-        for item in raw_targets
-    )
-elif isinstance(raw_targets, dict):
-    targets = {name: AvailabilityTargetConfig(**value) for name, value in raw_targets.items()}
-output = [
-    item.to_dict()
-    for item in check_link_availability_batch(
-        results,
-        config,
-        runtime_path=payload.get("runtime_path", ""),
-        targets=targets,
-    )
-]
-json.dump(output, sys.stdout, ensure_ascii=False)
-sys.stdout.write("\\n")
-`;
 function providerResultWithDefaults(result) {
     return {
         provider: result.provider,
@@ -735,63 +696,6 @@ async function checkBatchInNode(input, options) {
         });
     });
 }
-export function selectPipelineStageBackend(stage, env = process.env) {
-    void stage;
-    void env;
-    return 'node';
-}
-async function defaultResolvePythonCli(env) {
-    // @ts-expect-error Phase 1 runner remains plain ESM JavaScript.
-    const runner = await import('../../lib/runner.mjs');
-    return runner.resolveOrInstallPythonCli({ env });
-}
-function pythonCommandFor(resolved) {
-    const command = resolved.command;
-    const name = path.basename(command).toLowerCase();
-    if (['autovpn', 'autovpn.exe'].includes(name)) {
-        const executable = process.platform === 'win32' ? 'python.exe' : 'python';
-        return path.join(path.dirname(command), executable);
-    }
-    return process.platform === 'win32' ? 'python.exe' : 'python3';
-}
-async function availabilityWithPython(input, options) {
-    const env = mergeProjectEnv(options.cwd ?? process.cwd(), options.env ?? process.env);
-    const resolved = options.resolvePythonCli ? await options.resolvePythonCli() : await defaultResolvePythonCli(env);
-    const child = (options.spawn ?? defaultSpawn)(pythonCommandFor(resolved), ['-c', PYTHON_AVAILABILITY_HELPER], {
-        cwd: options.cwd ?? process.cwd(),
-        env,
-        stdio: ['pipe', 'pipe', 'pipe']
-    });
-    let stdout = '';
-    let stderr = '';
-    child.stdout?.on('data', (chunk) => {
-        stdout += String(chunk);
-    });
-    child.stderr?.on('data', (chunk) => {
-        stderr += String(chunk);
-    });
-    const completion = new Promise((resolve, reject) => {
-        child.on('error', reject);
-        child.on('close', (code) => {
-            if (code !== 0) {
-                reject(new Error(`Python availability backend failed with exit code ${code}: ${stderr.trim()}`));
-                return;
-            }
-            try {
-                resolve(JSON.parse(stdout));
-            }
-            catch (error) {
-                reject(new Error(`Python availability backend returned invalid JSON: ${error instanceof Error ? error.message : String(error)}`));
-            }
-        });
-    });
-    child.stdin?.write(JSON.stringify(input));
-    child.stdin?.end();
-    return completion;
-}
 export async function checkLinkAvailabilityBatchWithBackend(input, options = {}) {
-    if (selectPipelineStageBackend('availability', options.env ?? process.env) === 'python') {
-        return options.pythonAvailability ? options.pythonAvailability(input) : availabilityWithPython(input, options);
-    }
     return checkBatchInNode(input, options);
 }

package/dist/pipeline/dedupe.js

@@ -1,15 +1,3 @@
-import path from 'node:path';
-import { spawn as defaultSpawn } from 'node:child_process';
-import { mergeProjectEnv } from '../runtime/env.js';
-const PYTHON_DEDUPE_HELPER = `
-import json
-import sys
-from vpn_automation.pipeline.dedupe import dedupe_vmess_links
-
-payload = json.load(sys.stdin)
-json.dump(dedupe_vmess_links(payload["links"]), sys.stdout, ensure_ascii=False)
-sys.stdout.write("\\n")
-`;
 export function parseVmessLink(link) {
     const encoded = link.replace(/^vmess:\/\//, '');
     const padded = encoded + '='.repeat((4 - (encoded.length % 4)) % 4);
@@ -40,63 +28,7 @@ export function dedupeVmessLinks(links) {
     }
     return result;
 }
-export function selectPipelineStageBackend(stage, env = process.env) {
-    void stage;
-    void env;
-    return 'node';
-}
-async function defaultResolvePythonCli(env) {
-    // @ts-expect-error Phase 1 runner remains plain ESM JavaScript.
-    const runner = await import('../../lib/runner.mjs');
-    return runner.resolveOrInstallPythonCli({ env });
-}
-function pythonCommandFor(resolved) {
-    const command = resolved.command;
-    const name = path.basename(command).toLowerCase();
-    if (['autovpn', 'autovpn.exe'].includes(name)) {
-        const executable = process.platform === 'win32' ? 'python.exe' : 'python';
-        return path.join(path.dirname(command), executable);
-    }
-    return process.platform === 'win32' ? 'python.exe' : 'python3';
-}
-async function dedupeVmessLinksWithPython(links, options) {
-    const env = mergeProjectEnv(options.cwd ?? process.cwd(), options.env ?? process.env);
-    const resolved = options.resolvePythonCli ? await options.resolvePythonCli() : await defaultResolvePythonCli(env);
-    const child = (options.spawn ?? defaultSpawn)(pythonCommandFor(resolved), ['-c', PYTHON_DEDUPE_HELPER], {
-        cwd: options.cwd ?? process.cwd(),
-        env,
-        stdio: ['pipe', 'pipe', 'pipe']
-    });
-    let stdout = '';
-    let stderr = '';
-    child.stdout?.on('data', (chunk) => {
-        stdout += String(chunk);
-    });
-    child.stderr?.on('data', (chunk) => {
-        stderr += String(chunk);
-    });
-    const completion = new Promise((resolve, reject) => {
-        child.on('error', reject);
-        child.on('close', (code) => {
-            if (code !== 0) {
-                reject(new Error(`Python dedupe backend failed with exit code ${code}: ${stderr.trim()}`));
-                return;
-            }
-            try {
-                resolve(JSON.parse(stdout));
-            }
-            catch (error) {
-                reject(new Error(`Python dedupe backend returned invalid JSON: ${error instanceof Error ? error.message : String(error)}`));
-            }
-        });
-    });
-    child.stdin?.write(JSON.stringify({ links }));
-    child.stdin?.end();
-    return completion;
-}
 export async function dedupeVmessLinksWithBackend(links, options = {}) {
-    if (selectPipelineStageBackend('dedupe', options.env ?? process.env) === 'python') {
-        return options.pythonDedupe ? options.pythonDedupe(links) : dedupeVmessLinksWithPython(links, options);
-    }
+    void options;
     return dedupeVmessLinks(links);
 }