@feng3d/ctc 0.0.20 → 0.2.0

package/dist/cli.js

@@ -1,1006 +1,230 @@
 #!/usr/bin/env node
 /**
  * @module cli
- * @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 forward        # 管理正向穿透
- *   npx @feng3d/cts config         # 管理配置
- *   npx @feng3d/cts boot           # 管理开机自启动
- *   npx @feng3d/cts logs           # 查看日志
- *   npx @feng3d/cts open           # 打开管理页面
+ * 穿透客户端命令行入口。
+ *
+ * 提供两条命令：
+ *
+ *   1. 设置服务端访问信息（写入配置文件）：
+ *      npx -y @feng3d/ctc set -ip <serverip> -p <serverport> -t <token> [--tls]
+ *
+ *   2. 映射本地端口到服务端（服务端自动分配端口并返回）：
+ *      npx -y @feng3d/ctc -p <localPort> [-d]
+ *
+ * 运行模式：
+ *   - 默认前台：进程依附终端，终端关闭即停止
+ *   - -d / --detach：后台运行，脱离终端；停止用系统 kill <pid>
  */
 import { Command } from 'commander';
-import chalk from 'chalk';
-import { readFileSync, writeFileSync, mkdirSync, unlinkSync, existsSync, openSync, closeSync, readSync, statSync } from 'fs';
-import { join, dirname } from 'path';
+import { spawn } from 'child_process';
+import { writeFileSync, openSync, unlinkSync, mkdirSync, existsSync, readFileSync } from 'fs';
 import { homedir, platform } from 'os';
-import { spawn, execSync } from 'child_process';
+import { join } from 'path';
 import { fileURLToPath } from 'url';
-import { getActiveBootLevel, hasSystemPrivileges } from '@feng3d/chuantou-shared';
-import { registerBoot, unregisterBoot, isBootRegistered } from '@feng3d/chuantou-shared';
-import { killProcess } from './process-utils.js';
-/** 数据目录 */
+import chalk from 'chalk';
+import { PROTOCOL, DEFAULT_CONFIG } from '@feng3d/chuantou-shared';
+import { Controller } from './controller.js';
+import { ProxyManager } from './proxy-manager.js';
+import { loadConfig, saveConfig } from './config.js';
+/** chuantou 运行时目录：~/.chuantou */
 const DATA_DIR = join(homedir(), '.chuantou');
-/** IPC 请求目录 */
-const IPC_REQUEST_DIR = join(homedir(), '.chuantou', 'proxy-requests');
-/**
- * 通过 IPC 向守护进程发送请求
- * @param type - 请求类型
- * @param payload - 请求负载
- * @param timeout - 超时时间（毫秒）
- * @returns 响应数据
- */
-async function sendIpcRequest(type, payload = {}, timeout = 5000) {
-    const requestId = `${Date.now()}_${Math.random().toString(36).substring(7)}`;
-    const requestPath = join(IPC_REQUEST_DIR, `${requestId}.json`);
-    const responsePath = join(IPC_REQUEST_DIR, `${requestId}.resp`);
-    try {
-        // 写入请求文件
-        mkdirSync(IPC_REQUEST_DIR, { recursive: true });
-        writeFileSync(requestPath, JSON.stringify({ type, ...payload }));
-        // 轮询响应文件
-        const startTime = Date.now();
-        while (Date.now() - startTime < timeout) {
-            if (existsSync(responsePath)) {
-                const response = JSON.parse(readFileSync(responsePath, 'utf-8'));
-                // 删除响应文件
-                unlinkSync(responsePath);
-                return response;
-            }
-            await new Promise(resolve => setTimeout(resolve, 100));
-        }
-        return { success: false, error: '请求超时' };
-    }
-    catch (err) {
-        return { success: false, error: err.message };
-    }
-}
-/** 客户端目录 */
-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;
-/**
- * 帮助文本
- */
-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.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('示例：')}
-  ${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 {
-        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 文件
- */
-function removePidFile() {
-    try {
-        unlinkSync(PID_FILE);
-    }
-    catch {
-        // ignore
-    }
-}
-/**
- * 检查客户端是否正在运行
- */
-function isClientRunning() {
-    const info = readPidFile();
-    if (!info)
-        return false;
-    try {
-        process.kill(info.pid, 0);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * 获取客户端状态
- */
-async function getClientStatus(adminPort = ADMIN_PORT_DEFAULT) {
-    try {
-        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 cliPath = fileURLToPath(import.meta.url);
-// daemon-entry.js 是守护进程入口
-const daemonEntryPath = join(dirname(cliPath), 'daemon-entry.js');
-const nodePath = process.execPath;
-/**
- * 主程序入口
- */
+const PID_FILE = join(DATA_DIR, 'client.pid');
+const LOG_FILE = join(DATA_DIR, 'client.log');
+/** 标记已是后台子进程，避免无限 spawn */
+const DETACHED_ENV = '__CHUANTOU_DETACHED';
 const program = new Command();
 program
-    .name('@feng3d/cts')
+    .name('feng3d-ctc')
     .description(chalk.blue('穿透 - 内网穿透客户端'))
-    .version(VERSION)
-    .option('-h, --help', '显示帮助信息')
-    .hook('preAction', (thisCommand) => {
-    const options = thisCommand.opts();
-    if (options.help) {
-        showHelp();
-        process.exit(0);
+    .version('0.1.0');
+// ---- 子命令：set ----
+// 注意：commander 短选项只能是单字符，无法直接支持 "-ip"。
+// 通过在 parse 前将 "-ip" 重写为 "--ip" 来兼容用户习惯的 "-ip <serverip>" 写法。
+const setCmd = program.command('set').description('设置服务端访问信息');
+setCmd.requiredOption('--ip <ip>', '服务端 IP 或域名（可用 -ip 简写）');
+setCmd.requiredOption('-p, --server-port <port>', '服务端控制端口');
+setCmd.requiredOption('-t, --token <token>', '认证 token');
+setCmd.option('--tls', '服务端启用 TLS（使用 wss/https）', false);
+setCmd.action(async (options) => {
+    const config = {
+        serverIp: options.ip,
+        serverPort: parseInt(options.serverPort, 10),
+        token: options.token,
+        tls: !!options.tls,
+    };
+    try {
+        await saveConfig(config);
+        const scheme = config.tls ? 'wss' : 'ws';
+        console.log(chalk.green('配置已保存到 ~/.chuantou/config.json'));
+        console.log(chalk.gray(`  服务端: ${scheme}://${config.serverIp}:${config.serverPort}`));
+        console.log(chalk.gray(`  下一步: feng3d-ctc -p <本地端口>  映射本地端口`));
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        console.error(chalk.red(`保存配置失败: ${msg}`));
+        process.exit(1);
     }
 });
-// ==================== start 命令 ====================
-const startCmd = program.command('start')
-    .description('启动客户端（后台守护进程）')
-    .option('-s, --server <url>', '服务器地址')
-    .option('-t, --token <token>', '认证令牌')
-    .option('-p, --proxies <proxies>', '代理配置（格式：remotePort:localPort[:localHost]，多个用逗号分隔）')
-    .option('--no-boot', '不注册开机自启动')
+// ---- 默认动作：映射本地端口 ----
+program
+    .option('-p, --port <localPort>', '要映射的本地端口')
+    .option('-d, --detach', '后台运行（终端关闭不停止）')
     .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}`));
+    // 没有 -p 时显示帮助
+    if (!options.port) {
+        program.help();
         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'));
-    }
-    // 解析代理配置
-    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] : '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);
-    }
-    // 启动参数
-    const serveArgs = ['--config', CONFIG_FILE];
-    if (serverUrl)
-        serveArgs.push('--server', serverUrl);
-    if (token)
-        serveArgs.push('--token', token);
-    // 确保目录存在并打开日志文件
-    mkdirSync(CLIENT_DIR, { recursive: true });
-    const logFd = openSync(LOG_FILE, 'a');
-    // 启动守护进程
-    const child = spawn(nodePath, [daemonEntryPath, ...serveArgs], {
-        detached: true,
-        stdio: ['ignore', logFd, logFd],
-    });
-    // PID 文件由子进程（守护进程）在 checkSingleInstance 中自行写入
-    child.unref();
-    closeSync(logFd);
-    console.log(chalk.green('客户端已在后台启动'));
-    console.log(chalk.gray(`  PID: ${child.pid}`));
-    console.log(chalk.gray(`  服务器: ${serverUrl}`));
-    console.log(chalk.gray(`  配置: ${CONFIG_FILE}`));
-    console.log(chalk.gray(`  日志: ${LOG_FILE}`));
-    // 如果需要开机自启动（智能选择级别）
-    if (options.boot !== false) {
-        try {
-            const result = registerBoot({
-                isServer: false,
-                nodePath,
-                scriptPath: daemonEntryPath,
-                args: serveArgs,
-            }, { level: 'auto' }); // 默认使用 auto 智能选择
-            if (result.level === 'system') {
-                console.log(chalk.green('已启用开机自启动（系统级）'));
-                console.log(chalk.gray('  启动时机: 系统启动时（无需登录桌面）'));
-            }
-            else {
-                console.log(chalk.green('已启用开机自启动（用户级）'));
-                if (result.needsElevation) {
-                    console.log(chalk.yellow('  提示: 当前为用户级启动。如需登录前启动，请以管理员/root权限重试'));
-                }
-            }
-        }
-        catch (err) {
-            console.log(chalk.yellow(`注册开机自启动失败: ${err.message}`));
-        }
+    const localPort = parseInt(options.port, 10);
+    if (!localPort || localPort < 1 || localPort > 65535) {
+        console.error(chalk.red(`无效的本地端口: ${options.port}`));
+        process.exit(1);
     }
-});
-// ==================== stop 命令 ====================
-const stopCmd = program.command('stop')
-    .description('关闭客户端')
-    .action(async () => {
-    const info = readPidFile();
-    if (!info) {
-        console.log(chalk.yellow('客户端未在运行'));
+    // 后台模式：父进程 spawn 自身后退出
+    if (options.detach && process.env[DETACHED_ENV] !== '1') {
+        spawnDetached(localPort);
         return;
     }
-    // 降级关闭：kill → 检测存在性
-    const result = await killProcess(info.pid);
-    if (result.success) {
-        removePidFile();
-        // 取消开机自启动
-        try {
-            unregisterBoot();
-        }
-        catch {
-            // ignore
-        }
-        if (result.method === 'already-dead') {
-            console.log(chalk.yellow('进程已不存在，已清理状态'));
-        }
-        else {
-            console.log(chalk.green('客户端已关闭'));
-        }
-    }
-    else {
-        console.log(chalk.red(`关闭失败: ${result.error || '未知错误'}`));
-    }
+    await runProxy(localPort);
 });
-// ==================== restart 命令 ====================
-const restartCmd = program.command('restart')
-    .description('重启客户端')
-    .action(async () => {
-    console.log(chalk.blue('正在重启客户端...'));
-    const info = readPidFile();
-    const pid = info?.pid;
-    // 先停止
-    if (pid) {
+// 兼容用户习惯的 "-ip" 与 "set -p" 简写：
+//   1. commander 短选项只能是单字符，"-ip" 不合法 → 重写为 "--ip"
+//   2. 默认动作与 set 子命令都用 "-p"，program 级别的 "-p" 会拦截子命令参数。
+//      在 set 上下文中把 "-p" 重写为 "--server-port" 以正确路由到子命令。
+const rawArgv = process.argv.slice(2);
+const isSetCtx = rawArgv[0] === 'set';
+const argvRewritten = process.argv.map((arg) => {
+    if (arg === '-ip')
+        return '--ip';
+    if (isSetCtx && arg === '-p')
+        return '--server-port';
+    return arg;
+});
+program.parseAsync(argvRewritten).catch((error) => {
+    const msg = error instanceof Error ? error.message : String(error);
+    console.error(chalk.red(`错误: ${msg}`));
+    process.exit(1);
+});
+/**
+ * 运行端口映射：连接服务端 → 认证 → 注册代理（服务端自动分配端口）→ 打印结果
+ *
+ * @param localPort - 要映射的本地端口
+ */
+async function runProxy(localPort) {
+    let config;
+    try {
+        config = await loadConfig();
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        console.error(chalk.red(msg));
+        process.exit(1);
+    }
+    const scheme = config.tls ? 'wss' : 'ws';
+    const serverUrl = `${scheme}://${config.serverIp}:${config.serverPort}${PROTOCOL.CONTROL_PATH}`;
+    const controller = new Controller({
+        serverUrl,
+        token: config.token,
+        reconnectInterval: DEFAULT_CONFIG.RECONNECT_INTERVAL,
+        maxReconnectAttempts: DEFAULT_CONFIG.MAX_RECONNECT_ATTEMPTS,
+    });
+    const proxyManager = new ProxyManager(controller);
+    // 认证成功后注册代理
+    controller.on('authenticated', async () => {
         try {
-            // Windows 不支持 SIGTERM，需要使用 taskkill 命令
-            if (platform() === 'win32') {
-                execSync(`taskkill /F /PID ${pid}`, { stdio: 'ignore' });
-            }
-            else {
-                process.kill(pid, 'SIGTERM');
-            }
-            console.log(chalk.gray(`已发送停止信号到 PID ${pid}`));
+            await proxyManager.registerProxy({ localPort });
         }
-        catch (err) {
-            console.log(chalk.yellow(`停止失败: ${err.message}`));
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            console.error(chalk.red(`映射失败: ${msg}`));
+            process.exit(1);
         }
-    }
-    // 等待进程结束
-    await new Promise(resolve => setTimeout(resolve, 2000));
-    // 清除 PID 文件，让 start 命令重新读取
-    removePidFile();
-    // 重新启动（不带参数，使用配置文件）
-    // 启动一个新的 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 命令 ====================
-const statusCmd = program.command('status')
-    .description('查看运行状态')
-    .action(async () => {
-    const info = readPidFile();
-    if (!info) {
-        console.log(chalk.yellow('客户端未在运行'));
-        console.log(chalk.gray('状态: 已停止'));
-        return;
-    }
-    console.log(chalk.blue.bold('穿透客户端状态'));
-    console.log(chalk.gray(`  PID: ${info.pid}`));
-    console.log(chalk.gray(`  服务器: ${info.serverUrl}`));
-    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() ? '已启用' : '未启用'}`));
-    // 通过 IPC 获取详细状态
-    const response = await sendIpcRequest('get-status');
-    if (response.success && response.status) {
-        const status = response.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);
-            }
-        }
-        if (status.forwardProxies && status.forwardProxies.length > 0) {
-            console.log(chalk.gray(`  正向穿透: ${status.forwardProxies.length}个`));
-            for (const fp of status.forwardProxies) {
-                console.log(chalk.gray(`    :${fp.localPort} -> ${fp.targetClientId}:${fp.targetPort}`));
-            }
-        }
-    }
-    else {
-        console.log(chalk.yellow(`无法获取状态: ${response.error || '守护进程未就绪'}`));
-    }
-});
-// ==================== 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;
-    }
-    // 通过 IPC 添加
-    const response = await sendIpcRequest('add-proxy', {
-        proxy: { remotePort, localPort, localHost }
+    // 注册成功后打印映射端口
+    proxyManager.on('registered', (assignedPort) => {
+        // 代理端口启用 TLS（自签），访问地址用 https；控制端口仍为 ws/http
+        const accessScheme = 'https';
+        console.log('');
+        console.log(chalk.green('  端口映射成功'));
+        console.log(chalk.gray('  ───────────────────────────────────'));
+        console.log(`  ${chalk.cyan('本地端口')}: ${localPort}`);
+        console.log(`  ${chalk.cyan('服务端映射端口')}: ${chalk.yellow(assignedPort)}`);
+        console.log(`  ${chalk.cyan('访问地址')}: ${accessScheme}://${config.serverIp}:${assignedPort}`);
+        console.log(chalk.gray(`  提示: 首次访问会有证书警告，在教程页(${config.serverIp}:${config.serverPort})下载安装证书后可消除`));
+        console.log(chalk.gray('  ───────────────────────────────────'));
+        console.log('');
     });
-    if (response.success) {
-        console.log(chalk.green('代理映射已添加'));
-        const target = localHost || 'localhost';
-        console.log(chalk.gray(`  ${remotePort} -> ${target}:${localPort}`));
-    }
-    else {
-        console.log(chalk.red(`添加失败: ${response.error || '未知错误'}`));
-    }
-});
-// 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;
-    }
-    // 通过 IPC 删除
-    const response = await sendIpcRequest('remove-proxy', { remotePort: port });
-    if (response.success) {
-        console.log(chalk.green(`端口 ${port} 的代理映射已移除`));
-    }
-    else {
-        console.log(chalk.red(`移除失败: ${response.error || '未知错误'}`));
-    }
-});
-// proxies clear 子命令
-proxiesCmd.command('clear')
-    .description('清空所有代理映射')
-    .action(async () => {
-    const response = await sendIpcRequest('clear-proxies');
-    if (response.success) {
-        console.log(chalk.green('所有代理映射已清空'));
-    }
-    else {
-        console.log(chalk.red(`清空失败: ${response.error || '未知错误'}`));
-    }
-});
-// ==================== 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') {
+    // 写入 PID 文件
+    mkdirSync(DATA_DIR, { recursive: true });
+    writeFileSync(PID_FILE, String(process.pid), 'utf-8');
+    console.log(chalk.gray(`PID: ${process.pid}`));
+    // 优雅退出
+    const shutdown = async (signal) => {
+        console.log(chalk.yellow(`\n收到 ${signal}，正在停止...`));
         try {
-            parsedValue = JSON.parse(value);
+            await proxyManager.destroy();
         }
-        catch {
-            console.log(chalk.yellow('proxies 必须是有效的 JSON 数组'));
-            return;
+        catch { /* ignore */ }
+        controller.destroy();
+        try {
+            if (existsSync(PID_FILE))
+                unlinkSync(PID_FILE);
         }
-    }
-    // 更新配置
-    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',
+        catch { /* ignore */ }
+        process.exit(0);
     };
-    const editor = editors[platform()] || 'vi';
-    const configPath = CONFIG_FILE;
-    console.log(chalk.gray(`打开配置文件：${configPath}`));
-    console.log(chalk.gray(`使用编辑器：${editor}`));
+    process.on('SIGINT', () => void shutdown('SIGINT'));
+    process.on('SIGTERM', () => void shutdown('SIGTERM'));
+    // 启动连接
     try {
-        execSync(`${editor} "${configPath}"`, { stdio: 'ignore' });
+        await controller.connect();
     }
-    catch (err) {
-        console.log(chalk.yellow(`打开失败: ${err.message}`));
-        console.log(chalk.gray(`请手动打开：`));
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        console.error(chalk.red(`连接服务端失败: ${msg}`));
+        process.exit(1);
     }
-});
-// ==================== forward 命令（正向穿透模式）====================
-const forwardCmd = program.command('forward')
-    .description('管理正向穿透代理（本地端口 -> 远程客户端端口）')
-    .argument('[command]', '子命令：list, add, remove, clients, register', { default: 'list' });
-// forward list 子命令
-forwardCmd.command('list')
-    .description('列出所有正向穿透代理')
-    .action(async () => {
-    const response = await sendIpcRequest('forward-list');
-    if (!response.success) {
-        console.log(chalk.yellow(`无法获取代理列表: ${response.error || '客户端未运行'}`));
-        return;
-    }
-    const proxies = response.proxies || [];
-    if (proxies.length === 0) {
-        console.log(chalk.yellow('暂无正向穿透代理'));
-        return;
-    }
-    console.log(chalk.blue.bold('正向穿透代理列表：'));
-    for (const proxy of proxies) {
-        console.log(`  ${chalk.green('●')} 本地 :${proxy.localPort} → ${chalk.cyan(proxy.targetClientId)}:${proxy.targetPort}`);
-    }
-});
-// forward add 子命令
-forwardCmd.command('add')
-    .description('添加正向穿透代理')
-    .argument('<mapping>', '映射格式：localPort:targetPort:targetClientId (如: 8080:3000:clientB)')
-    .action(async (mapping) => {
-    const parts = mapping.split(':');
-    if (parts.length !== 3) {
-        console.log(chalk.yellow('参数格式错误，应为：localPort:targetPort: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;
-    }
-    const response = await sendIpcRequest('forward-add', {
-        forwardEntry: { localPort, targetPort, targetClientId }
+    // 前台驻留
+    process.stdin.resume();
+}
+/**
+ * 以后台模式 spawn 自身
+ */
+function spawnDetached(localPort) {
+    mkdirSync(DATA_DIR, { recursive: true });
+    cleanupStalePid(PID_FILE);
+    const logFd = openSync(LOG_FILE, 'a');
+    const nodePath = process.execPath;
+    const scriptPath = fileURLToPath(import.meta.url);
+    const child = spawn(nodePath, [scriptPath, '-p', String(localPort)], {
+        detached: true,
+        stdio: ['ignore', logFd, logFd],
+        env: { ...process.env, [DETACHED_ENV]: '1' },
     });
-    if (response.success) {
-        console.log(chalk.green('正向穿透代理已添加'));
-        console.log(chalk.gray(`  本地 :${localPort} → ${targetClientId}:${targetPort}`));
-    }
-    else {
-        console.log(chalk.red(`添加失败: ${response.error || '未知错误'}`));
-    }
-});
-// 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;
-    }
-    const response = await sendIpcRequest('forward-remove', { localPort: port });
-    if (response.success) {
-        console.log(chalk.green(`本地端口 ${port} 的正向穿透代理已移除`));
-    }
-    else {
-        console.log(chalk.red(`移除失败: ${response.error || '未知错误'}`));
-    }
-});
-// forward clients 子命令
-forwardCmd.command('clients')
-    .description('查看在线客户端列表')
-    .action(async () => {
-    const response = await sendIpcRequest('forward-clients');
-    if (!response.success) {
-        console.log(chalk.yellow(`无法获取客户端列表: ${response.error || '未知错误'}`));
-        return;
-    }
-    const clients = response.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}`);
-    }
-});
-// forward register 子命令
-forwardCmd.command('register')
-    .description('注册到服务器（启用正向穿透模式）')
-    .option('-d, --description <desc>', '客户端描述')
-    .action(async (options) => {
-    const response = await sendIpcRequest('forward-register', { description: options.description || '' });
-    if (response.success) {
-        console.log(chalk.green('已注册到服务器，正向穿透模式已启用'));
-    }
-    else {
-        console.log(chalk.red(`注册失败: ${response.error || '未知错误'}`));
-    }
-});
-// ==================== boot 命令 ====================
-const bootCmd = program.command('boot')
-    .description('管理开机自启动')
-    .argument('[command]', '子命令：enable, disable, status', { default: 'status' });
-// boot status 子命令
-bootCmd.command('status')
-    .description('查看开机自启动状态')
-    .action(async () => {
-    const activeLevel = getActiveBootLevel();
-    const hasSystemPriv = hasSystemPrivileges();
-    console.log(chalk.blue('开机自启动状态：'));
-    if (activeLevel === 'system') {
-        console.log(chalk.green('  状态: 已启用（系统级）'));
-        console.log(chalk.gray('  启动时机: 系统启动时（无需登录桌面）'));
-        console.log(chalk.gray('  配置路径: ' + (platform() === 'win32' ? 'C:\\ProgramData\\chuantou' : '/etc/chuantou')));
-    }
-    else if (activeLevel === 'user') {
-        console.log(chalk.yellow('  状态: 已启用（用户级）'));
-        console.log(chalk.gray('  启动时机: 用户登录后'));
-        if (hasSystemPriv) {
-            console.log(chalk.dim('  提示: 可升级到系统级启动（登录前启动）'));
-        }
-    }
-    else {
-        console.log(chalk.yellow('  状态: 未启用'));
-    }
-    // 显示权限状态
-    if (!activeLevel) {
-        console.log(chalk.gray(`  当前权限: ${hasSystemPriv ? '有管理员权限（可注册系统级）' : '普通用户（仅可注册用户级）'}`));
-    }
-});
-// boot enable 子命令
-bootCmd.command('enable')
-    .description('启用开机自启动（智能选择系统级/用户级）')
-    .option('--system', '强制使用系统级启动（需要管理员权限）')
-    .option('--user', '强制使用用户级启动（登录后启动）')
-    .action(async (options) => {
-    const info = readPidFile();
-    if (!info) {
-        console.log(chalk.yellow('客户端未启动过，请先使用 start 命令启动'));
+    child.unref();
+    console.log(chalk.green(`客户端已在后台启动（PID: ${child.pid}）`));
+    console.log(chalk.gray(`日志: ${LOG_FILE}`));
+    console.log(chalk.gray(`停止: ${platform() === 'win32' ? `taskkill /F /PID ${child.pid}` : `kill ${child.pid}`}`));
+    setTimeout(() => process.exit(0), 100);
+}
+/**
+ * 清理已失效的 PID 文件（对应进程已不存在）
+ */
+function cleanupStalePid(pidFile) {
+    if (!existsSync(pidFile))
         return;
-    }
     try {
-        const level = options.system ? 'system' : options.user ? 'user' : 'auto';
-        const result = registerBoot({
-            isServer: false,
-            nodePath,
-            scriptPath: daemonEntryPath,
-            args: info.args || [],
-        }, { level });
-        if (result.level === 'system') {
-            console.log(chalk.green('开机自启动已启用（系统级）'));
-            console.log(chalk.gray('  启动时机: 系统启动时（无需登录桌面）'));
-            console.log(chalk.gray('  配置路径: ' + (platform() === 'win32' ? 'C:\\ProgramData\\chuantou' : '/etc/chuantou')));
-        }
-        else {
-            console.log(chalk.green('开机自启动已启用（用户级）'));
-            console.log(chalk.gray('  启动时机: 用户登录后'));
-            if (result.needsElevation) {
-                console.log(chalk.yellow('  提示: 当前为用户级启动。如需登录前启动，请以管理员/root权限重试：'));
-                console.log(chalk.gray(`    ${platform() === 'win32' ? '右键 → 以管理员身份运行' : 'sudo npx @feng3d/ctc boot enable'}`));
-            }
+        const pid = parseInt(readFileSync(pidFile, 'utf-8').trim(), 10);
+        if (pid) {
+            process.kill(pid, 0);
         }
     }
-    catch (err) {
-        console.log(chalk.red(`启用失败: ${err.message}`));
-    }
-});
-// boot disable 子命令
-bootCmd.command('disable')
-    .description('禁用开机自启动（自动检测并禁用当前级别）')
-    .option('--system', '禁用系统级启动')
-    .option('--user', '禁用用户级启动')
-    .action(async (options) => {
-    try {
-        const level = options.system ? 'system' : options.user ? 'user' : 'auto';
-        unregisterBoot(undefined, { level });
-        console.log(chalk.green('已禁用开机自启动'));
-    }
-    catch (err) {
-        console.log(chalk.red(`禁用失败: ${err.message}`));
-    }
-});
-// ==================== 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 {
-        execSync(`${openCmd} ${adminPage}`, { stdio: 'ignore' });
-        console.log(chalk.green('管理页面已在浏览器中打开'));
-    }
-    catch (err) {
-        console.log(chalk.yellow(`提示: 请确保客户端正在运行`));
-    }
-});
-// ==================== 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 {
-                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 {
-                // ignore
-            }
-        };
-        // 读取最新内容
-        readLog();
-        // 监控文件变化
-        const watcher = () => {
-            try {
-                const stat = statSync(LOG_FILE);
-                const newSize = stat.size;
-                if (newSize > pos) {
-                    readLog();
-                }
-            }
-            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})`));
+    catch {
+        try {
+            unlinkSync(pidFile);
+        }
+        catch { /* ignore */ }
     }
-});
-// ==================== 默认处理 ====================
-// 当没有指定命令时显示帮助
-program.action(() => {
-    showHelp();
-});
-// 解析命令行参数
-program.parse();
+}
 //# sourceMappingURL=cli.js.map