@swimmingliu/autovpn 1.6.9 → 1.8.0

package/dist/pipeline/postprocess.js

@@ -1,3 +1,4 @@
+import { isIsoAlpha2CountryCode } from './country-codes.js';
 const EMOJI_MAP = {
     AE: '🇦🇪',
     AR: '🇦🇷',
@@ -37,7 +38,6 @@ const EMOJI_MAP = {
     ZA: '🇿🇦'
 };
 const FALLBACK_COUNTRY_CODE = 'US';
-const UNKNOWN_COUNTRY_CODE = 'ZZ';
 const DEFAULT_FILTERS = {
     excluded_country_codes: ['CN'],
     per_country_limit: {}
@@ -55,7 +55,7 @@ export function generateVmessLink(payload) {
 }
 export function normalizeCountryCode(countryCode) {
     const normalized = String(countryCode || '').trim().toUpperCase();
-    if (normalized.length !== 2 || !/^[A-Z]{2}$/.test(normalized) || normalized === UNKNOWN_COUNTRY_CODE) {
+    if (!isIsoAlpha2CountryCode(normalized)) {
         return FALLBACK_COUNTRY_CODE;
     }
     return normalized;

package/dist/pipeline/proxy-runtime.js

@@ -14,6 +14,7 @@ export const PROXY_ENV_KEYS = [
     'no_proxy'
 ];
 const MIHOMO_DELAY_TIMEOUT_MAX_MS = 30_000;
+const reservedAutomaticPorts = new Set();
 function padBase64(encoded) {
     return encoded + '='.repeat((4 - (encoded.length % 4)) % 4);
 }
@@ -85,16 +86,45 @@ function requireOkResponse(response, context) {
         throw new Error(`${context} failed with status ${response.status ?? 0} ${response.statusText ?? ''}`.trim());
     }
 }
-export async function selectMihomoProxy(controllerUrl, proxyName, _timeoutSeconds, options = {}) {
+async function fetchControllerWithTimeout(fetchImpl, url, init, timeoutSeconds) {
+    const controller = new AbortController();
+    let timedOut = false;
+    const timeoutMs = Math.max(1, Math.trunc(timeoutSeconds * 1000));
+    let timer;
+    const timeout = new Promise((_resolve, reject) => {
+        timer = setTimeout(() => {
+            timedOut = true;
+            const timeoutError = new Error(`mihomo controller request timed out after ${timeoutMs}ms`);
+            timeoutError.code = 'AUTOVPN_INTERNAL_TIMEOUT';
+            reject(timeoutError);
+            controller.abort();
+        }, timeoutMs);
+    });
+    try {
+        return await Promise.race([fetchImpl(url, { ...init, signal: controller.signal }), timeout]);
+    }
+    catch (error) {
+        if (!timedOut || (error instanceof Error && error.code === 'AUTOVPN_INTERNAL_TIMEOUT'))
+            throw error;
+        const timeoutError = new Error(`mihomo controller request timed out after ${timeoutMs}ms`, { cause: error });
+        timeoutError.code = 'AUTOVPN_INTERNAL_TIMEOUT';
+        throw timeoutError;
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
+export async function selectMihomoProxy(controllerUrl, proxyName, timeoutSeconds, options = {}) {
     if (!controllerUrl) {
         return;
     }
     const fetchImpl = requireFetch(options.fetch);
-    const response = await fetchImpl(`${controllerUrl}/proxies/GLOBAL`, {
+    const response = await fetchControllerWithTimeout(fetchImpl, `${controllerUrl}/proxies/GLOBAL`, {
         method: 'PUT',
         headers: { 'content-type': 'application/json' },
         body: JSON.stringify({ name: proxyName })
-    });
+    }, timeoutSeconds);
     requireOkResponse(response, 'mihomo proxy selection');
 }
 export async function probeMihomoProxyDelay(controllerUrl, proxyName, probeUrl, timeoutSeconds, options = {}) {
@@ -103,7 +133,7 @@ export async function probeMihomoProxyDelay(controllerUrl, proxyName, probeUrl,
     const timeoutMs = Math.min(MIHOMO_DELAY_TIMEOUT_MAX_MS, Math.max(1, Math.trunc(timeoutSeconds * 1000)));
     url.searchParams.set('timeout', String(timeoutMs));
     url.searchParams.set('url', probeUrl);
-    const response = await fetchImpl(url.toString(), { method: 'GET' });
+    const response = await fetchControllerWithTimeout(fetchImpl, url.toString(), { method: 'GET' }, timeoutSeconds);
     requireOkResponse(response, 'mihomo proxy delay probe');
     const payload = await response.json?.();
     const delay = Number(payload?.delay ?? -1);
@@ -132,6 +162,19 @@ async function findFreePort() {
         });
     });
 }
+async function reserveAutomaticPort(allocatePort) {
+    for (let attempt = 0; attempt < 100; attempt += 1) {
+        const port = await allocatePort();
+        if (!Number.isInteger(port) || port <= 0) {
+            throw new Error(`invalid automatically allocated port: ${port}`);
+        }
+        if (!reservedAutomaticPorts.has(port)) {
+            reservedAutomaticPorts.add(port);
+            return port;
+        }
+    }
+    throw new Error('unable to reserve a unique local port after 100 attempts');
+}
 async function canConnectToPort(port) {
     return await new Promise((resolve) => {
         const socket = net.createConnection({ host: '127.0.0.1', port });
@@ -164,18 +207,29 @@ async function closeChildProcess(process) {
     if (process.exitCode !== null || process.killed) {
         return;
     }
-    await new Promise((resolve) => {
+    await new Promise((resolve, reject) => {
         const timer = setTimeout(() => {
-            if (process.exitCode === null && !process.killed) {
-                process.kill('SIGKILL');
+            try {
+                if (process.exitCode === null && !process.killed) {
+                    process.kill('SIGKILL');
+                }
+                resolve();
+            }
+            catch (error) {
+                reject(error);
             }
-            resolve();
         }, 2000);
         process.once('close', () => {
             clearTimeout(timer);
             resolve();
         });
-        process.kill('SIGTERM');
+        try {
+            process.kill('SIGTERM');
+        }
+        catch (error) {
+            clearTimeout(timer);
+            reject(error);
+        }
     });
 }
 async function fileExists(candidate) {
@@ -227,24 +281,54 @@ async function resolveMihomoCommand(runtimePath, env = process.env) {
 }
 export async function openMihomoRuntime(link, options = {}) {
     const startupWaitSeconds = Number(options.startupWaitSeconds ?? 1);
+    const payload = parseVmessLink(link);
+    const automaticPorts = [];
+    const allocatePort = options.allocatePort ?? findFreePort;
     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();
+        : await reserveAutomaticPort(allocatePort);
+    if (!(Number.isInteger(options.mixedPort) && Number(options.mixedPort) > 0))
+        automaticPorts.push(mixedPort);
+    let controllerPort;
+    try {
+        controllerPort = Number.isInteger(options.controllerPort) && Number(options.controllerPort) > 0
+            ? Number(options.controllerPort)
+            : await reserveAutomaticPort(allocatePort);
+        if (!(Number.isInteger(options.controllerPort) && Number(options.controllerPort) > 0))
+            automaticPorts.push(controllerPort);
+    }
+    catch (error) {
+        for (const port of automaticPorts)
+            reservedAutomaticPorts.delete(port);
+        throw error;
+    }
     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 command = await resolveMihomoCommand(options.runtimePath, options.env ?? process.env);
-    const child = (options.spawn ?? defaultSpawn)(command, ['-f', configPath], {
-        stdio: ['ignore', 'pipe', 'pipe'],
-        env: stripProxyEnv(options.env ?? process.env)
-    });
+    let tempDir = '';
+    let configPath = '';
+    let child;
+    try {
+        const config = buildMihomoRuntimeConfig(payload, { mixedPort, controllerPort });
+        tempDir = await mkdtemp(path.join(os.tmpdir(), 'autovpn-mihomo-'));
+        configPath = path.join(tempDir, 'config.json');
+        await writeFile(configPath, JSON.stringify(config), 'utf8');
+        const command = await resolveMihomoCommand(options.runtimePath, options.env ?? process.env);
+        child = (options.spawn ?? defaultSpawn)(command, ['-f', configPath], {
+            stdio: ['ignore', 'pipe', 'pipe'],
+            env: stripProxyEnv(options.env ?? process.env)
+        });
+    }
+    catch (error) {
+        try {
+            if (tempDir)
+                await rm(tempDir, { recursive: true, force: true });
+        }
+        finally {
+            for (const port of automaticPorts)
+                reservedAutomaticPorts.delete(port);
+        }
+        throw error;
+    }
     let rejectStartupError;
     const startupError = new Promise((_resolve, reject) => {
         rejectStartupError = reject;
@@ -253,25 +337,43 @@ export async function openMihomoRuntime(link, options = {}) {
         rejectStartupError?.(error);
     };
     child.once('error', onStartupError);
+    let rejectStartupExit;
+    const startupExit = new Promise((_resolve, reject) => {
+        rejectStartupExit = reject;
+    });
+    const onStartupExit = (code, signal) => {
+        const error = new Error(`mihomo exited during startup with code ${code ?? 'unknown'}${signal ? ` signal ${signal}` : ''}`);
+        error.code = 'AUTOVPN_INTERNAL_TIMEOUT';
+        rejectStartupExit?.(error);
+    };
+    child.once('exit', onStartupExit);
     let closed = false;
     const close = async () => {
         if (closed) {
             return;
         }
         closed = true;
-        await closeChildProcess(child);
-        await rm(tempDir, { recursive: true, force: true });
+        try {
+            await closeChildProcess(child);
+            await rm(tempDir, { recursive: true, force: true });
+        }
+        finally {
+            for (const port of automaticPorts)
+                reservedAutomaticPorts.delete(port);
+        }
     };
     try {
         const waitForPort = options.waitForPort ?? defaultWaitForPort;
-        await Promise.race([waitForPort(mixedPort, startupWaitSeconds + 4), startupError]);
-        await Promise.race([waitForPort(controllerPort, startupWaitSeconds + 4), startupError]);
-        await Promise.race([(options.selectProxy ?? ((url, name, timeoutSeconds) => selectMihomoProxy(url, name, timeoutSeconds)))(controllerUrl, proxyName, startupWaitSeconds + 4), startupError]);
+        await Promise.race([waitForPort(mixedPort, startupWaitSeconds + 4), startupError, startupExit]);
+        await Promise.race([waitForPort(controllerPort, startupWaitSeconds + 4), startupError, startupExit]);
+        await Promise.race([(options.selectProxy ?? ((url, name, timeoutSeconds) => selectMihomoProxy(url, name, timeoutSeconds)))(controllerUrl, proxyName, startupWaitSeconds + 4), startupError, startupExit]);
         child.off('error', onStartupError);
+        child.off('exit', onStartupExit);
         child.on('error', () => { });
     }
     catch (error) {
         child.off('error', onStartupError);
+        child.off('exit', onStartupExit);
         child.on('error', () => { });
         await close();
         if (error instanceof Error