@swimmingliu/autovpn 1.4.0

package/dist/runtime/redaction.js

@@ -0,0 +1,56 @@
+const SECRET_DEPLOYMENT_KEYS = new Set([
+    'subscription_url',
+    'verify_subscription_url',
+    'secret_query',
+    'share_project_sub_value',
+    'pages_secret_admin'
+]);
+const SECRET_FIELD_NAMES = [
+    'token',
+    'serect_key',
+    'secret_key',
+    'api_token',
+    'api-token',
+    'cloudflare_api_token',
+    'subscription_url',
+    'verify_subscription_url',
+    'secret_query',
+    'share_project_sub_value',
+    'pages_secret_admin'
+];
+const SECRET_FIELD_PATTERN = new RegExp(`(["']?)\\b(${SECRET_FIELD_NAMES.map((key) => key.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&')).join('|')})\\b\\1(\\s*[:=]\\s*)(["']?)([^\\s"',}&]+)(\\4)`, 'gi');
+const SECRET_TEXT_PATTERNS = [
+    [SECRET_FIELD_PATTERN, (_match, keyQuote, key, separator, valueQuote, _value, closingQuote) => `${keyQuote}${key}${keyQuote}${separator}${valueQuote}<redacted>${closingQuote}`],
+    [/(Bearer\s+)[A-Za-z0-9._~+/\-=]+/gi, '$1<redacted>'],
+    [/vmess:\/\/[A-Za-z0-9_\-+/=]+/g, 'vmess://<redacted>']
+];
+export function redactText(value) {
+    return SECRET_TEXT_PATTERNS.reduce((result, [pattern, replacement]) => result.replace(pattern, replacement), value);
+}
+function redactNested(value) {
+    if (typeof value === 'string') {
+        return redactText(value);
+    }
+    if (value === null || ['number', 'boolean'].includes(typeof value)) {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.map(redactNested);
+    }
+    if (typeof value === 'object') {
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, redactNested(item)]));
+    }
+    return typeof value;
+}
+export function safeDeployment(deployment) {
+    const safe = {};
+    for (const [key, value] of Object.entries(deployment)) {
+        if (SECRET_DEPLOYMENT_KEYS.has(key)) {
+            safe[key] = value ? 'set' : '';
+        }
+        else {
+            safe[key] = redactNested(value);
+        }
+    }
+    return safe;
+}

package/lib/cache.mjs

@@ -0,0 +1,14 @@
+import os from 'node:os';
+import path from 'node:path';
+
+export function getCacheDir(env = process.env) {
+  const override = String(env.AUTOVPN_CACHE_DIR ?? '').trim();
+  if (override) {
+    return override;
+  }
+  return path.join(os.homedir(), '.cache', 'autovpn', 'npm-wrapper');
+}
+
+export function pythonBinName(platform = process.platform) {
+  return platform === 'win32' ? 'Scripts' : 'bin';
+}

package/lib/errors.mjs

@@ -0,0 +1,11 @@
+export class WrapperError extends Error {
+  constructor(message, options = {}) {
+    super(message);
+    this.name = 'WrapperError';
+    this.cause = options.cause;
+  }
+}
+
+export function isEnabled(value) {
+  return ['1', 'true', 'yes', 'on'].includes(String(value ?? '').trim().toLowerCase());
+}

package/lib/install-python-cli.mjs

@@ -0,0 +1,63 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawnSync as defaultSpawnSync } from 'node:child_process';
+
+import { getCacheDir, pythonBinName } from './cache.mjs';
+import { isEnabled, WrapperError } from './errors.mjs';
+
+export function buildPipInstallArgs({ env = process.env, packageVersion }) {
+  const packageSpec = String(env.AUTOVPN_WHEEL_URL ?? '').trim()
+    || `${String(env.AUTOVPN_PYTHON_PACKAGE ?? 'vpn-subscription-automation').trim()}==${packageVersion}`;
+  const args = ['-m', 'pip', 'install'];
+  if (env.AUTOVPN_PIP_INDEX_URL) {
+    args.push('--index-url', String(env.AUTOVPN_PIP_INDEX_URL));
+  }
+  if (env.AUTOVPN_PIP_EXTRA_INDEX_URL) {
+    args.push('--extra-index-url', String(env.AUTOVPN_PIP_EXTRA_INDEX_URL));
+  }
+  args.push(packageSpec);
+  return args;
+}
+
+export function installPythonCli({
+  env = process.env,
+  packageVersion,
+  spawnSync = defaultSpawnSync,
+  cacheDir = getCacheDir(env),
+  platform = process.platform
+} = {}) {
+  if (isEnabled(env.AUTOVPN_NO_INSTALL)) {
+    throw new WrapperError('No compatible Python autovpn CLI found and AUTOVPN_NO_INSTALL is enabled.');
+  }
+  if (!packageVersion) {
+    throw new WrapperError('Cannot install Python AutoVPN backend without an npm package version.');
+  }
+
+  const venvDir = path.join(cacheDir, `python-${packageVersion}`);
+  const executable = platform === 'win32' ? 'autovpn.exe' : 'autovpn';
+  const cliPath = path.join(venvDir, pythonBinName(platform), executable);
+  const forceInstall = isEnabled(env.AUTOVPN_FORCE_INSTALL);
+
+  if (!forceInstall && fs.existsSync(cliPath)) {
+    return { command: cliPath, args: [], source: 'managed-venv' };
+  }
+
+  fs.mkdirSync(cacheDir, { recursive: true });
+  const pythonCommand = String(env.PYTHON ?? env.PYTHON3 ?? 'python3');
+  const venvResult = spawnSync(pythonCommand, ['-m', 'venv', venvDir], { stdio: 'inherit', env });
+  if (venvResult.status !== 0) {
+    throw new WrapperError(`Failed to create AutoVPN Python backend venv with ${pythonCommand}.`);
+  }
+
+  const pythonPath = path.join(venvDir, pythonBinName(platform), platform === 'win32' ? 'python.exe' : 'python');
+  const installResult = spawnSync(pythonPath, buildPipInstallArgs({ env, packageVersion }), { stdio: 'inherit', env });
+  if (installResult.status !== 0) {
+    throw new WrapperError('Failed to install AutoVPN Python backend into the wrapper-managed venv.');
+  }
+
+  if (!fs.existsSync(cliPath)) {
+    throw new WrapperError(`Installed Python backend did not provide autovpn at ${cliPath}.`);
+  }
+
+  return { command: cliPath, args: [], source: 'managed-venv' };
+}

package/lib/runner.mjs

@@ -0,0 +1,113 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import {
+  spawn as defaultSpawn,
+  spawnSync as defaultSpawnSync
+} from 'node:child_process';
+
+import { isEnabled, WrapperError } from './errors.mjs';
+import { installPythonCli } from './install-python-cli.mjs';
+
+const packageJsonPath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', 'package.json');
+
+export function readPackageVersion() {
+  const payload = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+  return String(payload.version);
+}
+
+function normalizeVersionOutput(stdout) {
+  return String(stdout ?? '').trim();
+}
+
+export function versionMatches(stdout, packageVersion) {
+  return normalizeVersionOutput(stdout) === `autovpn ${packageVersion}`;
+}
+
+export function resolvePythonCli({
+  env = process.env,
+  packageVersion = readPackageVersion(),
+  spawnSync = defaultSpawnSync
+} = {}) {
+  if (isEnabled(env.AUTOVPN_NO_PYTHON)) {
+    throw new WrapperError('Python backend is disabled by AUTOVPN_NO_PYTHON.');
+  }
+
+  const explicit = String(env.AUTOVPN_PYTHON_CLI ?? '').trim();
+  if (explicit) {
+    return { command: explicit, args: [], source: 'AUTOVPN_PYTHON_CLI' };
+  }
+
+  const probe = spawnSync('autovpn', ['--version'], {
+    encoding: 'utf-8',
+    env: { ...env, AUTOVPN_WRAPPER_PROBE: '1' },
+    stdio: ['ignore', 'pipe', 'pipe']
+  });
+  if (probe.status === 0) {
+    if (versionMatches(probe.stdout, packageVersion) || isEnabled(env.AUTOVPN_ALLOW_VERSION_MISMATCH)) {
+      return { command: 'autovpn', args: [], source: 'PATH' };
+    }
+  }
+
+  throw new WrapperError(
+    `No compatible Python autovpn CLI found for version ${packageVersion}. Set AUTOVPN_PYTHON_CLI or allow the wrapper to install the backend.`
+  );
+}
+
+export function resolveOrInstallPythonCli({
+  env = process.env,
+  packageVersion = readPackageVersion(),
+  spawnSync = defaultSpawnSync,
+  installer = installPythonCli
+} = {}) {
+  try {
+    return resolvePythonCli({ env, packageVersion, spawnSync });
+  } catch (error) {
+    if (isEnabled(env.AUTOVPN_NO_PYTHON)) {
+      throw error;
+    }
+    return installer({ env, packageVersion, spawnSync });
+  }
+}
+
+export function runForwarder(argv = process.argv.slice(2), {
+  env = process.env,
+  cwd = process.cwd(),
+  packageVersion = readPackageVersion(),
+  spawn = defaultSpawn,
+  spawnSync = defaultSpawnSync,
+  installer = installPythonCli
+} = {}) {
+  const resolved = resolveOrInstallPythonCli({ env, packageVersion, spawnSync, installer });
+  const child = spawn(resolved.command, [...resolved.args, ...argv], {
+    cwd,
+    env,
+    stdio: 'inherit'
+  });
+
+  return new Promise((resolve, reject) => {
+    child.on('error', reject);
+    child.on('exit', (code, signal) => {
+      if (signal) {
+        resolve(1);
+        return;
+      }
+      resolve(typeof code === 'number' ? code : 1);
+    });
+  });
+}
+
+export async function main(argv = process.argv.slice(2), options = {}) {
+  const env = options.env ?? process.env;
+  if (isEnabled(env.AUTOVPN_WRAPPER_PROBE) && argv.length === 1 && argv[0] === '--version') {
+    return 42;
+  }
+
+  try {
+    return await runForwarder(argv, { ...options, env });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`autovpn npm wrapper error: ${message}`);
+    return 1;
+  }
+}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@swimmingliu/autovpn",
+  "version": "1.4.0",
+  "description": "npm wrapper for the AutoVPN headless CLI",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/SwimmingLiu/auto-vpn.git",
+    "directory": "npm/autovpn-cli"
+  },
+  "bin": {
+    "autovpn": "bin/autovpn.mjs"
+  },
+  "files": [
+    "bin/",
+    "dist/",
+    "lib/",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "prepack": "npm run build",
+    "test": "npm run build && node --test test/*.test.mjs test/parity/*.test.mjs test/jobs/*.test.mjs test/pipeline/*.test.mjs test/runtime/*.test.mjs"
+  },
+  "engines": {
+    "node": ">=22.5.0"
+  },
+  "license": "UNLICENSED",
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "typescript": "^5.9.2"
+  },
+  "dependencies": {
+    "@iarna/toml": "^2.2.5"
+  }
+}