@swimmingliu/autovpn 1.4.0

package/dist/pipeline/postprocess.js

@@ -0,0 +1,214 @@
+import path from 'node:path';
+import { spawn as defaultSpawn } from 'node:child_process';
+import { mergeProjectEnv } from '../runtime/env.js';
+const EMOJI_MAP = {
+    AE: '🇦🇪',
+    AR: '🇦🇷',
+    AU: '🇦🇺',
+    BE: '🇧🇪',
+    BR: '🇧🇷',
+    CA: '🇨🇦',
+    CH: '🇨🇭',
+    CL: '🇨🇱',
+    CN: '🇨🇳',
+    CO: '🇨🇴',
+    DE: '🇩🇪',
+    DK: '🇩🇰',
+    ES: '🇪🇸',
+    FR: '🇫🇷',
+    GB: '🇬🇧',
+    HK: '🇭🇰',
+    IN: '🇮🇳',
+    IT: '🇮🇹',
+    JP: '🇯🇵',
+    KR: '🇰🇷',
+    MX: '🇲🇽',
+    MY: '🇲🇾',
+    NL: '🇳🇱',
+    NO: '🇳🇴',
+    NZ: '🇳🇿',
+    PL: '🇵🇱',
+    PT: '🇵🇹',
+    RU: '🇷🇺',
+    SA: '🇸🇦',
+    SE: '🇸🇪',
+    SG: '🇸🇬',
+    TH: '🇹🇭',
+    TR: '🇹🇷',
+    TW: '🇹🇼',
+    US: '🇺🇸',
+    ZA: '🇿🇦'
+};
+const FALLBACK_COUNTRY_CODE = 'US';
+const UNKNOWN_COUNTRY_CODE = 'ZZ';
+const DEFAULT_FILTERS = {
+    excluded_country_codes: ['CN'],
+    per_country_limit: {}
+};
+const LEADING_EMOJI_AND_COUNTRY_PATTERN = /^(?:\S+\s+)?([A-Za-z]{2})\s+(.*)$/;
+const PYTHON_POSTPROCESS_HELPER = `
+import json
+import sys
+from vpn_automation.config.models import FilterConfig
+from vpn_automation.pipeline.postprocess import decorate_link_with_country, select_links_by_country_limit
+
+payload = json.load(sys.stdin)
+filters = payload.get("filters")
+ranked_links = payload.get("ranked_links") or []
+filter_config = FilterConfig() if filters is None else FilterConfig(
+    excluded_country_codes=list(filters.get("excluded_country_codes") or []),
+    per_country_limit=dict(filters.get("per_country_limit") or {}),
+)
+selected = select_links_by_country_limit(
+    [(item["link"], {}, item.get("country_code") or item.get("countryCode") or "") for item in ranked_links],
+    filter_config,
+)
+country_by_link = {
+    item["link"]: item.get("country_code") or item.get("countryCode") or ""
+    for item in ranked_links
+}
+json.dump({"links": [decorate_link_with_country(link, country_by_link[link]) for link in selected]}, 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);
+    return JSON.parse(Buffer.from(padded, 'base64url').toString('utf8'));
+}
+export function generateVmessLink(payload) {
+    const json = JSON.stringify(payload);
+    const encoded = Buffer.from(json, 'utf8').toString('base64').replaceAll('+', '-').replaceAll('/', '_');
+    return `vmess://${encoded}`;
+}
+export function normalizeCountryCode(countryCode) {
+    const normalized = String(countryCode || '').trim().toUpperCase();
+    if (normalized.length !== 2 || !/^[A-Z]{2}$/.test(normalized) || normalized === UNKNOWN_COUNTRY_CODE) {
+        return FALLBACK_COUNTRY_CODE;
+    }
+    return normalized;
+}
+export function countryToEmoji(countryCode) {
+    const normalized = normalizeCountryCode(countryCode);
+    return EMOJI_MAP[normalized] ?? EMOJI_MAP[FALLBACK_COUNTRY_CODE];
+}
+function resolveFilters(filters) {
+    return {
+        excluded_country_codes: filters?.excluded_country_codes ?? DEFAULT_FILTERS.excluded_country_codes,
+        per_country_limit: filters?.per_country_limit ?? DEFAULT_FILTERS.per_country_limit
+    };
+}
+function stripLeadingCountryPrefix(originalName) {
+    const name = String(originalName || '').trim();
+    if (!name) {
+        return '';
+    }
+    const match = name.match(LEADING_EMOJI_AND_COUNTRY_PATTERN);
+    if (!match) {
+        return name;
+    }
+    const remainder = String(match[2] ?? '').trim();
+    return remainder || name;
+}
+export function decorateNodeName(originalName, countryCode, emoji) {
+    const cleanedName = stripLeadingCountryPrefix(originalName);
+    return `${emoji} ${countryCode} ${cleanedName}`.trim();
+}
+export function decorateLinkWithCountry(link, countryCode) {
+    const payload = parseVmessLink(link);
+    const normalizedCountry = normalizeCountryCode(countryCode);
+    payload.ps = decorateNodeName(String(payload.ps ?? ''), normalizedCountry, countryToEmoji(normalizedCountry));
+    return generateVmessLink(payload);
+}
+export function selectLinksByCountryLimit(rankedLinks, filters = {}) {
+    const resolvedFilters = resolveFilters(filters);
+    const excluded = new Set(resolvedFilters.excluded_country_codes.map((country) => normalizeCountryCode(country)));
+    const limits = Object.fromEntries(Object.entries(resolvedFilters.per_country_limit).map(([country, limit]) => [normalizeCountryCode(country), Number(limit)]));
+    const counters = new Map();
+    const selected = [];
+    for (const item of rankedLinks) {
+        const country = normalizeCountryCode(String(item.country_code ?? item.countryCode ?? ''));
+        if (excluded.has(country)) {
+            continue;
+        }
+        if (country in limits) {
+            const current = counters.get(country) ?? 0;
+            if (current >= limits[country]) {
+                continue;
+            }
+            counters.set(country, current + 1);
+        }
+        selected.push(item.link);
+    }
+    return selected;
+}
+export function runPostprocess(input) {
+    const rankedLinks = input.ranked_links ?? [];
+    const selected = selectLinksByCountryLimit(rankedLinks, input.filters);
+    const countries = new Map(rankedLinks.map((item) => [item.link, String(item.country_code ?? item.countryCode ?? '')]));
+    return {
+        links: selected.map((link) => decorateLinkWithCountry(link, countries.get(link) ?? ''))
+    };
+}
+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';
+}
+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 postprocessWithPython(input, options) {
+    const env = mergeProjectEnv(options.cwd ?? process.cwd(), options.env ?? process.env);
+    const resolved = options.resolvePythonCli ? await options.resolvePythonCli() : await defaultResolvePythonCli(env);
+    const helperInput = { ...input, filters: resolveFilters(input.filters) };
+    const child = (options.spawn ?? defaultSpawn)(pythonCommandFor(resolved), ['-c', PYTHON_POSTPROCESS_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 postprocess backend failed with exit code ${code}: ${stderr.trim()}`));
+                return;
+            }
+            try {
+                resolve(JSON.parse(stdout));
+            }
+            catch (error) {
+                reject(new Error(`Python postprocess backend returned invalid JSON: ${error instanceof Error ? error.message : String(error)}`));
+            }
+        });
+    });
+    child.stdin?.write(JSON.stringify(helperInput));
+    child.stdin?.end();
+    return completion;
+}
+export async function postprocessLinksWithBackend(input, options = {}) {
+    if (selectPipelineStageBackend('postprocess', options.env ?? process.env) === 'python') {
+        return options.pythonPostprocess ? options.pythonPostprocess(input) : postprocessWithPython(input, options);
+    }
+    return runPostprocess(input);
+}

package/dist/pipeline/proxy-runtime.js

@@ -0,0 +1,228 @@
+import { spawn as defaultSpawn } from 'node:child_process';
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import net from 'node:net';
+import os from 'node:os';
+import path from 'node:path';
+export const PROXY_ENV_KEYS = [
+    'HTTP_PROXY',
+    'HTTPS_PROXY',
+    'ALL_PROXY',
+    'http_proxy',
+    'https_proxy',
+    'all_proxy',
+    'NO_PROXY',
+    'no_proxy'
+];
+function padBase64(encoded) {
+    return encoded + '='.repeat((4 - (encoded.length % 4)) % 4);
+}
+export function parseVmessLink(link) {
+    const encoded = link.startsWith('vmess://') ? link.slice('vmess://'.length) : link;
+    return JSON.parse(Buffer.from(padBase64(encoded), 'base64url').toString('utf8'));
+}
+export function buildMihomoRuntimeConfig(payload, ports) {
+    const network = String(payload.net ?? 'ws');
+    const tlsEnabled = String(payload.tls ?? '').toLowerCase() === 'tls';
+    const proxyName = 'runtime-node';
+    const proxy = {
+        name: proxyName,
+        type: 'vmess',
+        server: payload.add,
+        port: Number(payload.port),
+        uuid: payload.id,
+        alterId: Number(String(payload.aid ?? '0') || 0),
+        cipher: payload.scy ?? 'auto',
+        udp: false,
+        network
+    };
+    if (tlsEnabled) {
+        proxy.tls = true;
+        proxy['skip-cert-verify'] = true;
+        proxy.servername = payload.sni || payload.host || payload.add;
+    }
+    if (network === 'ws') {
+        proxy['ws-opts'] = {
+            path: payload.path ?? '',
+            headers: { Host: payload.host || payload.add || '' }
+        };
+    }
+    return {
+        'mixed-port': ports.mixedPort,
+        'allow-lan': false,
+        mode: 'global',
+        'log-level': 'silent',
+        ipv6: false,
+        'external-controller': `127.0.0.1:${ports.controllerPort}`,
+        dns: { enable: false },
+        proxies: [proxy],
+        'proxy-groups': [
+            {
+                name: 'GLOBAL',
+                type: 'select',
+                proxies: [proxyName]
+            }
+        ],
+        rules: ['MATCH,GLOBAL']
+    };
+}
+export function stripProxyEnv(env = process.env) {
+    const stripped = { ...env };
+    for (const key of PROXY_ENV_KEYS) {
+        delete stripped[key];
+    }
+    return stripped;
+}
+function requireFetch(fetchImpl) {
+    const selected = fetchImpl ?? globalThis.fetch?.bind(globalThis);
+    if (!selected) {
+        throw new Error('Node proxy runtime requires fetch support');
+    }
+    return selected;
+}
+function requireOkResponse(response, context) {
+    if (response.ok === false || Number(response.status ?? 200) >= 400) {
+        throw new Error(`${context} failed with status ${response.status ?? 0} ${response.statusText ?? ''}`.trim());
+    }
+}
+export async function selectMihomoProxy(controllerUrl, proxyName, _timeoutSeconds, options = {}) {
+    if (!controllerUrl) {
+        return;
+    }
+    const fetchImpl = requireFetch(options.fetch);
+    const response = await fetchImpl(`${controllerUrl}/proxies/GLOBAL`, {
+        method: 'PUT',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ name: proxyName })
+    });
+    requireOkResponse(response, 'mihomo proxy selection');
+}
+export async function probeMihomoProxyDelay(controllerUrl, proxyName, probeUrl, timeoutSeconds, options = {}) {
+    const fetchImpl = requireFetch(options.fetch);
+    const url = new URL(`${controllerUrl}/proxies/${encodeURIComponent(proxyName)}/delay`);
+    url.searchParams.set('timeout', String(Math.trunc(timeoutSeconds * 1000)));
+    url.searchParams.set('url', probeUrl);
+    const response = await fetchImpl(url.toString(), { method: 'GET' });
+    requireOkResponse(response, 'mihomo proxy delay probe');
+    const payload = await response.json?.();
+    const delay = Number(payload?.delay ?? -1);
+    if (!Number.isFinite(delay) || delay < 0) {
+        throw new Error(`mihomo returned invalid delay payload: ${JSON.stringify(payload)}`);
+    }
+    return Math.trunc(delay);
+}
+async function findFreePort() {
+    return await new Promise((resolve, reject) => {
+        const server = net.createServer();
+        server.once('error', reject);
+        server.listen(0, '127.0.0.1', () => {
+            const address = server.address();
+            server.close((error) => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                if (typeof address === 'object' && address?.port) {
+                    resolve(address.port);
+                    return;
+                }
+                reject(new Error('failed to allocate a free local port'));
+            });
+        });
+    });
+}
+async function canConnectToPort(port) {
+    return await new Promise((resolve) => {
+        const socket = net.createConnection({ host: '127.0.0.1', port });
+        socket.once('connect', () => {
+            socket.destroy();
+            resolve(true);
+        });
+        socket.once('error', () => {
+            socket.destroy();
+            resolve(false);
+        });
+    });
+}
+function sleep(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+async function defaultWaitForPort(port, timeoutSeconds) {
+    const deadline = Date.now() + Math.max(timeoutSeconds, 0.1) * 1000;
+    while (Date.now() < deadline) {
+        if (await canConnectToPort(port)) {
+            return;
+        }
+        await sleep(100);
+    }
+    throw new Error(`proxy port ${port} did not open in time`);
+}
+async function closeChildProcess(process) {
+    if (process.exitCode !== null || process.killed) {
+        return;
+    }
+    await new Promise((resolve) => {
+        const timer = setTimeout(() => {
+            if (process.exitCode === null && !process.killed) {
+                process.kill('SIGKILL');
+            }
+            resolve();
+        }, 2000);
+        process.once('close', () => {
+            clearTimeout(timer);
+            resolve();
+        });
+        process.kill('SIGTERM');
+    });
+}
+export async function openMihomoRuntime(link, options = {}) {
+    const startupWaitSeconds = Number(options.startupWaitSeconds ?? 1);
+    const mixedPort = Number.isInteger(options.mixedPort) && Number(options.mixedPort) > 0
+        ? Number(options.mixedPort)
+        : await findFreePort();
+    const controllerPort = Number.isInteger(options.controllerPort) && Number(options.controllerPort) > 0
+        ? Number(options.controllerPort)
+        : await findFreePort();
+    const proxyName = 'runtime-node';
+    const controllerUrl = `http://127.0.0.1:${controllerPort}`;
+    const payload = parseVmessLink(link);
+    const config = buildMihomoRuntimeConfig(payload, { mixedPort, controllerPort });
+    const tempDir = await mkdtemp(path.join(os.tmpdir(), 'autovpn-mihomo-'));
+    const configPath = path.join(tempDir, 'config.json');
+    await writeFile(configPath, JSON.stringify(config), 'utf8');
+    const child = (options.spawn ?? defaultSpawn)(options.runtimePath || 'mihomo', ['-f', configPath], {
+        stdio: ['ignore', 'pipe', 'pipe'],
+        env: stripProxyEnv(options.env ?? process.env)
+    });
+    let closed = false;
+    const close = async () => {
+        if (closed) {
+            return;
+        }
+        closed = true;
+        await closeChildProcess(child);
+        await rm(tempDir, { recursive: true, force: true });
+    };
+    try {
+        const waitForPort = options.waitForPort ?? defaultWaitForPort;
+        await waitForPort(mixedPort, startupWaitSeconds + 4);
+        await waitForPort(controllerPort, startupWaitSeconds + 4);
+        await (options.selectProxy ?? ((url, name, timeoutSeconds) => selectMihomoProxy(url, name, timeoutSeconds)))(controllerUrl, proxyName, startupWaitSeconds + 4);
+    }
+    catch (error) {
+        await close();
+        throw error;
+    }
+    return {
+        process: child,
+        proxies: {
+            http: `http://127.0.0.1:${mixedPort}`,
+            https: `http://127.0.0.1:${mixedPort}`
+        },
+        configPath,
+        controllerUrl,
+        proxyName,
+        close
+    };
+}

package/dist/pipeline/render.js

@@ -0,0 +1,91 @@
+import path from 'node:path';
+import { spawn as defaultSpawn } from 'node:child_process';
+import { mergeProjectEnv } from '../runtime/env.js';
+export const MAIN_DATA_PLACEHOLDER = '__MAIN_DATA__';
+const PYTHON_RENDER_HELPER = `
+import json
+import sys
+from vpn_automation.pipeline.render import replace_main_data
+
+payload = json.load(sys.stdin)
+json.dump(
+    {"rendered_source": replace_main_data(payload["template"], list(payload.get("links") or []))},
+    sys.stdout,
+    ensure_ascii=False,
+)
+sys.stdout.write("\\n")
+`;
+export function replaceMainData(template, links) {
+    const occurrences = template.split(MAIN_DATA_PLACEHOLDER).length - 1;
+    if (occurrences !== 1) {
+        throw new Error('Template must contain exactly one MainData placeholder');
+    }
+    return template.replace(MAIN_DATA_PLACEHOLDER, links.join('\n'));
+}
+export function runRender(input) {
+    return {
+        rendered_source: replaceMainData(input.template, input.links ?? [])
+    };
+}
+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';
+}
+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 renderWithPython(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_RENDER_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 render backend failed with exit code ${code}: ${stderr.trim()}`));
+                return;
+            }
+            try {
+                resolve(JSON.parse(stdout));
+            }
+            catch (error) {
+                reject(new Error(`Python render 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 renderMainDataWithBackend(input, options = {}) {
+    if (selectPipelineStageBackend('render', options.env ?? process.env) === 'python') {
+        return options.pythonRender ? options.pythonRender(input) : renderWithPython(input, options);
+    }
+    return runRender(input);
+}