@feng3d/ctc 0.0.11 → 0.0.12

package/dist/cli.js

@@ -1,46 +1,171 @@
 #!/usr/bin/env node
 /**
  * @module cli
- * @description 穿透客户端命令行工具模块。
- * 提供 `feng3d-ctc` CLI 命令，支持启动、停止和查询客户端状态。
- * 单实例模式：只允许一个客户端实例运行，多次 start 会向已运行进程添加端口映射。
+ * @description 穿透客户端 CLI - 简洁的命令行工具
+ *
+ * 使用方法：
+ *   npx @feng3d/cts start          # 启动客户端（后台守护进程）
+ *   npx @feng3d/cts stop           # 停止客户端
+ *   npx @feng3d/cts restart        # 重启客户端
+ *   npx @feng3d/cts status         # 查看状态
+ *   npx @feng3d/cts proxies        # 管理代理映射
+ *   npx @feng3d/cts config         # 管理配置
+ *   npx @feng3d/cts boot           # 管理开机自启动
+ *   npx @feng3d/cts logs           # 查看日志
+ *   npx @feng3d/cts open           # 打开管理页面
  */
 import { Command } from 'commander';
 import chalk from 'chalk';
-import { readFileSync, writeFileSync, mkdirSync, unlinkSync, openSync, closeSync, existsSync } from 'fs';
-import { join } from 'path';
+import { readFileSync, writeFileSync, mkdirSync, unlinkSync, existsSync, openSync, closeSync, readSync, statSync } from 'fs';
+import { join, dirname } from 'path';
 import { homedir, platform } from 'os';
 import { spawn, execSync } from 'child_process';
 import { fileURLToPath } from 'url';
-import { WebSocket } from 'ws';
-import { MessageType, createMessage } from '@feng3d/chuantou-shared';
-/** 客户端实例数据目录 */
+import { registerBoot, unregisterBoot, isBootRegistered } from '@feng3d/chuantou-shared';
+/** 数据目录 */
 const DATA_DIR = join(homedir(), '.chuantou');
-/** PID 文件路径 */
-const PID_FILE = join(DATA_DIR, 'client.pid');
-/** 添加代理请求目录 */
-const REQUEST_DIR = join(DATA_DIR, 'proxy-requests');
-/** 添加代理请求文件路径 */
-const ADD_PROXY_REQUEST_FILE = join(DATA_DIR, 'add-proxy-request.json');
+/** 客户端目录 */
+const CLIENT_DIR = join(DATA_DIR, 'client');
+/** 配置文件 */
+const CONFIG_FILE = join(CLIENT_DIR, 'config.json');
+/** PID 文件 */
+const PID_FILE = join(CLIENT_DIR, 'client.pid');
+/** 日志文件 */
+const LOG_FILE = join(CLIENT_DIR, 'client.log');
+/** 管理服务器 URL 默认值 */
+const ADMIN_URL_DEFAULT = 'http://127.0.0.1:9001';
+/** 管理服务器端口默认值 */
+const ADMIN_PORT_DEFAULT = 9001;
 /**
- * 写入 PID 文件
+ * 帮助文本
  */
-function writePidFile(info) {
-    mkdirSync(DATA_DIR, { recursive: true });
-    writeFileSync(PID_FILE, JSON.stringify(info, null, 2));
+const HELP_TEXT = `
+${chalk.bold('用法：')} cts <${chalk.bold('命令')}> [选项]
+
+${chalk.bold('命令：')}
+  ${chalk.cyan('start')}      启动客户端（后台守护进程）
+  ${chalk.cyan('stop')}       关闭客户端
+  ${chalk.cyan('restart')}    重启客户端
+  ${chalk.cyan('status')}     查看运行状态
+  ${chalk.cyan('proxies')}    管理反向代理映射
+  ${chalk.cyan('forward')}    管理正向穿透代理
+  ${chalk.cyan('config')}     管理配置
+  ${chalk.cyan('boot')}      管理开机自启动
+  ${chalk.cyan('logs')}       查看日志
+  ${chalk.cyan('open')}       打开管理页面
+
+${chalk.bold('全局选项：')}
+  ${chalk.yellow('-h, --help')}     显示帮助信息
+  ${chalk.yellow('-v, --version')}  显示版本号
+
+${chalk.bold('start 命令选项：')}
+  ${chalk.yellow('-s, --server <url>')}    服务器地址 (默认: ws://localhost:9000)
+  ${chalk.yellow('-t, --token <token>')}     认证令牌
+  ${chalk.yellow('-p, --proxies <proxies>')}  代理配置 (如: 8080:3000,8081:3001)
+  ${chalk.yellow('--no-boot')}         不注册开机自启动
+  ${chalk.yellow('-o, --open')}            启动后打开管理页面
+
+${chalk.bold('proxies 命令（反向代理）：')}
+  ${chalk.yellow('list')}              列出所有代理映射
+  ${chalk.yellow('add <remote:local>')}  添加代理 (如: 8080:3000)
+  ${chalk.yellow('remove <port>')}     移除指定端口的代理
+  ${chalk.yellow('clear')}            清空所有代理
+
+${chalk.bold('forward 命令（正向穿透）：')}
+  ${chalk.yellow('list')}              列出所有正向穿透代理
+  ${chalk.yellow('add <local:remote:client>')}  添加穿透 (如: 8080:3000:clientB)
+  ${chalk.yellow('remove <localPort>')} 移除指定本地端口的穿透
+  ${chalk.yellow('clients')}           查看在线客户端列表
+  ${chalk.yellow('register')}          注册到服务器启用正向穿透
+
+${chalk.bold('config 命令选项：')}
+  ${chalk.yellow('get [key]')}       获取配置项
+  ${chalk.yellow('set <key> <value>')}  设置配置项
+  ${chalk.yellow('list')}            列出所有配置
+  ${chalk.yellow('edit')}           编辑配置文件
+
+${chalk.bold('boot 命令选项：')}
+  ${chalk.yellow('enable')}           启用开机自启动
+  ${chalk.yellow('disable')}          禁用开机自启动
+
+${chalk.dim('配置文件位置：')} ${CONFIG_FILE}
+${chalk.dim('日志文件位置：')} ${LOG_FILE}
+${chalk.dim('管理页面：')} http://127.0.0.1:9001
+
+${chalk.dim('示例：')}
+  ${chalk.gray('# 启动客户端')}
+  cts start --server ws://192.168.1.100:9000 --token mytoken
+
+  ${chalk.gray('# 正向穿透模式：注册并添加映射')}
+  cts forward register --description "我的电脑"
+  cts forward clients
+  cts forward add 8080:3000:clientB
+  cts forward list
+
+  ${chalk.gray('# 反向代理模式：暴露本地服务')}
+  cts proxies add 8080:3000
+  cts proxies list
+
+  ${chalk.gray('# 管理配置')}
+  cts config set serverUrl ws://localhost:9000
+  cts config set token mytoken
+
+  ${chalk.gray('# 开机自启动')}
+  cts boot enable
+`;
+/**
+ * 版本号
+ */
+const VERSION = '0.1.0';
+/**
+ * 显示帮助信息
+ */
+function showHelp() {
+    console.log(HELP_TEXT);
+}
+/**
+ * 显示版本号
+ */
+function showVersion() {
+    console.log(`@feng3d/cts v${VERSION}`);
+}
+/**
+ * 读取配置文件
+ */
+function readConfig() {
+    try {
+        const content = readFileSync(CONFIG_FILE, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * 写入配置文件
+ */
+function writeConfig(config) {
+    mkdirSync(CLIENT_DIR, { recursive: true });
+    writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
 }
 /**
  * 读取 PID 文件
  */
 function readPidFile() {
     try {
-        const content = readFileSync(PID_FILE, 'utf-8');
-        return JSON.parse(content);
+        return JSON.parse(readFileSync(PID_FILE, 'utf-8'));
     }
     catch {
         return null;
     }
 }
+/**
+ * 写入 PID 文件
+ */
+function writePidFile(info) {
+    mkdirSync(CLIENT_DIR, { recursive: true });
+    writeFileSync(PID_FILE, JSON.stringify(info, null, 2));
+}
 /**
  * 删除 PID 文件
  */
@@ -64,178 +189,184 @@ function isClientRunning() {
         return true;
     }
     catch {
-        // 进程不存在，清理 PID 文件
-        removePidFile();
         return false;
     }
 }
 /**
- * 在浏览器中打开 URL
+ * 获取客户端状态
  */
-function openBrowser(url) {
-    const os = platform();
+async function getClientStatus(adminPort = ADMIN_PORT_DEFAULT) {
     try {
-        if (os === 'win32') {
-            execSync(`cmd.exe /c start "" "${url}"`, { stdio: 'ignore' });
-        }
-        else if (os === 'darwin') {
-            execSync(`open "${url}"`, { stdio: 'ignore' });
-        }
-        else {
-            // Linux
-            execSync(`xdg-open "${url}"`, { stdio: 'ignore' });
-        }
+        const res = await fetch(`http://127.0.0.1:${adminPort}/_ctc/status`, { method: 'GET' });
+        if (!res.ok)
+            return null;
+        const data = await res.json();
+        return data;
     }
     catch {
-        // 忽略错误，浏览器打开失败不影响服务
+        return null;
     }
 }
-/** 通用服务器选项 */
-const serverOptions = [
-    ['-s, --server <url>', '服务器地址 (如 ws://localhost:9000)', 'ws://localhost:9000'],
-    ['-t, --token <token>', '认证令牌'],
-    ['-p, --proxies <proxies>', '代理配置 (格式: remotePort:localPort[:localHost]，每个端口同时支持 HTTP/WebSocket/TCP)'],
-    ['--reconnect-interval <ms>', '重连间隔（毫秒）', '5000'],
-    ['--max-reconnect <number>', '最大重连次数', '10'],
-];
+/**
+ * 脚本路径
+ */
+const cliPath = fileURLToPath(import.meta.url);
+// index.js 是实际运行客户端的入口（包含管理服务器）
+const indexPath = join(dirname(cliPath), 'index.js');
+const nodePath = process.execPath;
+/**
+ * 主程序入口
+ */
 const program = new Command();
 program
-    .name('feng3d-ctc')
+    .name('@feng3d/cts')
     .description(chalk.blue('穿透 - 内网穿透客户端'))
-    .version('0.0.5');
-// ====== start 命令 ======
-const startCmd = program.command('start').description('启动客户端（后台运行）');
-for (const opt of serverOptions) {
-    if (opt.length === 3) {
-        startCmd.option(opt[0], opt[1], opt[2]);
+    .version(VERSION)
+    .option('-h, --help', '显示帮助信息')
+    .hook('preAction', (thisCommand) => {
+    const options = thisCommand.opts();
+    if (options.help) {
+        showHelp();
+        process.exit(0);
     }
-    else {
-        startCmd.option(opt[0], opt[1]);
+});
+// ==================== start 命令 ====================
+const startCmd = program.command('start')
+    .description('启动客户端（后台守护进程）')
+    .option('-s, --server <url>', '服务器地址')
+    .option('-t, --token <token>', '认证令牌')
+    .option('-p, --proxies <proxies>', '代理配置（格式：remotePort:localPort[:localHost]，多个用逗号分隔）')
+    .option('--admin-port <port>', '管理页面端口（默认：9001）')
+    .option('--no-boot', '不注册开机自启动')
+    .option('-o, --open', '启动后打开管理页面')
+    .action(async (options) => {
+    // 检查是否已在运行
+    if (isClientRunning()) {
+        const info = readPidFile();
+        console.log(chalk.yellow('客户端已在运行中'));
+        console.log(chalk.gray(`  PID: ${info?.pid}`));
+        console.log(chalk.gray(`  服务器: ${info?.serverUrl}`));
+        return;
+    }
+    // 加载配置
+    let serverUrl = options.server;
+    let token = options.token;
+    const proxiesArg = options.proxies;
+    // 如果命令行没有指定，从配置文件读取
+    if (!serverUrl || !token) {
+        const config = readConfig();
+        if (config) {
+            if (!serverUrl)
+                serverUrl = config.serverUrl;
+            if (!token)
+                token = config.token || '';
+        }
+    }
+    // 如果仍然没有服务器地址，使用默认值
+    if (!serverUrl) {
+        serverUrl = 'ws://localhost:9000';
+        console.log(chalk.yellow('未指定服务器地址，使用默认值：ws://localhost:9000'));
     }
-}
-startCmd.option('--no-daemon', '前台运行（不作为后台守护进程）');
-startCmd.option('-o, --open', '启动后在浏览器中打开管理页面');
-startCmd.action(async (options) => {
-    const serverUrl = options.server;
-    const token = options.token;
-    const proxiesStr = options.proxies;
-    const shouldOpenBrowser = options.open;
     // 解析代理配置
-    const proxies = [];
-    if (proxiesStr) {
-        for (const p of proxiesStr.split(',')) {
-            const parts = p.trim().split(':');
+    if (proxiesArg) {
+        const defaultConfig = {
+            serverUrl: '',
+            token: '',
+            reconnectInterval: 30000,
+            maxReconnectAttempts: 10,
+            proxies: []
+        };
+        const config = readConfig() || defaultConfig;
+        config.serverUrl = serverUrl;
+        config.token = token;
+        // 解析代理配置：remotePort:localPort[:localHost]，多个用逗号分隔
+        const proxyList = proxiesArg.split(',').map((p) => p.trim()).filter((p) => p);
+        for (const proxyStr of proxyList) {
+            const parts = proxyStr.split(':');
+            if (parts.length < 2) {
+                console.log(chalk.yellow(`忽略无效的代理配置: ${proxyStr}`));
+                continue;
+            }
             const remotePort = parseInt(parts[0], 10);
             const localPort = parseInt(parts[1], 10);
-            const localHost = (parts.length >= 3 && parts[2]) ? parts[2] : 'localhost';
-            proxies.push({ remotePort, localPort, localHost });
+            const localHost = parts.length >= 3 ? parts[2] : 'localhost';
+            if (isNaN(remotePort) || isNaN(localPort)) {
+                console.log(chalk.yellow(`忽略无效的代理配置: ${proxyStr}`));
+                continue;
+            }
+            if (!config.proxies)
+                config.proxies = [];
+            // 检查是否已存在相同 remotePort
+            const existingIndex = config.proxies.findIndex(p => p.remotePort === remotePort);
+            if (existingIndex !== -1) {
+                config.proxies[existingIndex] = { remotePort, localPort, localHost };
+            }
+            else {
+                config.proxies.push({ remotePort, localPort, localHost });
+            }
         }
+        writeConfig(config);
     }
-    // 检查客户端是否已运行
-    if (isClientRunning()) {
-        const info = readPidFile();
-        // 检查服务器地址是否一致
-        if (info.serverUrl !== serverUrl) {
-            console.log(chalk.yellow('客户端正在运行，但连接到不同的服务器'));
-            console.log(chalk.gray(`  当前: ${info.serverUrl}`));
-            console.log(chalk.gray(`  新请求: ${serverUrl}`));
-            console.log(chalk.yellow('请先停止当前客户端，或使用相同的服务器地址'));
-            process.exit(1);
-        }
-        // 客户端已运行，添加代理映射
-        console.log(chalk.green('客户端正在运行，添加新的代理映射...'));
-        for (const proxy of proxies) {
-            await addProxyToRunningClient(info.serverUrl, token, proxy);
-        }
-        return;
-    }
-    // 构建 _serve 参数
-    const serveArgs = [];
-    serveArgs.push('--server', serverUrl);
+    // 启动参数
+    const serveArgs = ['--config', CONFIG_FILE];
+    if (serverUrl)
+        serveArgs.push('--server', serverUrl);
     if (token)
         serveArgs.push('--token', token);
-    if (proxiesStr)
-        serveArgs.push('--proxies', proxiesStr);
-    serveArgs.push('--reconnect-interval', options.reconnectInterval);
-    serveArgs.push('--max-reconnect', options.maxReconnect);
-    // 是否后台运行
-    const daemon = options.daemon !== false;
-    if (daemon) {
-        // 后台守护进程模式
-        const scriptPath = fileURLToPath(import.meta.url);
-        const nodePath = process.execPath;
-        const logPath = join(DATA_DIR, 'client.log');
-        // 打开日志文件
-        const logFd = openSync(logPath, 'a');
-        // 启动后台守护进程
-        const child = spawn(nodePath, [scriptPath, '_serve', ...serveArgs], {
-            detached: true,
-            stdio: ['ignore', logFd, logFd],
-        });
-        child.unref();
-        closeSync(logFd);
-        // 等待一小段时间让进程启动
-        await new Promise((r) => setTimeout(r, 500));
-        // 验证进程是否启动成功
-        const pid = child.pid;
-        if (pid === undefined) {
-            console.log(chalk.red('客户端启动失败，请查看日志文件:'));
-            console.log(chalk.gray(`  ${logPath}`));
-            process.exit(1);
-        }
-        try {
-            process.kill(pid, 0);
-        }
-        catch {
-            console.log(chalk.red('客户端启动失败，请查看日志文件:'));
-            console.log(chalk.gray(`  ${logPath}`));
-            process.exit(1);
-        }
-        // 写入 PID 文件
+    const adminPort = options.adminPort ? parseInt(options.adminPort, 10) : ADMIN_PORT_DEFAULT;
+    serveArgs.push('--admin-port', adminPort.toString());
+    // 打开日志文件
+    const logFd = openSync(LOG_FILE, 'a');
+    // 启动守护进程
+    const child = spawn(nodePath, [indexPath, ...serveArgs], {
+        detached: true,
+        stdio: ['ignore', logFd, logFd],
+    });
+    // 写入 PID 文件
+    if (child.pid !== undefined) {
         writePidFile({
+            pid: child.pid,
             serverUrl,
-            pid,
+            adminPort,
             startedAt: Date.now(),
         });
-        console.log(chalk.green('客户端已在后台启动'));
-        console.log(chalk.gray(`  PID: ${pid}`));
-        console.log(chalk.gray(`  服务器: ${serverUrl}`));
-        console.log(chalk.gray(`  日志: ${logPath}`));
-        if (proxies.length > 0) {
-            console.log(chalk.gray(`  代理映射:`));
-            for (const proxy of proxies) {
-                console.log(chalk.gray(`    :${proxy.remotePort} -> ${proxy.localHost || 'localhost'}:${proxy.localPort}`));
-            }
+    }
+    child.unref();
+    closeSync(logFd);
+    console.log(chalk.green('客户端已在后台启动'));
+    console.log(chalk.gray(`  PID: ${child.pid}`));
+    console.log(chalk.gray(`  服务器: ${serverUrl}`));
+    console.log(chalk.gray(`  管理页面: http://127.0.0.1:${adminPort}`));
+    console.log(chalk.gray(`  配置: ${CONFIG_FILE}`));
+    console.log(chalk.gray(`  日志: ${LOG_FILE}`));
+    // 如果需要开机自启动
+    if (options.boot !== false) {
+        try {
+            registerBoot({
+                isServer: false,
+                nodePath,
+                scriptPath: indexPath,
+                args: serveArgs,
+            });
+            console.log(chalk.green('已启用开机自启动'));
         }
-        // 打开浏览器
-        if (shouldOpenBrowser) {
-            setTimeout(() => {
-                openBrowser('http://127.0.0.1:9001/');
-            }, 2000);
+        catch (err) {
+            console.log(chalk.yellow(`注册开机自启动失败: ${err.message}`));
         }
     }
-    else {
-        // 前台运行模式
-        await runServe(serverUrl, token, proxiesStr, options.reconnectInterval, options.maxReconnect, shouldOpenBrowser);
-    }
-});
-// ====== _serve 命令（隐藏，前台运行）======
-const serveCmd = program.command('_serve', { hidden: true }).description('前台运行客户端（内部命令）');
-for (const opt of serverOptions) {
-    if (opt.length === 3) {
-        serveCmd.option(opt[0], opt[1], opt[2]);
-    }
-    else {
-        serveCmd.option(opt[0], opt[1]);
+    // 打开管理页面
+    if (options.open) {
+        setTimeout(() => {
+            const adminPage = `http://127.0.0.1:${adminPort}`;
+            console.log(chalk.gray(`打开管理页面: ${adminPage}`));
+            const openCmd = platform() === 'win32' ? 'start' : 'open';
+            execSync(`${openCmd} ${adminPage}`, { stdio: 'ignore' });
+        }, 1000);
     }
-}
-serveCmd.action(async (options) => {
-    await runServe(options.server, options.token, options.proxies, options.reconnectInterval, options.maxReconnect);
 });
-// ====== stop 命令 ======
-program
-    .command('stop')
-    .description('停止客户端')
+// ==================== stop 命令 ====================
+const stopCmd = program.command('stop')
+    .description('关闭客户端')
     .action(async () => {
     const info = readPidFile();
     if (!info) {
@@ -246,197 +377,677 @@ program
         process.kill(info.pid, 'SIGTERM');
     }
     catch (err) {
-        console.log(chalk.yellow(`停止客户端失败: ${err instanceof Error ? err.message : err}`));
+        console.log(chalk.yellow(`关闭失败: ${err.message}`));
+        return;
     }
-    // 清理代理请求目录
+    removePidFile();
+    // 取消开机自启动
     try {
-        const { readdirSync, unlinkSync, existsSync } = require('fs');
-        const REQUEST_DIR = require('./path').join(require('os').homedir(), '.chuantou', 'proxy-requests');
-        if (existsSync(REQUEST_DIR)) {
-            const files = readdirSync(REQUEST_DIR);
-            for (const file of files) {
-                if (file.endsWith('.json') || file.endsWith('.resp')) {
-                    try {
-                        unlinkSync(require('./path').join(REQUEST_DIR, file));
-                    }
-                    catch {
-                        // 忽略错误
-                    }
-                }
-            }
-        }
+        unregisterBoot();
     }
-    catch {
-        // 忽略清理错误
+    catch (err) {
+        // ignore
     }
+    console.log(chalk.green('客户端已关闭'));
+});
+// ==================== restart 命令 ====================
+const restartCmd = program.command('restart')
+    .description('重启客户端')
+    .action(async () => {
+    console.log(chalk.blue('正在重启客户端...'));
+    const info = readPidFile();
+    const pid = info?.pid;
+    // 先停止
+    if (pid) {
+        try {
+            process.kill(pid, 'SIGTERM');
+            console.log(chalk.gray(`已发送停止信号到 PID ${pid}`));
+        }
+        catch (err) {
+            console.log(chalk.yellow(`停止失败: ${err.message}`));
+        }
+    }
+    // 等待进程结束
+    await new Promise(resolve => setTimeout(resolve, 2000));
+    // 清除 PID 文件，让 start 命令重新读取
     removePidFile();
-    console.log(chalk.green('客户端已停止'));
+    // 重新启动（不带参数，使用配置文件）
+    // 启动一个新的 start 命令进程
+    const startChild = spawn(nodePath, [cliPath, 'start'], {
+        detached: true,
+        stdio: 'ignore',
+    });
+    startChild.unref();
+    console.log(chalk.green('客户端已重启'));
+    // 等待客户端启动并显示状态
+    await new Promise(resolve => setTimeout(resolve, 2000));
+    const newInfo = readPidFile();
+    if (newInfo) {
+        console.log(chalk.gray(`  PID: ${newInfo.pid}`));
+        console.log(chalk.gray(`  管理页面: http://127.0.0.1:${newInfo.adminPort}`));
+    }
+    else {
+        console.log(chalk.yellow('  启动状态: 未知'));
+    }
 });
-// ====== status 命令 ======
-program
-    .command('status')
-    .description('查询客户端状态')
+// ==================== status 命令 ====================
+const statusCmd = program.command('status')
+    .description('查看运行状态')
     .action(async () => {
     const info = readPidFile();
     if (!info) {
         console.log(chalk.yellow('客户端未在运行'));
+        console.log(chalk.gray('状态: 已停止'));
         return;
     }
-    const uptime = Math.floor((Date.now() - info.startedAt) / 1000);
-    const minutes = Math.floor(uptime / 60);
-    const seconds = uptime % 60;
     console.log(chalk.blue.bold('穿透客户端状态'));
-    console.log(chalk.gray(`  运行中: 是`));
-    console.log(chalk.gray(`  服务器: ${info.serverUrl}`));
     console.log(chalk.gray(`  PID: ${info.pid}`));
-    console.log(chalk.gray(`  运行时长: ${minutes}分${seconds}秒`));
-    // 尝试获取代理列表状态
+    console.log(chalk.gray(`  服务器: ${info.serverUrl}`));
+    console.log(chalk.gray(`  管理页面: http://127.0.0.1:${info.adminPort}`));
+    console.log(chalk.gray(`  配置: ${CONFIG_FILE}`));
+    console.log(chalk.gray(`  日志: ${LOG_FILE}`));
+    console.log(chalk.gray(`  启动时间: ${new Date(info.startedAt).toLocaleString('zh-CN')}`));
+    console.log(chalk.gray(`  开机启动: ${isBootRegistered() ? '已启用' : '未启用'}`));
+    // 获取详细状态
+    const status = await getClientStatus(info.adminPort);
+    if (status) {
+        const uptime = Math.floor(status.uptime / 1000);
+        const minutes = Math.floor(uptime / 60);
+        const seconds = uptime % 60;
+        console.log(chalk.gray(`  连接状态: ${status.authenticated ? '已认证' : status.connected ? '已连接' : '未连接'}`));
+        if (uptime > 0) {
+            console.log(chalk.gray(`  运行时长: ${minutes}分${seconds}秒`));
+        }
+        if (status.reconnectAttempts && status.reconnectAttempts > 0) {
+            console.log(chalk.gray(`  重连次数: ${status.reconnectAttempts}次`));
+        }
+        if (status.proxies.length === 0) {
+            console.log(chalk.gray('  代理映射: 无'));
+        }
+        else {
+            console.log(chalk.gray(`  代理映射: ${status.proxies.length}个`));
+            for (const proxy of status.proxies) {
+                const index = proxy.index ? `#${proxy.index}` : ' -';
+                const target = proxy.localHost || 'localhost';
+                const registered = proxy.registered === false ? chalk.yellow(' (待注册)') : '';
+                console.log(chalk.gray(`    ${index} ${proxy.remotePort} -> ${target}:${proxy.localPort}`) + registered);
+            }
+        }
+    }
+    else {
+        console.log(chalk.yellow('无法获取状态（管理服务器未就绪）'));
+    }
+});
+// ==================== proxies 命令 ====================
+const proxiesCmd = program.command('proxies')
+    .description('管理代理映射')
+    .argument('[command]', '子命令：list, add, remove, clear', { default: 'list' });
+// proxies list 子命令
+proxiesCmd.command('list')
+    .description('列出现有代理映射')
+    .action(async () => {
+    const config = readConfig();
+    const proxies = config?.proxies || [];
+    if (proxies.length === 0) {
+        console.log(chalk.yellow('暂无代理映射'));
+        return;
+    }
+    console.log(chalk.blue.bold('代理映射列表：'));
+    for (let i = 0; i < proxies.length; i++) {
+        const proxy = proxies[i];
+        const index = proxy.index ? `#${proxy.index}` : ' -';
+        const target = proxy.localHost || 'localhost';
+        console.log(`  ${chalk.cyan(index)} ${chalk.cyan(proxy.remotePort.toString())} -> ${chalk.cyan(target)}:${chalk.cyan(proxy.localPort.toString())}`);
+    }
+});
+// proxies add 子命令
+proxiesCmd.command('add')
+    .description('添加代理映射')
+    .argument('<remote:local>', '远程端口:本地端口 (如: 8080:3000 或 8080:3000:192.168.1.100)')
+    .option('-h, --host <address>', '本地主机地址 (默认为 localhost)')
+    .action(async (remoteLocal, options) => {
+    // 解析参数
+    const parts = remoteLocal.split(':');
+    if (parts.length < 2) {
+        console.log(chalk.yellow('参数格式错误，应为：远程端口:本地端口'));
+        console.log(chalk.gray('示例：8080:3000 或 8080:3000:192.168.1.100'));
+        return;
+    }
+    const remotePort = parseInt(parts[0], 10);
+    let localPort;
+    let localHost = 'localhost';
+    // 检查是否有第三部分（主机地址）
+    if (parts.length >= 3) {
+        localPort = parseInt(parts[1], 10);
+        localHost = parts[2];
+    }
+    else {
+        localPort = parseInt(parts[1], 10);
+    }
+    // 验证端口
+    if (isNaN(remotePort) || remotePort < 1024 || remotePort > 65535) {
+        console.log(chalk.yellow('远程端口无效：1024-65535'));
+        return;
+    }
+    if (isNaN(localPort) || localPort < 1 || localPort > 65535) {
+        console.log(chalk.yellow('本地端口无效：1-65535'));
+        return;
+    }
+    // 通过 API 添加
     try {
-        const proxies = await getProxiesFromRunningClient(info.serverUrl);
-        if (proxies.length > 0) {
-            console.log(chalk.gray(`  代理数量: ${proxies.length}`));
+        const info = readPidFile();
+        const adminPort = info?.adminPort ?? ADMIN_PORT_DEFAULT;
+        const res = await fetch(`http://127.0.0.1:${adminPort}/_ctc/proxies`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                remotePort,
+                localPort,
+                localHost,
+            }),
+        });
+        if (res.ok) {
+            console.log(chalk.green('代理映射已添加'));
+            // 更新本地配置文件
+            const config = readConfig();
+            if (config) {
+                if (!config.proxies)
+                    config.proxies = [];
+                config.proxies.push({ remotePort, localPort, localHost });
+                writeConfig(config);
+            }
+            const target = localHost || 'localhost';
+            console.log(chalk.gray(`  ${remotePort} -> ${target}:${localPort}`));
+        }
+        else if (res.status === 404) {
+            console.log(chalk.yellow('代理映射不存在（管理服务器未运行）'));
+        }
+        else {
+            const data = await res.json();
+            console.log(chalk.red(`添加失败: ${data.error || '未知错误'}`));
         }
     }
-    catch {
-        // 无法获取代理列表，可能客户端还未完全启动
+    catch (err) {
+        console.log(chalk.red(`请求失败: ${err.message}`));
     }
 });
-// ====== list 命令（列出代理）======
-program
-    .command('list')
-    .description('列出当前代理映射')
+// proxies remove 子命令
+proxiesCmd.command('remove')
+    .description('移除指定端口的代理映射')
+    .argument('<port>', '远程端口号')
+    .action(async (remotePort) => {
+    const port = parseInt(remotePort, 10);
+    if (isNaN(port) || port < 1024 || port > 65535) {
+        console.log(chalk.yellow('端口号无效：1024-65535'));
+        return;
+    }
+    // 通过 API 删除
+    try {
+        const info = readPidFile();
+        const adminPort = info?.adminPort ?? ADMIN_PORT_DEFAULT;
+        const res = await fetch(`http://127.0.0.1:${adminPort}/_ctc/proxies/${port}`, {
+            method: 'DELETE',
+        });
+        if (res.ok) {
+            console.log(chalk.green(`端口 ${port} 的代理映射已移除`));
+            // 更新本地配置文件
+            const config = readConfig();
+            if (config && config.proxies) {
+                const index = config.proxies.findIndex(p => p.remotePort === port);
+                if (index !== -1) {
+                    config.proxies.splice(index, 1);
+                    writeConfig(config);
+                }
+            }
+        }
+        else if (res.status === 404) {
+            console.log(chalk.yellow('代理映射不存在'));
+        }
+        else {
+            const data = await res.json();
+            console.log(chalk.red(`移除失败: ${data.error || '未知错误'}`));
+        }
+    }
+    catch (err) {
+        console.log(chalk.red(`请求失败: ${err.message}`));
+    }
+});
+// proxies clear 子命令
+proxiesCmd.command('clear')
+    .description('清空所有代理映射')
     .action(async () => {
-    const info = readPidFile();
-    if (!info) {
-        console.log(chalk.yellow('客户端未在运行'));
+    try {
+        const info = readPidFile();
+        const adminPort = info?.adminPort ?? ADMIN_PORT_DEFAULT;
+        const res = await fetch(`http://127.0.0.1:${adminPort}/_ctc/proxies`, {
+            method: 'DELETE',
+        });
+        if (res.ok) {
+            console.log(chalk.green('所有代理映射已清空'));
+            // 更新本地配置文件
+            const config = readConfig();
+            if (config) {
+                config.proxies = [];
+                writeConfig(config);
+            }
+        }
+        else {
+            const data = await res.json();
+            console.log(chalk.red(`清空失败: ${data.error || '未知错误'}`));
+        }
+    }
+    catch (err) {
+        console.log(chalk.red(`请求失败: ${err.message}`));
+    }
+});
+// ==================== config 命令 ====================
+const configCmd = program.command('config')
+    .description('管理配置')
+    .argument('[command]', '子命令：get, set, list, edit', { default: 'list' });
+// config get 子命令
+configCmd.command('get')
+    .description('获取配置项')
+    .argument('<key>', '配置项名称 (如: serverUrl, token, reconnectInterval, maxReconnectAttempts)')
+    .action(async (key) => {
+    const config = readConfig();
+    if (!config) {
+        console.log(chalk.yellow('配置文件不存在'));
+        return;
+    }
+    const value = config[key];
+    if (value === undefined) {
+        console.log(chalk.yellow(`配置项 "${key}" 不存在`));
+        console.log(chalk.gray('可用配置项：serverUrl, token, reconnectInterval, maxReconnectAttempts, proxies'));
+        return;
+    }
+    // 显示值
+    if (typeof value === 'object') {
+        console.log(chalk.green(`${key}:`));
+        console.log(chalk.gray(JSON.stringify(value, null, 2)));
+    }
+    else {
+        console.log(chalk.green(`${key}: ${value}`));
+    }
+});
+// config set 子命令
+configCmd.command('set')
+    .description('设置配置项')
+    .argument('<key>', '配置项名称')
+    .argument('<value>', '配置值')
+    .action(async (key, value) => {
+    // 读取现有配置
+    const config = readConfig() || {};
+    const oldValue = config[key];
+    // 解析值
+    let parsedValue = value;
+    if (key === 'serverUrl' || key === 'token') {
+        parsedValue = value;
+    }
+    else if (key === 'reconnectInterval' || key === 'maxReconnectAttempts') {
+        parsedValue = parseInt(value, 10);
+    }
+    else if (key === 'proxies') {
+        try {
+            parsedValue = JSON.parse(value);
+        }
+        catch {
+            console.log(chalk.yellow('proxies 必须是有效的 JSON 数组'));
+            return;
+        }
+    }
+    // 更新配置
+    config[key] = parsedValue;
+    writeConfig(config);
+    if (oldValue !== undefined) {
+        console.log(chalk.green(`已更新：${key}`));
+        console.log(chalk.gray(`  旧值: ${typeof oldValue === 'object' ? JSON.stringify(oldValue) : oldValue}`));
+        console.log(chalk.gray(`  新值: ${typeof parsedValue === 'object' ? JSON.stringify(parsedValue) : parsedValue}`));
+    }
+    else {
+        console.log(chalk.green(`已设置：${key} = ${typeof parsedValue === 'object' ? JSON.stringify(parsedValue) : parsedValue}`));
+    }
+});
+// config list 子命令
+configCmd.command('list')
+    .description('列出所有配置项')
+    .action(async () => {
+    const config = readConfig();
+    if (!config) {
+        console.log(chalk.yellow('配置文件不存在'));
         return;
     }
+    console.log(chalk.blue.bold('配置列表：'));
+    console.log(`  ${chalk.cyan('serverUrl')}:     ${chalk.gray(config.serverUrl || '(未设置)')}`);
+    console.log(`  ${chalk.cyan('token')}:         ${chalk.gray(config.token || '(未设置)')}`);
+    console.log(`  ${chalk.cyan('proxies')}:       ${chalk.gray(`[${config.proxies?.map(p => `${p.remotePort}:${p.localPort}`).join(', ') || '(空)'}]`)}`);
+    console.log(`  ${chalk.cyan('reconnectInterval')}: ${chalk.gray(config.reconnectInterval || 30000)}ms`);
+    console.log(`  ${chalk.cyan('maxReconnectAttempts')}: ${chalk.gray(config.maxReconnectAttempts || 10)}`);
+});
+// config edit 子命令
+configCmd.command('edit')
+    .description('编辑配置文件')
+    .action(async () => {
+    const editors = {
+        win32: 'notepad',
+        darwin: 'open -a TextEdit',
+        linux: 'nano',
+    };
+    const editor = editors[platform()] || 'vi';
+    const configPath = CONFIG_FILE;
+    console.log(chalk.gray(`打开配置文件：${configPath}`));
+    console.log(chalk.gray(`使用编辑器：${editor}`));
     try {
-        const proxies = await getProxiesFromRunningClient(info.serverUrl);
+        execSync(`${editor} "${configPath}"`, { stdio: 'ignore' });
+    }
+    catch (err) {
+        console.log(chalk.yellow(`打开失败: ${err.message}`));
+        console.log(chalk.gray(`请手动打开：`));
+    }
+});
+// ==================== forward 命令（正向穿透模式）====================
+const forwardCmd = program.command('forward')
+    .description('管理正向穿透代理（本地端口 -> 远程客户端端口）')
+    .argument('[command]', '子命令：list, add, remove, clients, register', { default: 'list' });
+// forward list 子命令
+forwardCmd.command('list')
+    .description('列出所有正向穿透代理')
+    .action(async () => {
+    try {
+        const info = readPidFile();
+        const adminPort = info?.adminPort ?? ADMIN_PORT_DEFAULT;
+        const res = await fetch(`http://127.0.0.1:${adminPort}/_ctc/forward/list`);
+        if (!res.ok) {
+            console.log(chalk.yellow('无法获取代理列表（客户端未运行或功能不可用）'));
+            return;
+        }
+        const data = await res.json();
+        const proxies = data.proxies || [];
         if (proxies.length === 0) {
-            console.log(chalk.yellow('没有代理映射'));
+            console.log(chalk.yellow('暂无正向穿透代理'));
             return;
         }
-        console.log(chalk.blue.bold('当前代理映射:'));
-        console.log();
+        console.log(chalk.blue.bold('正向穿透代理列表：'));
         for (const proxy of proxies) {
-            console.log(chalk.gray(`  :${proxy.remotePort} -> ${proxy.localHost || 'localhost'}:${proxy.localPort}`));
+            const status = proxy.enabled ? chalk.green('●') : chalk.gray('○');
+            console.log(`  ${status} 本地 :${proxy.localPort} → ${chalk.cyan(proxy.targetClientId)}:${proxy.targetPort}`);
         }
     }
     catch (err) {
-        console.log(chalk.yellow(`获取代理列表失败: ${err instanceof Error ? err.message : err}`));
+        console.log(chalk.red(`请求失败: ${err.message}`));
     }
 });
-/**
- * 向正在运行的客户端添加代理映射
- * 通过写入请求文件，让主客户端进程来处理注册
- */
-async function addProxyToRunningClient(serverUrl, token, proxy) {
-    // 检查服务器地址是否匹配
+// forward add 子命令
+forwardCmd.command('add')
+    .description('添加正向穿透代理')
+    .argument('<mapping>', '映射格式：localPort:remotePort:targetClientId (如: 8080:3000:clientB)')
+    .action(async (mapping) => {
+    const parts = mapping.split(':');
+    if (parts.length !== 3) {
+        console.log(chalk.yellow('参数格式错误，应为：localPort:remotePort:targetClientId'));
+        console.log(chalk.gray('示例：8080:3000:clientB'));
+        return;
+    }
+    const localPort = parseInt(parts[0], 10);
+    const targetPort = parseInt(parts[1], 10);
+    const targetClientId = parts[2];
+    if (isNaN(localPort) || localPort < 1 || localPort > 65535) {
+        console.log(chalk.yellow('本地端口无效：1-65535'));
+        return;
+    }
+    if (isNaN(targetPort) || targetPort < 1 || targetPort > 65535) {
+        console.log(chalk.yellow('目标端口无效：1-65535'));
+        return;
+    }
+    if (!targetClientId || targetClientId.length === 0) {
+        console.log(chalk.yellow('目标客户端 ID 不能为空'));
+        return;
+    }
+    try {
+        const info = readPidFile();
+        const adminPort = info?.adminPort ?? ADMIN_PORT_DEFAULT;
+        const res = await fetch(`http://127.0.0.1:${adminPort}/_ctc/forward/add`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ localPort, targetClientId, targetPort }),
+        });
+        if (res.ok) {
+            console.log(chalk.green('正向穿透代理已添加'));
+            console.log(chalk.gray(`  本地 :${localPort} → ${targetClientId}:${targetPort}`));
+        }
+        else if (res.status === 404) {
+            console.log(chalk.yellow('客户端未运行或功能不可用'));
+        }
+        else {
+            const data = await res.json();
+            console.log(chalk.red(`添加失败: ${data.error || '未知错误'}`));
+        }
+    }
+    catch (err) {
+        console.log(chalk.red(`请求失败: ${err.message}`));
+    }
+});
+// forward remove 子命令
+forwardCmd.command('remove')
+    .description('移除正向穿透代理')
+    .argument('<localPort>', '本地端口号')
+    .action(async (localPort) => {
+    const port = parseInt(localPort, 10);
+    if (isNaN(port) || port < 1 || port > 65535) {
+        console.log(chalk.yellow('端口号无效：1-65535'));
+        return;
+    }
+    try {
+        const info = readPidFile();
+        const adminPort = info?.adminPort ?? ADMIN_PORT_DEFAULT;
+        const res = await fetch(`http://127.0.0.1:${adminPort}/_ctc/forward/remove`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ localPort: port }),
+        });
+        if (res.ok) {
+            console.log(chalk.green(`本地端口 ${port} 的正向穿透代理已移除`));
+        }
+        else {
+            const data = await res.json();
+            console.log(chalk.red(`移除失败: ${data.error || '未知错误'}`));
+        }
+    }
+    catch (err) {
+        console.log(chalk.red(`请求失败: ${err.message}`));
+    }
+});
+// forward clients 子命令
+forwardCmd.command('clients')
+    .description('查看在线客户端列表')
+    .action(async () => {
+    try {
+        const info = readPidFile();
+        const adminPort = info?.adminPort ?? ADMIN_PORT_DEFAULT;
+        const res = await fetch(`http://127.0.0.1:${adminPort}/_ctc/forward/clients`);
+        if (!res.ok) {
+            console.log(chalk.yellow('无法获取客户端列表'));
+            return;
+        }
+        const data = await res.json();
+        const clients = data.clients || [];
+        if (clients.length === 0) {
+            console.log(chalk.yellow('暂无在线客户端'));
+            return;
+        }
+        console.log(chalk.blue.bold('在线客户端列表：'));
+        for (const client of clients) {
+            const desc = client.description ? ` (${client.description})` : '';
+            console.log(`  ${chalk.cyan(client.id)}${desc}`);
+        }
+    }
+    catch (err) {
+        console.log(chalk.red(`请求失败: ${err.message}`));
+    }
+});
+// forward register 子命令
+forwardCmd.command('register')
+    .description('注册到服务器（启用正向穿透模式）')
+    .option('-d, --description <desc>', '客户端描述')
+    .action(async (options) => {
+    try {
+        const info = readPidFile();
+        const adminPort = info?.adminPort ?? ADMIN_PORT_DEFAULT;
+        const res = await fetch(`http://127.0.0.1:${adminPort}/_ctc/forward/register`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ description: options.description || '' }),
+        });
+        if (res.ok) {
+            console.log(chalk.green('已注册到服务器，正向穿透模式已启用'));
+        }
+        else {
+            const data = await res.json();
+            console.log(chalk.red(`注册失败: ${data.error || '未知错误'}`));
+        }
+    }
+    catch (err) {
+        console.log(chalk.red(`请求失败: ${err.message}`));
+    }
+});
+// ==================== boot 命令 ====================
+const bootCmd = program.command('boot')
+    .description('管理开机自启动')
+    .argument('[command]', '子命令：enable, disable, status', { default: 'status' });
+// boot status 子命令
+bootCmd.command('status')
+    .description('查看开机自启动状态')
+    .action(async () => {
+    const registered = isBootRegistered();
+    const status = registered ? chalk.green('已启用') : chalk.yellow('未启用');
+    console.log(chalk.blue('开机自启动状态：') + status);
+    if (registered) {
+        const info = readPidFile();
+        if (info) {
+            console.log(chalk.gray(`  启动文件将运行：${info.serverUrl}`));
+        }
+    }
+});
+// boot enable 子命令
+bootCmd.command('enable')
+    .description('启用开机自启动')
+    .action(async () => {
     const info = readPidFile();
-    if (info && info.serverUrl !== serverUrl) {
-        throw new Error('服务器地址不匹配');
-    }
-    // 创建请求目录
-    mkdirSync(REQUEST_DIR, { recursive: true });
-    // 写入请求文件
-    const requestId = `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-    const requestFilePath = join(REQUEST_DIR, `${requestId}.json`);
-    const requestData = {
-        type: 'add-proxy',
-        proxy,
-        timestamp: Date.now(),
-    };
-    writeFileSync(requestFilePath, JSON.stringify(requestData, null, 2));
-    // 等待响应文件
-    const responseFilePath = join(REQUEST_DIR, `${requestId}.resp`);
-    const timeout = 10000; // 10秒超时
-    const startTime = Date.now();
-    while (Date.now() - startTime < timeout) {
-        if (existsSync(responseFilePath)) {
-            const response = JSON.parse(readFileSync(responseFilePath, 'utf-8'));
-            // 清理请求和响应文件
+    if (!info) {
+        console.log(chalk.yellow('客户端未启动过，请先使用 start 命令启动'));
+        return;
+    }
+    try {
+        registerBoot({
+            isServer: false,
+            nodePath,
+            scriptPath: indexPath,
+            args: info.args || [],
+        });
+        console.log(chalk.green('已启用开机自启动'));
+    }
+    catch (err) {
+        console.log(chalk.red(`启用失败: ${err.message}`));
+    }
+});
+// boot disable 子命令
+bootCmd.command('disable')
+    .description('禁用开机自启动')
+    .action(async () => {
+    try {
+        unregisterBoot();
+        console.log(chalk.green('已禁用开机自启动'));
+    }
+    catch (err) {
+        console.log(chalk.red(`禁用失败: ${err.message}`));
+    }
+});
+// ==================== logs 命令 ====================
+const logsCmd = program.command('logs')
+    .description('查看或跟踪日志')
+    .option('-f, --follow', '跟踪日志输出（类似 tail -f）')
+    .action(async (options) => {
+    if (!existsSync(LOG_FILE)) {
+        console.log(chalk.yellow('日志文件不存在'));
+        return;
+    }
+    if (options.follow) {
+        console.log(chalk.blue('跟踪日志输出 (Ctrl+C 退出)...'));
+        console.log(chalk.dim('---'));
+        const logFd = openSync(LOG_FILE, 'r');
+        const buffer = Buffer.alloc(1024);
+        let pos = 0;
+        const readLog = () => {
             try {
-                unlinkSync(requestFilePath);
-                unlinkSync(responseFilePath);
+                const bytesRead = readSync(logFd, buffer, 0, buffer.length, pos);
+                if (bytesRead > 0) {
+                    const content = buffer.toString('utf-8', 0, bytesRead);
+                    process.stdout.write(content);
+                    pos += bytesRead;
+                }
             }
-            catch { }
-            if (response.success) {
-                console.log(chalk.green(`✓ 代理已添加: :${proxy.remotePort} -> ${proxy.localHost || 'localhost'}:${proxy.localPort}`));
-                return;
+            catch {
+                // ignore
             }
-            else {
-                const errorMsg = response.error || '未知错误';
-                // 检查是否是重复代理错误
-                if (errorMsg.includes('已存在') || errorMsg.includes('already') || errorMsg.includes('duplicate')) {
-                    console.log(chalk.yellow(`⚠  代理已存在: :${proxy.remotePort} -> ${proxy.localHost || 'localhost'}:${proxy.localPort}`));
-                    return;
+        };
+        // 读取最新内容
+        readLog();
+        // 监控文件变化
+        const watcher = () => {
+            try {
+                const stat = statSync(LOG_FILE);
+                const newSize = stat.size;
+                if (newSize > pos) {
+                    readLog();
                 }
-                throw new Error(errorMsg);
             }
-        }
-        await new Promise(r => setTimeout(r, 100));
+            catch (err) {
+                // ignore
+            }
+        };
+        // 每秒检查一次
+        const interval = setInterval(watcher, 1000);
+        // 处理退出
+        process.on('SIGINT', () => {
+            clearInterval(interval);
+            closeSync(logFd);
+            process.stdout.write('\n');
+            console.log(chalk.gray('\n--- 日志跟踪已结束'));
+            process.exit(0);
+        });
+    }
+    else {
+        // 显示所有日志
+        const content = readFileSync(LOG_FILE, 'utf-8');
+        console.log(chalk.blue('最近日志：'));
+        console.log(chalk.dim('---'));
+        console.log(content.split('\n').slice(-30).join('\n'));
+        console.log(chalk.dim('---'));
+        console.log(chalk.gray(`(日志文件：${LOG_FILE})`));
     }
-    // 超时，清理请求文件
+});
+// ==================== open 命令 ====================
+const openCmd = program.command('open')
+    .description('在浏览器中打开管理页面')
+    .action(async () => {
+    const info = readPidFile();
+    const adminPort = info?.adminPort ?? ADMIN_PORT_DEFAULT;
+    const adminPage = `http://127.0.0.1:${adminPort}`;
+    const openCmd = platform() === 'win32' ? 'start' : 'open';
+    console.log(chalk.gray(`打开管理页面: ${adminPage}`));
     try {
-        unlinkSync(requestFilePath);
+        execSync(`${openCmd} ${adminPage}`, { stdio: 'ignore' });
+        console.log(chalk.green('管理页面已在浏览器中打开'));
     }
-    catch { }
-    throw new Error('添加代理超时');
-}
-/**
- * 从正在运行的客户端获取代理列表
- */
-async function getProxiesFromRunningClient(serverUrl) {
-    return new Promise((resolve, reject) => {
-        const ws = new WebSocket(serverUrl);
-        const timeout = setTimeout(() => {
-            ws.close();
-            resolve([]);
-        }, 3000);
-        ws.on('open', async () => {
-            // 发送获取代理列表请求（使用心跳消息保持连接）
-            const heartbeatMsg = createMessage(MessageType.HEARTBEAT, {
-                timestamp: Date.now(),
-            });
-            ws.send(JSON.stringify(heartbeatMsg));
-            // 这里简化处理，实际上应该有一个专门的 GET_PROXIES 消息类型
-            // 目前返回空数组
-            clearTimeout(timeout);
-            ws.close();
-            resolve([]);
-        });
-        ws.on('error', () => {
-            clearTimeout(timeout);
-            resolve([]);
-        });
-    });
-}
-/**
- * 运行客户端（前台模式）
- */
-async function runServe(serverUrl, token, proxies, reconnectInterval, maxReconnect, shouldOpenBrowser) {
-    // 设置 process.argv 供 Config.load 读取
-    process.argv = [
-        process.argv[0],
-        process.argv[1],
-        '--server', serverUrl,
-        '--reconnect-interval', reconnectInterval,
-        '--max-reconnect', maxReconnect,
-    ];
-    if (token)
-        process.argv.push('--token', token);
-    if (proxies)
-        process.argv.push('--proxies', proxies);
-    // 动态导入 index 模块运行
-    const { run } = await import('./index.js');
-    // 如果需要打开浏览器，延迟打开
-    if (shouldOpenBrowser) {
-        setTimeout(() => {
-            openBrowser('http://127.0.0.1:9001/');
-        }, 3000);
+    catch (err) {
+        console.log(chalk.yellow(`打开失败: ${err.message}`));
+        console.log(chalk.gray(`请手动访问：${adminPage}`));
     }
-    await run();
-}
+});
+// ==================== 默认处理 ====================
+// 当没有指定命令时显示帮助
+program.action(() => {
+    showHelp();
+});
+// 解析命令行参数
 program.parse();
 //# sourceMappingURL=cli.js.map