clash-switcher 0.0.1

package/dist/core.js

@@ -0,0 +1,677 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClashSwitcher = void 0;
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const axios_1 = __importDefault(require("axios"));
+/**
+ * 获取默认的 Clash Verge 配置目录
+ */
+function getDefaultVergeConfigDir() {
+    const platform = os.platform();
+    if (platform === 'win32') {
+        const appData = process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming');
+        return path.join(appData, 'io.github.clash-verge-rev.clash-verge-rev');
+    }
+    else if (platform === 'darwin') {
+        return path.join(os.homedir(), 'Library', 'Application Support', 'io.github.clash-verge-rev.clash-verge-rev');
+    }
+    return path.join(os.homedir(), '.config', 'clash-verge');
+}
+/**
+ * 默认配置
+ */
+const DEFAULT_CONFIG = {
+    host: '127.0.0.1',
+    port: 9097,
+    testUrl: 'http://www.gstatic.com/generate_204',
+    timeout: 5000,
+    vergeConfigDir: getDefaultVergeConfigDir(),
+};
+/**
+ * Clash Switcher 主类
+ * @description 用于控制 Clash Verge 代理切换的核心类
+ * @example
+ * ```typescript
+ * import { ClashSwitcher } from 'clash-switcher';
+ *
+ * const switcher = new ClashSwitcher({
+ *   port: 9097,
+ *   timeout: 3000,
+ * });
+ *
+ * // 获取所有代理组
+ * const groups = await switcher.getProxyGroups();
+ *
+ * // 切换节点
+ * await switcher.setNode('代理组名', '节点名');
+ * ```
+ */
+class ClashSwitcher {
+    /**
+     * 创建 ClashSwitcher 实例
+     * @param config - 配置选项
+     * @param config.host - API 主机地址，默认 '127.0.0.1'
+     * @param config.port - API 端口号，默认 9097
+     * @param config.secret - API 访问密钥，默认无
+     * @param config.testUrl - 延迟测试 URL，默认 'http://www.gstatic.com/generate_204'
+     * @param config.timeout - 超时时间（毫秒），默认 5000
+     * @param config.vergeConfigDir - Clash Verge 配置目录，默认自动检测
+     */
+    constructor(config) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        this.client = this.createClient();
+    }
+    createClient() {
+        const { host, port, timeout } = this.config;
+        const secret = this.config.secret ?? this.readSecretFromConfig();
+        return axios_1.default.create({
+            baseURL: `http://${host}:${port}`,
+            timeout,
+            headers: secret ? { Authorization: `Bearer ${secret}` } : {},
+        });
+    }
+    /**
+     * 从 Clash Verge 配置文件读取 secret
+     */
+    readSecretFromConfig() {
+        try {
+            const configPath = path.join(this.config.vergeConfigDir, 'config.yaml');
+            if (!fs.existsSync(configPath))
+                return undefined;
+            const content = fs.readFileSync(configPath, 'utf-8');
+            const match = content.match(/^secret:\s*['"]?([^'"\n]+)['"]?/m);
+            return match?.[1]?.trim() || undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /**
+     * 更新配置
+     * @param config - 要更新的配置项，只需传入需要修改的字段
+     * @example
+     * ```typescript
+     * switcher.setConfig({ port: 9090 });
+     * switcher.setConfig({ timeout: 3000, testUrl: 'http://example.com' });
+     * ```
+     */
+    setConfig(config) {
+        this.config = { ...this.config, ...config };
+        this.client = this.createClient();
+    }
+    /**
+     * 获取当前配置
+     * @returns 当前完整配置对象
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+    /**
+     * 获取当前代理模式
+     * @returns 当前模式：'rule'(规则) | 'global'(全局) | 'direct'(直连)
+     */
+    async getMode() {
+        const { data } = await this.client.get('/configs');
+        return data.mode;
+    }
+    /**
+     * 设置代理模式
+     * @param mode - 目标模式：'rule'(规则) | 'global'(全局) | 'direct'(直连)
+     */
+    async setMode(mode) {
+        await this.client.patch('/configs', { mode });
+    }
+    /**
+     * 获取所有代理信息
+     */
+    async getProxies() {
+        const { data } = await this.client.get('/proxies');
+        return data.proxies;
+    }
+    /**
+     * 获取代理组列表
+     * @param mode - 模式筛选
+     *   - 不传或 'active': 当前激活模式的代理组
+     *   - 'rule': 规则模式的代理组（排除 GLOBAL）
+     *   - 'global': 全局模式的代理组（仅 GLOBAL）
+     *   - 'direct': 直连模式（返回空数组）
+     *   - 'all': 所有代理组
+     * @param filter - 结果筛选
+     *   - 不传: 返回所有匹配的代理组
+     *   - number: 按索引位置返回（从 0 开始）
+     *   - string: 按名称模糊匹配返回
+     * @returns 代理组列表，按配置文件顺序排序
+     */
+    async getGroups(mode, filter) {
+        // direct 模式直接返回空数组
+        if (mode === 'direct') {
+            return [];
+        }
+        const proxies = await this.getProxies();
+        const allGroups = Object.values(proxies).filter((p) => 'all' in p && Array.isArray(p.all));
+        // 按配置文件顺序排序
+        const order = this.getProxyGroupOrder();
+        const sortedGroups = order.length > 0
+            ? allGroups.sort((a, b) => {
+                const indexA = order.indexOf(a.name);
+                const indexB = order.indexOf(b.name);
+                if (indexA === -1 && indexB === -1)
+                    return 0;
+                if (indexA === -1)
+                    return 1;
+                if (indexB === -1)
+                    return -1;
+                return indexA - indexB;
+            })
+            : allGroups;
+        // 系统保留组
+        const systemGroups = ['DIRECT', 'REJECT', 'PASS', 'COMPATIBLE'];
+        // 根据 mode 过滤
+        const effectiveMode = mode === 'active' || mode === undefined
+            ? await this.getMode()
+            : mode;
+        let result;
+        if (effectiveMode === 'all') {
+            result = sortedGroups.filter(g => !systemGroups.includes(g.name));
+        }
+        else if (effectiveMode === 'global') {
+            result = sortedGroups.filter(g => g.name === 'GLOBAL');
+        }
+        else {
+            // rule 模式：排除 GLOBAL 和系统组
+            result = sortedGroups.filter(g => g.all.length > 0 &&
+                g.name !== 'GLOBAL' &&
+                !systemGroups.includes(g.name));
+        }
+        // 应用 filter 筛选
+        if (filter === undefined) {
+            return result;
+        }
+        if (typeof filter === 'number') {
+            // 按索引返回
+            if (filter < 0 || filter >= result.length) {
+                return [];
+            }
+            return [result[filter]];
+        }
+        // 按名称模糊匹配
+        const keyword = filter.toLowerCase();
+        return result.filter(g => g.name.toLowerCase().includes(keyword));
+    }
+    /**
+     * 获取单个代理组
+     * @param mode - 模式筛选（同 getGroups）
+     * @param filter - 结果筛选
+     *   - 不传: 返回第一个代理组（主代理组）
+     *   - number: 按索引位置返回（从 0 开始）
+     *   - string: 按名称模糊匹配返回第一个匹配的
+     * @returns 代理组对象，未找到返回 null
+     */
+    async getGroup(mode, filter) {
+        const groups = await this.getGroups(mode);
+        if (groups.length === 0) {
+            return null;
+        }
+        if (filter === undefined) {
+            return groups[0];
+        }
+        if (typeof filter === 'number') {
+            if (filter < 0 || filter >= groups.length)
+                return null;
+            return groups[filter];
+        }
+        // 按名称模糊匹配
+        const keyword = filter.toLowerCase();
+        return groups.find(g => g.name.toLowerCase().includes(keyword)) || null;
+    }
+    /**
+     * 从当前订阅配置文件读取代理组顺序
+     */
+    getProxyGroupOrder() {
+        try {
+            const currentProfile = this.getSub();
+            if (!currentProfile)
+                return [];
+            const profilePath = path.join(this.config.vergeConfigDir, 'profiles', `${currentProfile.uid}.yaml`);
+            if (!fs.existsSync(profilePath))
+                return [];
+            const content = fs.readFileSync(profilePath, 'utf-8');
+            // 找到 proxy-groups: 部分
+            const groupsMatch = content.match(/^proxy-groups:\s*\n([\s\S]*?)(?=^[a-z-]+:|$)/m);
+            if (!groupsMatch)
+                return [];
+            const groupsSection = groupsMatch[1];
+            const order = [];
+            // 匹配内联格式: - { name: xxx, ... } 或 - {name: xxx, ...}
+            const inlineRegex = /^\s*-\s*\{\s*name:\s*([^,}]+)/gm;
+            // 匹配多行格式: - name: xxx
+            const multilineRegex = /^\s*-\s+name:\s*(.+)$/gm;
+            let match;
+            while ((match = inlineRegex.exec(groupsSection)) !== null) {
+                // 去掉引号
+                const name = match[1].trim().replace(/^['"]|['"]$/g, '');
+                order.push(name);
+            }
+            // 如果内联格式没匹配到，尝试多行格式
+            if (order.length === 0) {
+                while ((match = multilineRegex.exec(groupsSection)) !== null) {
+                    const name = match[1].trim().replace(/^['"]|['"]$/g, '');
+                    order.push(name);
+                }
+            }
+            return order;
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * 解析代理组（支持模糊匹配和索引）
+     */
+    async resolveProxyGroup(groupArg) {
+        const groups = await this.getGroups();
+        if (groups.length === 0) {
+            throw new Error('未找到可用的代理组');
+        }
+        if (!groupArg) {
+            return groups[0];
+        }
+        if (groupArg.startsWith('#')) {
+            const index = parseInt(groupArg.slice(1), 10) - 1;
+            if (isNaN(index) || index < 0 || index >= groups.length) {
+                throw new Error(`无效的索引: ${groupArg}，可用范围: #1 - #${groups.length}`);
+            }
+            return groups[index];
+        }
+        const keyword = groupArg.toLowerCase();
+        const matched = groups.find(g => g.name.toLowerCase().includes(keyword));
+        if (!matched) {
+            throw new Error(`未找到匹配的代理组: ${groupArg}`);
+        }
+        return matched;
+    }
+    /**
+     * 解析节点（支持模糊匹配和索引）
+     */
+    resolveProxy(group, proxyArg) {
+        const proxies = group.all;
+        if (proxies.length === 0) {
+            throw new Error(`代理组 ${group.name} 没有可用节点`);
+        }
+        if (proxyArg.startsWith('#')) {
+            const index = parseInt(proxyArg.slice(1), 10) - 1;
+            if (isNaN(index) || index < 0 || index >= proxies.length) {
+                throw new Error(`无效的索引: ${proxyArg}，可用范围: #1 - #${proxies.length}`);
+            }
+            return proxies[index];
+        }
+        const keyword = proxyArg.toLowerCase();
+        const matched = proxies.find(p => p.toLowerCase().includes(keyword));
+        if (!matched) {
+            throw new Error(`未找到匹配的节点: ${proxyArg}`);
+        }
+        return matched;
+    }
+    /**
+     * 切换节点
+     * @param group - 代理组筛选：索引(number)或名称模糊匹配(string)
+     * @param node - 目标节点名称，支持模糊匹配
+     */
+    async setNode(group, node) {
+        const resolvedGroup = await this.getGroup(undefined, group);
+        if (!resolvedGroup) {
+            throw new Error(`未找到代理组: ${group}`);
+        }
+        const keyword = node.toLowerCase();
+        const resolvedNode = resolvedGroup.all.find(n => n.toLowerCase().includes(keyword));
+        if (!resolvedNode) {
+            throw new Error(`未找到节点: ${node}`);
+        }
+        await this.client.put(`/proxies/${encodeURIComponent(resolvedGroup.name)}`, { name: resolvedNode });
+    }
+    /**
+     * 获取代理组内的所有节点
+     * @param filter - 代理组筛选：不传返回主代理组，索引(number)或名称模糊匹配(string)
+     * @returns 节点名称列表
+     */
+    async getNodes(filter) {
+        const group = await this.getGroup(undefined, filter);
+        return group?.all || [];
+    }
+    /**
+     * 测试单个节点延迟
+     * @param node - 节点名称，支持模糊匹配
+     * @param url - 测试 URL，不传使用默认配置
+     * @param timeout - 超时时间（毫秒），不传使用默认配置
+     * @returns 延迟测试结果 { name: 完整节点名, delay: 延迟毫秒数 }
+     */
+    async testNode(node, url, timeout) {
+        // 从主代理组中模糊匹配节点名
+        const group = await this.getGroup();
+        if (!group) {
+            throw new Error('未找到代理组');
+        }
+        const keyword = node.toLowerCase();
+        const resolvedNode = group.all.find(n => n.toLowerCase().includes(keyword)) || node;
+        const testUrl = url || this.config.testUrl;
+        const { data } = await this.client.get(`/proxies/${encodeURIComponent(resolvedNode)}/delay`, { params: { url: testUrl, timeout: timeout || this.config.timeout } });
+        return { name: resolvedNode, delay: data.delay };
+    }
+    /**
+     * 测试多个节点延迟
+     * @param filter - 筛选参数
+     *   - 不传: 测试主代理组的所有节点
+     *   - number: 按索引指定代理组
+     *   - string: 按名称模糊匹配代理组
+     *   - string[]: 指定节点名称列表（可配合 getNodes 使用）
+     * @param url - 测试 URL，不传使用默认配置
+     * @param timeout - 超时时间（毫秒），不传使用默认配置
+     * @returns 延迟测试结果列表，delay 为 -1 表示超时
+     */
+    async testNodes(filter, url, timeout) {
+        const testUrl = url || this.config.testUrl;
+        const testTimeout = timeout || this.config.timeout;
+        // 如果传入节点列表，逐个测试
+        if (Array.isArray(filter)) {
+            const results = [];
+            for (const node of filter) {
+                try {
+                    const { data } = await this.client.get(`/proxies/${encodeURIComponent(node)}/delay`, { params: { url: testUrl, timeout: testTimeout } });
+                    results.push({ name: node, delay: data.delay });
+                }
+                catch {
+                    results.push({ name: node, delay: -1 });
+                }
+            }
+            return results;
+        }
+        // 否则按代理组测试
+        const group = await this.getGroup(undefined, filter);
+        if (!group) {
+            throw new Error(`未找到代理组: ${filter}`);
+        }
+        const { data } = await this.client.get(`/group/${encodeURIComponent(group.name)}/delay`, { params: { url: testUrl, timeout: testTimeout } });
+        return Object.entries(data).map(([name, delay]) => ({
+            name,
+            delay,
+        }));
+    }
+    /**
+     * 自动选择最快节点
+     * @param filter - 代理组筛选：不传使用主代理组，索引(number)或名称模糊匹配(string)
+     * @param url - 测试 URL，不传使用默认配置
+     * @param timeout - 超时时间（毫秒），不传使用默认配置
+     * @returns 切换到的节点信息，无可用节点返回 null
+     */
+    async autoNode(filter, url, timeout) {
+        const group = await this.getGroup(undefined, filter);
+        if (!group) {
+            throw new Error(`未找到代理组: ${filter}`);
+        }
+        const results = await this.testNodes(filter, url, timeout);
+        const available = results
+            .filter(r => r.delay > 0)
+            .sort((a, b) => a.delay - b.delay);
+        if (available.length === 0) {
+            return null;
+        }
+        const best = available[0];
+        await this.setNode(group.name, best.name);
+        return best;
+    }
+    /**
+     * 获取所有订阅列表
+     * @returns 远程订阅列表（type 为 'remote' 的订阅）
+     */
+    getSubs() {
+        const profilesPath = path.join(this.config.vergeConfigDir, 'profiles.yaml');
+        if (!fs.existsSync(profilesPath)) {
+            throw new Error(`未找到配置文件: ${profilesPath}`);
+        }
+        const content = fs.readFileSync(profilesPath, 'utf-8');
+        const profiles = this.parseProfilesYaml(content);
+        return profiles.items.filter(p => p.type === 'remote');
+    }
+    parseProfilesYaml(content) {
+        const result = { current: [], items: [] };
+        const lines = content.split('\n');
+        let inItems = false;
+        let currentItem = null;
+        for (const line of lines) {
+            if (line.startsWith('current:')) {
+                const value = line.slice(8).trim();
+                if (value)
+                    result.current = [value];
+                continue;
+            }
+            if (line.trim() === 'items:') {
+                inItems = true;
+                continue;
+            }
+            if (inItems) {
+                if (line.startsWith('- ')) {
+                    if (currentItem?.uid)
+                        result.items.push(currentItem);
+                    currentItem = {};
+                    const match = line.slice(2).match(/^(\w+):\s*(.*)$/);
+                    if (match && match[2] && match[2] !== 'null') {
+                        currentItem[match[1]] = match[2];
+                    }
+                }
+                else if (line.startsWith('  ') && !line.startsWith('    ') && currentItem) {
+                    const match = line.trim().match(/^(\w+):\s*(.*)$/);
+                    if (match) {
+                        let value = match[2].trim();
+                        if (value === 'null' || value === '')
+                            value = undefined;
+                        else if (/^\d+$/.test(value))
+                            value = parseInt(value);
+                        if (value !== undefined)
+                            currentItem[match[1]] = value;
+                    }
+                }
+            }
+        }
+        if (currentItem?.uid)
+            result.items.push(currentItem);
+        return result;
+    }
+    /**
+     * 获取订阅
+     * @param filter - 筛选参数：不传返回当前激活订阅，索引(number)或名称/UID模糊匹配(string)
+     * @returns 订阅对象，未找到返回 null
+     */
+    getSub(filter) {
+        const subs = this.getSubs();
+        if (filter === undefined) {
+            // 返回当前激活的订阅
+            const profilesPath = path.join(this.config.vergeConfigDir, 'profiles.yaml');
+            if (!fs.existsSync(profilesPath))
+                return null;
+            const content = fs.readFileSync(profilesPath, 'utf-8');
+            const { current } = this.parseProfilesYaml(content);
+            if (current.length === 0)
+                return null;
+            return subs.find(p => p.uid === current[0]) || null;
+        }
+        if (typeof filter === 'number') {
+            if (filter < 0 || filter >= subs.length)
+                return null;
+            return subs[filter];
+        }
+        // 按名称模糊匹配
+        const keyword = filter.toLowerCase();
+        return subs.find(p => p.uid === filter || p.name?.toLowerCase().includes(keyword)) || null;
+    }
+    /**
+     * 切换订阅
+     * @param filter - 订阅筛选：索引(number)或名称/UID模糊匹配(string)
+     * @param restart - 是否重启 Clash Verge，默认 true
+     * @returns 切换到的订阅对象
+     */
+    async setSub(filter, restart = true) {
+        const sub = this.getSub(filter);
+        if (!sub) {
+            throw new Error(`未找到订阅: ${filter}`);
+        }
+        const profilesPath = path.join(this.config.vergeConfigDir, 'profiles.yaml');
+        let content = fs.readFileSync(profilesPath, 'utf-8');
+        content = content.replace(/^current:.*$/m, `current: ${sub.uid}`);
+        fs.writeFileSync(profilesPath, content, 'utf-8');
+        if (restart) {
+            await this.restartClashVerge();
+            await this.waitReady(10000, 200, true);
+        }
+        return sub;
+    }
+    /**
+     * 等待 API 就绪
+     * @param timeout - 超时时间（毫秒），默认 10000
+     * @param interval - 检测间隔（毫秒），默认 200
+     * @param waitDisconnect - 是否先等待 API 断开，默认 false
+     */
+    async waitReady(timeout = 10000, interval = 200, waitDisconnect = false) {
+        const start = Date.now();
+        // 先等待 API 断开
+        if (waitDisconnect) {
+            while (Date.now() - start < timeout) {
+                try {
+                    await this.client.get('/configs');
+                    // 还能连接，继续等待断开
+                    await new Promise(resolve => setTimeout(resolve, interval));
+                }
+                catch {
+                    // 断开了，跳出循环
+                    break;
+                }
+            }
+            // 超时也继续执行，不报错
+        }
+        // 再等待 API 恢复
+        while (Date.now() - start < timeout) {
+            try {
+                const { data: proxies } = await this.client.get('/proxies');
+                const groups = Object.values(proxies.proxies || {}).filter((p) => 'all' in p && Array.isArray(p.all));
+                if (groups.length > 0 && groups.some((g) => g.all?.length > 0)) {
+                    return;
+                }
+            }
+            catch {
+                // 忽略错误，继续等待
+            }
+            await new Promise(resolve => setTimeout(resolve, interval));
+        }
+        throw new Error('等待 API 就绪超时');
+    }
+    /**
+     * 检测进程是否存在
+     */
+    async isProcessRunning(processName) {
+        const execAsync = (0, util_1.promisify)(child_process_1.exec);
+        const platform = os.platform();
+        try {
+            if (platform === 'win32') {
+                const { stdout } = await execAsync(`tasklist /FI "IMAGENAME eq ${processName}" /NH`);
+                return stdout.toLowerCase().includes(processName.toLowerCase());
+            }
+            else {
+                await execAsync(`pgrep -x "${processName}"`);
+                return true;
+            }
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * 等待进程退出
+     */
+    async waitForProcessExit(processName, timeout = 5000, interval = 100) {
+        const start = Date.now();
+        while (Date.now() - start < timeout) {
+            if (!(await this.isProcessRunning(processName))) {
+                return;
+            }
+            await new Promise(resolve => setTimeout(resolve, interval));
+        }
+    }
+    /**
+     * 重启 Clash Verge 应用
+     */
+    async restartClashVerge() {
+        const execAsync = (0, util_1.promisify)(child_process_1.exec);
+        const platform = os.platform();
+        if (platform === 'win32') {
+            const { stdout } = await execAsync('powershell -Command "Get-Process clash-verge -ErrorAction SilentlyContinue | Select-Object -ExpandProperty Path"');
+            const appPath = stdout.trim();
+            if (!appPath)
+                throw new Error('未找到运行中的 Clash Verge 进程');
+            await execAsync('taskkill /IM "clash-verge.exe" /F').catch(() => { });
+            await this.waitForProcessExit('clash-verge.exe');
+            const child = (0, child_process_1.spawn)('cmd', ['/c', 'start', '""', appPath], {
+                detached: true,
+                stdio: 'ignore',
+            });
+            child.unref();
+        }
+        else if (platform === 'darwin') {
+            await execAsync('pkill -x "Clash Verge"').catch(() => { });
+            await this.waitForProcessExit('Clash Verge');
+            const child = (0, child_process_1.spawn)('open', ['-a', 'Clash Verge'], {
+                detached: true,
+                stdio: 'ignore',
+            });
+            child.unref();
+        }
+        else {
+            await execAsync('pkill -x clash-verge').catch(() => { });
+            await this.waitForProcessExit('clash-verge');
+            const child = (0, child_process_1.spawn)('clash-verge', [], {
+                detached: true,
+                stdio: 'ignore',
+            });
+            child.unref();
+        }
+    }
+}
+exports.ClashSwitcher = ClashSwitcher;

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};