@chenpu17/tcpmapping 2.0.1 → 2.1.1

package/README.md

@@ -1,227 +1,185 @@
 # TcpMapping
 
-TCP端口转发服务器，支持多端口映射、WebUI管理界面和实时连接监控。
+TCP port forwarding server with WebUI management and real-time connection monitoring.
 
-## 功能特性
+TCP端口转发服务器，支持WebUI管理界面和实时连接监控。
 
-- **TCP端口转发** - 将TCP流量转发到后端服务器
-- **多端口映射** - 同时管理多个转发规则
-- **WebUI管理** - 现代化Web界面，实时监控和管理
-- **连接监控** - 实时显示每个映射的连接数和流量统计
-- **安全认证** - bcrypt密码加密、登录失败保护、会话管理
+---
 
-## 安装方式
+## Features | 功能特性
 
-### 方式一：NPM全局安装（推荐）
+- **TCP Port Forwarding** - Forward TCP traffic to backend servers | TCP端口转发
+- **Multiple Mappings** - Manage multiple forwarding rules simultaneously | 多端口映射
+- **WebUI Management** - Modern web interface for real-time monitoring | WebUI管理界面
+- **Connection Monitoring** - Real-time connection count and traffic statistics | 实时连接监控
+- **Secure Authentication** - bcrypt password hashing, login protection | 安全认证
 
-```bash
-# 全局安装
-npm install -g @chenpu17/tcpmapping
+---
 
-# 初始化配置文件
-tcpmapping init
+## Installation | 安装
 
-# 设置管理员密码
-tcpmapping setup-password
+### NPM Global Install (Recommended) | NPM全局安装（推荐）
+
+```bash
+npm install -g @chenpu17/tcpmapping
 
-# 启动服务
-tcpmapping start
+tcpmapping setup-password   # Set admin password | 设置管理员密码
+tcpmapping init             # Create config file | 创建配置文件
+tcpmapping start            # Start server | 启动服务
 ```
 
-### 方式二：本地安装
+### Local Install | 本地安装
 
 ```bash
-# 克隆项目
 git clone https://github.com/chenpu17/TcpMapping.git
 cd TcpMapping
-
-# 安装依赖
 npm install
-
-# 设置管理员密码
 npm run setup-password
-
-# 启动服务器
 npm start
 ```
 
-## CLI命令
+---
+
+## CLI Commands | CLI命令
+
+| Command | Description |
+|---------|-------------|
+| `tcpmapping start` | Start server in background | 后台启动服务 |
+| `tcpmapping stop` | Stop server | 停止服务 |
+| `tcpmapping restart` | Restart server | 重启服务 |
+| `tcpmapping status` | Show status and config paths | 查看状态和配置路径 |
+| `tcpmapping logs` | Show recent logs | 查看最近日志 |
+| `tcpmapping logs -f` | Follow logs in real-time | 实时跟踪日志 |
+| `tcpmapping setup-password` | Set admin password | 设置管理员密码 |
+| `tcpmapping init` | Create config file | 创建配置文件 |
+
+---
 
-全局安装后，可使用以下命令：
+## WebUI
 
-| 命令 | 说明 |
-|------|------|
-| `tcpmapping start` | 后台启动服务 |
-| `tcpmapping stop` | 停止服务 |
-| `tcpmapping restart` | 重启服务 |
-| `tcpmapping status` | 查看服务状态 |
-| `tcpmapping logs` | 查看最近日志 |
-| `tcpmapping logs -f` | 实时跟踪日志 |
-| `tcpmapping setup-password` | 设置管理员密码 |
-| `tcpmapping init` | 创建默认配置文件 |
-| `tcpmapping version` | 显示版本号 |
-| `tcpmapping help` | 显示帮助信息 |
+After starting, visit **http://localhost:9999**
 
-## 访问WebUI
+启动后访问 **http://localhost:9999**
 
-启动服务后，访问 **http://localhost:9999** 进入管理界面。
+Default username | 默认用户名: `admin`
 
-默认用户名：`admin`
+---
 
-## 配置说明
+## Configuration | 配置
 
-编辑 `config.json` 配置端口映射：
+Config file location (priority order) | 配置文件位置（优先级）:
+1. `./config.json` - Current directory | 当前目录
+2. `~/.tcpmapping/config.json` - User data directory | 用户数据目录
+
+### Example | 示例
 
 ```json
 {
   "mappings": [
     {
-      "name": "Web服务",
+      "name": "web-server",
       "listen": { "host": "0.0.0.0", "port": 8080 },
       "target": { "host": "192.168.1.100", "port": 3000 }
     },
     {
-      "name": "数据库",
-      "listen": { "host": "0.0.0.0", "port": 3307 },
-      "target": { "host": "192.168.1.100", "port": 3306 }
+      "name": "database",
+      "listen": { "host": "127.0.0.1", "port": 3307 },
+      "target": { "host": "db.example.com", "port": 3306 }
     }
   ],
-  "webui": {
-    "enabled": true,
-    "port": 9999,
-    "host": "0.0.0.0"
-  },
-  "logging": {
-    "enabled": true,
-    "level": "info"
-  }
+  "webui": { "port": 9999 },
+  "logging": { "level": "info" }
 }
 ```
 
-### 配置项说明
+### Config Options | 配置项
 
-| 配置项 | 说明 |
-|--------|------|
-| `mappings[].name` | 映射名称，用于标识 |
-| `mappings[].listen.host` | 监听地址，0.0.0.0表示所有网卡 |
-| `mappings[].listen.port` | 监听端口 |
-| `mappings[].target.host` | 目标主机IP或域名 |
-| `mappings[].target.port` | 目标端口 |
-| `webui.enabled` | 是否启用WebUI |
-| `webui.port` | WebUI端口，默认9999 |
-| `logging.level` | 日志级别：debug/info/warn/error |
+| Option | Description |
+|--------|-------------|
+| `mappings[].name` | Mapping name | 映射名称 |
+| `mappings[].listen.host` | Listen address (0.0.0.0 for all) | 监听地址 |
+| `mappings[].listen.port` | Listen port | 监听端口 |
+| `mappings[].target.host` | Target host IP or domain | 目标主机 |
+| `mappings[].target.port` | Target port | 目标端口 |
+| `webui.port` | WebUI port (default: 9999) | WebUI端口 |
+| `logging.level` | Log level: debug/info/warn/error | 日志级别 |
 
-## 使用示例
+---
 
-### 示例1：转发本地开发服务
+## Data Persistence | 数据持久化
 
-将本地8080端口转发到开发服务器的3000端口：
+User configuration is stored in `~/.tcpmapping/`:
 
-```json
-{
-  "name": "开发服务",
-  "listen": { "host": "0.0.0.0", "port": 8080 },
-  "target": { "host": "127.0.0.1", "port": 3000 }
-}
-```
+用户配置存储在 `~/.tcpmapping/` 目录：
 
-### 示例2：转发远程数据库
+- `config.json` - Port mapping configuration | 端口映射配置
+- `auth-config.json` - Authentication configuration | 认证配置
+- `tcpmapping.log` - Log file | 日志文件
+- `tcpmapping.pid` - PID file | PID文件
 
-将本地3307端口转发到远程MySQL：
+**Upgrading will NOT overwrite your configuration.**
 
-```json
-{
-  "name": "MySQL",
-  "listen": { "host": "127.0.0.1", "port": 3307 },
-  "target": { "host": "db.example.com", "port": 3306 }
-}
-```
+**升级不会覆盖你的配置文件。**
 
-### 示例3：通过WebUI动态添加
+---
 
-1. 访问 http://localhost:9999
-2. 登录管理界面
-3. 点击"添加映射"按钮
-4. 填写映射信息并保存
+## Security | 安全特性
 
-## 安全特性
+- **Strong Password Policy** - 8+ chars, uppercase, lowercase, numbers | 强密码策略
+- **Login Protection** - Lock after 5 failed attempts for 30 minutes | 登录保护
+- **Session Timeout** - 24 hours auto expiration | 会话超时
+- **Password Encryption** - bcrypt with 12 rounds | bcrypt加密
 
-- **强密码策略** - 8字符以上，包含大小写字母和数字
-- **登录保护** - 5次失败后锁定30分钟
-- **会话超时** - 24小时自动过期
-- **密码加密** - bcrypt 12轮哈希
+---
 
-## API接口
+## API
+
+See [docs/API.md](docs/API.md) for API documentation.
 
 详细API文档请参阅 [docs/API.md](docs/API.md)
 
-### 快速参考
+### Quick Reference | 快速参考
 
 ```bash
-# 健康检查（无需认证）
+# Health check (no auth) | 健康检查
 curl http://localhost:9999/api/health
 
-# 登录
+# Login | 登录
 curl -X POST http://localhost:9999/api/login \
   -H "Content-Type: application/json" \
   -d '{"username":"admin","password":"YourPassword"}' \
   -c cookies.txt
 
-# 获取映射列表
+# Get mappings | 获取映射列表
 curl http://localhost:9999/api/mappings -b cookies.txt
-
-# 添加映射
-curl -X POST http://localhost:9999/api/mappings \
-  -H "Content-Type: application/json" \
-  -d '{"name":"测试","listen":{"port":8888},"target":{"host":"127.0.0.1","port":80}}' \
-  -b cookies.txt
 ```
 
-## 项目结构
-
-```
-├── bin/
-│   └── tcpmapping.js    # CLI入口
-├── public/
-│   ├── login.html       # 登录页面
-│   └── dashboard.html   # 管理面板
-├── docs/
-│   └── API.md           # API文档
-├── server.js            # 主服务器
-├── setup-password.js    # 密码设置工具
-├── config.json          # 端口映射配置
-└── package.json         # 项目配置
-```
+---
 
-## 常见问题
+## FAQ | 常见问题
 
-### Q: 忘记密码怎么办？
+### Forgot password? | 忘记密码？
 
-运行密码重置命令：
 ```bash
-# NPM全局安装
 tcpmapping setup-password
-
-# 本地安装
+# or | 或
 npm run reset-password
 ```
 
-### Q: 如何查看服务是否运行？
+### Check if running? | 检查运行状态？
 
 ```bash
 tcpmapping status
 ```
 
-### Q: 端口被占用怎么办？
+### Port already in use? | 端口被占用？
 
-修改 `config.json` 中的 `webui.port` 或映射的 `listen.port`。
+Edit `webui.port` or `mappings[].listen.port` in config.json.
 
-### Q: 如何查看实时日志？
+修改 config.json 中的 `webui.port` 或 `mappings[].listen.port`。
 
-```bash
-tcpmapping logs -f
-```
+---
 
-## 许可证
+## License | 许可证
 
 MIT License

package/bin/tcpmapping.js

@@ -6,8 +6,9 @@ const fs = require('fs');
 const os = require('os');
 
 const APP_NAME = 'tcpmapping';
-const PID_FILE = path.join(os.tmpdir(), 'tcpmapping.pid');
-const LOG_FILE = path.join(os.tmpdir(), 'tcpmapping.log');
+const DATA_DIR = path.join(os.homedir(), '.tcpmapping');
+const PID_FILE = path.join(DATA_DIR, 'tcpmapping.pid');
+const LOG_FILE = path.join(DATA_DIR, 'tcpmapping.log');
 const SERVER_FILE = path.join(__dirname, '..', 'server.js');
 const SETUP_PASSWORD_FILE = path.join(__dirname, '..', 'setup-password.js');
 
@@ -21,11 +22,52 @@ const colors = {
   red: (text) => `\x1b[31m${text}\x1b[0m`,
   yellow: (text) => `\x1b[33m${text}\x1b[0m`,
   blue: (text) => `\x1b[34m${text}\x1b[0m`,
-  cyan: (text) => `\x1b[36m${text}\x1b[0m`
+  cyan: (text) => `\x1b[36m${text}\x1b[0m`,
+  gray: (text) => `\x1b[90m${text}\x1b[0m`
 };
 
+// 确保数据目录存在
+function ensureDataDir() {
+  if (!fs.existsSync(DATA_DIR)) {
+    fs.mkdirSync(DATA_DIR, { recursive: true });
+  }
+}
+
+// 获取配置文件路径（按优先级）
+function getConfigPath() {
+  // 优先级1: 当前工作目录
+  const cwdPath = path.join(process.cwd(), 'config.json');
+  if (fs.existsSync(cwdPath)) {
+    return cwdPath;
+  }
+
+  // 优先级2: 用户数据目录
+  const dataPath = path.join(DATA_DIR, 'config.json');
+  if (fs.existsSync(dataPath)) {
+    return dataPath;
+  }
+
+  return null;
+}
+
+// 获取认证配置文件路径
+function getAuthConfigPath() {
+  const cwdPath = path.join(process.cwd(), 'auth-config.json');
+  if (fs.existsSync(cwdPath)) {
+    return cwdPath;
+  }
+
+  const dataPath = path.join(DATA_DIR, 'auth-config.json');
+  if (fs.existsSync(dataPath)) {
+    return dataPath;
+  }
+
+  return null;
+}
+
 // 检查进程是否运行
 function isRunning() {
+  ensureDataDir();
   if (!fs.existsSync(PID_FILE)) {
     return false;
   }
@@ -50,6 +92,17 @@ function start() {
     return;
   }
 
+  // 检查是否已初始化
+  const configPath = getConfigPath();
+  const authPath = getAuthConfigPath();
+
+  if (!authPath) {
+    console.log(colors.yellow('未设置管理员密码，请先运行:'));
+    console.log(colors.cyan('  tcpmapping setup-password'));
+    return;
+  }
+
+  ensureDataDir();
   console.log(colors.blue(`Starting ${APP_NAME}...`));
 
   const out = fs.openSync(LOG_FILE, 'a');
@@ -58,7 +111,7 @@ function start() {
   const child = spawn('node', [SERVER_FILE], {
     detached: true,
     stdio: ['ignore', out, err],
-    cwd: path.dirname(SERVER_FILE)
+    cwd: process.cwd() // 使用当前目录，以便server可以找到当前目录的config
   });
 
   fs.writeFileSync(PID_FILE, child.pid.toString());
@@ -66,7 +119,10 @@ function start() {
 
   console.log(colors.green(`${APP_NAME} started successfully (PID: ${child.pid})`));
   console.log(colors.cyan(`WebUI: http://localhost:9999`));
-  console.log(colors.cyan(`Log file: ${LOG_FILE}`));
+  console.log(colors.gray(`Log file: ${LOG_FILE}`));
+  if (configPath) {
+    console.log(colors.gray(`Config: ${configPath}`));
+  }
 }
 
 // 停止服务
@@ -126,8 +182,14 @@ function restart() {
 // 查看状态
 function status() {
   const pid = isRunning();
+  const configPath = getConfigPath();
+  const authPath = getAuthConfigPath();
+
+  console.log(colors.cyan('=== TcpMapping Status ===\n'));
+
+  // 服务状态
   if (pid) {
-    console.log(colors.green(`${APP_NAME} is running (PID: ${pid})`));
+    console.log(colors.green(`Service: Running (PID: ${pid})`));
 
     // 尝试获取健康状态
     try {
@@ -138,23 +200,36 @@ function status() {
         res.on('end', () => {
           try {
             const health = JSON.parse(data);
-            console.log(colors.cyan(`  Status: ${health.status}`));
-            console.log(colors.cyan(`  Uptime: ${Math.floor(health.uptime / 60)} minutes`));
-            console.log(colors.cyan(`  Active Mappings: ${health.activeMappings}`));
-            console.log(colors.cyan(`  Active Connections: ${health.activeConnections}`));
+            console.log(`  Uptime: ${Math.floor(health.uptime / 60)} minutes`);
+            console.log(`  Active Mappings: ${health.activeMappings}`);
+            console.log(`  Active Connections: ${health.activeConnections}`);
           } catch (e) {}
+          showPaths();
         });
       });
-      req.on('error', () => {});
-      req.on('timeout', () => req.destroy());
-    } catch (e) {}
+      req.on('error', () => showPaths());
+      req.on('timeout', () => { req.destroy(); showPaths(); });
+    } catch (e) {
+      showPaths();
+    }
   } else {
-    console.log(colors.red(`${APP_NAME} is not running`));
+    console.log(colors.red('Service: Stopped'));
+    showPaths();
+  }
+
+  function showPaths() {
+    console.log('');
+    console.log(colors.cyan('=== Configuration ===\n'));
+    console.log(`Data Dir: ${DATA_DIR}`);
+    console.log(`Config: ${configPath || colors.yellow('Not found (run: tcpmapping init)')}`);
+    console.log(`Auth: ${authPath || colors.yellow('Not found (run: tcpmapping setup-password)')}`);
+    console.log(`Log: ${LOG_FILE}`);
   }
 }
 
 // 查看日志
 function logs(follow = false) {
+  ensureDataDir();
   if (!fs.existsSync(LOG_FILE)) {
     console.log(colors.yellow('No log file found'));
     return;
@@ -176,10 +251,15 @@ function logs(follow = false) {
 
 // 设置密码
 function setupPassword() {
+  ensureDataDir();
   console.log(colors.blue('Setting up password...'));
+  console.log(colors.gray(`Config will be saved to: ${DATA_DIR}`));
+  console.log('');
+
   const child = spawn('node', [SETUP_PASSWORD_FILE], {
     stdio: 'inherit',
-    cwd: path.dirname(SETUP_PASSWORD_FILE)
+    cwd: DATA_DIR, // 在数据目录运行，使auth-config.json保存到数据目录
+    env: { ...process.env, TCPMAPPING_DATA_DIR: DATA_DIR }
   });
 
   child.on('exit', (code) => {
@@ -189,29 +269,41 @@ function setupPassword() {
 
 // 初始化配置
 function init() {
-  const configDir = process.cwd();
-  const configFile = path.join(configDir, 'config.json');
+  ensureDataDir();
+
+  // 检查当前目录和数据目录是否已有配置
+  const cwdConfig = path.join(process.cwd(), 'config.json');
+  const dataConfig = path.join(DATA_DIR, 'config.json');
+
+  if (fs.existsSync(cwdConfig)) {
+    console.log(colors.yellow(`config.json already exists in current directory`));
+    console.log(colors.gray(`  ${cwdConfig}`));
+    return;
+  }
 
-  if (fs.existsSync(configFile)) {
-    console.log(colors.yellow('config.json already exists'));
+  if (fs.existsSync(dataConfig)) {
+    console.log(colors.yellow(`config.json already exists in data directory`));
+    console.log(colors.gray(`  ${dataConfig}`));
+    console.log('');
+    console.log('To create a local config, copy it to current directory:');
+    console.log(colors.cyan(`  cp ${dataConfig} ./config.json`));
     return;
   }
 
   const defaultConfig = {
-    mappings: [
-      {
-        name: "Example",
-        listen: { host: "0.0.0.0", port: 8080 },
-        target: { host: "127.0.0.1", port: 3000 }
-      }
-    ],
-    webui: { enabled: true, port: 9999, host: "0.0.0.0" },
-    logging: { enabled: true, level: "info" }
+    mappings: [],
+    webui: { port: 9999 },
+    logging: { level: "info" }
   };
 
-  fs.writeFileSync(configFile, JSON.stringify(defaultConfig, null, 2));
+  // 保存到数据目录
+  fs.writeFileSync(dataConfig, JSON.stringify(defaultConfig, null, 2));
   console.log(colors.green('Created config.json'));
-  console.log(colors.cyan('Edit config.json to configure your port mappings'));
+  console.log(colors.gray(`  ${dataConfig}`));
+  console.log('');
+  console.log('Edit the config file to add your port mappings.');
+  console.log('Or copy it to current directory for project-specific config:');
+  console.log(colors.cyan(`  cp ${dataConfig} ./config.json`));
 }
 
 // 显示版本
@@ -232,7 +324,7 @@ ${colors.yellow('Commands:')}
   ${colors.green('start')}           Start the server in background
   ${colors.green('stop')}            Stop the server
   ${colors.green('restart')}         Restart the server
-  ${colors.green('status')}          Show server status
+  ${colors.green('status')}          Show server status and config paths
   ${colors.green('logs')}            Show recent logs
   ${colors.green('logs -f')}         Follow logs in real-time
   ${colors.green('setup-password')}  Set up admin password
@@ -240,10 +332,15 @@ ${colors.yellow('Commands:')}
   ${colors.green('version')}         Show version
   ${colors.green('help')}            Show this help message
 
+${colors.yellow('Config Paths (priority order):')}
+  1. ./config.json       (current directory - project config)
+  2. ~/.tcpmapping/      (user data directory - global config)
+
 ${colors.yellow('Examples:')}
-  tcpmapping start          # Start server
-  tcpmapping status         # Check if server is running
-  tcpmapping logs -f        # Follow logs
+  tcpmapping init             # Create config file
+  tcpmapping setup-password   # Set admin password
+  tcpmapping start            # Start server
+  tcpmapping status           # Check status and config paths
 
 ${colors.yellow('WebUI:')}
   After starting, visit http://localhost:9999

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chenpu17/tcpmapping",
-  "version": "2.0.1",
+  "version": "2.1.1",
   "description": "TCP端口转发服务器，支持多端口映射、WebUI管理界面和实时连接监控",
   "main": "server.js",
   "bin": {
@@ -16,8 +16,7 @@
     "bin/",
     "public/",
     "server.js",
-    "setup-password.js",
-    "config.json"
+    "setup-password.js"
   ],
   "keywords": [
     "tcp",

package/server.js

@@ -1,11 +1,59 @@
 const net = require('net');
 const fs = require('fs');
 const path = require('path');
+const os = require('os');
 const express = require('express');
 const session = require('express-session');
 const bcrypt = require('bcryptjs');
 const bodyParser = require('body-parser');
 
+// 数据目录 - 用于存储用户配置（持久化）
+const DATA_DIR = path.join(os.homedir(), '.tcpmapping');
+
+// 获取配置文件路径（按优先级搜索）
+function getConfigPath(filename) {
+  // 优先级1: 当前工作目录
+  const cwdPath = path.join(process.cwd(), filename);
+  if (fs.existsSync(cwdPath)) {
+    return cwdPath;
+  }
+
+  // 优先级2: 用户数据目录 (~/.tcpmapping/)
+  const dataPath = path.join(DATA_DIR, filename);
+  if (fs.existsSync(dataPath)) {
+    return dataPath;
+  }
+
+  // 优先级3: 包安装目录（仅作为模板）
+  const pkgPath = path.join(__dirname, filename);
+  if (fs.existsSync(pkgPath)) {
+    return pkgPath;
+  }
+
+  return null;
+}
+
+// 获取配置保存路径
+function getConfigSavePath(filename) {
+  // 如果当前工作目录有配置文件，保存到当前目录
+  const cwdPath = path.join(process.cwd(), filename);
+  if (fs.existsSync(cwdPath)) {
+    return cwdPath;
+  }
+
+  // 否则保存到用户数据目录
+  ensureDataDir();
+  return path.join(DATA_DIR, filename);
+}
+
+// 确保数据目录存在
+function ensureDataDir() {
+  if (!fs.existsSync(DATA_DIR)) {
+    fs.mkdirSync(DATA_DIR, { recursive: true });
+    console.log(`创建配置目录: ${DATA_DIR}`);
+  }
+}
+
 // 全局变量
 let config = {};
 const servers = new Map(); // 存储所有TCP转发服务器实例
@@ -21,12 +69,16 @@ const loginAttempts = new Map();
 // 加载认证配置
 function loadAuthConfig() {
   try {
-    const authConfigPath = path.join(__dirname, 'auth-config.json');
+    const authConfigPath = getConfigPath('auth-config.json');
+    if (!authConfigPath) {
+      throw new Error('认证配置文件不存在');
+    }
     const authConfigData = fs.readFileSync(authConfigPath, 'utf8');
+    console.log(`加载认证配置: ${authConfigPath}`);
     return JSON.parse(authConfigData);
   } catch (error) {
     console.error('警告: 未找到认证配置文件，使用默认配置');
-    console.error('请运行 "node setup-password.js" 来设置安全密码');
+    console.error('请运行 "tcpmapping setup-password" 或 "npm run setup-password" 来设置安全密码');
     
     // 返回默认配置（仅用于向后兼容）
     return {
@@ -125,15 +177,21 @@ const LOG_LEVELS = {
 // 读取配置文件
 function loadConfig() {
   try {
-    const configPath = path.join(__dirname, 'config.json');
+    const configPath = getConfigPath('config.json');
+    if (!configPath) {
+      console.log('未找到配置文件，使用默认配置');
+      console.log('运行 "tcpmapping init" 创建配置文件');
+      return getDefaultConfig();
+    }
     const configData = fs.readFileSync(configPath, 'utf8');
     const loadedConfig = JSON.parse(configData);
-    
+    console.log(`加载配置文件: ${configPath}`);
+
     // 验证配置
     if (!loadedConfig.mappings || !Array.isArray(loadedConfig.mappings)) {
       loadedConfig.mappings = [];
     }
-    
+
     // 添加默认WebUI配置
     if (!loadedConfig.webui) {
       loadedConfig.webui = {
@@ -142,32 +200,37 @@ function loadConfig() {
         host: '0.0.0.0'
       };
     }
-    
+
     return loadedConfig;
   } catch (error) {
     console.error('读取配置文件失败:', error.message);
-    // 返回默认配置
-    return {
-      mappings: [],
-      webui: {
-        enabled: true,
-        port: 9999,
-        host: '0.0.0.0'
-      },
-      logging: {
-        enabled: true,
-        level: 'info'
-      }
-    };
+    return getDefaultConfig();
   }
 }
 
+// 获取默认配置
+function getDefaultConfig() {
+  return {
+    mappings: [],
+    webui: {
+      enabled: true,
+      port: 9999,
+      host: '0.0.0.0'
+    },
+    logging: {
+      enabled: true,
+      level: 'info'
+    }
+  };
+}
+
 // 保存配置文件
 function saveConfig(newConfig) {
   try {
-    const configPath = path.join(__dirname, 'config.json');
+    const configPath = getConfigSavePath('config.json');
     fs.writeFileSync(configPath, JSON.stringify(newConfig, null, 2));
     config = newConfig;
+    console.log(`配置已保存: ${configPath}`);
     return true;
   } catch (error) {
     console.error('保存配置文件失败:', error.message);

package/setup-password.js

@@ -1,8 +1,19 @@
 const fs = require('fs');
 const path = require('path');
+const os = require('os');
 const bcrypt = require('bcryptjs');
 const readline = require('readline');
 
+// 获取配置保存目录
+function getConfigDir() {
+  // 优先使用环境变量指定的目录
+  if (process.env.TCPMAPPING_DATA_DIR) {
+    return process.env.TCPMAPPING_DATA_DIR;
+  }
+  // 其次使用当前工作目录
+  return process.cwd();
+}
+
 // 创建readline接口
 const rl = readline.createInterface({
   input: process.stdin,
@@ -44,36 +55,70 @@ function validatePassword(password) {
 // 获取用户输入（隐藏密码）
 function getPassword(prompt) {
   return new Promise((resolve) => {
-    // 对于密码输入，我们使用标准输入但隐藏输出
+    const rl2 = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+
+    // Windows 兼容：使用简单的输入方式
+    // 在某些终端上密码可能可见，但这是最兼容的方式
+    if (process.platform === 'win32') {
+      // Windows: 尝试隐藏输入
+      const spawn = require('child_process').spawnSync;
+      process.stdout.write(prompt);
+
+      try {
+        // 使用 PowerShell 读取密码
+        const result = spawn('powershell', [
+          '-Command',
+          '$pwd = Read-Host -AsSecureString; [Runtime.InteropServices.Marshal]::PtrToStringAuto([Runtime.InteropServices.Marshal]::SecureStringToBSTR($pwd))'
+        ], { stdio: ['inherit', 'pipe', 'inherit'] });
+
+        if (result.status === 0 && result.stdout) {
+          resolve(result.stdout.toString().trim());
+          return;
+        }
+      } catch (e) {
+        // PowerShell 不可用，回退到普通输入
+      }
+
+      // 回退方案：普通输入（密码可见）
+      console.log('(密码将可见)');
+      rl2.question('', (answer) => {
+        rl2.close();
+        resolve(answer);
+      });
+      return;
+    }
+
+    // Unix/Mac: 使用 raw mode 隐藏密码
     process.stdout.write(prompt);
     process.stdin.setRawMode(true);
     process.stdin.setEncoding('utf8');
-    
+
     let password = '';
-    
+
     const onData = (char) => {
       if (char === '\n' || char === '\r' || char === '\u0004') {
-        // 结束输入
         process.stdin.setRawMode(false);
         process.stdin.removeListener('data', onData);
+        process.stdin.pause();
         process.stdout.write('\n');
         resolve(password);
       } else if (char === '\u0003') {
-        // Ctrl+C
         process.exit();
-      } else if (char === '\u007f') {
-        // 退格键
+      } else if (char === '\u007f' || char === '\b') {
         if (password.length > 0) {
           password = password.slice(0, -1);
           process.stdout.write('\b \b');
         }
-      } else {
-        // 普通字符
+      } else if (char.charCodeAt(0) >= 32) {
         password += char;
         process.stdout.write('*');
       }
     };
-    
+
+    process.stdin.resume();
     process.stdin.on('data', onData);
   });
 }
@@ -81,7 +126,7 @@ function getPassword(prompt) {
 // 读取现有的认证配置
 function loadAuthConfig() {
   try {
-    const configPath = path.join(__dirname, 'auth-config.json');
+    const configPath = path.join(getConfigDir(), 'auth-config.json');
     const configData = fs.readFileSync(configPath, 'utf8');
     return JSON.parse(configData);
   } catch (error) {
@@ -107,8 +152,14 @@ function loadAuthConfig() {
 
 // 保存认证配置
 function saveAuthConfig(config) {
-  const configPath = path.join(__dirname, 'auth-config.json');
+  const configDir = getConfigDir();
+  // 确保目录存在
+  if (!fs.existsSync(configDir)) {
+    fs.mkdirSync(configDir, { recursive: true });
+  }
+  const configPath = path.join(configDir, 'auth-config.json');
   fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+  console.log(`配置已保存到: ${configPath}`);
 }
 
 // 主要设置流程

package/config.json

@@ -1,46 +0,0 @@
-{
-  "mappings": [
-    {
-      "name": "Dify",
-      "listen": {
-        "host": "0.0.0.0",
-        "port": 5588
-      },
-      "target": {
-        "host": "113.45.34.202",
-        "port": 5588
-      }
-    },
-    {
-      "name": "语音助手",
-      "listen": {
-        "host": "0.0.0.0",
-        "port": 3443
-      },
-      "target": {
-        "host": "115.120.49.208",
-        "port": 443
-      }
-    },
-    {
-      "name": "语音助手",
-      "listen": {
-        "host": "0.0.0.0",
-        "port": 443
-      },
-      "target": {
-        "host": "115.120.49.208",
-        "port": 443
-      }
-    }
-  ],
-  "webui": {
-    "enabled": true,
-    "port": 9999,
-    "host": "0.0.0.0"
-  },
-  "logging": {
-    "enabled": true,
-    "level": "info"
-  }
-}