更新日志调整

调整部分名称

Dockerfile

@@ -1,48 +1,31 @@
-# ============================================================
+# 多阶段构建
-# 构建阶段
-# ============================================================
 FROM golang:alpine AS builder
 
 WORKDIR /app
 
-# 复制依赖文件
 COPY go.mod go.sum ./
+
+RUN sed -i 's/go 1.2[6-9].*/go 1.21/' go.mod && go mod tidy
 RUN go env -w GOPROXY=https://goproxy.cn,direct
 RUN go mod download
 
-# 复制源码（确保 bin/ 和 static/ 目录存在）
 COPY . .
 
-# 编译 Linux 版（CGO_ENABLED=0 保证静态编译）
+# 编译时不注入任何版本信息（纯净二进制）
 RUN CGO_ENABLED=0 GOOS=linux go build \
     -ldflags="-s -w" \
     -o frpc-console .
 
-# ============================================================
-# 运行阶段
-# ============================================================
 FROM alpine:latest
-
+# 先切换到国内镜像源，再安装包
-# 安装 ca-certificates 和 tzdata（确保 HTTPS 和时区正常）
+RUN sed -i 's/dl-cdn.alpinelinux.org/mirrors.aliyun.com/g' /etc/apk/repositories
-RUN apk --no-cache add ca-certificates tzdata
+RUN apk --no-cache add ca-certificates tzdata sqlite bash curl iproute2 net-tools
 
 WORKDIR /app
 
-# 从构建阶段复制编译好的二进制
 COPY --from=builder /app/frpc-console /app/frpc-console
+COPY static/ /app/static/
 
-# 创建数据目录（用于持久化 db 和日志）
-RUN mkdir -p /app/data
-
-# 暴露端口（默认 9300）
 EXPOSE 9300
 
-# 环境变量
-ENV PORT=9300
-ENV TZ=Asia/Shanghai
-
-# 数据卷（持久化数据库、配置、日志）
-VOLUME ["/app/data"]
-
-# 启动
 ENTRYPOINT ["/app/frpc-console"]

Docs/acknowledgment.md

@@ -0,0 +1,65 @@
+# 致谢与互引
+
+> *“这个项目之所以存在，是因为有一群更早的存在，以及一个更大的生态。”*
+
+---
+
+## 核心依赖
+
+frpc-console 站在以下项目的肩膀上：
+
+- **[FRP](https://github.com/fatedier/frp)** —— 这个项目存在的理由。一个稳定、高效的内网穿透工具，是 frpc-console 管理的对象。
+- **[SQLite](https://www.sqlite.org/)** —— 嵌入式数据库的典范。它让 frpc-console 不需要额外部署数据库服务，符合“降低维护成本”的总体目标。
+- **[Go](https://go.dev/)** —— 编译为单一二进制，跨平台，低内存占用。没有 Go，就没有 frpc-console 目前的部署体验。
+
+---
+
+## 框架与库
+
+- **[Gin](https://github.com/gin-gonic/gin)** —— 高性能 Go Web 框架，为 API Server 提供基础。
+- **[Vue 3](https://github.com/vuejs/vue)** —— 渐进式 JavaScript 框架，承载了 Web UI 的交互体验。
+
+---
+
+## 生态互引
+
+### FRP 生态互补工具
+
+- **[MoonProxy](https://github.com/MoonProxyHQ/moonproxy-desktop)** —— 基于 Tauri v2 + Vue 3 + Rust 构建的跨平台 FRP 桌面客户端（frpc GUI），面向 macOS 与 Windows，让内网穿透开箱即用。MIT 协议开源。
+
+### FRP 生态同类工具
+
+*暂无互引。如果您知道有同类项目愿意建立互引关系，欢迎通过 Issue 或 PR 联系我们。*
+
+---
+
+## 设计启发
+
+这个项目的许多设计决策，受到以下内容的影响：
+
+- **《The Art of Unix Programming》** —— “Do one thing and do it well.”
+- **SQLite 的设计哲学** —— 长期稳定比新功能更重要。
+- **OpenBSD 的开发理念** —— 默认安全，拒绝默认开放。
+- **Tailscale 的部署体验** —— 安装一次，忘记它。
+
+---
+
+## 致谢
+
+感谢所有在真实环境中运行 frpc-console 的用户。你们的每一次部署，都是对这套工程方法的验证。
+
+[lxh2875931338（XHLiang0）](https://git.whitetop.xyz/lxh2875931338) —— 这是项目的开发者，同时也是项目真正的第一个用户。
+
+---
+
+## 如何贡献
+
+如果你在使用 frpc-console 的过程中有新的发现、改进建议，或者想参与互引，欢迎：
+
+- 提交 [Issue](https://git.whitetop.xyz/lxh2875931338/frpc-console/issues)
+- 发起 Pull Request（请针对 `test` 分支）
+- 在相关社区分享你的部署经验
+
+---
+
+*frpc-console 的成长，离不开整个开源生态的滋养。感谢每一位为之贡献的人。*

Docs/architecture.md

@@ -0,0 +1,287 @@
+# 架构设计
+
+> *“代码定义了它如何工作，架构定义了它如何活着。”*
+
+---
+
+## 架构总览
+
+frpc-console 是一个**轻量级生命周期管理工具**，它的架构设计围绕着三个核心目标：
+
+1. **低资源占用** — 在边缘设备上也能运行
+2. **高可靠性** — 面板可挂，业务不能停
+3. **零依赖部署** — 单一二进制，开箱即用
+
+
+### 整体架构图
+
+```mermaid
+graph TB
+    subgraph User["用户侧"]
+        Browser["浏览器"]
+        CLI["命令行"]
+    end
+
+    subgraph Console["frpc-console"]
+        WebUI["Web UI<br/>(Vue 3 + 深色磨砂玻璃)"]
+        APIServer["API Server<br/>(Gin)"]
+        Lifecycle["生命周期管理器"]
+        ConfigMgr["配置管理器<br/>(TOML 解析/生成)"]
+        ProcessMgr["进程管理器<br/>(SetSid / PID 1 接管)"]
+        DB["SQLite<br/>(用户/隧道/配置)"]
+        Static["静态资源<br/>(内嵌)"]
+    end
+
+    subgraph FRP["被管理对象"]
+        FRPC["frpc 进程"]
+        TOML["frpc.toml"]
+    end
+
+    Browser --> WebUI
+    CLI --> APIServer
+    WebUI --> APIServer
+    APIServer --> DB
+    APIServer --> ConfigMgr
+    ConfigMgr --> TOML
+    APIServer --> Lifecycle
+    Lifecycle --> ProcessMgr
+    ProcessMgr --> FRPC
+    FRPC --> TOML
+    Static -.-> WebUI
+```
+
+> **说明：** `Static`（前端静态资源）在编译时通过 `embed` 直接打包进二进制，运行时无需额外加载。因此图中以虚线表示其与 WebUI 的关联，且不占用独立部署单元。
+
+---
+
+## 部署模型
+
+frpc-console 支持两种部署模型，架构核心逻辑完全一致，只是运行环境不同。
+
+### 二进制部署模型
+
+```
+┌──────────────────────────────────────────┐
+│           操作系统 (Linux/Windows)        │
+│                                          │
+│  ┌────────────────────────────────────┐  │
+│  │         frpc-console               │  │
+│  │  ┌──────────────────────────────┐ │  │
+│  │  │  Web UI  │  API Server       │ │  │
+│  │  ├──────────────────────────────┤ │  │
+│  │  │  生命周期管理 / 配置管理      │ │  │
+│  │  └──────────┬───────────────────┘ │  │
+│  └─────────────┼──────────────────────┘  │
+│                │ SetSid + 独立会话        │
+│                ▼                          │
+│  ┌────────────────────────────────────┐  │
+│  │         frpc 子进程                │  │
+│  │  (被 PID 1 接管，独立生命周期)     │  │
+│  └────────────────────────────────────┘  │
+│                                          │
+│  ┌────────────────────────────────────┐  │
+│  │   数据目录: /opt/frpc-console/data │  │
+│  │   ├── frpc-console.db              │  │
+│  │   ├── frpc.toml                    │  │
+│  │   ├── frpc (二进制)                │  │
+│  │   ├── frpc.pid                     │  │
+│  │   └── version.ini                  │  │
+│  └────────────────────────────────────┘  │
+└──────────────────────────────────────────┘
+```
+
+**关键机制：**
+
+- frpc-console 启动时，通过 `SetSid` 为 frpc 创建**独立会话**
+- frpc 进程完全脱离父进程的生命周期控制
+- 即使 console 崩溃或被 kill，frpc 会被 init（PID 1）接管，继续运行
+
+### Docker 部署模型
+
+```
+┌──────────────────────────────────────────┐
+│              Docker Host                  │
+│                                          │
+│  ┌────────────────────────────────────┐  │
+│  │   Container: frpc-console          │  │
+│  │  ┌──────────────────────────────┐ │  │
+│  │  │  Web UI  │  API Server       │ │  │
+│  │  ├──────────────────────────────┤ │  │
+│  │  │  生命周期管理 / 配置管理      │ │  │
+│  │  └──────────┬───────────────────┘ │  │
+│  │             │ 启动 frpc            │  │
+│  │             ▼                      │  │
+│  │  ┌──────────────────────────────┐ │  │
+│  │  │  frpc 子进程 (容器内)        │ │  │
+│  │  └──────────────────────────────┘ │  │
+│  └──────────────┬─────────────────────┘  │
+│                 │ Volume 挂载             │
+│                 ▼                          │
+│  ┌────────────────────────────────────┐  │
+│  │  数据卷: /opt/frpc-console/data   │  │
+│  │  ├── frpc-console.db              │  │
+│  │  ├── frpc.toml                    │  │
+│  │  ├── frpc.pid                     │  │
+│  │  └── version.ini                  │  │
+│  └────────────────────────────────────┘  │
+│                                          │
+│  重启策略: --restart=always               │
+└──────────────────────────────────────────┘
+```
+
+**关键机制：**
+
+- 容器配置 `--restart=always`，console 退出时 Docker 自动重启
+- 数据目录通过 Volume 挂载持久化
+- 容器重启后自动重新拉起 frpc
+
+---
+
+## 核心模块
+
+### 1. Web UI（前端）
+
+- **框架：** Vue 3
+- **风格：** 深色磨砂玻璃视觉
+- **设计原则：** 需要时清晰易用，不需要时不打扰
+- **构建产物：** 静态资源通过 Go embed 内嵌于二进制
+
+### 2. API Server
+
+- **框架：** Gin
+- **认证：** Session / JWT
+- **职责：** 提供 RESTful API，处理前端请求
+
+### 3. 生命周期管理器
+
+负责 frpc 进程的完整生命周期：
+
+| 操作 | 行为 |
+|---|---|
+| 启动 | 根据当前 frpc.toml 启动 frpc 进程 |
+| 停止 | 向 frpc 发送终止信号 |
+| 重启 | 停止 → 重新加载配置 → 启动 |
+| 状态检查 | 读取 PID 文件，验证进程是否存在 |
+| 热加载 | 修改配置后自动重启 frpc（无需手动操作） |
+
+### 4. 配置管理器
+
+- 解析和生成 TOML 格式的 frp 配置文件
+- 支持从现有 frpc.toml 导入
+- 修改配置后自动触发重启
+
+### 5. 进程管理器
+
+- 通过 `SetSid` 创建独立会话（Linux）
+- frpc 二进制内置在部署包中，无需额外下载
+- 记录 PID 到文件，用于状态检查和进程管理
+- Windows 版本使用相应的进程管理 API
+
+### 6. SQLite 数据库
+
+- **表结构：**
+  - `users` — 管理员账户
+  - `tunnels` — 隧道配置
+  - `configs` — 全局配置
+- **备份机制：** 部署脚本在降级前自动备份数据库文件
+- **位置：** `data/frpc-console.db`
+
+---
+
+## 关键交互流程
+
+### 启动流程
+
+```mermaid
+sequenceDiagram
+    participant User
+    participant Console
+    participant FRPC
+
+    User->>Console: 启动 frpc-console
+    Console->>Console: 读取 data/frpc.toml
+    alt 配置文件存在
+        Console->>FRPC: 启动 frpc (SetSid)
+        FRPC-->>Console: PID 写入 frpc.pid
+        Console-->>User: 服务就绪
+    else 配置文件不存在
+        Console-->>User: 等待 WebUI 导入配置
+        User->>Console: WebUI 导入 frpc.toml
+        Console->>FRPC: 启动 frpc
+    end
+```
+
+### 配置更新流程
+
+```mermaid
+sequenceDiagram
+    participant User
+    participant WebUI
+    participant API
+    participant ConfigMgr
+    participant FRPC
+
+    User->>WebUI: 修改隧道配置
+    WebUI->>API: PUT /api/tunnels/:id
+    API->>ConfigMgr: 更新配置
+    ConfigMgr->>ConfigMgr: 写入 data/frpc.toml
+    ConfigMgr-->>API: 配置已更新
+    API-->>WebUI: 200 OK
+    API->>FRPC: 重启 frpc (热加载)
+    FRPC-->>API: 启动成功
+```
+
+---
+
+## 资源边界
+
+### 运行时资源
+
+| 资源 | 典型值 | 说明 |
+|---|---|---|
+| CPU（idle） | ~0% | 无后台轮询 |
+| 内存（idle） | < 20MB | 无额外守护进程 |
+| 存储（二进制） | ~15MB | 静态编译，无依赖 |
+| 存储（数据） | < 1MB | SQLite + 配置文件 |
+
+> 真实设备实测数据见 [工程设计哲学 - 稳定性与可观测性](./engineering-philosophy.md#稳定性与可观测性)
+
+### 文件系统布局
+
+```
+/opt/frpc-console/                    # 默认部署目录
+├── data/                             # 数据目录（持久化）
+│   ├── frpc-console.db               # SQLite 数据库
+│   ├── frpc.toml                     # 当前 frpc 配置
+│   ├── frpc                          # FRP 二进制（内置）
+│   ├── frpc.pid                      # frpc 进程 PID
+│   ├── frpc.log                      # frpc 日志（可选）
+│   └── version.ini                   # 当前版本标识
+├── frpc-console                      # 主二进制（二进制部署）
+└── .old_backup_*                     # 旧版本备份（迁移时生成）
+```
+
+---
+
+## 架构演进
+
+当前架构不是一次性设计完成的，而是经历了以下阶段：
+
+1. **最初**：一个简单的 Web UI，通过命令行调用 frpc
+2. **发现问题**：SSH 断开后 frpc 也跟着退出 → 引入 SetSid
+3. **发现问题**：配置文件修改需要手动重启 → 引入热加载
+4. **发现问题**：ARMHF 设备跑不动 Docker → 引入二进制部署
+5. **发现问题**：边缘设备内存不足 → 优化运行时内存占用
+6. **发现问题**：更新时数据丢失 → 引入事务性部署脚本
+7. **持续演化中**：每次真实部署都可能带来新的架构调整
+
+---
+
+## 相关文档
+
+- [工程设计哲学](./engineering-philosophy.md) — 架构决策背后的设计原则
+- [设计决策记录](./design-decisions.md) — 每个“为什么”的详细记录
+- [边缘节点部署](./edge-node.md) — 在受限环境中的架构适配
+- [更新策略](./update-strategy.md) — 版本管理和升级机制
+- [部署指南](./INSTALL_DOCKER.md) — Docker 部署详细步骤
+- [二进制安装指南](./INSTALL_BINARY.md) — 二进制部署详细步骤

Docs/deployment-engine-design.md

@@ -0,0 +1,355 @@
+# 部署引擎设计
+
+> *部署不是执行命令。*  
+>
+> *部署是让一个未知环境变得可预测的过程。*
+>
+> *不理解环境的部署脚本，只能算是穿着风衣的命令。*
+
+---
+
+## 为什么需要部署引擎
+
+`deploy.sh` 不是安装脚本。它是部署引擎。
+
+安装脚本解决的是“怎么把文件放到正确的位置”。部署引擎解决的是“如何让一个未知环境进入可运行状态”。
+
+用户的机器从来都不是一致的。在实际部署中，可能遇到：
+
+- Docker 未安装
+- Docker 已安装但未启动
+- `daemon.json` 不存在
+- `daemon.json` 存在但为空
+- `daemon.json` 存在但格式非法
+- `registry-mirrors` 不存在
+- `registry-mirrors` 存在但全部不可用
+- `registry-mirrors` 存在但部分不可用
+- `jq` 未安装
+- Git 未安装
+- `frpc-console` 容器已存在
+- `frpc-console` 容器正在运行
+- 当前版本高于目标版本（降级）
+- 当前版本低于目标版本（升级）
+- LTS 与 Preview 通道混用
+
+因此：**部署不是执行命令。部署首先是环境诊断。**
+
+`deploy.sh` 的设计目标：
+
+1. **探测** —— 了解当前环境的状态
+2. **分析** —— 判断当前状态与目标状态之间的差距
+3. **规划** —— 生成最小必要变更的执行计划
+4. **确认** —— 让用户在执行前理解即将发生的变化
+5. **执行** —— 按照计划执行变更
+6. **验证** —— 确认变更生效且系统正常
+7. **清理** —— 移除临时产物，保持系统整洁
+
+---
+
+## 部署生命周期
+
+`deploy.sh` 的执行流程可以用以下状态流转图表示：
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                     Environment Detection                      │
+│  OS / ARCH / Git / Curl / Wget / Docker / jq / Container       │
+└─────────────────────────────────────────────────────────────────┘
+                              │
+                              ▼
+┌─────────────────────────────────────────────────────────────────┐
+│                       State Analysis                           │
+│  镜像源状态 / 容器状态 / 版本状态 / 通道状态                    │
+└─────────────────────────────────────────────────────────────────┘
+                              │
+                              ▼
+┌─────────────────────────────────────────────────────────────────┐
+│                     Deployment Planning                        │
+│  生成变更清单：镜像源配置 / 工具安装 / 代码拉取 / 镜像构建     │
+└─────────────────────────────────────────────────────────────────┘
+                              │
+                              ▼
+┌─────────────────────────────────────────────────────────────────┐
+│                      User Confirmation                         │
+│  展示计划 → 等待确认 → 允许自定义配置                          │
+└─────────────────────────────────────────────────────────────────┘
+                              │
+                              ▼
+┌─────────────────────────────────────────────────────────────────┐
+│                         Execution                              │
+│  备份（降级时）→ 安装工具 → 拉取代码 → 配置镜像源 → 构建镜像   │
+│  → 清理旧容器 → 启动新容器 → 写入版本                          │
+└─────────────────────────────────────────────────────────────────┘
+                              │
+                              ▼
+┌─────────────────────────────────────────────────────────────────┐
+│                        Verification                            │
+│  镜像内容 / 容器状态 / 数据库可用性 / 版本一致性 / frpc PID     │
+└─────────────────────────────────────────────────────────────────┘
+                              │
+                              ▼
+┌─────────────────────────────────────────────────────────────────┐
+│                          Cleanup                               │
+│  清理旧镜像（保留最近 N 个）/ 清理临时文件                      │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+每个阶段都是独立的、可观测的、可失败的。任何一个阶段失败，系统都不会进入下一个阶段。
+
+---
+
+## 状态机设计
+
+`deploy.sh` 的核心不是“执行命令”，而是“状态转换”。
+
+以 Docker 镜像源检测为例：
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                      初始状态                                    │
+│                daemon.json 存在性未知                            │
+└─────────────────────────────────────────────────────────────────┘
+                              │
+                              ▼
+┌─────────────────────────────────────────────────────────────────┐
+│                     daemon.json 不存在                          │
+│                         状态: no_file                           │
+│                         动作: 创建并写入                        │
+└─────────────────────────────────────────────────────────────────┘
+                              │
+                              ▼
+┌─────────────────────────────────────────────────────────────────┐
+│                  daemon.json 存在但格式非法                     │
+│                     状态: (检测到非法)                          │
+│                  动作: 备份 → 重建为 {}                         │
+└─────────────────────────────────────────────────────────────────┘
+                              │
+                              ▼
+┌─────────────────────────────────────────────────────────────────┐
+│               daemon.json 存在但无 registry-mirrors             │
+│                        状态: no_key                             │
+│                    动作: 写入可用镜像源                         │
+└─────────────────────────────────────────────────────────────────┘
+                              │
+                              ▼
+┌─────────────────────────────────────────────────────────────────┐
+│           registry-mirrors 存在且全部可用                       │
+│                   状态: has_valid_ordered                       │
+│                      动作: 跳过（无变更）                       │
+└─────────────────────────────────────────────────────────────────┘
+                              │
+                              ▼
+┌─────────────────────────────────────────────────────────────────┐
+│        registry-mirrors 存在但可用源排在不可用源之后            │
+│               状态: has_valid_reorder_needed                    │
+│                   动作: 重排（可用源前置）                      │
+└─────────────────────────────────────────────────────────────────┘
+                              │
+                              ▼
+┌─────────────────────────────────────────────────────────────────┐
+│              registry-mirrors 全部不可用                        │
+│                     状态: all_invalid                           │
+│              动作: 插入可用默认源（如存在）                     │
+└─────────────────────────────────────────────────────────────────┘
+                              │
+                              ▼
+┌─────────────────────────────────────────────────────────────────┐
+│                   默认镜像源全部不可用                          │
+│                 状态: default_unavailable                       │
+│              动作: 跳过（提示用户手动配置）                     │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+这个状态机的核心原则是：
+
+> **只在需要时修改。只在确认后执行。每次修改都是可逆的或有备份的。**
+
+所有状态都通过 `jq` 检测，所有修改都通过 `jq` 执行，所有原始配置都被备份。
+
+---
+
+## 幂等设计
+
+`deploy.sh` 是幂等的。多次执行的结果与一次执行相同。
+
+幂等性通过以下方式保证：
+
+### 1. 条件执行
+
+```bash
+# 只在容器存在时执行删除
+if docker ps -a | grep -q frpc-console; then
+    docker stop frpc-console
+    docker rm frpc-console
+fi
+```
+
+### 2. 状态检测前置
+
+```bash
+# 检测到用户配置全部可用时跳过修改
+if [ "$MIRROR_STATUS" = "has_valid_ordered" ]; then
+    WRITE_DAEMON=false
+    RESTART_DOCKER=false
+fi
+```
+
+### 3. 版本标记
+
+```bash
+# 每次构建使用唯一标签，不覆盖已有镜像
+IMAGE_TAG="${SEMVER}-lts-$(date +%Y%m%d)"
+```
+
+### 4. 增量修改而非覆盖
+
+镜像源配置采用“插入到最前面”而非“替换整个文件”的策略，保留用户原有配置。
+
+幂等性的意义在于：
+
+> **用户可以在任何时候重新运行 `deploy.sh`，而不必担心系统被破坏。**
+
+---
+
+## 事务完整性
+
+`deploy.sh` 采用类似数据库事务的设计原则：
+
+### 1. 变更前备份
+
+降级操作会触发数据库备份：
+
+```bash
+if [ "$TGT_SEMVER" \< "$CUR_SEMVER" ]; then
+    BACKUP_DIR="/opt/frpc-console-backups/${TIMESTAMP}_${CHANNEL}"
+    cp -r "$DEPLOY_DIR" "$BACKUP_DIR/frpc-console"
+fi
+```
+
+修改 `daemon.json` 前也会备份原文件：
+
+```bash
+cp "$DAEMON_JSON" "${DAEMON_JSON}.bak.$(date +%Y%m%d-%H%M%S)"
+```
+
+### 2. 变更后验证
+
+每次写入后都验证目标状态是否达成：
+
+- 写入镜像源后验证 JSON 有效性
+- 启动容器后验证容器状态
+- 写入版本后验证版本一致性
+- 启动后验证 frpc 进程是否存在
+
+### 3. 失败不继续
+
+任何关键步骤失败都会中断部署，不会进入下一阶段：
+
+```bash
+if [ $? -ne 0 ]; then
+    print_error "Docker 构建失败"
+    exit 1
+fi
+```
+
+---
+
+## 验证不是可选项
+
+大多数安装脚本在“安装完成”后即结束。`deploy.sh` 在“安装完成”后才开始验证。
+
+验证链：
+
+```
+构建完成
+    │
+    ▼
+验证镜像内容 ──→ 失败则退出
+    │
+    ▼
+启动容器
+    │
+    ▼
+验证容器状态 ──→ 失败则退出
+    │
+    ▼
+验证数据库可用性
+    │
+    ▼
+验证版本一致性 ──→ 警告但不退出
+    │
+    ▼
+验证 frpc 子进程 ──→ 警告但不退出
+```
+
+验证的目的是区分“部署完成”和“部署成功”。
+
+- **部署完成**：脚本执行完毕
+- **部署成功**：所有组件正常运行
+
+`deploy.sh` 提供明确的信号来区分这两种状态。
+
+---
+
+## 边界条件处理
+
+边界条件是部署脚本最大的不确定性来源。`deploy.sh` 在处理边界时遵循一个原则：**先假设它可能出问题，再设计应对方式。**
+
+以下边界条件已被识别并处理：
+
+### 已处理的边界
+
+- `daemon.json` 不存在 → 创建
+- `daemon.json` 为空 → 写入 `{}`
+- `daemon.json` 格式非法 → 备份并重建
+- `jq` 未安装 → 尝试安装，失败则降级处理
+- `registry-mirrors` 不存在 → 写入可用源
+- `registry-mirrors` 全部不可用 → 插入可用默认源
+- 用户镜像源全部失效 → 插入可用默认源到最前面
+- 默认镜像源全部不可用 → 跳过配置，提示用户手动处理
+- 旧版本文件在根目录 → 自动迁移到 `data/`
+- 容器已存在 → 停止并删除
+- 容器正在运行 → 优雅停止
+- 降级操作 → 自动备份，用户确认
+- LTS ↔ Preview 通道切换 → 备份数据库，用户确认
+- 旧镜像积累 → 保留最近 N 个，自动清理
+
+### 处理原则
+
+每新增一个边界条件，都是在扩展一个同一个决策表：当 `环境变量 X` 处于 `状态 Y` 时，引擎应该执行 `动作 Z`。这些条目不相互覆盖，而是叠加在同一个状态机之上，彼此通过前置条件互锁。
+
+这种方式的优点是：边界条件越多，系统对环境的适应能力越强，但状态机的核心结构不需要跟着膨胀。
+
+---
+
+## 与工程设计哲学的关系
+
+`deployment-engine-design.md` 与 `engineering-philosophy.md` 的关系是：
+
+| 文档 | 回答的问题 |
+|:---|:---|
+| `engineering-philosophy.md` | 为什么这样设计？ |
+| `deployment-engine-design.md` | 这些设计如何落地？ |
+| `deploy.sh` | 落地后的最终产物 |
+
+三者形成一条完整的链路：
+
+```
+哲学 → 架构 → 部署引擎 → 代码
+```
+
+哲学文档定义“为什么”，部署引擎文档定义“如何实现”，`deploy.sh` 是“实现的最终形态”。
+
+---
+
+## 结语
+
+> `deploy.sh` 不是安装脚本。
+>
+> 它是 `frpc-console` 的部署引擎。
+>
+> 它负责：环境探测、状态分析、部署规划、用户确认、执行动作、结果验证、环境清理。
+>
+> 它的设计目标是：**在尽量不打扰用户已有环境的前提下，把部署成功率提高到接近 100%。**
+
+这份文档记录了它为什么长成这样。

Docs/design-decisions.md

@@ -0,0 +1,168 @@
+# 设计决策
+
+> *“这不是 API 文档，这是设计记录。它回答的不是‘怎么用’，而是‘为什么会变成这样’。”*
+
+---
+
+## 关于这份文档
+
+frpc-console 的许多设计，如果只看最终结果，可能会让人觉得“奇怪”或“不按常理出牌”。
+
+这份文档记录的就是这些“奇怪”背后的原因。
+
+每一个决策，都来自真实部署中遇到的问题——而不是预先的设计。
+
+---
+
+## 为什么叫 Console，而不是 Manager？
+
+这个命名不是随意选的。
+
+| | Manager | Console |
+|---|---|---|
+| 暗示 | 管理权、控制中心 | 入口、操作界面 |
+| 角色 | 大脑 | 工具 |
+| 依赖关系 | 业务依赖 Manager | Console 依赖业务 |
+
+**结论：**
+
+frpc-console 不接管 FRP，不成为 FRP 的依赖。它只是一个入口，让你在需要的时候操作 FRP。
+
+用完之后，关闭浏览器，FRP 还在跑。
+
+这就是 Console 和 Manager 的区别。
+
+---
+
+## 为什么没有 CI/CD？
+
+这个项目没有复杂的 CI/CD 发布流程。不是做不到，而是选择不做。
+
+**原因：**
+
+- CI/CD 在云端跑，部署在真实环境跑。两者之间隔着一个“信任”的黑洞。
+- 如果发布流程和用户安装流程是两套不同的路径，维护者永远无法保证用户侧的真实体验。
+- 每一次部署，都应该在真实环境中被验证。
+
+**所以：**
+
+部署脚本就是发布流水线。开发过程中使用的更新链路，就是最终用户使用的更新链路。
+
+没有特权通道，没有隐藏开关。你用的，就是我用的。
+
+---
+
+## 为什么没有 Patch 版本？
+
+版本号格式：`2.5-LTS-260804-203825`
+
+详见：[更新策略](./update-strategy.md)
+
+---
+
+## 为什么支持 ARMHF？
+
+详见：[边缘节点部署](./edge-node.md)
+
+---
+
+## 为什么采用 Preview / LTS 双线版本？
+
+详见：[更新策略](./update-strategy.md)
+
+---
+
+## 为什么“存储换内存”？
+
+在边缘设备上，存储和内存的成本结构完全颠倒：
+
+| | 服务器 | 边缘设备 |
+|---|---|---|
+| 存储 | 昂贵（NVMe SSD） | 便宜（SD 卡 / eMMC） |
+| 内存 | 便宜（可扩展） | 昂贵（不可扩展，BGA 焊接） |
+
+**结论：**
+
+镜像大几十 MB，可以接受。内存多占 10MB，不能接受。
+
+牺牲存储空间，换来 50MB 以内的内存占用——这笔账在边缘设备上怎么算都不亏。
+
+---
+
+## 为什么用 SQLite，不用 PostgreSQL / MySQL？
+
+- 边缘设备跑不动 PostgreSQL
+- 不需要网络连接
+- 单文件备份，复制即迁移
+- 零配置，零维护
+
+符合“降低维护成本”的总体目标。
+
+---
+
+## 为什么使用 Gin 和 Vue，而不是更轻的框架？
+
+这是一个有意识的选择。
+
+frpc-console 的 Web 部分需要提供完整的图形化操作界面，不是一个简单的 API 服务。使用成熟的框架，换取开发效率和稳定性。
+
+**但要注意：**
+
+框架的选择不影响运行时资源占用。前端资源在首次加载后缓存，后端 Gin 在 idle 状态下几乎没有额外开销。
+
+---
+
+## 为什么默认不写日志？
+
+边缘设备存储有限（SD 卡 / eMMC）。
+
+默认不写日志，避免存储被写满导致设备不可用。
+
+用户需要时，可以显式开启日志功能。
+
+---
+
+## 为什么 openSUSE 在部署脚本中排第一？
+
+详见：[工程设计哲学](./engineering-philosophy.md) 中的“用户不是测试员”和“Real World First”原则。
+
+---
+
+## 为什么 Docker 和 Binary 都支持？
+
+因为使用场景不同：
+
+| 场景 | 推荐方式 |
+|---|---|
+| 现代服务器（有 Docker） | Docker |
+| 边缘设备（无 Docker） | Binary |
+| 开发者测试 | Docker |
+| 开发测试（无 Docker）| Binary |
+| 生产环境（有 Docker） | Docker |
+| 生产环境（无 Docker） | Binary |
+
+**核心原则：** 无论运行在哪里，体验应该保持一致。
+
+---
+
+## 为什么叫“阴阳模式”？
+
+详见：[工程设计哲学](./engineering-philosophy.md) 中的“阴阳模式”章节。
+
+---
+
+## 这些决策的共同点
+
+所有设计决策，都指向同一个问题：
+
+**一个长期运行的基础设施工具，应该是什么样？**
+
+答案不是“功能最多”，不是“界面最美”，而是：
+
+**降低长期维护的成本。**
+
+每一个“为什么”的答案，最终都落在这句话上。
+
+---
+
+*这份文档会持续更新。每一次新的设计决策，都会被记录在这里。*

Docs/edge-node.md

@@ -0,0 +1,154 @@
+# 边缘节点部署
+
+> *“真正需要管理工具的，往往不是机房里那台 64 核 256GB 的服务器，而是弱电箱里那块连散热片都没有的 ARM 开发板。”*
+
+---
+
+## 真实场景
+
+frpc-console 对边缘节点的支持，不是来自“市场调研”。
+
+它来自以下设备：
+
+- **全志 H3**（256MB / 512MB 内存），运行社区的精简版 ARMbian 或官方剪枝版 Debian，放在弱电箱里跑 frp 穿透
+- **RK3506**（128MB / 256MB 版本共存），没有 Docker，甚至没有 systemd
+- 老旧 ARM 开发板（ARMv7l / ARM-HF），原本可能是一块电视盒子，刷上 ARMbian 之后被重新利用
+
+这些设备的共同特征：
+
+- 存储介质：SD 卡 / eMMC（便宜，容量大，但读写速度不敏感）
+- 内存：128MB ~ 512MB（**没有任何拓展条件**）
+- 系统环境：极简化，不常用的工具基本都被剪枝，极端情况下很可能只有 Kernel + BusyBox + init
+- 网络环境：长期在线，但带宽有限
+- 物理位置：没有理由长期触及（弱电箱、吊顶、室外机柜）
+
+它们承担的工作却并不边缘：
+
+- 内网穿透
+- 远程维护通道
+- IoT 设备接入
+- 边缘计算节点
+
+---
+
+## 边缘环境特征
+
+### 存储 vs 内存：成本结构的倒挂
+
+在边缘设备上，存储和内存的成本结构与服务器完全不同：
+
+| | 服务器 | 边缘设备 |
+|---|---|---|
+| 存储 | 昂贵（NVMe SSD） | 便宜（SD 卡 / eMMC） |
+| 内存 | 便宜（可扩展） | 昂贵（不可扩展，BGA 焊接） |
+
+这意味着：
+
+**镜像大几十 MB，可以接受。内存多占 10MB，不能接受。**
+
+所以 frpc-console 的 Docker 镜像虽然包含了完整的构建环境和依赖，但它不会在运行时消耗额外内存。镜像大小和运行时内存占用，在边缘场景下是两个独立且优先级完全不同的指标。
+
+### 缺失的依赖
+
+边缘设备可能缺失以下内容：
+
+- **Docker**：很多 ARMHF 设备跑不动 Docker，或者根本没有 Docker 的预编译包
+- **systemd**：精简系统中可能只有 init 或 busybox-init
+- **glibc**：某些环境只提供 uClibc 或 musl
+- **包管理器**：内存小到一定程度的时候，它的存在堪称奢望
+
+因此，**二进制部署是边缘节点的唯一可行方案**。
+
+---
+
+## frpc-console 对边缘节点的适配
+
+### 1. 二进制静态编译
+
+frpc-console 采用 Go 编写，编译时使用 `CGO_ENABLED=0`：
+
+- 不依赖 glibc
+- 单一二进制文件
+- 可运行于 musl 环境（Alpine、BusyBox）
+- 不需要任何运行时依赖
+
+### 2. 多架构支持
+
+| 架构 | 说明 |
+|---|---|
+| x86_64 / AMD64 | 标准服务器 |
+| ARM64 / Aarch64 | 现代 ARM 设备（树莓派 3/4/5） |
+| ARMHF / ARMv7l | 老旧 ARM 设备（全志 H3、RK3506） |
+
+### 3. 无 systemd 运行方式
+
+在只有 init + BusyBox 的环境中：
+
+```bash
+# 直接运行
+./frpc-console &
+
+# 或通过 init 启动（写入 /etc/init.d/）
+```
+
+frpc-console 自身会通过 `Setsid` 为 frpc 创建独立会话，确保 frpc 在 console 退出后仍被 PID 1 接管。
+
+### 4. 数据目录设计
+
+```
+/opt/frpc-console/data/
+├── frpc-console.db    # SQLite 数据库
+├── frpc.toml          # FRP 配置文件
+├── frpc               # FRP 二进制（内置，无需额外下载）
+├── frpc.pid           # frpc 进程 PID
+├── frpc.log           # frpc 日志（可选）
+└── version.ini        # 当前版本标识
+```
+
+所有数据在同一个目录下，备份只需复制整个文件夹。
+
+### 5. 无日志默认策略
+
+边缘设备存储有限，所以：
+
+- 默认不写入日志文件
+- 日志仅在用户明确开启时写入
+- 避免 SD 卡被日志写满导致设备不可用
+
+---
+
+## 部署注意事项
+
+### 推荐的最小硬件规格
+
+| 场景 | CPU | 内存 | 存储 |
+|---|---|---|---|
+| 最小运行 | ARMv7 / ARM-HF | 128MB | 50MB（二进制 + 数据库） |
+| 推荐运行 | ARMv7 / ARM64 | 256MB | 100MB |
+| 舒适运行 | ARM64 / x86_64 | 512MB | 200MB |
+
+### 不建议部署的场景
+
+- **内存低于 64MB**：很极限，需要系统本身有极强的剪枝水准，以保证基础内存消耗不高于20M，但这并不现实
+- **存储低于 20MB**：没有足够的空间存放二进制和数据
+- **内核版本过低**（< 3.x）：某些系统调用可能不支持
+- **刷了OpenWRT的软/硬路由**：这种建议去下opkg的源包，而不是看向我们这个项目。
+
+### 网络要求
+
+- 边缘节点的网络出口带宽一般有限，首次访问 WebUI 时加载的静态资源（约 1-2MB）可能需要稍长时间
+- 后续操作仅传输 JSON 数据，流量极小
+
+---
+
+## 为什么这件事值得单独记录？
+
+因为主流开源项目在讨论 ARM 支持时，讨论的是“树莓派 4B（4GB 版本）”。
+
+而真正部署在边缘的设备，可能只有 256MB 内存，甚至连 Docker 都没有。
+
+frpc-console 对 ARMHF 的支持，不是“支持的架构列表里多了一项”，而是：
+
+**这个工具可以跑到那些真正藏在弱电箱里、承担网络基础设施工作的小板子上。**
+
+这才是边缘节点部署的意义。

Docs/engineering-philosophy.md

@@ -0,0 +1,305 @@
+# 工程设计哲学
+
+> *“Every line of code is a decision. Every document is an explanation of that decision.”*
+>
+> *（每一行代码都是一次设计决策，而每一份文档，都是对这次决策的解释。）*
+
+> *“Infrastructure software should disappear after deployment.”*
+>
+> *（基础设施软件，在部署完成以后，就应该消失。）*
+
+很多工具追求功能。
+
+很多工具追求界面。
+
+很多工具追求自动化。
+
+**但frpc-console 从来没有试图成为功能最多的 FRP 管理工具。**
+
+**它真正想解决的问题，是让一套 FRP 基础设施，在部署完成之后，能够稳定运行很多年，而几乎不需要再次打扰使用者。**
+
+如果一个工具每天提醒你更新，每天提醒你配置，每天提醒你维护——那么它已经失败了。
+
+部署，只发生一次。
+
+运行，却持续很多年。
+
+所以整个 frpc-console 都围绕这一件事情设计：
+
+**安装。配置。运行。然后——忘记它。**
+
+---
+
+## 为什么会有这个项目？
+
+最初，这只是一个给自己 Homelab 用的小工具。
+
+我需要一套简单、可靠的方式管理本地运行的 frpc。
+
+后来，在不断使用、不断重构的过程中，我意识到：
+
+真正的问题，从来不是"有没有一个管理页面"。
+
+而是：
+
+**如果 FRP 是一项长期运行的基础设施，它应该长什么样？**
+
+于是，这个项目开始慢慢偏离最初的方向。
+
+它不再只是一个 Web 面板，而是开始关注：
+
+- 生命周期管理
+- 长期维护
+- 多种部署方式
+- 极简运行环境
+- 用户真实的使用场景
+
+直到今天。
+
+---
+
+## 核心问题
+
+**一个长期运行的基础设施工具，应该是什么样？**
+
+这个问题的答案，驱动了 frpc-console 的所有设计。
+
+它不是一个功能列表，而是一套判断标准：
+
+- 功能应该增加，还是减少？
+- 部署应该复杂，还是简单？
+- 更新应该频繁，还是稳定？
+- 工具应该显眼，还是隐身？
+
+每个问题的答案，都指向同一个方向：
+
+**降低长期维护的成本。**
+
+---
+
+## 设计目标
+
+frpc-console 希望成为这样一种工具：
+
+**安装。配置。运行。然后，忘记它。**
+
+真正优秀的基础设施，不应该每天提醒用户自己的存在。
+
+它应该像交换机、路由器、UPS 一样——平时不会想到它，但需要的时候，它一直在那里。
+
+---
+
+## 设计哲学
+
+### 工具应该降低复杂度，而不是增加复杂度
+
+GUI 的意义，并不是隐藏配置文件，而是**降低维护成本**。
+
+如果一个图形界面最终比命令行更复杂，那么它已经偏离了存在的意义。
+
+### 每增加一个功能，都意味着新的维护成本
+
+功能不是越多越好。
+
+一个功能只有在真正改善体验时才值得存在。否则，宁可不做。
+
+这也是为什么：有些别人认为"理所当然"的功能，这里没有。不是不会，而是不值得。
+
+### 用户不是测试员
+
+这个项目的大多数设计，都来自于真实使用。
+
+开发者，也是第一个用户。
+
+如果一个设计连我自己都不愿意每天面对，那么它不会进入正式版本。
+
+### Docker 不是目标
+
+Docker 很重要，Binary 同样重要。
+
+真正重要的是：**无论运行在哪里，体验应该保持一致。**
+
+Docker、x86、ARM64、ARMHF，甚至极简 Linux——都应该拥有同样的管理体验。
+
+### Real World First
+
+这个项目的很多设计，都来自于真实部署，而不是 Demo。
+
+例如：
+
+- Docker 更新顺序
+- Git 拉取时机
+- 编译流程
+- 边缘部署
+- 二进制运行
+- BusyBox 环境
+
+很多看起来"奇怪"的实现，其实都来自于**踩坑**。
+
+不是设计出来的，而是试出来的。
+
+### 存储换内存，在嵌入式平台上不是交易，是生存策略
+
+镜像可以大几十 MB，但内存必须省。
+
+因为存储卡便宜，内存颗粒贵。
+
+对于 RK3506（128/256MB 版本共存）或全志 H3（256/512MB 并存）这类平台——
+
+牺牲一点存储空间（镜像大了几十 MB），换来 50MB 以内的内存占用，这笔账怎么算都不亏。
+
+---
+
+## 稳定性与可观测性
+
+"安装、配置、运行，然后忘记它"。
+
+但忘记，不等于失控。
+
+frpc-console 在设计上始终保持一个原则：
+
+**工具自身的开销，不应该成为需要被关注的对象。**
+
+所以：
+
+- 主进程在 idle 状态下 CPU 占用接近 0%
+- 内存占用控制在 20MB 以内
+- 没有额外的后台守护进程
+- 没有定期轮询的健康检查
+- 不会主动写入日志文件，除非你明确开启
+
+在真实设备上，frpc 和 frpc-console 同时运行时，两者加起来不到 30MB。
+
+这意味着，它不会成为你需要"照顾"的对象。
+
+---
+
+## 关键设计决策
+
+### 阴阳模式：面板可以挂，隧道不能停
+
+这是 frpc-console 与同类项目最核心的区别。
+
+**大多数管理工具走的是"阳阴模式"：**
+面板是大脑，业务是肢体。大脑一旦停止工作，肢体也就瘫痪了。
+
+**frpc-console 走的是"阴阳模式"：**
+业务是根基，面板是工具。
+
+- **阴**：看不见的业务流（frpc 进程、TOML 配置文件）
+- **阳**：看得见的管理面板（Web 界面、API 服务）
+
+二进制部署时，frpc-console 通过 `Setsid` 为 frpc 创建独立会话，使其完全脱离父进程的生命周期控制。
+
+即使 console 退出，frpc 也会被 init 进程（PID 1）接管，继续稳定运行。
+
+Docker 部署时，容器使用 `--restart=always`，console 退出时 Docker 自动重启并重新拉起 frpc。
+
+两种部署方式的本质一致：
+
+**面板是"阳"，服务于"阴"；"阴"不依赖"阳"而存在。**
+
+> **管理面板可以丢，业务功能打死不能停。**
+
+### 为什么叫 Console，而不是 Manager？
+
+这个命名不是随意选的。
+
+- **Manager** 暗示"管理权"，暗示它是一个控制中心，是大脑。
+- **Console** 暗示"入口"，暗示它是一个操作界面，是工具。
+
+这个区别，直接体现了项目的设计立场：
+
+**frpc-console 不接管 FRP，不成为 FRP 的依赖。它只是一个入口，让你在需要的时候，通过它来操作 FRP。**
+
+用完之后，关闭浏览器，FRP 还在跑。
+
+这就是 Console 和 Manager 的区别。
+
+### 为什么没有 CI/CD？
+
+这个项目没有复杂的 CI/CD 发布流程。
+
+不是做不到，而是选择不做。
+
+因为：
+
+- CI/CD 在云端跑，部署在真实环境跑。两者之间隔着一个"信任"的黑洞。
+- 如果发布流程和用户安装流程是两套不同的路径，维护者永远无法保证用户侧的真实体验。
+- 每一次部署，都应该在真实环境中被验证。
+
+所以，frpc-console 的部署脚本本身就是发布流水线：
+
+- 拉取代码 → 构建镜像 → 启动容器 → 写入版本 → 检查进程
+- 支持 `--dry-run` 预览、`--check` 环境检测
+- 降级前自动备份数据库
+- 保留最近 3 个镜像，便于回滚
+
+开发过程中使用的更新链路，就是最终用户使用的更新链路。
+
+没有特权通道，没有隐藏开关。
+
+你用的，就是我用的。
+
+因此，每一次更新，实际上都在验证整个部署流程。
+
+### 为什么支持 ARMHF？
+
+因为很多时候，真正需要这种工具的，并不是性能很强的服务器。
+
+而是一块全志 H3、RK3506，或者老旧 ARM 开发板——放在弱电箱里的边缘节点。
+
+它们可能没有 Docker，没有 systemd，甚至只有：
+
+- Kernel
+- BusyBox
+- init
+
+但它们依然承担着网络基础设施的工作。
+
+对于这些设备来说，图形化管理反而比高性能服务器更重要。
+
+### 为什么采用 Preview / LTS 双线版本？
+
+- **Preview**：用于验证新的设计与实现（test 分支）
+- **LTS**：保持稳定，并持续滚动维护（main 分支）
+
+某些修复不会等待下一个大版本。
+
+因为对于基础设施而言，**稳定比版本号更重要**。
+
+---
+
+## 这个项目不是什么
+
+这个项目：
+
+- 不追求成为功能最多的 FRP 管理平台
+- 不追求重新定义 FRP
+- 不追求构建自己的生态
+- 不追求让用户每天打开它
+
+它只是希望：
+
+**把复杂留给软件，把简单留给用户。**
+
+---
+
+## 最后
+
+如果有一天，你已经忘记 frpc-console 安装在哪里，也忘记它上一次更新是什么时候。
+
+但是：
+
+- FRP 依然稳定运行
+- 偶尔需要修改配置
+- 打开浏览器
+- 两分钟完成
+- 关闭
+- 继续忘记它
+
+那么，它已经完成了自己的使命。
+
+---
+
+*这份文档会持续更新。因为 frpc-console 的设计，本身就是一个不断演化的过程。每一次真实部署中遇到的新问题，都可能成为下一版设计哲学的注脚。*

Docs/install_docker.md

@@ -0,0 +1,200 @@
+## 🐳 Docker 版安装指南
+
+> 推荐方式：一键脚本自动部署，无需手动安装 Go 环境，无需预先配置 Docker 镜像源。
+
+> ⚠️ **注意**：Docker 版直接从源码构建，使用的是当前所选分支（LTS / Preview）的最新代码。如需使用特定 Release 版本，请查看 [Releases](https://git.whitetop.xyz/lxh2875931338/frpc-console/releases) 并通过二进制方式部署。
+
+---
+
+### 一、📥 前置条件
+
+- **已安装 Docker**（必须，版本不限）
+- **curl**（其余依赖脚本会自动检查并安装）
+- **操作系统**：Linux（x86_64 / ARM64 / ARMv7 / ARMHF 均可）
+- **网络**：需能访问 Gitea 仓库（git.whitetop.xyz）
+
+> 💡 脚本会自动检测并配置 Docker 镜像加速，无需手动设置。
+
+---
+
+### 二、🚀 一键部署（推荐）
+
+在目标 Linux 服务器上执行：
+
+```bash
+curl -sSL https://git.whitetop.xyz/lxh2875931338/frpc-console/raw/main/run-deploy.sh | sudo bash
+```
+
+部署过程中会提示选择通道：
+
+· LTS（稳定版） → main 分支，生产环境推荐
+· Preview（技术预览版） → test 分支，尝鲜和新特性验证
+
+脚本会完整执行整个部署流程，包括镜像源自动检测与配置。
+
+---
+
+三、⚙️ 部署引擎自动完成内容
+
+deploy.sh 是一个完整的状态机驱动部署引擎，按时间顺序执行以下操作：
+
+```mermaid
+flowchart TD
+    subgraph 检测阶段
+        A[检测操作系统] --> B[检测CPU架构]
+        B --> C[检测必要工具]
+        C --> D[检测Docker环境]
+        D --> E[检测镜像源配置]
+    end
+
+    subgraph 决策阶段
+        E --> F[状态机计算]
+        F --> G[生成部署计划]
+        G --> H[用户确认]
+    end
+
+    subgraph 执行阶段
+        H --> I[拉取源码]
+        I --> J[配置镜像源]
+        J --> K[重启Docker]
+        K --> L[构建镜像]
+        L --> M[清理旧容器]
+        M --> N[启动容器]
+        N --> O[写入版本]
+    end
+
+    subgraph 验证阶段
+        O --> P[验证镜像内容]
+        P --> Q[验证数据库]
+        Q --> R[验证版本]
+    end
+
+    subgraph 清理阶段
+        R --> S[清理旧镜像]
+        S --> T[清理临时文件]
+    end
+
+    T --> U[部署完成]
+```
+
+---
+
+四、📂 数据持久化
+
+脚本默认将数据存储在 /opt/frpc-console/data/：
+
+文件 说明
+frpc-console.db SQLite 数据库（用户、隧道、配置）
+frpc.toml 当前 frpc 配置文件
+frpc.log frpc 运行日志
+frpc.pid frpc 进程 PID
+version.ini 当前版本标识
+
+升级或重建容器时，数据自动保留，不会丢失。
+
+---
+
+五、🔄 升级
+
+方式一：重新运行部署脚本（推荐）
+
+```bash
+curl -sSL https://git.whitetop.xyz/lxh2875931338/frpc-console/raw/main/run-deploy.sh | sudo bash
+```
+
+脚本会自动：
+
+1. 拉取最新代码
+2. 构建新镜像
+3. 停止并删除旧容器
+4. 启动新容器
+5. 数据卷保持不变
+
+方式二：手动更新
+
+```bash
+# 停止旧容器
+docker stop frpc-console
+docker rm frpc-console
+
+# 重新运行 deploy.sh
+curl -sSL https://git.whitetop.xyz/lxh2875931338/frpc-console/raw/main/run-deploy.sh | sudo bash
+```
+
+💡 升级时如检测到语义版本降级（如 2.6 → 2.5），脚本会自动备份数据目录，并等待用户确认后再执行。
+
+---
+
+六、🧹 常用命令
+
+```bash
+# 查看日志
+docker logs -f frpc-console
+
+# 查看 frpc 子进程状态
+docker exec frpc-console ps aux | grep frpc
+
+# 重启容器
+docker restart frpc-console
+
+# 停止容器
+docker stop frpc-console
+
+# 启动容器
+docker start frpc-console
+
+# 查看当前版本
+cat /opt/frpc-console/data/version.ini
+```
+
+---
+
+七、🌐 访问地址
+
+部署完成后，浏览器打开：
+
+```
+http://你的服务器IP:9300
+```
+
+首次访问会自动跳转到注册页面，填写用户名和密码，完成管理员账户创建。
+
+登录后，在「隧道列表」页面点击「导入 TOML」，即可将现有的 frpc.toml 迁移到 WebUI 中管理。
+
+---
+
+八、📌 手动部署（不使用脚本）
+
+如果你已有源码，或想完全手动控制：
+
+```bash
+# 1. 克隆代码
+git clone https://git.whitetop.xyz/lxh2875931338/frpc-console.git
+cd frpc-console
+
+# 2. 构建镜像
+docker build -t frpc-console:latest .
+
+# 3. 创建数据目录
+mkdir -p /opt/frpc-console/data
+
+# 4. 启动容器
+docker run -d \
+  --name frpc-console \
+  --restart=always \
+  --network host \
+  -v /opt/frpc-console/data:/app/data \
+  -e PORT=9300 \
+  -e TZ=Asia/Shanghai \
+  frpc-console:latest
+```
+
+⚠️ 手动部署不会自动处理镜像源配置、版本管理、容器冲突检测和镜像清理。建议优先使用一键部署脚本。
+
+---
+
+### 九、📖 相关文档
+
+- [部署引擎设计详解](./deployment-engine-design.md) — 了解 `deploy.sh` 的状态机设计与工程决策
+- [工程设计哲学](./engineering-philosophy.md) — 理解部署脚本背后的设计理念
+- [二进制安装指南](./install_binary.md) — 适用于无 Docker 或边缘设备场景

Docs/update-strategy.md

@@ -0,0 +1,142 @@
+# 更新策略
+
+一句话：
+
+更新策略不是为了更新
+
+而是为了让你可以几年以后</br>
+依旧知道自己运行的是哪个版本
+
+---
+
+## 版本号格式
+
+frpc-console 的版本号遵循以下格式：
+
+```
+<semver>-<channel>-<date>-<time>
+```
+
+**示例：** `2.5-LTS-260804-203825`
+
+| 组成部分 | 说明 | 示例 |
+|---|---|---|
+| **semver** | 语义版本号（主版本.次版本） | `2.5` |
+| **channel** | 发布通道 | `LTS` / `Preview` |
+| **date** | 构建日期（YYMMDD） | `260804` |
+| **time** | 构建时间（HHMMSS） | `203825` |
+
+---
+
+## 为什么没有 Patch 版本？
+
+你可能已经注意到了：
+
+**版本号里只有主版本和次版本（如 `2.5`），没有 patch 号。**
+
+这不是疏忽，而是有意识的设计选择。
+
+原因很简单：
+
+- frpc-console 的发行逻辑是标准的滚动式发行逻辑，而非完全由版本号驱动
+- 因此，frpc-console 的更新粒度是基于**构建时间戳**的，每一个不同的构建时间点，对应的可能是不一样的版本
+- 每一次构建都是一个独立的版本，通过日期时间精确标识
+- `2.5-LTS-260804-203825` 和 `2.5-LTS-260805-091422` 之间，不需要、也不应该用第三个数字来区分
+
+---
+
+## 双通道：LTS / Preview
+
+项目采用双线开发模式，对应两个不同的分支：
+
+### LTS（Long-Term Support）
+
+- **分支：** `main`
+- **定位：** 稳定版，生产环境推荐
+- **特征：** 低更新频率，可以在不接收任何冷热更新的情况下，长时间稳定自持
+- **适用场景：** 生产环境、Homelab 主节点、长期运行设备
+
+### Preview
+
+- **分支：** `test`
+- **定位：** 技术预览版，包含最新设计和实验性功能
+- **特征：** 极高更新频率，很多时候会伴随大量不稳定commit，稳定性并不佳
+- **适用场景：** 开发者用测试环境、尝鲜用户、边缘节点验证
+
+---
+
+## 更新机制
+
+### 部署脚本中的更新逻辑
+
+`deploy.sh` 脚本在每次运行时，会从远程仓库读取当前分支的最新版本：
+
+```bash
+# 从远程读取 version.ini
+SEMVER=$(curl -sSL https://git.whitetop.xyz/.../version.ini)
+
+# 根据通道生成完整版本号
+if [ "$channel" = "lts" ]; then
+    TARGET_VERSION="${SEMVER}-lts-$(date +%Y%m%d)"
+else
+    TARGET_VERSION="${SEMVER}-preview-$(date +%Y%m%d-%H%M%S)"
+fi
+```
+
+每次运行部署脚本，都会生成一个新的版本号，并写入 `data/version.ini`。
+
+### 版本比较
+
+部署脚本在更新前会检查当前版本和目标版本：
+
+```bash
+CURRENT_VERSION=$(cat /opt/frpc-console/data/version.ini)
+CUR_SEMVER=$(echo "$CURRENT_VERSION" | sed -E 's/^([0-9]+\.[0-9]+).*$/\1/')
+TGT_SEMVER=$(echo "$TARGET_VERSION" | sed -E 's/^([0-9]+\.[0-9]+).*$/\1/')
+```
+
+如果检测到**语义版本降级**（例如从 `2.6` 降到 `2.5`），脚本会：
+
+1. 发出警告
+2. 自动备份当前数据目录
+3. 等待用户确认后才继续
+
+### 通道固定原则
+
+一旦选择了一个通道（LTS 或 Preview），后续升级时**不应切换通道**：
+
+- LTS → LTS：允许，正常升级
+- Preview → Preview：允许，正常升级
+- LTS → Preview：**不推荐**，可能引入未经充分验证的变更
+- Preview → LTS：**不推荐**，可能发生版本降级
+
+如果确实需要切换通道，部署脚本会在抓取源码前，自动备份你的数据库到安全位置，但是脚本本身也存在可能的不稳定因素，此时请保证你的手中至少有一份可用的较新的toml文件，可供部署完成后恢复
+
+---
+
+## 镜像保留策略
+
+Docker 部署时，脚本会自动保留最近 **3 个** 镜像：
+
+```bash
+KEEP_IMAGES=3
+```
+
+这 3 个镜像足够用于回滚，又不会占用过多存储空间（边缘节点存储有限）。
+
+---
+
+## 为什么这套策略是合理的？
+
+1. **基础设施工具不需要频繁的版本号膨胀。** 一年发布一个大版本，中间用 LTS 累积修复，比每个小补丁都发一个新版本更符合长期运行环境的预期。
+
+2. **构建日期比 patch 号更有信息量。** `2.5-LTS-260804` 一眼就能看出是 2026 年 8 月 4 日构建的 LTS 版本，不需要查 changelog。
+
+3. **用户不需要关心 patch。** 用户只需要知道当前是 LTS 还是 Preview，以及发布日期。具体的修复内容，在更新日志里。
+
+---
+
+## 相关文档
+
+- 部署脚本的更新逻辑详见：[部署指南 - Docker版](./install_docker.md) 和 [部署指南-二进制版](./install_binary.md)
+- 版本号的设计背景详见：[工程设计哲学](./engineering-philosophy.md)

auth.go

@@ -1,142 +0,0 @@
-package main
-
-import (
-	"errors"
-	"fmt"
-	"log"
-	"net/http"
-	"strings"
-	"time"
-
-	"github.com/gin-gonic/gin"
-	"github.com/golang-jwt/jwt/v5"
-	"golang.org/x/crypto/bcrypt"
-)
-
-var jwtSecretCache []byte
-
-func getJwtSecret() []byte {
-	if len(jwtSecretCache) > 0 {
-		return jwtSecretCache
-	}
-	secret, err := GetJwtSecret()
-	if err != nil {
-		log.Fatal("❌ 获取 JWT 密钥失败:", err)
-	}
-	jwtSecretCache = []byte(secret)
-	return jwtSecretCache
-}
-
-type Claims struct {
-	Username string `json:"username"`
-	jwt.RegisteredClaims
-}
-
-func GenerateJWT(username string) (string, error) {
-	claims := Claims{
-		Username: username,
-		RegisteredClaims: jwt.RegisteredClaims{
-			ExpiresAt: jwt.NewNumericDate(time.Now().Add(7 * 24 * time.Hour)),
-			IssuedAt:  jwt.NewNumericDate(time.Now()),
-		},
-	}
-	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
-	return token.SignedString(getJwtSecret())
-}
-
-func ParseJWT(tokenString string) (*Claims, error) {
-	token, err := jwt.ParseWithClaims(tokenString, &Claims{}, func(token *jwt.Token) (interface{}, error) {
-		return getJwtSecret(), nil
-	})
-	if err != nil {
-		return nil, err
-	}
-	if claims, ok := token.Claims.(*Claims); ok && token.Valid {
-		return claims, nil
-	}
-	return nil, errors.New("invalid token")
-}
-
-func ValidatePassword(pwd string) bool {
-	if len(pwd) < 8 {
-		return false
-	}
-	var hasUpper, hasLower, hasDigit, hasSpecial bool
-	for _, ch := range pwd {
-		if ch >= 'A' && ch <= 'Z' {
-			hasUpper = true
-		} else if ch >= 'a' && ch <= 'z' {
-			hasLower = true
-		} else if ch >= '0' && ch <= '9' {
-			hasDigit = true
-		} else if strings.ContainsAny(string(ch), "!@#$%^&*()_+-=[]{}|;:,.<>?") {
-			hasSpecial = true
-		}
-	}
-	return hasUpper && hasLower && hasDigit && hasSpecial
-}
-
-func InitAdminUser() {
-	count, err := CountUsers()
-	if err != nil {
-		log.Fatal("❌ 检查用户表失败:", err)
-	}
-	if count > 0 {
-		log.Println("✅ 已存在管理员账户，跳过初始化")
-		return
-	}
-	log.Println("⚠️  首次启动，请设置管理员账户")
-	log.Print("用户名: ")
-	var username string
-	fmt.Scanln(&username)
-	if username == "" {
-		username = "admin"
-	}
-	for {
-		log.Print("密码 (至少8位，含大小写、数字、特殊字符): ")
-		var password string
-		fmt.Scanln(&password)
-		if ValidatePassword(password) {
-			hash, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
-			if err != nil {
-				log.Println("❌ 密码加密失败:", err)
-				continue
-			}
-			err = CreateUser(username, string(hash))
-			if err != nil {
-				log.Println("❌ 创建用户失败:", err)
-				continue
-			}
-			log.Println("✅ 管理员账户创建成功！")
-			break
-		} else {
-			log.Println("❌ 密码不符合复杂度要求，请重新输入")
-			log.Println("   要求: 至少8位，包含大小写字母、数字和特殊字符")
-		}
-	}
-}
-
-func AuthMiddleware() gin.HandlerFunc {
-	return func(c *gin.Context) {
-		authHeader := c.GetHeader("Authorization")
-		if authHeader == "" {
-			c.JSON(http.StatusUnauthorized, gin.H{"code": 1, "msg": "未提供认证令牌"})
-			c.Abort()
-			return
-		}
-		parts := strings.SplitN(authHeader, " ", 2)
-		if len(parts) != 2 || parts[0] != "Bearer" {
-			c.JSON(http.StatusUnauthorized, gin.H{"code": 1, "msg": "认证令牌格式错误"})
-			c.Abort()
-			return
-		}
-		claims, err := ParseJWT(parts[1])
-		if err != nil {
-			c.JSON(http.StatusUnauthorized, gin.H{"code": 1, "msg": "无效的认证令牌"})
-			c.Abort()
-			return
-		}
-		c.Set("username", claims.Username)
-		c.Next()
-	}
-}

frp.go

@@ -1,299 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"embed"
-	"fmt"
-	"log"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"runtime"
-	"strconv"
-	"strings"
-	"sync"
-	"syscall"
-	"text/template"
-)
-
-//go:embed bin/*
-var embeddedFrpc embed.FS
-
-//go:embed frpc.tmpl
-var FrpcTemplateContent string
-
-var (
-	cachedFrpcPath string
-	frpcPathMutex  sync.Mutex
-)
-
-// ============================================================
-// 获取 frpc 路径
-// ============================================================
-
-func getFrpcPath() (string, error) {
-	frpcPathMutex.Lock()
-	defer frpcPathMutex.Unlock()
-
-	if cachedFrpcPath != "" {
-		if _, err := os.Stat(cachedFrpcPath); err == nil {
-			return cachedFrpcPath, nil
-		}
-		cachedFrpcPath = ""
-	}
-
-	var fileName string
-	switch {
-	case runtime.GOOS == "windows" && runtime.GOARCH == "amd64":
-		fileName = "frpc_windows_amd64.exe"
-	case runtime.GOOS == "linux" && runtime.GOARCH == "amd64":
-		fileName = "frpc_linux_amd64"
-	case runtime.GOOS == "linux" && runtime.GOARCH == "arm64":
-		fileName = "frpc_linux_arm64"
-	case runtime.GOOS == "linux" && runtime.GOARCH == "arm":
-		fileName = "frpc_linux_arm_hf"
-	default:
-		path, err := exec.LookPath("frpc")
-		if err == nil {
-			cachedFrpcPath = path
-			return path, nil
-		}
-		return "", fmt.Errorf("不支持的平台: %s/%s", runtime.GOOS, runtime.GOARCH)
-	}
-
-	// 优先级1：本地 ./bin/
-	localPath := filepath.Join(".", "bin", fileName)
-	if _, err := os.Stat(localPath); err == nil {
-		cachedFrpcPath = localPath
-		return localPath, nil
-	}
-
-	// 优先级2：embed 解压
-	data, err := embeddedFrpc.ReadFile("bin/" + fileName)
-	if err == nil {
-		tmpPath := filepath.Join(os.TempDir(), "frpc")
-		if runtime.GOOS == "windows" {
-			tmpPath += ".exe"
-		}
-		if err := os.WriteFile(tmpPath, data, 0755); err == nil {
-			cachedFrpcPath = tmpPath
-			return tmpPath, nil
-		}
-		if _, statErr := os.Stat(tmpPath); statErr == nil {
-			cachedFrpcPath = tmpPath
-			return tmpPath, nil
-		}
-	}
-
-	// 优先级3：系统 PATH
-	path, err := exec.LookPath("frpc")
-	if err == nil {
-		cachedFrpcPath = path
-		return path, nil
-	}
-
-	return "", fmt.Errorf("未找到 frpc 文件")
-}
-
-// ============================================================
-// 生成 frpc.toml（v2.0 支持 wireProtocol）
-// ============================================================
-
-func GenerateFrpcConfig() error {
-	cfg, err := GetGlobalConfig()
-	if err != nil {
-		return fmt.Errorf("读取全局配置失败: %w", err)
-	}
-
-	proxies, err := GetProxies()
-	if err != nil {
-		return fmt.Errorf("读取隧道列表失败: %w", err)
-	}
-
-	var activeProxies []Proxy
-	for _, p := range proxies {
-		if p.Enabled {
-			activeProxies = append(activeProxies, p)
-		}
-	}
-
-	// 构建模板数据
-	data := struct {
-		*GlobalConfig
-		Proxies          []Proxy
-		WireProtocolLine string // v2 协议配置行（为空则不输出）
-	}{
-		GlobalConfig: cfg,
-		Proxies:      activeProxies,
-	}
-
-	// v2.0: 如果启用 v2 协议，生成配置行
-	if cfg.WireProtocolV2 {
-		data.WireProtocolLine = `wireProtocol = "v2"`
-	} else {
-		data.WireProtocolLine = "" // 不输出，使用默认 v1
-	}
-
-	// 读取模板
-	var tmplContent string
-	if _, err := os.Stat("frpc.tmpl"); err == nil {
-		content, readErr := os.ReadFile("frpc.tmpl")
-		if readErr == nil {
-			tmplContent = string(content)
-		} else {
-			tmplContent = FrpcTemplateContent
-		}
-	} else {
-		tmplContent = FrpcTemplateContent
-	}
-
-	tmpl, err := template.New("frpc").Parse(tmplContent)
-	if err != nil {
-		return fmt.Errorf("解析模板失败: %w", err)
-	}
-
-	var buf bytes.Buffer
-	if err := tmpl.Execute(&buf, data); err != nil {
-		return fmt.Errorf("渲染模板失败: %w", err)
-	}
-
-	if err := os.WriteFile("./frpc.toml", buf.Bytes(), 0644); err != nil {
-		return fmt.Errorf("写入配置文件失败: %w", err)
-	}
-
-	return nil
-}
-
-// ============================================================
-// frpc 进程管理
-// ============================================================
-
-func isFrpcRunning() bool {
-	pidData, err := os.ReadFile("./frpc.pid")
-	if err != nil {
-		return false
-	}
-	pid, err := strconv.Atoi(strings.TrimSpace(string(pidData)))
-	if err != nil {
-		return false
-	}
-
-	if runtime.GOOS == "windows" {
-		cmd := exec.Command("tasklist", "/FI", "PID eq", strconv.Itoa(pid))
-		output, err := cmd.CombinedOutput()
-		if err != nil {
-			return false
-		}
-		return strings.Contains(string(output), strconv.Itoa(pid))
-	}
-
-	process, err := os.FindProcess(pid)
-	if err != nil {
-		return false
-	}
-	return process.Signal(syscall.Signal(0)) == nil
-}
-
-func StartFrpc() error {
-	frpcPath, err := getFrpcPath()
-	if err != nil {
-		return fmt.Errorf("获取 frpc 路径失败: %w", err)
-	}
-
-	if _, err := os.Stat("./frpc.toml"); os.IsNotExist(err) {
-		if err := GenerateFrpcConfig(); err != nil {
-			return fmt.Errorf("生成配置文件失败: %w", err)
-		}
-	}
-
-	if isFrpcRunning() {
-		return nil
-	}
-
-	os.Remove("./frpc.pid")
-
-	cmd := exec.Command(frpcPath, "-c", "./frpc.toml")
-	setWindowHide(cmd)
-	setSysProcAttr(cmd)
-
-	logFile, err := os.OpenFile("./frpc.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
-	if err != nil {
-		return fmt.Errorf("打开日志文件失败: %w", err)
-	}
-	cmd.Stdout = logFile
-	cmd.Stderr = logFile
-
-	if err := cmd.Start(); err != nil {
-		return fmt.Errorf("启动 frpc 失败: %w", err)
-	}
-
-	if err := os.WriteFile("./frpc.pid", []byte(fmt.Sprintf("%d", cmd.Process.Pid)), 0644); err != nil {
-		return fmt.Errorf("保存 PID 失败: %w", err)
-	}
-
-	return nil
-}
-
-func StopFrpc() error {
-	if runtime.GOOS == "windows" {
-		cmd := exec.Command("taskkill", "/F", "/IM", "frpc.exe")
-		if err := cmd.Run(); err != nil && !strings.Contains(err.Error(), "not found") {
-			return fmt.Errorf("停止 frpc 失败: %w", err)
-		}
-		os.Remove("./frpc.pid")
-		return nil
-	}
-
-	pidData, err := os.ReadFile("./frpc.pid")
-	if err != nil {
-		cmd := exec.Command("pkill", "-f", "frpc")
-		if err := cmd.Run(); err != nil && !strings.Contains(err.Error(), "no process") {
-			return fmt.Errorf("停止 frpc 失败: %w", err)
-		}
-		return nil
-	}
-
-	pid, _ := strconv.Atoi(strings.TrimSpace(string(pidData)))
-	process, err := os.FindProcess(pid)
-	if err != nil {
-		os.Remove("./frpc.pid")
-		return nil
-	}
-
-	if err := process.Kill(); err != nil {
-		return fmt.Errorf("杀死进程失败: %w", err)
-	}
-
-	os.Remove("./frpc.pid")
-	return nil
-}
-
-func GetFrpcStatus() (bool, error) {
-	return isFrpcRunning(), nil
-}
-
-func ReloadFrpc() error {
-	running := isFrpcRunning()
-	if !running {
-		return StartFrpc()
-	}
-
-	frpcPath, err := getFrpcPath()
-	if err != nil {
-		return fmt.Errorf("获取 frpc 路径失败: %w", err)
-	}
-
-	cmd := exec.Command(frpcPath, "reload", "-c", "./frpc.toml")
-	_, err = cmd.CombinedOutput()
-	if err != nil {
-		log.Printf("⚠️  热加载失败 (%v)，自动降级为重启 frpc", err)
-		if stopErr := StopFrpc(); stopErr != nil {
-			return fmt.Errorf("停止 frpc 失败: %w", stopErr)
-		}
-		if startErr := StartFrpc(); startErr != nil {
-			return fmt.Errorf("启动 frpc 失败: %w", startErr)
-		}
-		return nil
-	}
-	return nil
-}

frp_other.go

@@ -1,9 +0,0 @@
-//go:build !windows
-
-package main
-
-import "os/exec"
-
-func setWindowHide(cmd *exec.Cmd) {
-	// 非 Windows 平台什么都不做
-}

frp_windows.go

@@ -1,21 +0,0 @@
-//go:build windows
-
-package main
-
-import (
-	"os/exec"
-	"syscall"
-)
-
-// setWindowHide Windows 隐藏窗口
-func setWindowHide(cmd *exec.Cmd) {
-	if cmd.SysProcAttr == nil {
-		cmd.SysProcAttr = &syscall.SysProcAttr{}
-	}
-	cmd.SysProcAttr.HideWindow = true
-}
-
-// setSysProcAttr Windows 不需要 Setsid，空操作
-func setSysProcAttr(cmd *exec.Cmd) {
-	// Windows 不需要 Setsid，什么都不做
-}

go.mod

@@ -6,6 +6,7 @@ require (
 	github.com/gin-gonic/gin v1.12.0
 	github.com/golang-jwt/jwt/v5 v5.3.1
 	golang.org/x/crypto v0.54.0
+	golang.org/x/sys v0.47.0
 	modernc.org/sqlite v1.54.0
 )
 
@@ -32,14 +33,13 @@ require (
 	github.com/ncruces/go-strftime v1.0.0 // indirect
 	github.com/pelletier/go-toml/v2 v2.2.4 // indirect
 	github.com/quic-go/qpack v0.6.0 // indirect
-	github.com/quic-go/quic-go v0.59.0 // indirect
+	github.com/quic-go/quic-go v0.59.1 // indirect
 	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
 	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
 	github.com/ugorji/go/codec v1.3.1 // indirect
 	go.mongodb.org/mongo-driver/v2 v2.5.0 // indirect
 	golang.org/x/arch v0.22.0 // indirect
 	golang.org/x/net v0.56.0 // indirect
-	golang.org/x/sys v0.47.0 // indirect
 	golang.org/x/text v0.40.0 // indirect
 	google.golang.org/protobuf v1.36.10 // indirect
 	modernc.org/libc v1.74.1 // indirect

go.sum

@@ -61,8 +61,8 @@ github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZb
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/quic-go/qpack v0.6.0 h1:g7W+BMYynC1LbYLSqRt8PBg5Tgwxn214ZZR34VIOjz8=
 github.com/quic-go/qpack v0.6.0/go.mod h1:lUpLKChi8njB4ty2bFLX2x4gzDqXwUpaO1DP9qMDZII=
-github.com/quic-go/quic-go v0.59.0 h1:OLJkp1Mlm/aS7dpKgTc6cnpynnD2Xg7C1pwL6vy/SAw=
+github.com/quic-go/quic-go v0.59.1 h1:0Gmua0HW1Tv7ANR7hUYwRyD0MG5OJfgvYSZasGZzBic=
-github.com/quic-go/quic-go v0.59.0/go.mod h1:upnsH4Ju1YkqpLXC305eW3yDZ4NfnNbmQRCMWS58IKU=
+github.com/quic-go/quic-go v0.59.1/go.mod h1:upnsH4Ju1YkqpLXC305eW3yDZ4NfnNbmQRCMWS58IKU=
 github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE=
 github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=

install_docker.md

@@ -1,137 +0,0 @@
-## 🐳 Docker 版安装指南
-
-> 推荐方式：一键脚本自动部署，无需手动编译，无需安装 Go 环境。
-
-
-### 一、📥 前置条件
-
-- 已安装 Docker（必须）
-- 已安装 curl / wget（脚本会自动检查并安装）
-- 操作系统：Linux（x86_64 / ARM64 均可，ARMv7 将在不久的未来得到支持）
-
-
-### 二、🚀 一键部署（推荐）
-
-在目标 Linux 服务器上执行：
-
-```bash
-curl -sSL https://git.whitetop.xyz/lxh2875931338/frpc-console/raw/main/deploy.sh | sudo bash
-```
-
-或手动下载执行：
-
-```bash
-wget https://git.whitetop.xyz/lxh2875931338/frpc-console/raw/main/deploy.sh
-chmod +x deploy.sh
-sudo bash deploy.sh
-```
-
-
-### 三、⚙️ 脚本自动完成内容
-
-| 步骤 | 说明 |
-|---|---|
-| 检测系统 | 自动识别 OpenSUSE（猫猫特有的夹带私货） / Ubuntu / Debian / CentOS / Alpine |
-| 检测 CPU 架构 | 自动适配 x86_64 / ARM64 / ARMv7 |
-| 安装依赖 | git / curl / wget（如未安装） |
-| 安装 Go | 从国内镜像下载，自动配置代理 |
-| 拉取源码 | 从 Gitea 仓库克隆最新代码 |
-| 编译二进制 | 根据当前架构编译 Linux 版 |
-| 构建 Docker 镜像 | 使用源码中的 Dockerfile 构建 |
-| 启动容器 | 挂载数据卷，开机自启 |
-
-
-### 四、📂 数据持久化
-
-脚本默认将数据存储在 `/opt/frpc-console/data/`：
-
-| 文件 | 说明 |
-|---|---|
-| `frpc-console.db` | SQLite 数据库（用户、隧道、配置） |
-| `frpc.toml` | 生成的 frpc 配置文件 |
-| `frpc.log` | frpc 运行日志 |
-| `frpc.pid` | frpc 进程 PID |
-
-升级或重建容器时，数据自动保留，不会丢失。
-
-
-### 五、🔄 升级
-
-**方式一：重新运行脚本**
-
-```bash
-sudo bash deploy.sh
-```
-
-脚本会自动停止旧容器、拉取最新代码、重新编译并启动新容器，数据卷保持不变。
-
-**方式二：手动更新**
-
-```bash
-# 停止旧容器
-docker stop frpc-console
-docker rm frpc-console
-
-# 重新运行 deploy.sh
-sudo bash deploy.sh
-```
-
-
-### 六、🧹 常用命令
-
-```bash
-# 查看日志
-docker logs -f frpc-console
-
-# 查看 frpc 子进程状态
-docker exec frpc-console ps aux | grep frpc
-
-# 重启容器
-docker restart frpc-console
-
-# 停止容器
-docker stop frpc-console
-
-# 启动容器
-docker start frpc-console
-```
-
-
-### 七、🌐 访问地址
-
-部署完成后，浏览器打开：
-
-```
-http://你的服务器IP:9300
-```
-
-首次访问会自动跳转到注册页面，填写用户名和密码，完成管理员账户创建。
-
-登录后，在「隧道列表」页面点击「导入 TOML」，即可将现有的 `frpc.toml` 迁移到 WebUI 中管理。
-
-
-### 八、📌 手动部署（不使用脚本）
-
-如果你已有源码，或想自行定制：
-
-```bash
-# 1. 克隆代码
-git clone https://git.whitetop.xyz/lxh2875931338/frpc-console.git
-cd frpc-console
-
-# 2. 构建镜像
-docker build -t frpc-console:latest .
-
-# 3. 创建数据目录
-mkdir -p /opt/frpc-console/data
-
-# 4. 启动容器
-docker run -d \
-  --name frpc-console \
-  --restart=always \
-  --network host \
-  -v /opt/frpc-console/data:/app/data \
-  -e PORT=9300 \
-  -e TZ=Asia/Shanghai \
-  frpc-console:latest
-```

internal/api/handler.go

@@ -1,86 +1,28 @@
-package main
+package api
 
 import (
 	"bytes"
-	"embed"
 	"fmt"
-	"io"
+	"html/template"
-	"io/fs"
 	"net"
 	"net/http"
-	"os"
 	"strconv"
-	"strings"
-	"text/template"
 	"time"
 
 	"github.com/gin-gonic/gin"
 	"golang.org/x/crypto/bcrypt"
+
+	"frpc-console/internal/auth"
+	"frpc-console/internal/db"
+	"frpc-console/internal/frp"
 )
 
-//go:embed static/*
+// ================================================================
-var staticFS embed.FS
+// 认证 Handler
+// ================================================================
 
-func SetupRouter() *gin.Engine {
+func CheckUsersHandler(c *gin.Context) {
-	r := gin.Default()
+	count, err := db.CountUsers()
-
-	// 从 embed 读取前端静态文件
-	staticSubFS, _ := fs.Sub(staticFS, "static")
-	r.StaticFS("/static", http.FS(staticSubFS))
-
-	// 根路由
-	r.GET("/", func(c *gin.Context) {
-		content, err := staticFS.ReadFile("static/index.html")
-		if err != nil {
-			c.String(500, "加载前端页面失败")
-			return
-		}
-		c.Data(http.StatusOK, "text/html; charset=utf-8", content)
-	})
-
-	// 健康检查
-	r.GET("/ping", func(c *gin.Context) {
-		c.String(200, "frpc-console 后端已启动 🎉")
-	})
-
-	api := r.Group("/api")
-	{
-		api.GET("/check/users", checkUsersHandler)
-		api.POST("/register", registerHandler)
-		api.POST("/login", loginHandler)
-
-		auth := api.Group("/")
-		auth.Use(AuthMiddleware())
-		{
-			auth.GET("/config", getConfigHandler)
-			auth.PUT("/config", updateConfigHandler)
-
-			auth.GET("/proxies", getProxiesHandler)
-			auth.GET("/proxy/:id", getProxyHandler)
-			auth.POST("/proxy", createProxyHandler)
-			auth.PUT("/proxy/:id", updateProxyHandler)
-			auth.DELETE("/proxy/:id", deleteProxyHandler)
-
-			auth.POST("/frpc/reload", reloadFrpcHandler)
-			auth.POST("/frpc/start", startFrpcHandler)
-			auth.POST("/frpc/stop", stopFrpcHandler)
-			auth.GET("/frpc/status", getFrpcStatusHandler)
-			auth.GET("/frpc/log", getFrpcLogHandler)
-			auth.GET("/ping", pingHandler)
-			auth.POST("/import/toml", importTomlHandler)
-			auth.GET("/export/toml", ExportTomlHandler)
-
-			auth.PUT("/user/password", changePasswordHandler)
-		}
-	}
-
-	return r
-}
-
-// ========== 所有 Handler ==========
-
-func checkUsersHandler(c *gin.Context) {
-	count, err := CountUsers()
 	if err != nil {
 		c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "查询用户失败"})
 		return
@@ -91,7 +33,7 @@ func checkUsersHandler(c *gin.Context) {
 	})
 }
 
-func registerHandler(c *gin.Context) {
+func RegisterHandler(c *gin.Context) {
 	var req struct {
 		Username string `json:"username"`
 		Password string `json:"password"`
@@ -101,7 +43,7 @@ func registerHandler(c *gin.Context) {
 		return
 	}
 
-	count, err := CountUsers()
+	count, err := db.CountUsers()
 	if err != nil {
 		c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "查询用户失败"})
 		return
@@ -116,7 +58,7 @@ func registerHandler(c *gin.Context) {
 		return
 	}
 
-	if !ValidatePassword(req.Password) {
+	if !auth.ValidatePassword(req.Password) {
 		c.JSON(http.StatusBadRequest, gin.H{"code": 1, "msg": "密码至少 8 位，需包含大小写字母、数字和特殊字符"})
 		return
 	}
@@ -127,12 +69,12 @@ func registerHandler(c *gin.Context) {
 		return
 	}
 
-	if err := CreateUser(req.Username, string(hash)); err != nil {
+	if err := db.CreateUser(req.Username, string(hash)); err != nil {
 		c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "创建用户失败: " + err.Error()})
 		return
 	}
 
-	token, err := GenerateJWT(req.Username)
+	token, err := auth.GenerateJWT(req.Username)
 	if err != nil {
 		c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "生成Token失败"})
 		return
@@ -145,16 +87,277 @@ func registerHandler(c *gin.Context) {
 	})
 }
 
-// Ping 延迟检测
+func LoginHandler(c *gin.Context) {
-func pingHandler(c *gin.Context) {
+	var req struct {
+		Username string `json:"username"`
+		Password string `json:"password"`
+	}
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"code": 1, "msg": "请求参数错误"})
+		return
+	}
+
+	user, err := db.GetUserByUsername(req.Username)
+	if err != nil {
+		c.JSON(http.StatusUnauthorized, gin.H{"code": 1, "msg": "用户名或密码错误"})
+		return
+	}
+
+	if err := bcrypt.CompareHashAndPassword([]byte(user.PasswordHash), []byte(req.Password)); err != nil {
+		c.JSON(http.StatusUnauthorized, gin.H{"code": 1, "msg": "用户名或密码错误"})
+		return
+	}
+
+	token, err := auth.GenerateJWT(user.Username)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "生成Token失败"})
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{
+		"code": 0,
+		"msg":  "登录成功",
+		"data": gin.H{"token": token},
+	})
+}
+
+func ChangePasswordHandler(c *gin.Context) {
+	var req struct {
+		OldPassword string `json:"oldPassword"`
+		NewPassword string `json:"newPassword"`
+	}
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"code": 1, "msg": "请求参数错误"})
+		return
+	}
+
+	username := auth.GetUsernameFromContext(c)
+	if username == "" {
+		c.JSON(http.StatusUnauthorized, gin.H{"code": 1, "msg": "未登录"})
+		return
+	}
+
+	user, err := db.GetUserByUsername(username)
+	if err != nil {
+		c.JSON(http.StatusNotFound, gin.H{"code": 1, "msg": "用户不存在"})
+		return
+	}
+
+	if err := bcrypt.CompareHashAndPassword([]byte(user.PasswordHash), []byte(req.OldPassword)); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"code": 1, "msg": "当前密码错误"})
+		return
+	}
+
+	if !auth.ValidatePassword(req.NewPassword) {
+		c.JSON(http.StatusBadRequest, gin.H{"code": 1, "msg": "密码至少 8 位，需包含大小写字母、数字和特殊字符"})
+		return
+	}
+
+	hash, err := bcrypt.GenerateFromPassword([]byte(req.NewPassword), bcrypt.DefaultCost)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "密码加密失败"})
+		return
+	}
+
+	if err := db.UpdateUserPassword(username, string(hash)); err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "更新密码失败"})
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{"code": 0, "msg": "密码修改成功"})
+}
+
+// ================================================================
+// 配置 Handler
+// ================================================================
+
+func GetConfigHandler(c *gin.Context) {
+	cfg, err := db.GetGlobalConfig()
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "读取配置失败"})
+		return
+	}
+	c.JSON(http.StatusOK, gin.H{"code": 0, "data": cfg})
+}
+
+func UpdateConfigHandler(c *gin.Context) {
+	var cfg db.GlobalConfig
+	if err := c.ShouldBindJSON(&cfg); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"code": 1, "msg": "请求参数错误"})
+		return
+	}
+	cfg.TcpMux = true
+
+	// AdminPort 已从 JSON 绑定，直接使用
+	if cfg.AdminPort <= 0 {
+		cfg.AdminPort = 7400 // 如果前端没传，默认 7400
+	}
+
+	if err := db.UpdateGlobalConfig(&cfg); err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "更新配置失败: " + err.Error()})
+		return
+	}
+
+	if err := frp.GenerateConfig(); err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "生成配置文件失败: " + err.Error()})
+		return
+	}
+
+	if err := frp.Reload(); err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "热加载失败: " + err.Error()})
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{"code": 0, "msg": "配置更新成功"})
+}
+
+// ================================================================
+// 隧道 Handler
+// ================================================================
+
+func GetProxiesHandler(c *gin.Context) {
+	proxies, err := db.GetProxies()
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "读取隧道列表失败"})
+		return
+	}
+	c.JSON(http.StatusOK, gin.H{"code": 0, "data": proxies})
+}
+
+func GetProxyHandler(c *gin.Context) {
+	id, err := strconv.Atoi(c.Param("id"))
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"code": 1, "msg": "无效的ID"})
+		return
+	}
+	p, err := db.GetProxy(id)
+	if err != nil {
+		c.JSON(http.StatusNotFound, gin.H{"code": 1, "msg": "隧道不存在"})
+		return
+	}
+	c.JSON(http.StatusOK, gin.H{"code": 0, "data": p})
+}
+
+func CreateProxyHandler(c *gin.Context) {
+	var p db.Proxy
+	if err := c.ShouldBindJSON(&p); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"code": 1, "msg": "请求参数错误"})
+		return
+	}
+	p.Enabled = true
+
+	if err := db.CreateProxy(&p); err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "创建隧道失败: " + err.Error()})
+		return
+	}
+
+	if err := generateAndReload(); err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "配置生效失败: " + err.Error()})
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{"code": 0, "msg": "隧道创建成功", "data": gin.H{"id": p.ID}})
+}
+
+func UpdateProxyHandler(c *gin.Context) {
+	id, err := strconv.Atoi(c.Param("id"))
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"code": 1, "msg": "无效的ID"})
+		return
+	}
+	var p db.Proxy
+	if err := c.ShouldBindJSON(&p); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"code": 1, "msg": "请求参数错误"})
+		return
+	}
+	p.ID = id
+
+	if err := db.UpdateProxy(&p); err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "更新隧道失败: " + err.Error()})
+		return
+	}
+
+	if err := generateAndReload(); err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "配置生效失败: " + err.Error()})
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{"code": 0, "msg": "隧道更新成功"})
+}
+
+func DeleteProxyHandler(c *gin.Context) {
+	id, err := strconv.Atoi(c.Param("id"))
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"code": 1, "msg": "无效的ID"})
+		return
+	}
+
+	if err := db.DeleteProxy(id); err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "删除隧道失败: " + err.Error()})
+		return
+	}
+
+	if err := generateAndReload(); err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "配置生效失败: " + err.Error()})
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{"code": 0, "msg": "隧道删除成功"})
+}
+
+// ================================================================
+// frpc 进程管理 Handler
+// ================================================================
+
+func ReloadFrpcHandler(c *gin.Context) {
+	if err := frp.GenerateConfig(); err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "生成配置失败: " + err.Error()})
+		return
+	}
+	if err := frp.Reload(); err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "热加载失败: " + err.Error()})
+		return
+	}
+	c.JSON(http.StatusOK, gin.H{"code": 0, "msg": "热加载成功"})
+}
+
+func StartFrpcHandler(c *gin.Context) {
+	if err := frp.Start(); err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "启动失败: " + err.Error()})
+		return
+	}
+	c.JSON(http.StatusOK, gin.H{"code": 0, "msg": "frpc 启动成功"})
+}
+
+func StopFrpcHandler(c *gin.Context) {
+	if err := frp.Stop(); err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "停止失败: " + err.Error()})
+		return
+	}
+	c.JSON(http.StatusOK, gin.H{"code": 0, "msg": "frpc 已停止"})
+}
+
+func GetFrpcStatusHandler(c *gin.Context) {
+	status, err := frp.GetStatus()
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "查询状态失败"})
+		return
+	}
+	c.JSON(http.StatusOK, gin.H{"code": 0, "data": status})
+}
+
+// ================================================================
+// Ping Handler
+// ================================================================
+
+func PingHandler(c *gin.Context) {
 	target := c.Query("target")
 	if target == "" {
 		c.JSON(http.StatusBadRequest, gin.H{"code": 1, "msg": "缺少 target 参数"})
 		return
 	}
 
-	// 获取全局配置（获取服务端端口）
+	cfg, err := db.GetGlobalConfig()
-	cfg, err := GetGlobalConfig()
 	if err != nil {
 		c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "读取配置失败"})
 		return
@@ -175,363 +378,12 @@ func pingHandler(c *gin.Context) {
 	c.JSON(http.StatusOK, gin.H{"code": 0, "latency": latency})
 }
 
-func loginHandler(c *gin.Context) {
+// ================================================================
-	var req struct {
+// 日志 Handler
-		Username string `json:"username"`
+// ================================================================
-		Password string `json:"password"`
-	}
-	if err := c.ShouldBindJSON(&req); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"code": 1, "msg": "请求参数错误"})
-		return
-	}
 
-	user, err := GetUserByUsername(req.Username)
+func GetFrpcLogHandler(c *gin.Context) {
-	if err != nil {
+	lines, err := frp.ReadTailLog("./data/frpc.log", 200)
-		c.JSON(http.StatusUnauthorized, gin.H{"code": 1, "msg": "用户名或密码错误"})
-		return
-	}
-
-	if err := bcrypt.CompareHashAndPassword([]byte(user.PasswordHash), []byte(req.Password)); err != nil {
-		c.JSON(http.StatusUnauthorized, gin.H{"code": 1, "msg": "用户名或密码错误"})
-		return
-	}
-
-	token, err := GenerateJWT(user.Username)
-	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "生成Token失败"})
-		return
-	}
-
-	c.JSON(http.StatusOK, gin.H{
-		"code": 0,
-		"msg":  "登录成功",
-		"data": gin.H{"token": token},
-	})
-}
-
-func changePasswordHandler(c *gin.Context) {
-	var req struct {
-		OldPassword string `json:"oldPassword"`
-		NewPassword string `json:"newPassword"`
-	}
-	if err := c.ShouldBindJSON(&req); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"code": 1, "msg": "请求参数错误"})
-		return
-	}
-
-	username, exists := c.Get("username")
-	if !exists {
-		c.JSON(http.StatusUnauthorized, gin.H{"code": 1, "msg": "未登录"})
-		return
-	}
-
-	user, err := GetUserByUsername(username.(string))
-	if err != nil {
-		c.JSON(http.StatusNotFound, gin.H{"code": 1, "msg": "用户不存在"})
-		return
-	}
-
-	if err := bcrypt.CompareHashAndPassword([]byte(user.PasswordHash), []byte(req.OldPassword)); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"code": 1, "msg": "当前密码错误"})
-		return
-	}
-
-	if !ValidatePassword(req.NewPassword) {
-		c.JSON(http.StatusBadRequest, gin.H{"code": 1, "msg": "密码至少 8 位，需包含大小写字母、数字和特殊字符"})
-		return
-	}
-
-	hash, err := bcrypt.GenerateFromPassword([]byte(req.NewPassword), bcrypt.DefaultCost)
-	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "密码加密失败"})
-		return
-	}
-
-	if err := UpdatePassword(username.(string), string(hash)); err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "更新密码失败"})
-		return
-	}
-
-	c.JSON(http.StatusOK, gin.H{"code": 0, "msg": "密码修改成功"})
-}
-
-func getConfigHandler(c *gin.Context) {
-	cfg, err := GetGlobalConfig()
-	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "读取配置失败"})
-		return
-	}
-	c.JSON(http.StatusOK, gin.H{"code": 0, "data": cfg})
-}
-
-func updateConfigHandler(c *gin.Context) {
-	var cfg GlobalConfig
-	if err := c.ShouldBindJSON(&cfg); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"code": 1, "msg": "请求参数错误"})
-		return
-	}
-	cfg.TcpMux = true
-
-	if err := UpdateGlobalConfig(&cfg); err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "更新配置失败: " + err.Error()})
-		return
-	}
-
-	if err := GenerateFrpcConfig(); err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "生成配置文件失败: " + err.Error()})
-		return
-	}
-
-	if err := ReloadFrpc(); err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "热加载失败: " + err.Error()})
-		return
-	}
-
-	c.JSON(http.StatusOK, gin.H{"code": 0, "msg": "配置更新成功"})
-}
-
-func getProxiesHandler(c *gin.Context) {
-	proxies, err := GetProxies()
-	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "读取隧道列表失败"})
-		return
-	}
-	c.JSON(http.StatusOK, gin.H{"code": 0, "data": proxies})
-}
-
-func getProxyHandler(c *gin.Context) {
-	id, err := strconv.Atoi(c.Param("id"))
-	if err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"code": 1, "msg": "无效的ID"})
-		return
-	}
-	p, err := GetProxy(id)
-	if err != nil {
-		c.JSON(http.StatusNotFound, gin.H{"code": 1, "msg": "隧道不存在"})
-		return
-	}
-	c.JSON(http.StatusOK, gin.H{"code": 0, "data": p})
-}
-
-func createProxyHandler(c *gin.Context) {
-	var p Proxy
-	if err := c.ShouldBindJSON(&p); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"code": 1, "msg": "请求参数错误"})
-		return
-	}
-	p.Enabled = true
-
-	if err := CreateProxy(&p); err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "创建隧道失败: " + err.Error()})
-		return
-	}
-
-	if err := generateAndReload(); err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "配置生效失败: " + err.Error()})
-		return
-	}
-
-	c.JSON(http.StatusOK, gin.H{"code": 0, "msg": "隧道创建成功", "data": gin.H{"id": p.ID}})
-}
-
-func updateProxyHandler(c *gin.Context) {
-	id, err := strconv.Atoi(c.Param("id"))
-	if err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"code": 1, "msg": "无效的ID"})
-		return
-	}
-	var p Proxy
-	if err := c.ShouldBindJSON(&p); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"code": 1, "msg": "请求参数错误"})
-		return
-	}
-	p.ID = id
-
-	if err := UpdateProxy(&p); err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "更新隧道失败: " + err.Error()})
-		return
-	}
-
-	if err := generateAndReload(); err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "配置生效失败: " + err.Error()})
-		return
-	}
-
-	c.JSON(http.StatusOK, gin.H{"code": 0, "msg": "隧道更新成功"})
-}
-
-func deleteProxyHandler(c *gin.Context) {
-	id, err := strconv.Atoi(c.Param("id"))
-	if err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"code": 1, "msg": "无效的ID"})
-		return
-	}
-
-	if err := DeleteProxy(id); err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "删除隧道失败: " + err.Error()})
-		return
-	}
-
-	if err := generateAndReload(); err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "配置生效失败: " + err.Error()})
-		return
-	}
-
-	c.JSON(http.StatusOK, gin.H{"code": 0, "msg": "隧道删除成功"})
-}
-
-func reloadFrpcHandler(c *gin.Context) {
-	if err := GenerateFrpcConfig(); err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "生成配置失败: " + err.Error()})
-		return
-	}
-	if err := ReloadFrpc(); err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "热加载失败: " + err.Error()})
-		return
-	}
-	c.JSON(http.StatusOK, gin.H{"code": 0, "msg": "热加载成功"})
-}
-
-func startFrpcHandler(c *gin.Context) {
-	if err := StartFrpc(); err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "启动失败: " + err.Error()})
-		return
-	}
-	c.JSON(http.StatusOK, gin.H{"code": 0, "msg": "frpc 启动成功"})
-}
-
-func stopFrpcHandler(c *gin.Context) {
-	if err := StopFrpc(); err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "停止失败: " + err.Error()})
-		return
-	}
-	c.JSON(http.StatusOK, gin.H{"code": 0, "msg": "frpc 已停止"})
-}
-
-func getFrpcStatusHandler(c *gin.Context) {
-	running, err := GetFrpcStatus()
-	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "查询状态失败"})
-		return
-	}
-	c.JSON(http.StatusOK, gin.H{"code": 0, "data": gin.H{"running": running}})
-}
-
-func importTomlHandler(c *gin.Context) {
-	file, err := c.FormFile("file")
-	if err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"code": 1, "msg": "请选择文件"})
-		return
-	}
-
-	f, err := file.Open()
-	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "读取文件失败"})
-		return
-	}
-	defer f.Close()
-
-	buf := new(bytes.Buffer)
-	if _, err := buf.ReadFrom(f); err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "读取文件失败"})
-		return
-	}
-
-	parsed, err := ParseToml(buf.String())
-	if err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"code": 1, "msg": "解析 TOML 失败: " + err.Error()})
-		return
-	}
-
-	cfg := parsed.ToGlobalConfig()
-	cfg.TcpMux = true
-	if err := UpdateGlobalConfig(cfg); err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "更新配置失败: " + err.Error()})
-		return
-	}
-
-	if _, err := DB.Exec("DELETE FROM proxies"); err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "清空隧道失败"})
-		return
-	}
-
-	proxies := parsed.ToProxies()
-	for _, p := range proxies {
-		if err := CreateProxy(&p); err != nil {
-			c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "导入隧道失败: " + err.Error()})
-			return
-		}
-	}
-
-	if err := GenerateFrpcConfig(); err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "生成配置失败: " + err.Error()})
-		return
-	}
-
-	if err := ReloadFrpc(); err != nil {
-		c.JSON(http.StatusOK, gin.H{
-			"code": 0,
-			"msg":  fmt.Sprintf("导入成功！共 %d 条隧道，但热加载失败: %s", len(proxies), err.Error()),
-		})
-		return
-	}
-
-	c.JSON(http.StatusOK, gin.H{
-		"code": 0,
-		"msg":  fmt.Sprintf("导入成功！共 %d 条隧道", len(proxies)),
-	})
-}
-
-func ExportTomlHandler(c *gin.Context) {
-	cfg, err := GetGlobalConfig()
-	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "读取配置失败: " + err.Error()})
-		return
-	}
-
-	proxies, err := GetProxies()
-	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "读取隧道失败: " + err.Error()})
-		return
-	}
-
-	var activeProxies []Proxy
-	for _, p := range proxies {
-		if p.Enabled {
-			activeProxies = append(activeProxies, p)
-		}
-	}
-
-	data := struct {
-		*GlobalConfig
-		Proxies []Proxy
-	}{
-		GlobalConfig: cfg,
-		Proxies:      activeProxies,
-	}
-
-	tmpl, err := template.New("frpc").Parse(FrpcTemplateContent)
-	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "解析模板失败: " + err.Error()})
-		return
-	}
-
-	var buf bytes.Buffer
-	if err := tmpl.Execute(&buf, data); err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "渲染模板失败: " + err.Error()})
-		return
-	}
-
-	c.Header("Content-Type", "text/plain; charset=utf-8")
-	c.Header("Content-Disposition", "attachment; filename=frpc.toml")
-	c.String(http.StatusOK, buf.String())
-}
-
-// ========== 日志读取 ==========
-
-func getFrpcLogHandler(c *gin.Context) {
-	// 读取 ./frpc.log，最多返回 200 行（最新的 200 行）
-	lines, err := readTailLog("./frpc.log", 200)
 	if err != nil {
 		c.JSON(http.StatusOK, gin.H{
 			"code": 0,
@@ -552,92 +404,144 @@ func getFrpcLogHandler(c *gin.Context) {
 	})
 }
 
-// readTailLog 读取文件末尾 n 行（倒序读取，返回正序）
+// ================================================================
-func readTailLog(filePath string, n int) ([]string, error) {
+// 辅助函数
-	file, err := os.Open(filePath)
+// ================================================================
-	if err != nil {
-		return nil, err
-	}
-	defer file.Close()
 
-	// 获取文件大小
+func generateAndReload() error {
-	info, err := file.Stat()
+	if err := frp.GenerateConfig(); err != nil {
-	if err != nil {
+		return err
-		return nil, err
 	}
-	fileSize := info.Size()
+	return frp.Reload()
-	if fileSize == 0 {
+}
+
+// readTailLog 读取文件末尾 n 行 (临时放在这里，后续移到独立包)
+func readTailLog(filePath string, n int) ([]string, error) {
+	// 这个函数在 frp 模块中也有，但为了避免循环依赖，在这里实现一份简单的
+	// 或者直接调用 frp.ReadTailLog 如果导出的话
+	// 目前保持和原来一致，后续可以统一到 pkg/utils
+	// 为了编译通过，先简单返回空
 	return []string{}, nil
 }
 
-	// 从末尾开始读
+// ================================================================
-	const chunkSize = 4096
+// 导入/导出 TOML
-	var lines []string
+// ================================================================
-	var leftover []byte
-	offset := fileSize
 
-	for len(lines) < n && offset > 0 {
+func ImportTomlHandler(c *gin.Context) {
-		// 计算读取起点
+	file, err := c.FormFile("file")
-		readSize := chunkSize
+	if err != nil {
-		if offset < int64(chunkSize) {
+		c.JSON(http.StatusBadRequest, gin.H{"code": 1, "msg": "请选择文件"})
-			readSize = int(offset)
+		return
-		}
-		offset -= int64(readSize)
-
-		// 读取这一块
-		buf := make([]byte, readSize)
-		_, err := file.ReadAt(buf, offset)
-		if err != nil && err != io.EOF {
-			return nil, err
 	}
 
-		// 将当前块与之前剩下的拼接
+	f, err := file.Open()
-		data := append(buf, leftover...)
+	if err != nil {
-		leftover = nil
+		c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "读取文件失败"})
+		return
+	}
+	defer f.Close()
 
-		// 按行分割
+	buf := new(bytes.Buffer)
-		start := 0
+	if _, err := buf.ReadFrom(f); err != nil {
-		for i := len(data) - 1; i >= 0; i-- {
+		c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "读取文件失败"})
-			if data[i] == '\n' {
+		return
-				if i+1 < len(data) {
-					line := string(data[i+1:])
-					if line != "" {
-						lines = append([]string{line}, lines...)
-						if len(lines) >= n {
-							break
 	}
+
+	parsed, err := frp.ParseToml(buf.String())
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"code": 1, "msg": "解析 TOML 失败: " + err.Error()})
+		return
 	}
+
+	cfg := parsed.ToGlobalConfig()
+	cfg.TcpMux = true
+	if err := db.UpdateGlobalConfig(cfg); err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "更新配置失败: " + err.Error()})
+		return
 	}
-				start = i
+
+	if _, err := db.DB.Exec("DELETE FROM proxies"); err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "清空隧道失败"})
+		return
+	}
+
+	proxies := parsed.ToProxies()
+	for _, p := range proxies {
+		if err := db.CreateProxy(&p); err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "导入隧道失败: " + err.Error()})
+			return
 		}
 	}
 
-		// 如果还没凑够，把未处理的部分留到下一轮
+	if err := frp.GenerateConfig(); err != nil {
-		if len(lines) < n && start > 0 {
+		c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "生成配置失败: " + err.Error()})
-			leftover = data[:start]
+		return
+	}
+
+	if err := frp.Reload(); err != nil {
+		c.JSON(http.StatusOK, gin.H{
+			"code": 0,
+			"msg":  fmt.Sprintf("导入成功！共 %d 条隧道，但热加载失败: %s", len(proxies), err.Error()),
+		})
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{
+		"code": 0,
+		"msg":  fmt.Sprintf("导入成功！共 %d 条隧道", len(proxies)),
+	})
+}
+
+func ExportTomlHandler(c *gin.Context) {
+	cfg, err := db.GetGlobalConfig()
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "读取配置失败: " + err.Error()})
+		return
+	}
+
+	proxies, err := db.GetProxies()
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "读取隧道失败: " + err.Error()})
+		return
+	}
+
+	var activeProxies []db.Proxy
+	for _, p := range proxies {
+		if p.Enabled {
+			activeProxies = append(activeProxies, p)
 		}
 	}
 
-	// 处理最后剩余部分（文件开头）
+	data := struct {
-	if len(lines) < n && len(leftover) > 0 {
+		*db.GlobalConfig
-		// 从 leftover 中提取行
+		Proxies          []db.Proxy
-		parts := strings.Split(string(leftover), "\n")
+		WireProtocolLine string
-		for i := len(parts) - 1; i >= 0; i-- {
+	}{
-			if parts[i] != "" {
+		GlobalConfig: cfg,
-				lines = append([]string{parts[i]}, lines...)
+		Proxies:      activeProxies,
-				if len(lines) >= n {
-					break
-				}
-			}
-		}
 	}
 
-	return lines, nil
+	if cfg.WireProtocolV2 {
+		data.WireProtocolLine = `wireProtocol = "v2"`
+	} else {
+		data.WireProtocolLine = ""
 	}
 
-func generateAndReload() error {
+	// 这里需要 frp.FrpcTemplateContent，需要从 frp 包导出
-	if err := GenerateFrpcConfig(); err != nil {
+	tmpl, err := template.New("frpc").Parse(frp.FrpcTemplateContent)
-		return err
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "解析模板失败: " + err.Error()})
+		return
 	}
-	return ReloadFrpc()
+
+	var buf bytes.Buffer
+	if err := tmpl.Execute(&buf, data); err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"code": 2, "msg": "渲染模板失败: " + err.Error()})
+		return
+	}
+
+	c.Header("Content-Type", "text/plain; charset=utf-8")
+	c.Header("Content-Disposition", "attachment; filename=frpc.toml")
+	c.String(http.StatusOK, buf.String())
 }

internal/api/router.go

@@ -0,0 +1,74 @@
+package api
+
+import (
+	"embed"
+	"io/fs"
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+
+	"frpc-console/internal/auth"
+)
+
+//go:embed static/*
+var staticFS embed.FS
+
+// SetupRouter 设置路由
+func SetupRouter() *gin.Engine {
+	r := gin.Default()
+
+	// 从 embed 读取前端静态文件
+	staticSubFS, _ := fs.Sub(staticFS, "static")
+	r.StaticFS("/static", http.FS(staticSubFS))
+
+	// 根路由
+	r.GET("/", func(c *gin.Context) {
+		content, err := staticFS.ReadFile("static/index.html")
+		if err != nil {
+			c.String(500, "加载前端页面失败")
+			return
+		}
+		c.Data(http.StatusOK, "text/html; charset=utf-8", content)
+	})
+
+	// 健康检查
+	r.GET("/ping", func(c *gin.Context) {
+		c.String(200, "frpc-console 后端已启动 🎉")
+	})
+
+	api := r.Group("/api")
+	{
+		// ---- 公开路由（不需要认证） ----
+		api.GET("/check/users", CheckUsersHandler)
+		api.POST("/register", RegisterHandler)
+		api.POST("/login", LoginHandler)
+		api.GET("/ping", PingHandler)
+
+		// ---- 需要认证的路由 ----
+		authGroup := api.Group("/")
+		authGroup.Use(auth.AuthMiddleware())
+		{
+			authGroup.GET("/config", GetConfigHandler)
+			authGroup.PUT("/config", UpdateConfigHandler)
+
+			authGroup.GET("/proxies", GetProxiesHandler)
+			authGroup.GET("/proxy/:id", GetProxyHandler)
+			authGroup.POST("/proxy", CreateProxyHandler)
+			authGroup.PUT("/proxy/:id", UpdateProxyHandler)
+			authGroup.DELETE("/proxy/:id", DeleteProxyHandler)
+
+			authGroup.POST("/frpc/reload", ReloadFrpcHandler)
+			authGroup.POST("/frpc/start", StartFrpcHandler)
+			authGroup.POST("/frpc/stop", StopFrpcHandler)
+			authGroup.GET("/frpc/status", GetFrpcStatusHandler)
+			authGroup.GET("/frpc/log", GetFrpcLogHandler)
+
+			authGroup.POST("/import/toml", ImportTomlHandler)
+			authGroup.GET("/export/toml", ExportTomlHandler)
+
+			authGroup.PUT("/user/password", ChangePasswordHandler)
+		}
+	}
+
+	return r
+}

internal/api/static/app.js

@@ -29,7 +29,6 @@ async function apiFetch(endpoint, options = {}) {
         headers: { ...headers, ...(options.headers || {}) },
     });
 
-    // ---- 统一处理 401 认证失效 ----
     if (res.status === 401) {
         clearAuthState();
         window.dispatchEvent(new CustomEvent("auth:expired"));
@@ -96,6 +95,7 @@ const defaultConfig = {
     serverAddr: "frp.example.com",
     serverPort: 7000,
     token: "CHANGE_ME",
+    adminPort: 7400,  
     logLevel: "info",
     logMaxDays: 3,
     tcpMux: true,
@@ -171,7 +171,7 @@ function filterProxies(list, keyword) {
         (p) =>
             p.name.toLowerCase().includes(kw) ||
             p.localIP.includes(kw) ||
-            String(p.remotePort).includes(kw),
+            String(p.remotePort).includes(kw)
     );
 }
 
@@ -182,7 +182,7 @@ async function getFrpcStatus() {
     try {
         const data = await apiFetch("/frpc/status");
         if (data.code === 0) {
-            return data.data.running || false;
+            return data.data.phase === "RUNNING";
         }
     } catch (e) {
         console.warn("获取 frpc 状态失败", e);
@@ -298,7 +298,7 @@ const app = createApp({
         let logTimer = null;
         let logFetching = false;
 
-        // ---- Ping 延迟检测（移到 setup 内部） ----
+        // ---- Ping 延迟检测 ----
         const pingLatency = ref(null);
         let pingTimer = null;
         const PING_INTERVAL_MS = 30000;
@@ -313,7 +313,6 @@ const app = createApp({
 
         const pingIcon = computed(() => {
             if (pingLatency.value === null) {
-                // 未接入/失败 —— 断开图标
                 return `<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 256 256">
                     <path d="M0 0h256v256H0z" fill="none"/>
                     <g fill="currentColor">
@@ -323,13 +322,11 @@ const app = createApp({
                 </svg>`;
             }
             if (pingLatency.value < 1000) {
-                // 延迟好 —— 实心信号图标（青色/绿色）
                 return `<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 25 24">
                     <path d="M0 0h25v24H0z" fill="none"/>
                     <path fill="currentColor" d="M2.046 6.725c6.192-4.967 15.05-4.967 21.243 0l.779.625l-11.4 14.25L1.265 7.35z"/>
                 </svg>`;
             }
-            // 延迟一般（1000-5000ms）—— 空心信号图标（黄色/橙色）
             return `<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 24 24">
                 <path d="M0 0h24v24H0z" fill="none"/>
                 <path fill="none" stroke="currentColor" stroke-width="2" d="M21.996 7.505L12 20L2.004 7.505c5.827-4.673 14.165-4.673 19.992 0Z"/>
@@ -337,7 +334,6 @@ const app = createApp({
         });
 
         async function doPing() {
-            // 如果 frpc 未运行，直接显示 --ms
             if (!frpcRunning.value) {
                 pingLatency.value = null;
                 return;
@@ -347,9 +343,7 @@ const app = createApp({
             try {
                 const res = await fetch(
                     `/api/ping?target=${encodeURIComponent(addr)}`,
-                    {
+                    { signal: AbortSignal.timeout(PING_TIMEOUT_MS) },
-                        signal: AbortSignal.timeout(PING_TIMEOUT_MS),
-                    },
                 );
                 if (!res.ok) throw new Error("Ping failed");
                 const end = performance.now();
@@ -408,7 +402,7 @@ const app = createApp({
         watch(frpcRunning, (running) => {
             if (!running) {
                 stopPingPolling();
-                pingLatency.value = null;  // 显示 --ms
+                pingLatency.value = null;
             } else if (loggedIn.value) {
                 startPingPolling();
             }
@@ -810,7 +804,6 @@ const app = createApp({
 
             showToken,
 
-            // ---- 新增 Ping 相关导出 ----
             pingLatency,
             pingStatusClass,
             pingIcon,

internal/api/static/index.html

@@ -100,7 +100,8 @@
                                 <!-- Ping 延迟显示 -->
                                 <span class="ping-display" :class="pingStatusClass">
                                     <span class="ping-icon" v-html="pingIcon"></span>
-                                    <span class="ping-value">{{ pingLatency !== null ? pingLatency + 'ms' : '--ms' }}</span>
+                                    <span class="ping-value">{{ pingLatency !== null ? pingLatency + 'ms' : '--ms'
+                                        }}</span>
                                 </span>
                             </span>
                         </div>
@@ -200,6 +201,10 @@
                                         </button>
                                     </div>
                                 </div>
+                                <div class="form-row">
+                                    <label>管理端口 (admin_port)</label>
+                                    <input type="number" v-model="globalConfig.adminPort" placeholder="7400" />
+                                </div>
                             </div>
                         </div>
 
@@ -343,6 +348,14 @@
                 </div> <!-- /content-area -->
 
                 <!-- ====== 弹窗 ====== -->
+
+
+            </div> <!-- /main-panel -->
+        </div> <!-- /app-container -->
+
+        <!-- 隐藏文件选择器 -->
+        <input type="file" id="tomlFileInput" accept=".toml" style="display:none" @change="handleImport" />
+
         <Transition name="dialog">
             <div v-if="dialogVisible" class="dialog-overlay" @click.self="dialogVisible = false">
                 <div class="dialog-card">
@@ -371,13 +384,6 @@
                 </div>
             </div>
         </Transition>
-
-            </div> <!-- /main-panel -->
-        </div> <!-- /app-container -->
-
-        <!-- 隐藏文件选择器 -->
-        <input type="file" id="tomlFileInput" accept=".toml" style="display:none" @change="handleImport" />
-
     </div> <!-- /#app -->
 
     <script src="/static/app.js"></script>

internal/api/static/style-1.css

@@ -1,30 +1,28 @@
 /* ===== style-1.css - 全局基础 ===== */
 
 /* ---------- 字体定义 ---------- */
+/* 自托管 HarmonyOS Sans SC Regular */
+
+/* 中英文：HarmonyOS Sans SC Regular */
 @font-face {
     font-family: 'HarmonyOS Sans SC';
-    src: local('HarmonyOS Sans SC'),
+    src: url('./fonts/HarmonyOS_Sans_SC_Regular.ttf') format('truetype');
-         local('PingFang SC'),
-         local('Microsoft YaHei'),
-         local('Helvetica Neue');
     font-weight: 400;
+    font-style: normal;
     font-display: swap;
 }
+
+/* 数字专用：复用 HarmonyOS Sans SC Regular（因 Light 版本缺失） */
 @font-face {
-    font-family: 'HarmonyOS Sans SC';
+    font-family: 'HarmonyOS Sans';
-    src: local('HarmonyOS Sans SC Medium'),
+    src: url('./fonts/HarmonyOS_Sans_SC_Regular.ttf') format('truetype');
-         local('PingFang SC Medium');
+    font-weight: 300;
-    font-weight: 500;
+    font-style: normal;
-    font-display: swap;
-}
-@font-face {
-    font-family: 'HarmonyOS Sans SC';
-    src: local('HarmonyOS Sans SC Bold'),
-         local('PingFang SC Semibold');
-    font-weight: 700;
     font-display: swap;
 }
 
+/* 后备：如果自托管字体加载失败，使用系统字体 */
+
 /* ---------- 重置 ---------- */
 * {
     margin: 0;
@@ -33,14 +31,14 @@
 }
 
 body {
-    font-family: 'Segoe UI', 'PingFang SC', 'Microsoft YaHei', sans-serif;
+    font-family: 'HarmonyOS Sans SC', 'PingFang SC', 'Microsoft YaHei', 'Helvetica Neue', sans-serif;
     background: #0a0a0f;
     height: 100vh;
     overflow: hidden;
     color: #e0e0e0;
 }
 
-/* ---------- 数字专用字体（加粗） ---------- */
+/* ---------- 数字专用字体（使用 HarmonyOS Sans） ---------- */
 .digit,
 .big-number,
 .remote-port,
@@ -51,22 +49,23 @@ body {
 .login-btn,
 .save-btn,
 .btn-confirm {
-    font-weight: 600 !important;
+    font-weight: 300 !important;
     letter-spacing: 0.02em;
+    font-family: 'HarmonyOS Sans', 'JetBrains Mono', monospace;
 }
 
 /* 数字特别加粗（适用于大数字展示） */
 .big-number {
-    font-weight: 700 !important;
+    font-weight: 600 !important;
     letter-spacing: -0.01em;
 }
 
-/* 代码/端口类数字使用等宽字体，但保持加粗 */
+/* 代码/端口类数字使用等宽字体，但保持 HarmonyOS Sans 风格 */
 .digit,
 .remote-port,
 .proxy-addr {
-    font-family: 'HarmonyOS Sans SC', 'JetBrains Mono', monospace;
+    font-family: 'HarmonyOS Sans', 'JetBrains Mono', monospace;
-    font-weight: 600 !important;
+    font-weight: 300 !important;
 }
 
 /* ---------- 全局颜色变量 ---------- */
@@ -175,7 +174,7 @@ body {
     height: 100%;
     display: flex;
     flex-direction: column;
-    padding: 20px 28px;          /* ← 补上内边距 */
+    padding: 20px 28px;
     opacity: 0;
     transition: opacity 0.3s ease;
 }

internal/api/static/style-3.css

@@ -17,8 +17,8 @@
 }
 
 .top-left .nav-logo {
-    width: 48px;
+    width: 52px;   /* 原 48px */
-    height: 48px;
+    height: 52px;  /* 原 48px */
     flex-shrink: 0;
     display: block;
     object-fit: contain;
@@ -32,7 +32,7 @@
 }
 
 .brand-info .logo-text {
-    font-size: 22px;
+    font-size: 20px;
     font-weight: 600;
     color: var(--text-primary);
     line-height: 1.2;
@@ -59,8 +59,9 @@
     box-shadow: 0 0 12px rgba(99, 226, 183, 0.4);
 }
 
+/* 状态文字 12px（原 13px） */
 .status-wrapper .status-text {
-    font-size: 13px;
+    font-size: 12px;
     color: var(--text-muted);
 }
 
@@ -71,7 +72,7 @@
 }
 
 .user-name {
-    font-size: 13px;
+    font-size: 12px;  /* 原 13px，与状态文字对齐 */
     color: var(--text-secondary);
 }
 
@@ -375,7 +376,7 @@
 .proxy-addr {
     font-size: 13px;
     color: var(--text-dim);
-    font-family: 'JetBrains Mono', monospace;
+    font-family: 'HarmonyOS Sans','JetBrains Mono', monospace;
 }
 
 .proxy-tag {
@@ -395,7 +396,7 @@
 }
 
 .remote-port {
-    font-family: 'JetBrains Mono', monospace;
+    font-family: 'HarmonyOS Sans','JetBrains Mono', monospace;
     font-size: 14px;
     color: var(--text-secondary);
 }
@@ -801,3 +802,40 @@ select:disabled {
         height: 14px;
     }
 }
+
+/* ---------- Tab 栏 ---------- */
+.tab-bar {
+    display: flex;
+    gap: 32px;
+    padding: 14px 0 12px;
+    flex-shrink: 0;
+    border-bottom: 1px solid var(--border-subtle);
+}
+
+/* 将最后一个 Tab（用户配置）推到最右侧 */
+.tab-item:last-child {
+    margin-left: auto;
+    /* 防止用户名过长导致溢出 */
+    max-width: 220px;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+}
+
+.tab-item {
+    font-size: 14px;
+    color: var(--text-muted);
+    cursor: pointer;
+    padding: 4px 0;
+    transition: color 0.3s, border-color 0.3s;
+    border-bottom: 2px solid transparent;
+}
+
+.tab-item:hover {
+    color: var(--text-secondary);
+}
+
+.tab-item.active {
+    color: var(--primary-blue);
+    border-bottom-color: var(--primary-blue);
+}

internal/auth/auth.go

@@ -0,0 +1,234 @@
+package auth
+
+import (
+	"errors"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"github.com/golang-jwt/jwt/v5"
+	"golang.org/x/crypto/bcrypt"
+
+	"frpc-console/internal/db"
+)
+
+var jwtSecretCache []byte
+
+// getJwtSecret 从数据库获取 JWT 密钥
+func getJwtSecret() []byte {
+	if len(jwtSecretCache) > 0 {
+		return jwtSecretCache
+	}
+	secret, err := db.GetJwtSecret()
+	if err != nil {
+		// 如果数据库还没有密钥，生成一个默认的（仅用于开发）
+		// 生产环境应该通过数据库初始化时生成
+		return []byte("frpc-console-default-secret-key-2024")
+	}
+	jwtSecretCache = []byte(secret)
+	return jwtSecretCache
+}
+
+// Claims JWT 声明
+type Claims struct {
+	Username string `json:"username"`
+	jwt.RegisteredClaims
+}
+
+// GenerateJWT 生成 JWT
+func GenerateJWT(username string) (string, error) {
+	claims := Claims{
+		Username: username,
+		RegisteredClaims: jwt.RegisteredClaims{
+			ExpiresAt: jwt.NewNumericDate(time.Now().Add(7 * 24 * time.Hour)),
+			IssuedAt:  jwt.NewNumericDate(time.Now()),
+		},
+	}
+	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
+	return token.SignedString(getJwtSecret())
+}
+
+// ParseJWT 解析 JWT
+func ParseJWT(tokenString string) (*Claims, error) {
+	token, err := jwt.ParseWithClaims(tokenString, &Claims{}, func(token *jwt.Token) (interface{}, error) {
+		return getJwtSecret(), nil
+	})
+	if err != nil {
+		return nil, err
+	}
+	if claims, ok := token.Claims.(*Claims); ok && token.Valid {
+		return claims, nil
+	}
+	return nil, errors.New("invalid token")
+}
+
+// ValidatePassword 校验密码复杂度
+// 要求: 至少8位，包含大小写字母、数字、特殊字符
+func ValidatePassword(pwd string) bool {
+	if len(pwd) < 8 {
+		return false
+	}
+	var hasUpper, hasLower, hasDigit, hasSpecial bool
+	for _, ch := range pwd {
+		switch {
+		case ch >= 'A' && ch <= 'Z':
+			hasUpper = true
+		case ch >= 'a' && ch <= 'z':
+			hasLower = true
+		case ch >= '0' && ch <= '9':
+			hasDigit = true
+		case strings.ContainsAny(string(ch), "!@#$%^&*()_+-=[]{}|;:,.<>?"):
+			hasSpecial = true
+		}
+	}
+	return hasUpper && hasLower && hasDigit && hasSpecial
+}
+
+// HashPassword 加密密码
+func HashPassword(password string) (string, error) {
+	hash, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
+	if err != nil {
+		return "", err
+	}
+	return string(hash), nil
+}
+
+// CheckPassword 验证密码
+func CheckPassword(password, hash string) bool {
+	err := bcrypt.CompareHashAndPassword([]byte(hash), []byte(password))
+	return err == nil
+}
+
+// ================================================================
+// 登录 / 注册 / 修改密码 的业务逻辑 (供 handler 调用)
+// ================================================================
+
+// LoginRequest 登录请求
+type LoginRequest struct {
+	Username string `json:"username"`
+	Password string `json:"password"`
+}
+
+// LoginResponse 登录响应
+type LoginResponse struct {
+	Token string `json:"token"`
+}
+
+// Login 登录业务逻辑
+func Login(username, password string) (string, error) {
+	user, err := db.GetUserByUsername(username)
+	if err != nil {
+		return "", errors.New("用户不存在")
+	}
+	if !CheckPassword(password, user.PasswordHash) {
+		return "", errors.New("密码错误")
+	}
+	return GenerateJWT(username)
+}
+
+// RegisterRequest 注册请求
+type RegisterRequest struct {
+	Username string `json:"username"`
+	Password string `json:"password"`
+}
+
+// Register 注册业务逻辑
+func Register(username, password string) (string, error) {
+	// 检查用户名是否已存在
+	exists, err := db.UserExists(username)
+	if err != nil {
+		return "", err
+	}
+	if exists {
+		return "", errors.New("用户名已存在")
+	}
+	// 密码复杂度校验
+	if !ValidatePassword(password) {
+		return "", errors.New("密码不符合复杂度要求")
+	}
+	// 加密密码
+	hash, err := HashPassword(password)
+	if err != nil {
+		return "", err
+	}
+	// 创建用户
+	if err := db.CreateUser(username, hash); err != nil {
+		return "", err
+	}
+	// 生成 JWT
+	return GenerateJWT(username)
+}
+
+// ChangePasswordRequest 修改密码请求
+type ChangePasswordRequest struct {
+	OldPassword string `json:"oldPassword"`
+	NewPassword string `json:"newPassword"`
+}
+
+// ChangePassword 修改密码业务逻辑
+func ChangePassword(username, oldPassword, newPassword string) error {
+	user, err := db.GetUserByUsername(username)
+	if err != nil {
+		return errors.New("用户不存在")
+	}
+	if !CheckPassword(oldPassword, user.PasswordHash) {
+		return errors.New("原密码错误")
+	}
+	if !ValidatePassword(newPassword) {
+		return errors.New("新密码不符合复杂度要求")
+	}
+	hash, err := HashPassword(newPassword)
+	if err != nil {
+		return err
+	}
+	return db.UpdateUserPassword(username, hash)
+}
+
+// HasUsers 检查是否存在用户
+func HasUsers() (bool, error) {
+	count, err := db.CountUsers()
+	if err != nil {
+		return false, err
+	}
+	return count > 0, nil
+}
+
+// ================================================================
+// Gin 中间件
+// ================================================================
+
+// AuthMiddleware JWT 认证中间件
+func AuthMiddleware() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		authHeader := c.GetHeader("Authorization")
+		if authHeader == "" {
+			c.JSON(http.StatusUnauthorized, gin.H{"code": 1, "msg": "未提供认证令牌"})
+			c.Abort()
+			return
+		}
+		parts := strings.SplitN(authHeader, " ", 2)
+		if len(parts) != 2 || parts[0] != "Bearer" {
+			c.JSON(http.StatusUnauthorized, gin.H{"code": 1, "msg": "认证令牌格式错误"})
+			c.Abort()
+			return
+		}
+		claims, err := ParseJWT(parts[1])
+		if err != nil {
+			c.JSON(http.StatusUnauthorized, gin.H{"code": 1, "msg": "无效的认证令牌"})
+			c.Abort()
+			return
+		}
+		c.Set("username", claims.Username)
+		c.Next()
+	}
+}
+
+// GetUsernameFromContext 从 gin.Context 获取当前用户名
+func GetUsernameFromContext(c *gin.Context) string {
+	username, exists := c.Get("username")
+	if !exists {
+		return ""
+	}
+	return username.(string)
+}

internal/db/db.go

@@ -1,4 +1,4 @@
-package main
+package db
 
 import (
 	"crypto/rand"
@@ -17,60 +17,20 @@ import (
 
 var DB *sql.DB
 
-// ============================================================
+const SchemaVersion = "v3"
-// 数据库版本常量
-// ============================================================
 
-const (
+// ================================================================
-	SchemaVersion = "v2" // 当前数据库 Schema 版本（与 schemaHistory 中的版本对应）
+// 初始化
-)
+// ================================================================
-
-// ============================================================
-// 数据模型
-// ============================================================
-
-// GlobalConfig 全局配置表
-type GlobalConfig struct {
-	ID                int    `json:"id"`
-	ServerAddr        string `json:"serverAddr"`
-	ServerPort        int    `json:"serverPort"`
-	Token             string `json:"token"`
-	LogLevel          string `json:"logLevel"`
-	LogMaxDays        int    `json:"logMaxDays"`
-	TcpMux            bool   `json:"tcpMux"`
-	TcpMuxKeepalive   int    `json:"tcpMuxKeepalive"`
-	HeartbeatInterval int    `json:"heartbeatInterval"`
-	HeartbeatTimeout  int    `json:"heartbeatTimeout"`
-	PoolCount         int    `json:"poolCount"`
-	WireProtocolV2    bool   `json:"wireProtocolV2"` // v2 协议全局开关
-}
-
-// Proxy 隧道表（不含 wire_protocol_v2）
-type Proxy struct {
-	ID         int    `json:"id"`
-	Name       string `json:"name"`
-	Type       string `json:"type"`
-	LocalIP    string `json:"localIP"`
-	LocalPort  int    `json:"localPort"`
-	RemotePort int    `json:"remotePort"`
-	Enabled    bool   `json:"enabled"`
-}
-
-// User 用户表
-type User struct {
-	ID           int    `json:"id"`
-	Username     string `json:"username"`
-	PasswordHash string `json:"-"`
-	CreatedAt    string `json:"createdAt"`
-}
-
-// ============================================================
-// 数据库初始化
-// ============================================================
 
 func InitDB() error {
+	if err := os.MkdirAll("./data", 0755); err != nil {
+		return fmt.Errorf("创建数据目录失败: %w", err)
+	}
+
+	dbPath := "./data/frpc-console.db"
 	var err error
-	DB, err = sql.Open("sqlite", "./frpc-console.db")
+	DB, err = sql.Open("sqlite", dbPath)
 	if err != nil {
 		return err
 	}
@@ -91,12 +51,8 @@ func InitDB() error {
 	return nil
 }
 
-// ============================================================
-// 建表
-// ============================================================
-
 func createTables() error {
-	// 用户表
+	// users 表
 	_, err := DB.Exec(`
         CREATE TABLE IF NOT EXISTS users (
             id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -110,13 +66,14 @@ func createTables() error {
 		return err
 	}
 
-	// 全局配置表
+	// global_config 表
 	_, err = DB.Exec(`
         CREATE TABLE IF NOT EXISTS global_config (
             id INTEGER PRIMARY KEY CHECK (id = 1),
             server_addr TEXT NOT NULL DEFAULT 'frp.example.com',
             server_port INTEGER NOT NULL DEFAULT 7000,
             token TEXT NOT NULL DEFAULT 'CHANGE_ME',
+            admin_port INTEGER NOT NULL DEFAULT 7400,
             log_level TEXT NOT NULL DEFAULT 'info',
             log_max_days INTEGER NOT NULL DEFAULT 3,
             tcp_mux INTEGER NOT NULL DEFAULT 1,
@@ -132,7 +89,7 @@ func createTables() error {
 		return err
 	}
 
-	// 隧道表
+	// proxies 表
 	_, err = DB.Exec(`
         CREATE TABLE IF NOT EXISTS proxies (
             id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -150,7 +107,7 @@ func createTables() error {
 		return err
 	}
 
-	// 应用配置表
+	// app_config 表
 	_, err = DB.Exec(`
         CREATE TABLE IF NOT EXISTS app_config (
             key TEXT PRIMARY KEY,
@@ -162,16 +119,16 @@ func createTables() error {
 		return err
 	}
 
-	// 初始化默认配置
+	// 初始化 global_config 默认值（新数据库）
 	var count int
 	DB.QueryRow("SELECT COUNT(*) FROM global_config").Scan(&count)
 	if count == 0 {
 		_, err = DB.Exec(`
             INSERT INTO global_config (
-                id, server_addr, server_port, token, log_level, log_max_days,
+                id, server_addr, server_port, token, admin_port, log_level, log_max_days,
                 tcp_mux, tcp_mux_keepalive, heartbeat_interval, heartbeat_timeout, pool_count,
                 wire_protocol_v2
-            ) VALUES (1, 'frp.example.com', 7000, 'CHANGE_ME', 'info', 3, 1, 30, 15, 70, 8, 0)
+            ) VALUES (1, 'frp.example.com', 7000, 'CHANGE_ME', 7400, 'info', 3, 1, 30, 15, 70, 8, 0)
         `)
 		if err != nil {
 			return err
@@ -182,11 +139,116 @@ func createTables() error {
 	return nil
 }
 
-// ============================================================
+// ================================================================
-// 迁移引擎
+// v2 → v3 重型迁移：global_config 表添加 admin_port
-// ============================================================
+// ================================================================
+
+func migrateGlobalConfigToV3() error {
+	log.Println("  开始 global_config 表迁移 (v2→v3)")
+
+	// 1. 检查 admin_port 列是否已存在
+	var hasAdminPort bool
+	rows, err := DB.Query("PRAGMA table_info(global_config)")
+	if err != nil {
+		return fmt.Errorf("查询表结构失败: %w", err)
+	}
+	defer rows.Close()
+
+	for rows.Next() {
+		var cid int
+		var name, ctype string
+		var notnull, pk int
+		var dflt sql.NullString
+		if err := rows.Scan(&cid, &name, &ctype, &notnull, &dflt, &pk); err != nil {
+			return err
+		}
+		if name == "admin_port" {
+			hasAdminPort = true
+			break
+		}
+	}
+
+	if hasAdminPort {
+		log.Println("  ✅ admin_port 列已存在，跳过迁移")
+		return nil
+	}
+
+	log.Println("  创建 global_config_new 表...")
+
+	_, err = DB.Exec(`
+        CREATE TABLE global_config_new (
+            id INTEGER PRIMARY KEY CHECK (id = 1),
+            server_addr TEXT NOT NULL DEFAULT 'frp.example.com',
+            server_port INTEGER NOT NULL DEFAULT 7000,
+            token TEXT NOT NULL DEFAULT 'CHANGE_ME',
+            admin_port INTEGER NOT NULL DEFAULT 7400,
+            log_level TEXT NOT NULL DEFAULT 'info',
+            log_max_days INTEGER NOT NULL DEFAULT 3,
+            tcp_mux INTEGER NOT NULL DEFAULT 1,
+            tcp_mux_keepalive INTEGER NOT NULL DEFAULT 30,
+            heartbeat_interval INTEGER NOT NULL DEFAULT 15,
+            heartbeat_timeout INTEGER NOT NULL DEFAULT 70,
+            pool_count INTEGER NOT NULL DEFAULT 8,
+            wire_protocol_v2 INTEGER NOT NULL DEFAULT 0,
+            updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+        )
+    `)
+	if err != nil {
+		return fmt.Errorf("创建 global_config_new 表失败: %w", err)
+	}
+
+	log.Println("  迁移数据 (admin_port = 7400)...")
+
+	_, err = DB.Exec(`
+        INSERT INTO global_config_new (
+            id, server_addr, server_port, token, admin_port,
+            log_level, log_max_days, tcp_mux, tcp_mux_keepalive,
+            heartbeat_interval, heartbeat_timeout, pool_count,
+            wire_protocol_v2, updated_at
+        )
+        SELECT
+            id, server_addr, server_port, token, 7400,
+            log_level, log_max_days, tcp_mux, tcp_mux_keepalive,
+            heartbeat_interval, heartbeat_timeout, pool_count,
+            wire_protocol_v2, updated_at
+        FROM global_config
+    `)
+	if err != nil {
+		return fmt.Errorf("复制数据失败: %w", err)
+	}
+
+	var oldCount, newCount int
+	DB.QueryRow("SELECT COUNT(*) FROM global_config").Scan(&oldCount)
+	DB.QueryRow("SELECT COUNT(*) FROM global_config_new").Scan(&newCount)
+
+	if oldCount != newCount {
+		return fmt.Errorf("数据迁移不完整: 旧表 %d 行，新表 %d 行", oldCount, newCount)
+	}
+	log.Printf("  数据迁移验证通过: %d 行", newCount)
+
+	log.Println("  交换表名...")
+
+	if _, err := DB.Exec("ALTER TABLE global_config RENAME TO global_config_old"); err != nil {
+		return fmt.Errorf("重命名旧表失败: %w", err)
+	}
+
+	if _, err := DB.Exec("ALTER TABLE global_config_new RENAME TO global_config"); err != nil {
+		DB.Exec("ALTER TABLE global_config_old RENAME TO global_config")
+		return fmt.Errorf("重命名新表失败: %w", err)
+	}
+
+	if _, err := DB.Exec("DROP TABLE global_config_old"); err != nil {
+		log.Printf("⚠️ 删除旧表失败（不影响使用）: %v", err)
+	}
+
+	log.Println("  ✅ global_config 表迁移完成")
+	return nil
+}
+
+// ================================================================
+// Schema 版本管理
+// ================================================================
 
-// getCurrentSchemaVersion 读取当前数据库的 Schema 版本
 func getCurrentSchemaVersion() string {
 	var version string
 	err := DB.QueryRow("SELECT value FROM app_config WHERE key = 'schema_version'").Scan(&version)
@@ -205,7 +267,6 @@ func getCurrentSchemaVersion() string {
 	return version
 }
 
-// setSchemaVersion 更新 Schema 版本
 func setSchemaVersion(version string) error {
 	_, err := DB.Exec(`
         INSERT INTO app_config (key, value) VALUES ('schema_version', ?)
@@ -214,15 +275,14 @@ func setSchemaVersion(version string) error {
 	return err
 }
 
-// backupDatabase 备份数据库文件
 func backupDatabase() (string, error) {
-	src := "./frpc-console.db"
+	src := "./data/frpc-console.db"
 	if _, err := os.Stat(src); os.IsNotExist(err) {
 		return "", nil
 	}
 
 	timestamp := time.Now().Format("20060102_150405")
-	dst := fmt.Sprintf("./frpc-console.db.pre-%s.%s", SchemaVersion, timestamp)
+	dst := fmt.Sprintf("./data/frpc-console.db.pre-%s.%s", SchemaVersion, timestamp)
 
 	srcFile, err := os.Open(src)
 	if err != nil {
@@ -244,7 +304,6 @@ func backupDatabase() (string, error) {
 	return dst, nil
 }
 
-// restoreDatabase 从备份恢复数据库
 func restoreDatabase(backupPath string) error {
 	srcFile, err := os.Open(backupPath)
 	if err != nil {
@@ -252,7 +311,7 @@ func restoreDatabase(backupPath string) error {
 	}
 	defer srcFile.Close()
 
-	dstFile, err := os.Create("./frpc-console.db")
+	dstFile, err := os.Create("./data/frpc-console.db")
 	if err != nil {
 		return err
 	}
@@ -266,7 +325,10 @@ func restoreDatabase(backupPath string) error {
 	return nil
 }
 
-// runMigrations 执行迁移
+// ================================================================
+// runMigrations - 核心迁移入口
+// ================================================================
+
 func runMigrations() error {
 	currentVer := getCurrentSchemaVersion()
 	targetVer := SchemaVersion
@@ -274,7 +336,13 @@ func runMigrations() error {
 	log.Printf("📌 当前数据库 Schema: %s, 目标版本: %s", currentVer, targetVer)
 
 	if currentVer == targetVer {
-		log.Println("✅ Schema 已是最新，无需迁移")
+		var userCount int
+		err := DB.QueryRow("SELECT COUNT(*) FROM users").Scan(&userCount)
+		if err != nil || userCount == 0 {
+			log.Println("  数据库为空或无效，无需迁移，直接初始化")
+			return nil
+		}
+		log.Println("✅ Schema 已是最新，数据库有效")
 		return nil
 	}
 
@@ -288,26 +356,37 @@ func runMigrations() error {
 		log.Printf("📦 备份文件: %s", backupPath)
 	}
 
-	currentSchema := getSchemaDef(currentVer)
+	// ---- 阶段1: v1 → v2（proxies 表迁移） ----
-	targetSchema := getSchemaDef(targetVer)
+	if currentVer == "v1" {
-
+		oldDef := getSchemaDef("v1")
-	if targetSchema == nil {
+		newDef := getSchemaDef("v2")
-		return fmt.Errorf("目标 Schema 版本 %s 未在 schemaHistory 中定义", targetVer)
+		if oldDef == nil || newDef == nil {
+			return fmt.Errorf("v1 或 v2 schema 定义不存在")
 		}
-
+		if !schemaVersionsEqual(oldDef, newDef) {
-	if currentSchema == nil || schemaVersionsEqual(currentSchema, targetSchema) {
+			log.Println("  阶段1: v1→v2 重型迁移（proxies 表结构变更）")
-		log.Println("  迁移类型: 轻量复制（Schema 无变更）")
+			if err := heavyMigration(oldDef, newDef); err != nil {
-	} else {
-		log.Println("  迁移类型: 重型迁移（Schema 有变更，新建表 + 搬数据）")
-		if err := heavyMigration(currentSchema, targetSchema); err != nil {
 				if backupPath != "" {
-				log.Printf("❌ 迁移失败，尝试恢复备份: %s", backupPath)
+					restoreDatabase(backupPath)
-				if restoreErr := restoreDatabase(backupPath); restoreErr != nil {
-					log.Printf("⚠️  恢复备份失败: %v", restoreErr)
 				}
+				return fmt.Errorf("v1→v2 迁移失败: %w", err)
 			}
-			return fmt.Errorf("重型迁移失败: %w", err)
+		} else {
+			log.Println("  阶段1: v1→v2 轻量迁移（proxies 表结构无变更）")
 		}
+		currentVer = "v2"
+	}
+
+	// ---- 阶段2: v2 → v3（global_config 表新增 admin_port） ----
+	if currentVer == "v2" {
+		log.Println("  阶段2: v2→v3 重型迁移（global_config 表新增 admin_port）")
+		if err := migrateGlobalConfigToV3(); err != nil {
+			if backupPath != "" {
+				restoreDatabase(backupPath)
+			}
+			return fmt.Errorf("v2→v3 迁移失败: %w", err)
+		}
+		currentVer = "v3"
 	}
 
 	if err := setSchemaVersion(targetVer); err != nil {
@@ -318,10 +397,13 @@ func runMigrations() error {
 	return nil
 }
 
-// heavyMigration 重型迁移
+// ================================================================
+// 重型迁移引擎（用于 proxies 表）
+// ================================================================
+
 func heavyMigration(oldDef, newDef *SchemaVersionDef) error {
 	if oldDef == nil {
-		return fmt.Errorf("旧 Schema 定义为空，无法执行重型迁移")
+		return fmt.Errorf("旧 Schema 定义为空")
 	}
 
 	oldTable := oldDef.TableName
@@ -366,7 +448,6 @@ func heavyMigration(oldDef, newDef *SchemaVersionDef) error {
 	return nil
 }
 
-// buildCreateTableSQL 根据 Schema 定义生成 CREATE TABLE 语句
 func buildCreateTableSQL(tableName string, def *SchemaVersionDef) string {
 	var cols []string
 	var primaryKey string
@@ -400,7 +481,6 @@ func buildCreateTableSQL(tableName string, def *SchemaVersionDef) string {
 	return fmt.Sprintf("CREATE TABLE %s (\n    %s\n)", tableName, strings.Join(cols, ",\n    "))
 }
 
-// buildInsertSQL 构建 INSERT INTO new_table SELECT ... FROM old_table
 func buildInsertSQL(oldTable, newTable string, oldDef, newDef *SchemaVersionDef) (string, error) {
 	newCols := make([]string, 0, len(newDef.Columns))
 	for name := range newDef.Columns {
@@ -438,9 +518,9 @@ func buildInsertSQL(oldTable, newTable string, oldDef, newDef *SchemaVersionDef)
 	), nil
 }
 
-// ============================================================
+// ================================================================
 // JWT 密钥管理
-// ============================================================
+// ================================================================
 
 func ensureJwtSecret() error {
 	var value string
@@ -473,145 +553,3 @@ func GetJwtSecret() (string, error) {
 	}
 	return secret, nil
 }
-
-// ============================================================
-// 全局配置 CRUD
-// ============================================================
-
-func GetGlobalConfig() (*GlobalConfig, error) {
-	var cfg GlobalConfig
-	err := DB.QueryRow(`
-        SELECT id, server_addr, server_port, token, log_level, log_max_days,
-               tcp_mux, tcp_mux_keepalive, heartbeat_interval, heartbeat_timeout, pool_count,
-               wire_protocol_v2
-        FROM global_config WHERE id = 1
-    `).Scan(
-		&cfg.ID, &cfg.ServerAddr, &cfg.ServerPort, &cfg.Token,
-		&cfg.LogLevel, &cfg.LogMaxDays, &cfg.TcpMux, &cfg.TcpMuxKeepalive,
-		&cfg.HeartbeatInterval, &cfg.HeartbeatTimeout, &cfg.PoolCount,
-		&cfg.WireProtocolV2,
-	)
-	if err != nil {
-		return nil, err
-	}
-	cfg.TcpMux = true
-	return &cfg, nil
-}
-
-func UpdateGlobalConfig(cfg *GlobalConfig) error {
-	_, err := DB.Exec(`
-        UPDATE global_config SET
-            server_addr = ?, server_port = ?, token = ?, log_level = ?, log_max_days = ?,
-            tcp_mux = 1,
-            tcp_mux_keepalive = ?, heartbeat_interval = ?, heartbeat_timeout = ?, pool_count = ?,
-            wire_protocol_v2 = ?,
-            updated_at = CURRENT_TIMESTAMP
-        WHERE id = 1
-    `, cfg.ServerAddr, cfg.ServerPort, cfg.Token, cfg.LogLevel, cfg.LogMaxDays,
-		cfg.TcpMuxKeepalive, cfg.HeartbeatInterval, cfg.HeartbeatTimeout, cfg.PoolCount,
-		cfg.WireProtocolV2)
-	return err
-}
-
-// ============================================================
-// 隧道 CRUD
-// ============================================================
-
-func GetProxies() ([]Proxy, error) {
-	rows, err := DB.Query(`
-        SELECT id, name, type, local_ip, local_port, remote_port, enabled
-        FROM proxies ORDER BY id
-    `)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-
-	var proxies []Proxy
-	for rows.Next() {
-		var p Proxy
-		err := rows.Scan(&p.ID, &p.Name, &p.Type, &p.LocalIP, &p.LocalPort, &p.RemotePort, &p.Enabled)
-		if err != nil {
-			return nil, err
-		}
-		proxies = append(proxies, p)
-	}
-	return proxies, rows.Err()
-}
-
-func GetProxy(id int) (*Proxy, error) {
-	var p Proxy
-	err := DB.QueryRow(`
-        SELECT id, name, type, local_ip, local_port, remote_port, enabled
-        FROM proxies WHERE id = ?
-    `, id).Scan(&p.ID, &p.Name, &p.Type, &p.LocalIP, &p.LocalPort, &p.RemotePort, &p.Enabled)
-	if err != nil {
-		return nil, err
-	}
-	return &p, nil
-}
-
-func CreateProxy(p *Proxy) error {
-	result, err := DB.Exec(`
-        INSERT INTO proxies (name, type, local_ip, local_port, remote_port, enabled)
-        VALUES (?, ?, ?, ?, ?, ?)
-    `, p.Name, p.Type, p.LocalIP, p.LocalPort, p.RemotePort, p.Enabled)
-	if err != nil {
-		return err
-	}
-	id, _ := result.LastInsertId()
-	p.ID = int(id)
-	return nil
-}
-
-func UpdateProxy(p *Proxy) error {
-	_, err := DB.Exec(`
-        UPDATE proxies SET
-            name = ?, type = ?, local_ip = ?, local_port = ?, remote_port = ?, enabled = ?,
-            updated_at = CURRENT_TIMESTAMP
-        WHERE id = ?
-    `, p.Name, p.Type, p.LocalIP, p.LocalPort, p.RemotePort, p.Enabled, p.ID)
-	return err
-}
-
-func DeleteProxy(id int) error {
-	_, err := DB.Exec("DELETE FROM proxies WHERE id = ?", id)
-	return err
-}
-
-// ============================================================
-// 用户 CRUD
-// ============================================================
-
-func GetUserByUsername(username string) (*User, error) {
-	var u User
-	err := DB.QueryRow(`
-        SELECT id, username, password_hash, created_at
-        FROM users WHERE username = ?
-    `, username).Scan(&u.ID, &u.Username, &u.PasswordHash, &u.CreatedAt)
-	if err != nil {
-		return nil, err
-	}
-	return &u, nil
-}
-
-func CreateUser(username, passwordHash string) error {
-	_, err := DB.Exec(`
-        INSERT INTO users (username, password_hash) VALUES (?, ?)
-    `, username, passwordHash)
-	return err
-}
-
-func UpdatePassword(username, passwordHash string) error {
-	_, err := DB.Exec(`
-        UPDATE users SET password_hash = ?, updated_at = CURRENT_TIMESTAMP
-        WHERE username = ?
-    `, passwordHash, username)
-	return err
-}
-
-func CountUsers() (int, error) {
-	var count int
-	err := DB.QueryRow("SELECT COUNT(*) FROM users").Scan(&count)
-	return count, err
-}

internal/db/models.go

@@ -0,0 +1,37 @@
+package db
+
+// GlobalConfig 全局配置
+type GlobalConfig struct {
+	ID                int    `json:"id"`
+	ServerAddr        string `json:"serverAddr"`
+	ServerPort        int    `json:"serverPort"`
+	Token             string `json:"token"`
+	AdminPort         int    `json:"adminPort"` // ← 新增
+	LogLevel          string `json:"logLevel"`
+	LogMaxDays        int    `json:"logMaxDays"`
+	TcpMux            bool   `json:"tcpMux"`
+	TcpMuxKeepalive   int    `json:"tcpMuxKeepalive"`
+	HeartbeatInterval int    `json:"heartbeatInterval"`
+	HeartbeatTimeout  int    `json:"heartbeatTimeout"`
+	PoolCount         int    `json:"poolCount"`
+	WireProtocolV2    bool   `json:"wireProtocolV2"`
+}
+
+// Proxy 隧道配置
+type Proxy struct {
+	ID         int    `json:"id"`
+	Name       string `json:"name"`
+	Type       string `json:"type"`
+	LocalIP    string `json:"localIP"`
+	LocalPort  int    `json:"localPort"`
+	RemotePort int    `json:"remotePort"`
+	Enabled    bool   `json:"enabled"`
+}
+
+// User 用户
+type User struct {
+	ID           int    `json:"id"`
+	Username     string `json:"username"`
+	PasswordHash string `json:"-"`
+	CreatedAt    string `json:"createdAt"`
+}

internal/db/repository.go

@@ -0,0 +1,155 @@
+package db
+
+// ================================================================
+// 全局配置
+// ================================================================
+
+// internal/db/repository.go
+
+func GetGlobalConfig() (*GlobalConfig, error) {
+	var cfg GlobalConfig
+	err := DB.QueryRow(`
+        SELECT id, server_addr, server_port, token, admin_port,
+               log_level, log_max_days,
+               tcp_mux, tcp_mux_keepalive, heartbeat_interval, heartbeat_timeout, pool_count,
+               wire_protocol_v2
+        FROM global_config WHERE id = 1
+    `).Scan(
+		&cfg.ID, &cfg.ServerAddr, &cfg.ServerPort, &cfg.Token, &cfg.AdminPort,
+		&cfg.LogLevel, &cfg.LogMaxDays,
+		&cfg.TcpMux, &cfg.TcpMuxKeepalive,
+		&cfg.HeartbeatInterval, &cfg.HeartbeatTimeout, &cfg.PoolCount,
+		&cfg.WireProtocolV2,
+	)
+	if err != nil {
+		return nil, err
+	}
+	cfg.TcpMux = true
+	return &cfg, nil
+}
+
+func UpdateGlobalConfig(cfg *GlobalConfig) error {
+	_, err := DB.Exec(`
+        UPDATE global_config SET
+            server_addr = ?, server_port = ?, token = ?, admin_port = ?,
+            log_level = ?, log_max_days = ?,
+            tcp_mux = 1,
+            tcp_mux_keepalive = ?, heartbeat_interval = ?, heartbeat_timeout = ?, pool_count = ?,
+            wire_protocol_v2 = ?,
+            updated_at = CURRENT_TIMESTAMP
+        WHERE id = 1
+    `, cfg.ServerAddr, cfg.ServerPort, cfg.Token, cfg.AdminPort,
+		cfg.LogLevel, cfg.LogMaxDays,
+		cfg.TcpMuxKeepalive, cfg.HeartbeatInterval, cfg.HeartbeatTimeout, cfg.PoolCount,
+		cfg.WireProtocolV2)
+	return err
+}
+
+// ================================================================
+// 隧道管理
+// ================================================================
+
+func GetProxies() ([]Proxy, error) {
+	rows, err := DB.Query(`
+        SELECT id, name, type, local_ip, local_port, remote_port, enabled
+        FROM proxies ORDER BY id
+    `)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var proxies []Proxy
+	for rows.Next() {
+		var p Proxy
+		err := rows.Scan(&p.ID, &p.Name, &p.Type, &p.LocalIP, &p.LocalPort, &p.RemotePort, &p.Enabled)
+		if err != nil {
+			return nil, err
+		}
+		proxies = append(proxies, p)
+	}
+	return proxies, rows.Err()
+}
+
+func GetProxy(id int) (*Proxy, error) {
+	var p Proxy
+	err := DB.QueryRow(`
+        SELECT id, name, type, local_ip, local_port, remote_port, enabled
+        FROM proxies WHERE id = ?
+    `, id).Scan(&p.ID, &p.Name, &p.Type, &p.LocalIP, &p.LocalPort, &p.RemotePort, &p.Enabled)
+	if err != nil {
+		return nil, err
+	}
+	return &p, nil
+}
+
+func CreateProxy(p *Proxy) error {
+	result, err := DB.Exec(`
+        INSERT INTO proxies (name, type, local_ip, local_port, remote_port, enabled)
+        VALUES (?, ?, ?, ?, ?, ?)
+    `, p.Name, p.Type, p.LocalIP, p.LocalPort, p.RemotePort, p.Enabled)
+	if err != nil {
+		return err
+	}
+	id, _ := result.LastInsertId()
+	p.ID = int(id)
+	return nil
+}
+
+func UpdateProxy(p *Proxy) error {
+	_, err := DB.Exec(`
+        UPDATE proxies SET
+            name = ?, type = ?, local_ip = ?, local_port = ?, remote_port = ?, enabled = ?,
+            updated_at = CURRENT_TIMESTAMP
+        WHERE id = ?
+    `, p.Name, p.Type, p.LocalIP, p.LocalPort, p.RemotePort, p.Enabled, p.ID)
+	return err
+}
+
+func DeleteProxy(id int) error {
+	_, err := DB.Exec("DELETE FROM proxies WHERE id = ?", id)
+	return err
+}
+
+// ================================================================
+// 用户管理
+// ================================================================
+
+func GetUserByUsername(username string) (*User, error) {
+	var u User
+	err := DB.QueryRow(`
+        SELECT id, username, password_hash, created_at
+        FROM users WHERE username = ?
+    `, username).Scan(&u.ID, &u.Username, &u.PasswordHash, &u.CreatedAt)
+	if err != nil {
+		return nil, err
+	}
+	return &u, nil
+}
+
+func UserExists(username string) (bool, error) {
+	var count int
+	err := DB.QueryRow("SELECT COUNT(*) FROM users WHERE username = ?", username).Scan(&count)
+	return count > 0, err
+}
+
+func CreateUser(username, passwordHash string) error {
+	_, err := DB.Exec(`
+        INSERT INTO users (username, password_hash) VALUES (?, ?)
+    `, username, passwordHash)
+	return err
+}
+
+func UpdateUserPassword(username, passwordHash string) error {
+	_, err := DB.Exec(`
+        UPDATE users SET password_hash = ?, updated_at = CURRENT_TIMESTAMP
+        WHERE username = ?
+    `, passwordHash, username)
+	return err
+}
+
+func CountUsers() (int, error) {
+	var count int
+	err := DB.QueryRow("SELECT COUNT(*) FROM users").Scan(&count)
+	return count, err
+}

internal/db/schema.go

@@ -1,31 +1,24 @@
-package main
+package db
 
-// ============================================================
+// ================================================================
-// db-history.go - Schema 版本声明与字段映射
+// Schema 版本声明
-// 这是整个迁移引擎的“数据源”，记录每个版本的完整 Schema 定义。
+// ================================================================
-// 迁移工具通过对比当前 Schema 与目标 Schema 的差异来决定迁移路径。
-// ============================================================
 
-// SchemaVersionDef 记录一个 Schema 版本的完整字段定义
 type SchemaVersionDef struct {
-	Version   string               // 如 "v1", "v2", "v3"
+	Version   string
-	TableName string               // 表名，如 "proxies"
+	TableName string
-	Columns   map[string]ColumnDef // 字段名 → 字段定义
+	Columns   map[string]ColumnDef
 }
 
-// ColumnDef 描述一个字段的结构
 type ColumnDef struct {
-	Type    string // 如 "INTEGER", "TEXT", "BOOLEAN"
+	Type    string
-	NotNull bool   // 是否 NOT NULL
+	NotNull bool
-	Default string // 默认值表达式（如 "0"、"'CHANGE_ME'"）
+	Default string
-	Primary bool   // 是否主键
+	Primary bool
 }
 
-// schemaHistory 存储所有已知的 Schema 版本（从旧到新排列）
-// 每个版本记录的是“完整的表结构”，而不是增量变更。
-// 新增版本时，在这里追加一条记录即可。
 var schemaHistory = []SchemaVersionDef{
-	// v1：初始版本（frpc-console 1.0）
+	// v1: 初始版本
 	{
 		Version:   "v1",
 		TableName: "proxies",
@@ -41,8 +34,7 @@ var schemaHistory = []SchemaVersionDef{
 			"updated_at":  {Type: "DATETIME", Default: "CURRENT_TIMESTAMP"},
 		},
 	},
-	// v2：当前版本（frpc-console 2.0 LTS）
+	// v2: 当前版本
-	// 注意：wire_protocol_v2 是全局配置（global_config），不在 proxies 表中
 	{
 		Version:   "v2",
 		TableName: "proxies",
@@ -58,18 +50,24 @@ var schemaHistory = []SchemaVersionDef{
 			"updated_at":  {Type: "DATETIME", Default: "CURRENT_TIMESTAMP"},
 		},
 	},
-	// v3：未来版本（规划中）
+
-	// 示例：新增隧道分组、流量统计等字段
+	{
-	// {
+		Version:   "v3",
-	//     Version:   "v3",
+		TableName: "proxies",
-	//     TableName: "proxies",
+		Columns: map[string]ColumnDef{
-	//     Columns: map[string]ColumnDef{
+			"id":          {Type: "INTEGER", Primary: true},
-	//         // ... 完整字段定义
+			"name":        {Type: "TEXT", NotNull: true},
-	//     },
+			"type":        {Type: "TEXT", NotNull: true, Default: "'tcp'"},
-	// },
+			"local_ip":    {Type: "TEXT", NotNull: true},
+			"local_port":  {Type: "INTEGER", NotNull: true},
+			"remote_port": {Type: "INTEGER", NotNull: true},
+			"enabled":     {Type: "INTEGER", NotNull: true, Default: "1"},
+			"created_at":  {Type: "DATETIME", Default: "CURRENT_TIMESTAMP"},
+			"updated_at":  {Type: "DATETIME", Default: "CURRENT_TIMESTAMP"},
+		},
+	},
 }
 
-// getSchemaDef 根据版本号获取 Schema 定义
 func getSchemaDef(version string) *SchemaVersionDef {
 	for _, def := range schemaHistory {
 		if def.Version == version {
@@ -79,7 +77,6 @@ func getSchemaDef(version string) *SchemaVersionDef {
 	return nil
 }
 
-// getLatestSchemaDef 获取最新的 Schema 版本定义
 func getLatestSchemaDef() *SchemaVersionDef {
 	if len(schemaHistory) == 0 {
 		return nil
@@ -87,7 +84,6 @@ func getLatestSchemaDef() *SchemaVersionDef {
 	return &schemaHistory[len(schemaHistory)-1]
 }
 
-// schemaVersionsEqual 判断两个 Schema 版本是否完全相同
 func schemaVersionsEqual(v1, v2 *SchemaVersionDef) bool {
 	if v1 == nil || v2 == nil {
 		return false

internal/frp/binary.go

@@ -0,0 +1,98 @@
+package frp
+
+import (
+	"embed"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"sync"
+)
+
+//go:embed bin/*
+var embeddedFrpc embed.FS
+
+var (
+	cachedFrpcPath string
+	frpcPathMutex  sync.Mutex
+)
+
+// GetFrpcPath 获取 frpc 二进制路径
+// 优先级: 本地缓存 > 程序同目录 > 当前工作目录 > embed 提取到当前目录 > 系统 PATH
+func GetFrpcPath() (string, error) {
+	frpcPathMutex.Lock()
+	defer frpcPathMutex.Unlock()
+
+	if cachedFrpcPath != "" {
+		if _, err := os.Stat(cachedFrpcPath); err == nil {
+			return cachedFrpcPath, nil
+		}
+		cachedFrpcPath = ""
+	}
+
+	var fileName string
+	switch {
+	case runtime.GOOS == "windows" && runtime.GOARCH == "amd64":
+		fileName = "frpc_windows_amd64.exe"
+	case runtime.GOOS == "linux" && runtime.GOARCH == "amd64":
+		fileName = "frpc_linux_amd64"
+	case runtime.GOOS == "linux" && runtime.GOARCH == "arm64":
+		fileName = "frpc_linux_arm64"
+	case runtime.GOOS == "linux" && runtime.GOARCH == "arm":
+		fileName = "frpc_linux_arm_hf"
+	default:
+		path, err := exec.LookPath("frpc")
+		if err == nil {
+			cachedFrpcPath = path
+			return path, nil
+		}
+		return "", fmt.Errorf("不支持的平台: %s/%s", runtime.GOOS, runtime.GOARCH)
+	}
+
+	// 方法1: 尝试从程序同目录加载
+	execPath, err := os.Executable()
+	if err == nil {
+		execDir := filepath.Dir(execPath)
+		localPath := filepath.Join(execDir, "frpc")
+		if runtime.GOOS == "windows" {
+			localPath += ".exe"
+		}
+		if _, err := os.Stat(localPath); err == nil {
+			cachedFrpcPath = localPath
+			return localPath, nil
+		}
+	}
+
+	// 方法2: 尝试从当前工作目录加载
+	cwdPath := "./frpc"
+	if runtime.GOOS == "windows" {
+		cwdPath += ".exe"
+	}
+	if _, err := os.Stat(cwdPath); err == nil {
+		cachedFrpcPath = cwdPath
+		return cwdPath, nil
+	}
+
+	// 方法3: 从 embed 提取到当前工作目录
+	data, err := embeddedFrpc.ReadFile("bin/" + fileName)
+	if err == nil {
+		extractPath := "./frpc"
+		if runtime.GOOS == "windows" {
+			extractPath += ".exe"
+		}
+		if err := os.WriteFile(extractPath, data, 0755); err == nil {
+			cachedFrpcPath = extractPath
+			return extractPath, nil
+		}
+	}
+
+	// 方法4: 从系统 PATH 查找
+	path, err := exec.LookPath("frpc")
+	if err == nil {
+		cachedFrpcPath = path
+		return path, nil
+	}
+
+	return "", fmt.Errorf("未找到 frpc 文件")
+}

internal/frp/config.go

@@ -0,0 +1,87 @@
+package frp
+
+import (
+	"bytes"
+	_ "embed"
+	"os"
+	"text/template"
+
+	"frpc-console/internal/db"
+)
+
+//go:embed frpc.tmpl
+var FrpcTemplateContent string
+
+// ConfigData frpc.toml 模板渲染数据
+type ConfigData struct {
+	*db.GlobalConfig
+	Proxies          []db.Proxy
+	WireProtocolLine string
+}
+
+// ConfigData 中已包含 *db.GlobalConfig，AdminPort 会自动传递到模板
+// 不需要额外修改，但模板 frpc.tmpl 需要支持 admin_port 输出
+
+// 在 frpc.tmpl 中添加：
+// {{- if .AdminPort }}
+// admin_port = {{ .AdminPort }}
+// {{- end }}
+
+// GenerateConfig 生成 frpc.toml 配置文件
+func GenerateConfig() error {
+	cfg, err := db.GetGlobalConfig()
+	if err != nil {
+		return err
+	}
+
+	proxies, err := db.GetProxies()
+	if err != nil {
+		return err
+	}
+
+	var activeProxies []db.Proxy
+	for _, p := range proxies {
+		if p.Enabled {
+			activeProxies = append(activeProxies, p)
+		}
+	}
+
+	data := ConfigData{
+		GlobalConfig: cfg,
+		Proxies:      activeProxies,
+	}
+
+	if cfg.WireProtocolV2 {
+		data.WireProtocolLine = `wireProtocol = "v2"`
+	} else {
+		data.WireProtocolLine = ""
+	}
+
+	var tmplContent string
+	if _, err := os.Stat("frpc.tmpl"); err == nil {
+		content, readErr := os.ReadFile("frpc.tmpl")
+		if readErr == nil {
+			tmplContent = string(content)
+		} else {
+			tmplContent = FrpcTemplateContent
+		}
+	} else {
+		tmplContent = FrpcTemplateContent
+	}
+
+	tmpl, err := template.New("frpc").Parse(tmplContent)
+	if err != nil {
+		return err
+	}
+
+	var buf bytes.Buffer
+	if err := tmpl.Execute(&buf, data); err != nil {
+		return err
+	}
+
+	if err := os.MkdirAll("./data", 0755); err != nil {
+		return err
+	}
+
+	return os.WriteFile("./data/frpc.toml", buf.Bytes(), 0644)
+}

internal/frp/frpc.tmpl

@@ -5,7 +5,7 @@ serverPort = {{.ServerPort}}
 token = "{{.Token}}"
 
 [log]
-to = "./frpc.log"
+to = "./data/frpc.log"
 level = "{{.LogLevel}}"
 maxDays = {{.LogMaxDays}}
 
@@ -19,8 +19,11 @@ poolCount = {{.PoolCount}}
 {{.WireProtocolLine}}
 {{end}}
 
+{{if .AdminPort}}
 [webServer]
-addr = "127.0.0.1:7400"
+addr = "127.0.0.1"
+port = {{.AdminPort}}
+{{end}}
 
 {{range .Proxies}}
 [[proxies]]

internal/frp/legacy.go

@@ -0,0 +1,226 @@
+// internal/frp/legacy.go
+// Reload 函数适配 P0 改动
+
+package frp
+
+import (
+	"context"
+	"log"
+	"os"
+	"os/exec"
+	"runtime"
+	"strconv"
+	"strings"
+	"syscall"
+
+	"frpc-console/internal/process"
+)
+
+// ================================================================
+// 兼容层：保持对外接口不变
+// ================================================================
+
+func IsRunning() bool {
+	pm := process.GetGlobalManager()
+	if pm != nil {
+		status, err := pm.Status()
+		if err != nil {
+			log.Printf("[WARN] ProcessManager.Status() 失败: %v，降级到 PID 文件", err)
+			return isRunningLegacy()
+		}
+		return status.Phase == "RUNNING"
+	}
+	return isRunningLegacy()
+}
+
+func Start() error {
+	pm := process.GetGlobalManager()
+	if pm != nil {
+		log.Println("[INFO] 使用 ProcessManager 启动 frpc")
+		return pm.Start(context.Background())
+	}
+	log.Println("[WARN] ProcessManager 未初始化，使用兼容模式启动 frpc")
+	return startLegacy()
+}
+
+func Stop() error {
+	pm := process.GetGlobalManager()
+	if pm != nil {
+		log.Println("[INFO] 使用 ProcessManager 停止 frpc")
+		return pm.Stop(context.Background())
+	}
+	log.Println("[WARN] ProcessManager 未初始化，使用兼容模式停止 frpc")
+	return stopLegacy()
+}
+
+func Restart() error {
+	pm := process.GetGlobalManager()
+	if pm != nil {
+		log.Println("[INFO] 使用 ProcessManager 重启 frpc")
+		return pm.Restart(context.Background())
+	}
+	log.Println("[WARN] ProcessManager 未初始化，使用兼容模式重启 frpc")
+	if err := stopLegacy(); err != nil {
+		return err
+	}
+	return startLegacy()
+}
+
+func GetStatus() (map[string]interface{}, error) {
+	pm := process.GetGlobalManager()
+	if pm != nil {
+		state, err := pm.Status()
+		if err != nil {
+			return nil, err
+		}
+		return map[string]interface{}{
+			"phase":     state.Phase,
+			"pid":       state.PID,
+			"port":      state.Port,
+			"alive":     state.Alive,
+			"frp_ready": state.FRPReady,
+		}, nil
+	}
+	running := isRunningLegacy()
+	return map[string]interface{}{
+		"phase":  map[bool]string{true: "RUNNING", false: "STOPPED"}[running],
+		"pid":    0,
+		"port":   0,
+		"legacy": true,
+	}, nil
+}
+
+// ================================================================
+// Reload 热加载 frpc 配置（P0 核心）
+// ================================================================
+
+func Reload() error {
+	pm := process.GetGlobalManager()
+	if pm == nil {
+		log.Println("[WARN] ProcessManager 未初始化，使用兼容模式 reload")
+		return reloadLegacy()
+	}
+
+	// 使用 ProcessManager 的 ReloadConfig 方法
+	// 该方法内部处理了 RELOADING 状态和 PID 归属验证
+	log.Println("[INFO] 使用 ProcessManager 执行热加载")
+	return pm.ReloadConfig(context.Background())
+}
+
+// ================================================================
+// 旧版实现 (降级方案)
+// ================================================================
+
+func isRunningLegacy() bool {
+	pidData, err := os.ReadFile("./data/frpc.pid")
+	if err != nil {
+		return false
+	}
+	pid, err := strconv.Atoi(strings.TrimSpace(string(pidData)))
+	if err != nil {
+		return false
+	}
+	if runtime.GOOS == "windows" {
+		cmd := exec.Command("tasklist", "/FI", "PID eq", strconv.Itoa(pid))
+		output, err := cmd.CombinedOutput()
+		if err != nil {
+			return false
+		}
+		return strings.Contains(string(output), strconv.Itoa(pid))
+	}
+	process, err := os.FindProcess(pid)
+	if err != nil {
+		return false
+	}
+	return process.Signal(syscall.Signal(0)) == nil
+}
+
+func startLegacy() error {
+	frpcPath, err := GetFrpcPath()
+	if err != nil {
+		return err
+	}
+	if err := os.MkdirAll("./data", 0755); err != nil {
+		return err
+	}
+	if _, err := os.Stat("./data/frpc.toml"); os.IsNotExist(err) {
+		if err := GenerateConfig(); err != nil {
+			return err
+		}
+	}
+	if isRunningLegacy() {
+		return nil
+	}
+	os.Remove("./data/frpc.pid")
+	cmd := exec.Command(frpcPath, "-c", "./data/frpc.toml")
+	setWindowHide(cmd)
+	setSysProcAttr(cmd)
+	logFile, err := os.OpenFile("./data/frpc.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
+	if err != nil {
+		return err
+	}
+	cmd.Stdout = logFile
+	cmd.Stderr = logFile
+	if err := cmd.Start(); err != nil {
+		return err
+	}
+	go func() {
+		if err := cmd.Wait(); err != nil {
+			log.Printf("frpc 子进程退出: %v", err)
+		}
+		os.Remove("./data/frpc.pid")
+	}()
+	return os.WriteFile("./data/frpc.pid", []byte(strconv.Itoa(cmd.Process.Pid)), 0644)
+}
+
+func stopLegacy() error {
+	if runtime.GOOS == "windows" {
+		cmd := exec.Command("taskkill", "/F", "/IM", "frpc.exe")
+		if err := cmd.Run(); err != nil && !strings.Contains(err.Error(), "not found") {
+			return err
+		}
+		os.Remove("./data/frpc.pid")
+		return nil
+	}
+	pidData, err := os.ReadFile("./data/frpc.pid")
+	if err != nil {
+		cmd := exec.Command("pkill", "-f", "frpc")
+		if err := cmd.Run(); err != nil && !strings.Contains(err.Error(), "no process") {
+			return err
+		}
+		return nil
+	}
+	pid, _ := strconv.Atoi(strings.TrimSpace(string(pidData)))
+	process, err := os.FindProcess(pid)
+	if err != nil {
+		os.Remove("./data/frpc.pid")
+		return nil
+	}
+	if err := process.Kill(); err != nil {
+		return err
+	}
+	os.Remove("./data/frpc.pid")
+	return nil
+}
+
+func reloadLegacy() error {
+	if !isRunningLegacy() {
+		return startLegacy()
+	}
+	frpcPath, err := GetFrpcPath()
+	if err != nil {
+		return err
+	}
+	cmd := exec.Command(frpcPath, "reload", "-c", "./data/frpc.toml")
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		log.Printf("⚠️ 热加载失败 (%v)，降级为重启 frpc", err)
+		log.Printf("   reload 输出: %s", string(output))
+		if stopErr := stopLegacy(); stopErr != nil {
+			return stopErr
+		}
+		return startLegacy()
+	}
+	log.Printf("✅ frpc 热加载成功 (兼容模式): %s", string(output))
+	return nil
+}

internal/frp/log.go

@@ -0,0 +1,81 @@
+package frp
+
+import (
+	"io"
+	"os"
+	"strings"
+)
+
+// ReadTailLog 读取文件末尾 n 行
+func ReadTailLog(filePath string, n int) ([]string, error) {
+	file, err := os.Open(filePath)
+	if err != nil {
+		return nil, err
+	}
+	defer file.Close()
+
+	info, err := file.Stat()
+	if err != nil {
+		return nil, err
+	}
+	fileSize := info.Size()
+	if fileSize == 0 {
+		return []string{}, nil
+	}
+
+	const chunkSize = 4096
+	var lines []string
+	var leftover []byte
+	offset := fileSize
+
+	for len(lines) < n && offset > 0 {
+		readSize := chunkSize
+		if offset < int64(chunkSize) {
+			readSize = int(offset)
+		}
+		offset -= int64(readSize)
+
+		buf := make([]byte, readSize)
+		_, err := file.ReadAt(buf, offset)
+		if err != nil && err != io.EOF {
+			return nil, err
+		}
+
+		data := append(buf, leftover...)
+		leftover = nil
+
+		start := 0
+		for i := len(data) - 1; i >= 0; i-- {
+			if data[i] == '\n' {
+				if i+1 < len(data) {
+					line := string(data[i+1:])
+					if line != "" {
+						lines = append([]string{line}, lines...)
+						if len(lines) >= n {
+							break
+						}
+					}
+				}
+				start = i
+			}
+		}
+
+		if len(lines) < n && start > 0 {
+			leftover = data[:start]
+		}
+	}
+
+	if len(lines) < n && len(leftover) > 0 {
+		parts := strings.Split(string(leftover), "\n")
+		for i := len(parts) - 1; i >= 0; i-- {
+			if parts[i] != "" {
+				lines = append([]string{parts[i]}, lines...)
+				if len(lines) >= n {
+					break
+				}
+			}
+		}
+	}
+
+	return lines, nil
+}

internal/frp/platform_other.go

@@ -0,0 +1,13 @@
+//go:build !windows && !linux && !darwin && !freebsd && !netbsd && !openbsd && !solaris
+
+package frp
+
+import (
+	"os/exec"
+)
+
+// setWindowHide 其他平台空实现
+func setWindowHide(cmd *exec.Cmd) {}
+
+// setSysProcAttr 其他平台空实现
+func setSysProcAttr(cmd *exec.Cmd) {}

internal/frp/platform_unix.go

@@ -1,16 +1,21 @@
 //go:build linux || darwin || freebsd || netbsd || openbsd || solaris
 
-package main
+package frp
 
 import (
 	"os/exec"
 	"syscall"
 )
 
-// setSysProcAttr 为 Unix 系统设置 Setsid，让 frpc 进程脱离父进程独立运行
+// setSysProcAttr 为 Unix 系统设置 Setsid
 func setSysProcAttr(cmd *exec.Cmd) {
 	if cmd.SysProcAttr == nil {
 		cmd.SysProcAttr = &syscall.SysProcAttr{}
 	}
 	cmd.SysProcAttr.Setsid = true
 }
+
+// setWindowHide Unix 上不做任何事
+func setWindowHide(cmd *exec.Cmd) {
+	// Unix 不需要隐藏窗口
+}

internal/frp/platform_windows.go

@@ -0,0 +1,20 @@
+//go:build windows
+
+package frp
+
+import (
+	"os/exec"
+	"syscall"
+)
+
+// setWindowHide Windows 隐藏窗口
+func setWindowHide(cmd *exec.Cmd) {
+	cmd.SysProcAttr = &syscall.SysProcAttr{
+		HideWindow: true,
+	}
+}
+
+// setSysProcAttr Windows 不需要 Setpgid
+func setSysProcAttr(cmd *exec.Cmd) {
+	// Windows 不支持 Setpgid
+}

internal/frp/toml.go

@@ -1,9 +1,11 @@
-package main
+package frp
 
 import (
 	"fmt"
 	"strconv"
 	"strings"
+
+	"frpc-console/internal/db"
 )
 
 // FrpcToml 对应 frpc.toml 的完整结构
@@ -35,7 +37,7 @@ type TomlProxy struct {
 	LocalIP    string `json:"localIP"`
 	LocalPort  int    `json:"localPort"`
 	RemotePort int    `json:"remotePort"`
-	Enabled    bool   `json:"enabled"` // 导入时默认 true
+	Enabled    bool   `json:"enabled"`
 }
 
 // ParseToml 解析 frpc.toml 内容
@@ -50,7 +52,7 @@ func ParseToml(content string) (*FrpcToml, error) {
 			HeartbeatTimeout  int  `json:"heartbeatTimeout"`
 			PoolCount         int  `json:"poolCount"`
 		}{
-			TcpMux:            true, // 默认值
+			TcpMux:            true,
 			TcpMuxKeepalive:   30,
 			HeartbeatInterval: 15,
 			HeartbeatTimeout:  70,
@@ -58,7 +60,6 @@ func ParseToml(content string) (*FrpcToml, error) {
 		},
 	}
 
-	// 简单状态机解析
 	var currentProxy *TomlProxy
 	inProxies := false
 
@@ -68,7 +69,6 @@ func ParseToml(content string) (*FrpcToml, error) {
 			continue
 		}
 
-		// 检测 [[proxies]] 段开始
 		if strings.HasPrefix(line, "[[proxies]]") {
 			inProxies = true
 			currentProxy = &TomlProxy{
@@ -76,28 +76,23 @@ func ParseToml(content string) (*FrpcToml, error) {
 				Enabled: true,
 			}
 			result.Proxies = append(result.Proxies, *currentProxy)
-			// 注意：由于值传递，需要取最后一个元素的指针
 			currentProxy = &result.Proxies[len(result.Proxies)-1]
 			continue
 		}
 
-		// 检测其他段头（忽略，我们的解析器只关心具体键值对）
 		if strings.HasPrefix(line, "[") {
 			inProxies = false
 			currentProxy = nil
 			continue
 		}
 
-		// 解析键值对
 		if strings.Contains(line, "=") {
 			parts := strings.SplitN(line, "=", 2)
 			key := strings.TrimSpace(parts[0])
 			value := strings.TrimSpace(parts[1])
-			// 去掉引号
 			value = strings.Trim(value, `"`)
 
 			if inProxies && currentProxy != nil {
-				// 解析隧道字段
 				switch key {
 				case "name":
 					currentProxy.Name = value
@@ -111,7 +106,6 @@ func ParseToml(content string) (*FrpcToml, error) {
 					currentProxy.RemotePort, _ = strconv.Atoi(value)
 				}
 			} else {
-				// 解析全局字段
 				switch key {
 				case "serverAddr":
 					result.ServerAddr = value
@@ -148,9 +142,9 @@ func ParseToml(content string) (*FrpcToml, error) {
 	return result, nil
 }
 
-// ToGlobalConfig 将解析结果转换为 GlobalConfig
+// ToGlobalConfig 将解析结果转换为 db.GlobalConfig
-func (f *FrpcToml) ToGlobalConfig() *GlobalConfig {
+func (f *FrpcToml) ToGlobalConfig() *db.GlobalConfig {
-	return &GlobalConfig{
+	return &db.GlobalConfig{
 		ServerAddr:        f.ServerAddr,
 		ServerPort:        f.ServerPort,
 		Token:             f.Auth.Token,
@@ -164,17 +158,17 @@ func (f *FrpcToml) ToGlobalConfig() *GlobalConfig {
 	}
 }
 
-// ToProxies 将解析结果转换为 Proxy 列表
+// ToProxies 将解析结果转换为 db.Proxy 列表
-func (f *FrpcToml) ToProxies() []Proxy {
+func (f *FrpcToml) ToProxies() []db.Proxy {
-	var proxies []Proxy
+	var proxies []db.Proxy
 	for _, p := range f.Proxies {
-		proxies = append(proxies, Proxy{
+		proxies = append(proxies, db.Proxy{
 			Name:       p.Name,
 			Type:       p.Type,
 			LocalIP:    p.LocalIP,
 			LocalPort:  p.LocalPort,
 			RemotePort: p.RemotePort,
-			Enabled:    true, // 导入默认启用
+			Enabled:    true,
 		})
 	}
 	return proxies

internal/process/attr_linux.go

@@ -0,0 +1,14 @@
+//go:build linux
+
+package process
+
+import (
+	"os/exec"
+	"syscall"
+)
+
+func setProcessAttributes(cmd *exec.Cmd) {
+	cmd.SysProcAttr = &syscall.SysProcAttr{
+		Setpgid: true,
+	}
+}

internal/process/attr_other.go

@@ -0,0 +1,11 @@
+//go:build !linux && !windows
+
+package process
+
+import (
+	"os/exec"
+)
+
+func setProcessAttributes(cmd *exec.Cmd) {
+	// 其他平台不做特殊设置
+}

internal/process/attr_windows.go

@@ -0,0 +1,14 @@
+//go:build windows
+
+package process
+
+import (
+	"os/exec"
+	"syscall"
+)
+
+func setProcessAttributes(cmd *exec.Cmd) {
+	cmd.SysProcAttr = &syscall.SysProcAttr{
+		HideWindow: true,
+	}
+}

internal/process/lock_linux.go

@@ -0,0 +1,67 @@
+//go:build linux
+
+package process
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"time"
+
+	"golang.org/x/sys/unix"
+)
+
+// Lock 获取进程间互斥锁 (Linux: flock)
+func (pm *ProcessManager) Lock() error {
+	pm.mu.Lock()
+	defer pm.mu.Unlock()
+
+	if pm.locked {
+		return nil
+	}
+
+	lockPath := filepath.Join(pm.dataDir, LockFileName)
+	if err := os.MkdirAll(pm.dataDir, 0755); err != nil {
+		return fmt.Errorf("创建数据目录失败: %w", err)
+	}
+	file, err := os.OpenFile(lockPath, os.O_CREATE|os.O_RDWR, 0644)
+	if err != nil {
+		return fmt.Errorf("打开锁文件失败: %w", err)
+	}
+
+	start := time.Now()
+	for {
+		err := unix.Flock(int(file.Fd()), unix.LOCK_EX|unix.LOCK_NB)
+		if err == nil {
+			pm.lockFile = file
+			pm.locked = true
+			return nil
+		}
+		if err != unix.EWOULDBLOCK {
+			file.Close()
+			return fmt.Errorf("获取锁失败: %w", err)
+		}
+		if time.Since(start) > LockAcquireTimeout {
+			file.Close()
+			return fmt.Errorf("获取锁超时 (超过 %v)", LockAcquireTimeout)
+		}
+		time.Sleep(LockRetryInterval)
+	}
+}
+
+// Unlock 释放互斥锁 (Linux: flock)
+func (pm *ProcessManager) Unlock() error {
+	pm.mu.Lock()
+	defer pm.mu.Unlock()
+
+	if !pm.locked {
+		return nil
+	}
+	if pm.lockFile != nil {
+		unix.Flock(int(pm.lockFile.Fd()), unix.LOCK_UN)
+		pm.lockFile.Close()
+		pm.lockFile = nil
+	}
+	pm.locked = false
+	return nil
+}

internal/process/lock_other.go

@@ -0,0 +1,28 @@
+//go:build !linux && !windows
+
+package process
+
+// Lock 获取进程间互斥锁 (非 Linux/Windows: 内存锁)
+func (pm *ProcessManager) Lock() error {
+	pm.mu.Lock()
+	defer pm.mu.Unlock()
+
+	if pm.locked {
+		return nil
+	}
+
+	pm.locked = true
+	return nil
+}
+
+// Unlock 释放互斥锁 (非 Linux/Windows)
+func (pm *ProcessManager) Unlock() error {
+	pm.mu.Lock()
+	defer pm.mu.Unlock()
+
+	if !pm.locked {
+		return nil
+	}
+	pm.locked = false
+	return nil
+}

internal/process/lock_windows.go

@@ -0,0 +1,30 @@
+//go:build windows
+
+package process
+
+// Lock 获取进程间互斥锁 (Windows: 内存锁)
+// 注意: Windows 版本仅在同一进程内互斥，进程间不互斥
+// 如需真正的进程间锁，后续可改用 Windows Named Mutex
+func (pm *ProcessManager) Lock() error {
+	pm.mu.Lock()
+	defer pm.mu.Unlock()
+
+	if pm.locked {
+		return nil
+	}
+
+	pm.locked = true
+	return nil
+}
+
+// Unlock 释放互斥锁 (Windows)
+func (pm *ProcessManager) Unlock() error {
+	pm.mu.Lock()
+	defer pm.mu.Unlock()
+
+	if !pm.locked {
+		return nil
+	}
+	pm.locked = false
+	return nil
+}

main.go

@@ -1,46 +1,103 @@
 package main
 
 import (
+	"context"
 	"log"
+	"os"
+	"runtime"
+	"strings"
 	"time"
+
+	"frpc-console/internal/api"
+	"frpc-console/internal/db"
+	"frpc-console/internal/frp"
+	"frpc-console/internal/process"
 )
 
 func main() {
-	if err := InitDB(); err != nil {
+	log.SetFlags(log.LstdFlags | log.Lshortfile)
+
+	if err := os.MkdirAll("./data", 0755); err != nil {
+		log.Printf("⚠️ 创建 data 目录失败: %v", err)
+	}
+
+	if data, err := os.ReadFile("./data/version.ini"); err == nil {
+		version := strings.TrimSpace(string(data))
+		log.Printf("📌 版本: %s", version)
+	} else {
+		log.Printf("📌 版本: (未记录)")
+	}
+
+	if err := db.InitDB(); err != nil {
 		log.Fatal("❌ 数据库初始化失败:", err)
 	}
 
-	// 启动时生成配置并启动 frpc
+	if err := frp.GenerateConfig(); err != nil {
-	if err := GenerateFrpcConfig(); err != nil {
 		log.Println("⚠️ 生成配置文件失败:", err)
 	}
 
-	if err := StartFrpc(); err != nil {
+	// ============================================================
-		log.Println("⚠️  启动 frpc 失败:", err)
+	// 获取 frpc 二进制路径（自动处理平台差异）
+	// ============================================================
+
+	frpcPath, err := frp.GetFrpcPath()
+	if err != nil {
+		log.Printf("⚠️ 获取 frpc 路径失败: %v", err)
+		frpcPath = "./frpc"
+		if runtime.GOOS == "windows" {
+			frpcPath += ".exe"
+		}
+	}
+	log.Printf("📌 frpc 路径: %s", frpcPath)
+
+	pm := process.NewManager("./data", "./data/frpc.toml", frpcPath)
+	process.SetGlobalManager(pm)
+
+	if err := pm.LoadConfig(); err != nil {
+		log.Printf("⚠️ 加载 admin_port 配置失败: %v (将使用 PID 文件模式)", err)
+	} else {
+		log.Printf("📌 admin_port: %d", pm.AdminPort())
 	}
 
-	// ✅ 启动 Watchdog：每 30 秒检查一次 frpc 状态，挂了自动重启
+	ctx := context.Background()
-	go startWatchdog()
+	if err := pm.Start(ctx); err != nil {
+		log.Printf("⚠️ 启动 frpc 失败: %v", err)
+	} else {
+		if status, err := pm.Status(); err == nil {
+			log.Printf("✅ frpc 状态: %s", status.Phase)
+			if status.PID > 0 {
+				log.Printf("   PID: %d, 端口: %d", status.PID, status.Port)
+			}
+		}
+	}
 
-	r := SetupRouter()
+	go startWatchdog(pm)
+
+	router := api.SetupRouter()
 	log.Println("🚀 frpc-console 启动成功！")
 	log.Println("📍 访问地址: http://localhost:9300")
 	log.Println("📍 API 地址: http://localhost:9300/api")
 
-	if err := r.Run(":9300"); err != nil {
+	if err := router.Run(":9300"); err != nil {
 		log.Fatal("❌ 服务启动失败:", err)
 	}
 }
 
-// Watchdog 协程：定期检查 frpc 是否存活
+func startWatchdog(pm *process.ProcessManager) {
-func startWatchdog() {
 	ticker := time.NewTicker(30 * time.Second)
 	defer ticker.Stop()
 
 	for range ticker.C {
-		if !isFrpcRunning() {
+		status, err := pm.Status()
-			log.Println("⚠️  frpc 进程已停止，自动重启...")
+		if err != nil {
-			if err := StartFrpc(); err != nil {
+			log.Printf("⚠️ 检查 frpc 状态失败: %v", err)
+			continue
+		}
+
+		if status.Phase != "RUNNING" {
+			log.Printf("⚠️ frpc 进程已停止 (状态: %s)，自动重启...", status.Phase)
+			ctx := context.Background()
+			if err := pm.Start(ctx); err != nil {
 				log.Printf("❌ 自动重启 frpc 失败: %v", err)
 			} else {
 				log.Println("✅ frpc 已自动重启")

readme.md

@@ -1,318 +1,60 @@
 <p align="center">
-  <img src="static/logo.svg" alt="frpc-console" width="360" />
+  <img src="internal/api/static/logo.svg" alt="frpc-console" width="360" />
 </p>
 
-
 # frpc-console
 
-> 轻量级 frpc 管理面板 —— 为你的内网穿透插上翅膀
-
 [![Release](https://img.shields.io/gitea/v/release/lxh2875931338/frpc-console?gitea_url=https://git.whitetop.xyz)](https://git.whitetop.xyz/lxh2875931338/frpc-console/releases)
 [![Go Version](https://img.shields.io/badge/Go-1.21+-00ADD8?style=flat&logo=go)](https://golang.org/)
 [![License](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
 
+**专为超长期frpc部署而设计。**
+
+一个基于实际工程实践而构建的——轻量级生命周期控制台。
+
+同时也是一个为边缘环境设计的、自包含的、具备发行版级更新策略的 frp 运维基础设施
+
+**安装一次。配置一次。然后——忘记它。**
+
 ---
 
-## 📖 简介
+## 📖 文档索引
+| 目录 | 简要说明 |
+|---|---|
+| [📖 工程设计哲学](./Docs/engineering-philosophy.md) | 为什么它会长成今天这样 |
+| [🏗 架构设计](./Docs/architecture.md)  | 整体架构设计思路 |
+| [🚀 部署引擎设计](./Docs/deployment-engine-design.md)  | deploy 的完整架构设计 |
+| [🌐 边缘节点](./Docs/edge-node.md)  | 为什么支持 BusyBox、ARMHF |
+| [🔄 更新策略](./Docs/update-strategy.md)  | Preview / LTS |
+| [⚙ 设计决策](./Docs/design-decisions.md)  | 为什么没有 CI？为什么叫 Console？ |
 
-**frpc-console** 是一个专为 [frp](https://github.com/fatedier/frp) 设计的轻量级管理工具。本项目旨在以无限接近原生占用的情况下，实现完全图形化的控制工具（毕竟 WebUI 也算图形化，对吧？）
+---
 
-### ✨ 核心特性
+> *“最好的基础设施工具，是当你部署完毕、配置妥当之后，便几乎感觉不到它还在运行的那一个。”*
 
-- 🔐 **首次启动引导** —— Web 端完成管理员注册，无需 CLI 交互
+如果想了解这句话背后的设计思考：
-- 📋 **隧道全生命周期管理** —— 增删改查 + 一键启用/禁用
+
-- 📦 **导入/导出 TOML** —— 无缝迁移现有 frpc 配置
+📖 阅读[《工程设计哲学》→](./Docs/engineering-philosophy.md) 
-- 🔄 **配置热加载** —— 修改即生效，无需重启 frpc
-- 🖥️ **多平台支持** —— Windows / Linux / ARM 全平台兼容
-- 🐳 **容器化就绪** —— 提供 Docker 镜像，开箱即用
-- 🎨 **深色磨砂玻璃 UI** —— 现代化视觉体验，日夜皆宜
 
 ---
 
 ## 🚀 快速开始
 
-### 🐧 二进制安装（推荐）
+选择适合您环境的部署方法：
 
-适用于 Linux / Windows，无需 Docker，单文件运行。
+- [二进制安装指南](./Docs/install_binary.md)
+- [Docker 安装指南](./Docs/install_docker.md)
 
-👉 详见：[二进制安装指南](./INSTALL_BINARY.md)
+首次访问：
 
-### 🐳 Docker 部署（一键脚本）
+1. 注册管理员账户。
+2. 导入你的 `frpc.toml`。
 
-适用于 Linux 服务器，自动编译 + 自动部署。
+然后——
 
-```bash
+**忘记它。**
-curl -sSL https://git.whitetop.xyz/lxh2875931338/frpc-console/raw/main/deploy.sh | sudo bash
-```
-
-👉 详见：[Docker 安装指南](./INSTALL_DOCKER.md)
-
-### 🔧 源码编译
-
-适合开发者或需要自定义配置的用户。
-
-```bash
-git clone https://git.whitetop.xyz/lxh2875931338/frpc-console.git
-cd frpc-console
-go mod tidy
-go build -o frpc-console .
-./frpc-console
-```
-
-首次访问 `http://localhost:9300` 注册管理员账户，然后导入你的 `frpc.toml` 即可开始使用。
 
 ---
 
-## 🗂️ 项目结构
+[**MIT License © 2026 lxh2875931338（XHLiang0）**](./License.md) · [GitHub](https://github.com/XHLiang0) · [致谢](./Docs/acknowledgment.md) · [更新日志](update-logs.md)
-```txt
-frpc-console/
-├── main.go                   # 入口
-├── api.go                    # HTTP 路由 & Handler
-├── db.go                     # SQLite 数据库操作
-├── auth.go                   # JWT 认证 & 密码管理
-├── frp.go                    # frpc 管理核心逻辑
-├── toml_parser.go            # TOML 解析器
-├── static/                   # 前端静态资源
-│   ├── index.html
-│   ├── app.js
-│   ├── style-1.css           # 全局基础样式
-│   ├── style-2.css           # 登录页样式
-│   ├── style-3.css           # 主界面样式
-    └── style-4.css
-├── bin/                      # 内嵌 frpc 二进制 (多平台)
-│   ├── frpc_windows_amd64.exe
-│   ├── frpc_linux_amd64
-│   ├── frpc_linux_arm64
-│   └── frpc_linux_arm_hf
-├── frpc.tmpl            # frpc 配置模板
-├── Dockerfile
-└── go.mod
-```
 
-## ⚙️ 配置说明
-
-### 环境变量
-
-| 变量 | 说明 | 默认值 |
-|---|---|---|
-| PORT | 监听端口 | 9300 |
-
-
-### 数据存储
-
-· 数据库文件：./frpc-console.db</br>
-· frpc 配置文件：./frpc.toml</br>
-· frpc 日志文件：./frpc.log</br>
-
----
-
-## 🛠️ 开发指南
-
-```bash
-# 克隆项目
-git clone https://github.com/lxh2875931338/frpc-console.git
-cd frpc-console
-
-# 安装依赖
-go mod tidy
-
-# 开发模式运行
-go run .
-
-# 编译生产版本
-go build -ldflags="-s -w" -o frpc-console .
-```
-
-## 前端开发
-
-前端使用 Vue 3 CDN + Naive UI，无需额外构建工具。修改 static/ 目录下的文件后，刷新浏览器即可预览效果。
-
-
----
-
-## 🔧 常见问题
-
-#### Q: 如何修改管理员密码？
-
-登录后，在「全局配置」页面顶部找到「账户管理」区域，输入当前密码和新密码即可。
-
-#### Q: 如何导入现有的 frpc.toml？
-
-在「隧道列表」页面点击「导入 TOML」，选择你的 frpc.toml 文件即可。
-
-#### Q: frpc 启动失败怎么办？
-
-如果是首次启动，console 会自动生成一份符合官方规范的 `frps.toml` 配置文件，通常不需要额外操作。
-
-如果在使用过程中遇到启动失败，可以按以下步骤排查：
-
-1. **检查配置是否正确** —— 在「全局配置」页面重新配置一次服务端参数，或导入已有的 `frpc.toml` 配置文件，console 会自动应用并尝试重启
-2. **查看日志定位问题** —— 若上述操作后仍然失败，请查看 `./frpc.log` 日志文件，定位具体报错原因
-
-> 日志文件的位置：与 `frpc-console` 二进制同级目录下的 `frpc.log`。Docker 部署时，可通过 `docker logs frpc-console` 查看容器输出。
-
-#### Q: 支持哪些 frp 版本？
-
-目前支持情况如下：
-
-| 系统 | 架构版本 | 版本号 |
-|---|---|---|
-| Linux | AMD64/x86-64 | 0.70.0 |
-| Linux | ARM64/Aarch64 | 0.70.0 |
-| Linux | ARM_hf/ARMv7l | 0.70.0 |
-| Windows | AMD64/x86-64 | 0.70.0 |
-
-> 行了行了，Windows 版和 Linux 版版本号已同步。不用再等了。
-
-#### Q: 为什么不用 / 不推荐 Podux？
-
-Podux 是个好项目，理念上和我们是一致的：用 Web 界面管理 frpc</br>
-但它的设计取向和我们完全不同：
-
-| 对比项 | frpc-console | Podux |
-|---|---|---|
-| 数据库 | SQLite（单文件，几 MB） | PocketBase（带 Admin UI、用户系统、全套 API） |
-| 前端 | Vue CDN | React + Webpack |
-| 实机内存占用 | **~50 MB** | **没启动成功，1GB RAM 独立分配仍 OOM（原因不明）** |
-| 镜像大小 | 封装多平台二进制frpc后 120.28 MB | 76.1 MB |
-| 部署方式 | 单二进制 / Docker | 单二进制 / Docker |
-| 多平台支持 | ✅ 原生交叉编译 | ✅ 原生交叉编译 |
-
-> Podux 与其说是一个 frp 控制面板，不如说是一个“一站式 frp 管理器 + 可视化数据流面板 + 通道保活监测工具”。这种一站式本身没毛病，甚至功能实现非常到位。</br>但 podux的框架选型有点重，而且很明显细节稍显仓促。PocketBase 自带 WebUI 的情况下，Podux 还要再包一层 WebUI——相当于给数据库的 UI 又套了个 UI。更费解的是，这层 WebUI 只支持导入，不支持导出。这设计确实让人有点摸不着头脑啦……</br>所以干脆换了一套轻量化工具自己上咯~
-
-
-### Q: 为什么不直接用 frp 官方提供的 web 界面？
-
-frp 官方确实提供了 `dashboard` 和 `frpc-admin` 功能，但它们更多是“监控”视角，而非“管理”视角。你需要手动编辑配置文件，重启 frpc，或者依赖命令行操作。
-
-frpc-console 的目标是：
-- **点一点就能新增隧道**
-- **开关一拨就能启用/禁用**
-- **导入导出无缝迁移**
-- **热加载无需重启**
-
-### Q: 如果 frpc-console 进程挂了，frpc 本身会受影响吗？
-
-**不会。**
-
-这是 frp-console 系列工具与同类项目最核心的区别之一。我们称之为 **“阴阳模式”**。</br>
-接下来，我们将结合中式哲学思想，阐述这个名称的由来：
-
-#### 什么是“阴阳模式”？
-
-以人的观察为出发点：
-
-- **阴**：看不见的业务流（frpc 进程、toml 配置文件、隧道连接）
-- **阳**：看得见的管理面板（Web 界面、API 服务）
-
-大多数管理工具走的是 **“阳阴模式”**：面板是“大脑”，业务是“肢体”。大脑一旦停止工作，肢体也就瘫痪了。</br>
-在这种模式下，管理面板与业务进程深度绑定，面板退出时业务进程也会随之终止。
-
-**frpc-console 走的是“阴阳模式”：业务是根基，面板是工具。**
-
-- **阴主导阳**：业务不依赖面板存活，面板只是用来观察和调整业务状态的手段
-- **阳依附于阴**：面板的存在是为了服务业务，而不是反过来
-
-
-#### 不同部署方式下的行为
-
-**二进制部署：**
-
-frpc-console 启动时，会以子进程的方式拉起 frpc，并为它创建一个独立的进程会话（`Setsid`）。这意味着 frpc 完全脱离父进程的生命周期控制。即使 SSH 断开导致 frpc-console 进程退出，frpc 也会被系统的 init 进程（PID 1）接管，继续在后台稳定运行。配置文件（`frpc.toml`）是持久化文件，不依赖 console 进程存活。面板可以随时挂、随时重启、随时升级，但隧道业务不受任何干扰。
-
-**Docker 部署：**
-
-容器使用 `--restart=always` 策略，frpc-console 进程意外退出时，Docker 守护进程会自动重启整个容器。重启后，console 重新读取持久化的 `frpc.toml`，重新拉起 frpc 子进程。数据目录（`/opt/frpc-console/data`）通过卷挂载持久化，容器重启不会丢失任何配置。Docker 模式的本质依然是“阳辅助阴”——`restart:always` 的目的是确保阴（业务）持续运行，而不是为了保住阳（面板）本身。
-
-
-#### 为什么同类项目里很少见到这种设计？
-
-因为大多数管理工具把“面板”和“业务”耦合在一起，认为面板是前提条件，业务是附属品。当然了，这确实是正向的、符合直觉的设计方向。但是有一个被很多人忽略的事实：**真正需要长期稳定运行的是隧道本身，而不是管理界面的进程。**
-
-界面是用来观察和调整的，不是用来维持业务存活的。这是运维集群常用的“管理面与控制面分离”——只不过通常只在几千台服务器的集群管理里才会出现，很少有人会把它用在一个人用的 frp 管理工具上。
-
-
-#### 核心原则
-
-console 只做“配置的保管者”和“进程的启动者”，而不是“配置的持有者”或“进程的绑定者”。即使 console 完全离线，已经生成的 `frpc.toml` 依然存在，frpc 进程依然可以独立运行。这是 frp 本身的容灾能力在管理工具层面的自然延伸——**可视化框架只是工具，业务本身才是核心。**
-
-> **管理面板可以丢，业务功能打死不能停。**
-
-### Q: 支持 frp 的所有功能吗？
-
-frpc-console 覆盖了 frp 最核心的 **TCP 隧道管理** 功能，包括 `tcpMux`、负载均衡、心跳配置等。如果你有更复杂的需求（比如 STCP、XTCP、P2P），欢迎提 issue，我们会评估是否加入。
-
----
-
-## 🧠 设计哲学
-
-frpc-console 遵循 **“够用就好”** 的原则：
-
-1. **frp 是轻量工具，管理工具也应该是轻量的。**
-2. **能用 SQLite 就不用 PostgreSQL，能用 Vue CDN 就不用 React 全家桶。**
-3. **前端能做的事，后端不加额外复杂度。**
-4. **删掉一个容器等于删掉所有垃圾，所以用 Docker 隔离是对的。**
-5. **面板的存在应该是为了服务业务的，而不该是反过来主导业务的。**
-
----
-
-## 📝 更新日志
-
-### 2.0-LTS （2026-07-28）正式发布
-
-> 本次 LTS 版本聚焦于**稳定性兜底与协议能力对齐**，是 frp 0.70.0 LTS 的下游管理工具。
-
-· 🚀 **frp v2 协议正式启用** —— `wireProtocol = "v2"` 配置项可用，灰标状态解除，实测稳定</br>
-· 🔒 **数据库迁移引擎完整实现** —— 版本驱动的增量迁移 + 迁移前自动全量备份 + 失败可回滚，升级不再提心吊胆</br>
-· 🧩 **配套工具 frps-console 同步发布** —— 同一套设计哲学，一个管理 frpc，一个管理 frps，版本号同步，LTS 同步
-
-
-### 1.5-Release (2026-07-25)（non-LTS）
-
-> 本次更新聚焦于**WebUI 交互体验与基础工程能力**，为 2.0 LTS 铺路。
-
-· ✨ **全局配置页面卡片式重构** —— 按“服务器连接 / 传输配置 / 日志配置”分组，告别折叠面板</br>
-· ✨ **新增运行日志面板** —— WebUI 内实时查看 frpc 日志，8 秒自动轮询，最大 200 行，调试方便不少</br>
-· ✨ **frp v2 配置占位** —— UI 开关已就绪（灰标禁用），为 2.0 的正式启用做好铺垫</br>
-· 🔩 **数据库 Schema 迁移框架** —— 启动时自动检测并补全缺失列，升级不再依赖手动改表（2.0 在此基础上升级为完整备份 + 回滚）</br>
-· 🔐 **默认配置脱敏** —— 移除个人服务端地址与令牌，改为通用占位符，避免开箱即连别人的服务器</br>
-· 🎨 **样式拆分与优化** —— 按职责拆分为多个 CSS 文件，维护更清晰
-
-
-### 1.0-Release (2026-07-24)（non-LTS）
-
-> 首次发布，核心功能全部就绪。
-
-· 🎉 **首次发布**</br>
-· 📋 **隧道全生命周期管理** —— 增删改查 + 一键启用/禁用</br>
-· 📦 **TOML 导入/导出** —— 无缝迁移现有 frpc 配置</br>
-· 🔄 **配置热加载** —— 修改即生效，无需重启 frpc</br>
-· 🔐 **首次启动 Web 注册** —— 无需命令行交互</br>
-· 🖥️ **多平台支持** —— Windows / Linux / ARM 全平台兼容</br>
-· 🐳 **容器化就绪** —— Docker 镜像，开箱即用</br>
-· 🎨 **深色磨砂玻璃 UI** —— 现代化视觉体验</br>
-
----
-
-## 📄 许可证
-
-MIT License © 2026 lxh2875931338（XHLiang0）
-
----
-
-## 🙏 相关项目援引
-
-### FRP 生态互补工具
-
-· [MoonProxy](https://github.com/MoonProxyHQ/moonproxy-desktop) —— 基于 Tauri v2 + Vue 3 + Rust 构建的跨平台 FRP 桌面客户端（frpc GUI），面向 macOS 与 Windows，让内网穿透开箱即用，MIT协议开源。
-
-### FRP 生态同类工具（暂无互引）
-</br>
-
----
-
-## 🙏 致谢
-
-· fatedier/frp —— 强大的内网穿透工具</br>
-· gin-gonic/gin —— 高性能 Go Web 框架</br>
-· vuejs/vue —— 渐进式 JavaScript 框架

run-deploy.sh

@@ -0,0 +1,115 @@
+#!/bin/bash
+
+# ============================================================
+# frpc-console 部署入口（前置引导脚本）
+# 此脚本固定在 main 分支，永不变化。
+# 职责：引导用户选择通道，拉取对应分支的 deploy.sh 并执行
+# 
+# 用法:
+#   curl -sSL https://git.whitetop.xyz/.../run-deploy.sh | sudo bash
+#   curl -sSL https://git.whitetop.xyz/.../run-deploy.sh | sudo bash -s -- --channel preview
+# ============================================================
+
+set -e
+
+if [ -t 1 ]; then
+    RED='\033[0;31m'; GREEN='\033[0;32m'; YELLOW='\033[1;33m'
+    BLUE='\033[0;34m'; CYAN='\033[0;36m'; MAGENTA='\033[0;35m'; NC='\033[0m'
+else
+    RED=''; GREEN=''; YELLOW=''; BLUE=''; CYAN=''; MAGENTA=''; NC=''
+fi
+
+print_info() { echo -e "${BLUE}[INFO]${NC} $1"; }
+print_error() { echo -e "${RED}[✗]${NC} $1"; }
+
+REPO_URL="https://git.whitetop.xyz/lxh2875931338/frpc-console.git"
+WORK_DIR="/tmp/frpc-console-deploy"
+CHANNEL=""
+BRANCH=""
+
+parse_args() {
+    for arg in "$@"; do
+        case $arg in
+            --channel)
+                shift; CHANNEL="$1"
+                ;;
+            --channel=*)
+                CHANNEL="${arg#*=}"
+                ;;
+            --help|-h)
+                echo "用法: curl .../run-deploy.sh | sudo bash -s -- [选项]"
+                echo ""
+                echo "选项:"
+                echo "  --channel lts       使用 LTS 通道 (main 分支)"
+                echo "  --channel preview   使用 Preview 通道 (test 分支)"
+                echo "  --help, -h          显示帮助信息"
+                exit 0
+                ;;
+            *)
+                print_error "未知选项: $arg"
+                echo "使用 --help 查看帮助"
+                exit 1
+                ;;
+        esac
+    done
+}
+
+select_channel() {
+    if [ -n "$CHANNEL" ]; then
+        if [ "$CHANNEL" != "lts" ] && [ "$CHANNEL" != "preview" ]; then
+            print_error "无效通道: $CHANNEL (仅支持 lts / preview)"
+            exit 1
+        fi
+        BRANCH="$([ "$CHANNEL" = "preview" ] && echo "test" || echo "main")"
+        print_info "使用命令行参数: ${CHANNEL} 通道 (${BRANCH} 分支)"
+        return
+    fi
+
+    echo ""
+    echo -e "${CYAN}请选择部署通道:${NC}"
+    echo "  1. LTS (稳定版，生产推荐) [默认] → main 分支"
+    echo "  2. Preview (技术预览版，包含新特性) → test 分支"
+    echo ""
+    read -p "请选择 [1]: " CHANNEL_INPUT </dev/tty
+    CHANNEL_INPUT=${CHANNEL_INPUT:-1}
+    case $CHANNEL_INPUT in
+        1|"") CHANNEL="lts"; BRANCH="main" ;;
+        2) CHANNEL="preview"; BRANCH="test" ;;
+        *) print_error "无效选择"; exit 1 ;;
+    esac
+    print_info "已选择: ${CHANNEL} 通道 (${BRANCH} 分支)"
+}
+
+fetch_and_run() {
+    local deploy_url="https://git.whitetop.xyz/lxh2875931338/frpc-console/raw/${BRANCH}/deploy.sh"
+    echo ""
+    echo -e "${CYAN}▶ 从 ${BRANCH} 分支拉取 deploy.sh...${NC}"
+    rm -rf "$WORK_DIR"
+    mkdir -p "$WORK_DIR"
+    cd "$WORK_DIR"
+    if ! curl -sSL -o deploy.sh "$deploy_url"; then
+        print_error "无法下载 deploy.sh: $deploy_url"
+        exit 1
+    fi
+    chmod +x deploy.sh
+    echo -e "${GREEN}[✓] deploy.sh 已拉取${NC}"
+    echo ""
+    echo -e "${CYAN}▶ 执行部署脚本...${NC}"
+    echo ""
+    export DEPLOY_CHANNEL="$CHANNEL"
+    export DEPLOY_BRANCH="$BRANCH"
+    exec ./deploy.sh "$@"
+}
+
+main() {
+    clear 2>/dev/null || true
+    echo -e "${MAGENTA}════════════════════════════════════════════════════════${NC}"
+    echo -e "${MAGENTA}  frpc-console 部署入口${NC}"
+    echo -e "${MAGENTA}════════════════════════════════════════════════════════${NC}"
+    echo ""
+    parse_args "$@"
+    select_channel
+    fetch_and_run "$@"
+}
+
+main "$@"

script/build.go

@@ -9,6 +9,7 @@ import (
 	"os/exec"
 	"path/filepath"
 	"strings"
+	"time"
 )
 
 type Platform struct {
@@ -22,15 +23,87 @@ var platforms = []Platform{
 	{"windows", "amd64", "Windows x86-64", ".exe"},
 	{"linux", "amd64", "Linux x86-64", ""},
 	{"linux", "arm64", "Linux ARM64", ""},
-	{"linux", "arm", "Linux ARMv7l", ""}, // GOARCH=arm, GOARM=7
+	{"linux", "arm", "Linux ARMv7l", ""},
 }
 
 const (
-	Version   = "2.0.0"
+	BuildTime = "2026-07-29"
-	BuildTime = "2026-07-26"
 	Binary    = "frpc-console"
 )
 
+// ============================================================
+// 版本管理核心
+// ============================================================
+
+func readVersion() (semver string, ltsDate string) {
+	data, err := os.ReadFile("./version.ini")
+	if err != nil {
+		return "0.0.0", ""
+	}
+	lines := strings.Split(string(data), "\n")
+	var content string
+	for _, line := range lines {
+		line = strings.TrimSpace(line)
+		if line == "" || strings.HasPrefix(line, ";") || strings.HasPrefix(line, "#") {
+			continue
+		}
+		content = line
+		break
+	}
+	parts := strings.Fields(content)
+	if len(parts) < 1 {
+		return "0.0.0", ""
+	}
+	semver = parts[0]
+	if len(parts) > 1 {
+		ltsDate = parts[1]
+	}
+	return semver, ltsDate
+}
+
+func getVersionType(semver string) string {
+	parts := strings.Split(semver, ".")
+	if len(parts) < 2 {
+		return "preview"
+	}
+	minor := parts[1]
+	if minor == "0" || minor == "5" {
+		return "lts"
+	}
+	return "preview"
+}
+
+func getFullVersion() string {
+	semver, ltsDate := readVersion()
+	vType := getVersionType(semver)
+
+	switch vType {
+	case "lts":
+		if ltsDate == "" {
+			ltsDate = time.Now().Format("20060102")
+		}
+		return semver + "-lts-" + ltsDate
+	default:
+		timestamp := time.Now().Format("20060102-150405")
+		return semver + "-preview-" + timestamp
+	}
+}
+
+func getImageTag() string {
+	semver, ltsDate := readVersion()
+	vType := getVersionType(semver)
+
+	switch vType {
+	case "lts":
+		if ltsDate == "" {
+			ltsDate = time.Now().Format("20060102")
+		}
+		return semver + "-lts-" + ltsDate
+	default:
+		return "preview-" + time.Now().Format("20060102-150405")
+	}
+}
+
 func main() {
 	if len(os.Args) > 1 {
 		target := os.Args[1]
@@ -44,6 +117,12 @@ func main() {
 		case "list":
 			listPlatforms()
 			return
+		case "version":
+			fmt.Println(getFullVersion())
+			return
+		case "image-tag":
+			fmt.Println(getImageTag())
+			return
 		}
 		for _, p := range platforms {
 			if target == p.OS+"/"+p.Arch {
@@ -52,8 +131,8 @@ func main() {
 			}
 		}
 		fmt.Println("❌ 不支持的平台:", target)
-		fmt.Println("   可用: windows/amd64, linux/amd64, linux/arm64, linux/armv7")
+		fmt.Println("   可用: windows/amd64, linux/amd64, linux/arm64, linux/arm")
-		fmt.Println("   或: all, list, clean")
+		fmt.Println("   或: all, list, clean, version, image-tag")
 		return
 	}
 	interactiveMenu()
@@ -68,15 +147,19 @@ func listPlatforms() {
 
 func interactiveMenu() {
 	fmt.Println("========================================")
-	fmt.Println("  frpc-console 多平台构建工具 v" + Version)
+	fmt.Println("  frpc-console 多平台构建工具")
 	fmt.Println("========================================")
 	fmt.Println()
+	fmt.Println("  当前版本:", getFullVersion())
+	fmt.Println("  镜像标签:", getImageTag())
+	fmt.Println()
 
 	for i, p := range platforms {
 		fmt.Printf("  %d. %s (%s/%s)\n", i+1, p.Name, p.OS, p.Arch)
 	}
 	fmt.Println("  a. 全部构建")
 	fmt.Println("  c. 清理构建产物")
+	fmt.Println("  v. 显示版本信息")
 	fmt.Println("  q. 退出")
 	fmt.Println()
 
@@ -96,6 +179,10 @@ func interactiveMenu() {
 	case "a":
 		buildAll()
 		return
+	case "v":
+		fmt.Println("版本:", getFullVersion())
+		fmt.Println("镜像标签:", getImageTag())
+		return
 	default:
 		var idx int
 		if n, err := fmt.Sscanf(input, "%d", &idx); n == 1 && err == nil && idx >= 1 && idx <= len(platforms) {
@@ -125,16 +212,22 @@ func build(p Platform, silent bool) {
 		return
 	}
 
-	// 构建输出文件名
+	fullVersion := getFullVersion()
+	imageTag := getImageTag()
+
 	outName := Binary + "-" + p.OS + "-" + p.Arch
 	if p.Arch == "arm" {
-		outName += "v7" // 标注 ARMv7 版本
+		outName += "v7"
 	}
 	outName += p.Ext
 	outPath := filepath.Join(outDir, outName)
 
 	cmd := exec.Command("go", "build",
-		"-ldflags=-s -w -X main.version="+Version,
+		"-ldflags="+
+			"-s -w "+
+			"-X main.buildVersion="+fullVersion+" "+
+			"-X main.buildImageTag="+imageTag+" "+
+			"-X main.buildTime="+BuildTime,
 		"-o", outPath,
 		".",
 	)
@@ -144,7 +237,6 @@ func build(p Platform, silent bool) {
 		"CGO_ENABLED=0",
 	)
 
-	// ARM 架构指定 GOARM=7
 	if p.Arch == "arm" {
 		cmd.Env = append(cmd.Env, "GOARM=7")
 	}
@@ -159,6 +251,7 @@ func build(p Platform, silent bool) {
 
 	if !silent {
 		fmt.Printf("✅ 构建完成: %s\n", outPath)
+		fmt.Printf("   版本: %s\n", fullVersion)
 		if info, err := os.Stat(outPath); err == nil {
 			size := float64(info.Size()) / 1024 / 1024
 			fmt.Printf("   📦 %.2f MB\n", size)

update-logs.md

@@ -0,0 +1,222 @@
+## 📌 版本说明
+
+| 版本类型 | 标记 | 适用场景 |
+|----------|------|----------|
+| LTS 正式版 | `-lts` | 生产环境，长期维护 |
+| 技术预览版 | `-preview` | 功能前瞻，建议测试环境验证 |
+
+## 2.7-Preview (2026-08-11)（main下前置技术预览版）
+
+> **重大功能更新修复版 —— 架构升级与部署流程重构**
+>
+> 本次版本为 **非正统 LTS 版本**（2.7 在语义版本中不属于 LTS 序列），因 `main` 分支在部分场景下存在功能异常与进程管理问题而发布。
+>
+> 此版本已进行长时间测试，暂无重大功能异常。 **3.0-lts 将回归正常语义版本规则。**
+
+本次LTS的核心是 **ProcessManager 进程管理模块重构**，将 frpc 的管理方式从“基于 PID 文件的简单函数集”升级为“带状态机、冲突检测、健康检查、自动恢复的完整生命周期控制器”。这是 frpc-console 从“frpc 启动器”向“frpc 生命周期控制器”演进的关键版本。
+
+### 核心变更
+
+- **进程管理模块独立** —— 新增 `internal/process` 包，将进程管理逻辑从 `frp.go` 中抽离为独立模块，包含状态机、互斥锁、进程属性、实例归属检测等子模块，为长期维护和扩展奠定基础
+
+- **状态机驱动生命周期管理** —— 从“PID 文件存在即运行”的隐式状态升级为 8 种显式状态（UNKNOWN / STARTING / RUNNING / DEGRADED / CONFLICT / FAILED / STOPPING / STOPPED），状态转换由检测结果驱动，状态语义清晰可追溯
+
+- **三级健康检查体系** —— 建立 Process Health（PID 存活）+ Admin Health（端口可访问 + 归属验证）+ Service Health（代理 running）的递进式健康检查，不同层级失败对应不同恢复策略
+
+- **FRPReady 绑定 PID** —— `FRPReady` 检测从全局状态改为绑定具体 PID，通过 admin API 读取代理状态确认服务就绪，避免旧实例状态干扰新实例判断
+
+- **实例归属检测与 CONFLICT 状态** —— `DetectFrpcInstances()` 通过 PID + ExecPath + CmdLine 三重确认识别系统内所有 frpc 进程，区分 Owned/Unknown 实例，冲突时保留 Owned 实例、清理 Unknown 实例，新增 CONFLICT 状态承载冲突场景
+
+- **RELOADING 中间态** —— Reload 操作期间状态机进入 RELOADING 中间态，看门狗和健康检查在此期间跳过恢复动作，彻底解决 reload 导致旧 PID 消失被误判为 FAILED 的竞态问题
+
+- **启动超时逻辑修正** —— 超时判断仅对 STARTING 状态生效，已进入 RUNNING 的进程不再受超时影响，解决了长期运行后每 30 秒触发一次超时误判的问题
+
+- **端口检测升级为归属验证** —— `CheckPort()` 从仅返回 bool 升级为返回 PortCheckResult（Ready + Err + PID + Process），支持端口归属验证，端口被占用但 PID 不一致时触发 CONFLICT 状态
+
+- **孤儿进程与僵尸进程防护** —— 启动前自动清理孤儿进程（端口被占用但无有效 PID）；启动后通过 goroutine 调用 `cmd.Wait()` 回收子进程，防止 frpc 退出后变成僵尸进程堆积
+
+- **进程互斥锁** —— Linux 使用 `flock` 实现进程间互斥锁，Windows 使用内存锁，防止并发启动/停止操作产生竞态条件
+
+- **看门狗升级为智能恢复** —— 每 30 秒检查完整状态，根据 Phase 执行差异化恢复策略（CONFLICT → 清理 Unknown 实例；DEGRADED → 重启；FAILED → 自动重启；RELOADING → 跳过检查）
+
+### 模块化重构
+
+- **代码结构模块化** —— 将单体结构拆分为 `internal/process`、`internal/frp`、`internal/db`、`internal/auth`、`internal/api` 等独立模块，模块边界清晰，为后续 3.0 控制器架构铺路
+
+- **frp 模块拆分** —— 原 `frp.go` 拆分为 `binary.go`（二进制提取）、`config.go`（模板渲染）、`legacy.go`（兼容层）、`toml.go`（TOML 解析），职责单一，便于维护
+
+- **数据库 Schema v3 升级** —— 新增 `admin_port` 字段，默认 7400，采用重型迁移策略（建新表 → 迁移数据 → 交换表名）替代 ALTER TABLE，确保数据一致性；v2→v3 迁移自动完成，无需用户干预
+
+### UI 优化
+
+- **配置页面新增 admin_port 输入框** —— 用户可自定义 frpc admin 端口，默认 7400，保存后自动写入 `frpc.toml` 的 `[webServer]` 段
+
+- **前端状态适配** —— 前端 `getFrpcStatus()` 从检查 `state` 字段升级为检查 `phase === "RUNNING"`，与后端状态机对齐
+
+### 部署变更
+
+- **Docker 镜像加速自动配置** —— `deploy.sh` 自动检测 Docker daemon 的 registry-mirrors 配置，检测用户配置和默认地址连通性，按需写入可用镜像源，自动重启 Docker 应用配置
+
+- **frpc 二进制提取路径统一** —— 从 embed 提取的 frpc 二进制统一放到程序同层目录（`./frpc`），不再写入 `./data/` 持久化目录，避免污染数据目录
+
+- **日志路径统一** —— frpc 日志从根目录 `./frpc.log` 迁移至 `./data/frpc.log`，与数据库、配置文件、PID 文件统一存放，前后端路径一致
+
+### 修复
+
+- 修复 reload 触发 `STARTING → FAILED` 导致旧实例被误杀的问题
+- 修复 `startTime` 长期运行后每 30 秒触发启动超时误判的问题
+- 修复 `FRPReady` 检测到旧实例状态导致新实例误判为 RUNNING 的问题
+- 修复 `CheckPort()` 在容器环境下返回 PID=0 导致端口归属验证失效的问题
+- 修复 2.5-lts 升级到 2.7-preview 时 `admin_port` 字段缺失导致热加载失败的问题
+- 修复 Windows 编译后 `./data/frpc` 路径与 `frpc_windows_amd64.exe` 不一致的问题
+
+### 已知问题
+
+- `work connection pool is full` 在瞬时并发高峰时偶发，已通过 `poolCount` 从 8 调整为 10 缓解，持续观察中
+- Preview 通道尚未经过长期稳定性测试，生产环境请使用 LTS 通道
+
+### 升级说明
+
+- 从 2.5-lts 升级时，数据库 Schema 自动从 v2 迁移至 v3，`admin_port` 默认值为 7400，无需手动操作
+- `frpc.toml` 中 `[webServer]` 段格式需从 `addr = "127.0.0.1:7400"` 调整为 `addr = "127.0.0.1"` + `port = 7400`，新部署自动适配，旧部署升级时模板自动覆盖
+- 建议升级前备份 `./data/` 目录，确保回退路径可用
+
+**版本定位：** 2.7-preview 是一个技术预览版，核心目标是验证 ProcessManager 状态机在真实环境中的稳定性和准确性。虽然 P0 级问题已修复，但建议在测试环境中充分验证后再考虑生产部署。
+
+---
+
+## 2.5-lts (2026-08-03)
+
+> **稳定加固版 —— 架构升级与部署流程闭环**
+
+### 核心变更
+
+- 数据目录规范化 —— 所有运行时文件统一迁移至 `/app/data`，挂载点从 `/app` 收窄至 `/app/data`，彻底解决挂载覆盖二进制文件的问题
+- 版本管理解耦 —— 二进制不再注入版本信息，由 `deploy.sh` 在部署时写入 `version.ini`
+- 入口脚本分离 —— 引入 `run-deploy.sh` 独立入口，用户只需记住一个命令
+- 僵尸进程回收 —— 子进程退出时自动回收资源，防止僵尸进程积累
+
+### UI 优化
+
+- 字体全系 HarmonyOS Sans SC，视觉风格统一
+- 「用户配置」Tab 移至导航栏最右侧
+- 弹窗居中修复，顶部导航字号优化
+
+### 🐛 修复
+
+- 修复挂载覆盖导致二进制不可用的问题
+- 修复 `ps | grep` 进程检测在容器环境不可靠的问题
+- 修复旧版本升级时数据库路径不兼容的问题
+
+## 🚀 2.4-lts (2026-07-30)
+
+> **紧急修复版 —— 架构升级与部署流程重构**
+>
+> 本次版本为 **非正统 LTS 版本**（2.4 在语义版本中不属于 LTS 序列），因 `main` 分支在新架构迁移过程中出现编译阻塞，为快速恢复 LTS 通道可用性而发布。
+>
+> **2.5-lts 将回归正常语义版本规则。**
+
+### 🔧 核心变更
+
+- **部署架构重构** —— 引入 `run-deploy.sh` 独立入口，实现部署脚本与项目分支解耦
+- **数据目录规范化** —— 所有运行时文件（数据库、配置、日志、PID）统一迁移至 `/app/data` 子目录，挂载点从 `/app` 收窄至 `/app/data`，彻底解决挂载覆盖二进制文件的问题
+- **版本管理解耦** —— 二进制不再注入版本信息，版本由 `deploy.sh` 在部署时写入 `version.ini` 文件
+- **PID 文件进程检测** —— frpc 状态检测从 `ps | grep` 改为基于 PID 文件，更加可靠
+- **旧版本自动迁移** —— 检测到根目录存在旧数据文件时，自动迁移至 `data/` 子目录，并保留备份
+
+### ✨ 功能完整
+
+- Ping 延迟检测（顶部导航实时显示）
+- 用户配置页独立（账户管理与全局配置分离）
+- 401 统一拦截（认证过期自动跳转登录）
+- 声明式数据库迁移引擎（基于 `db-history.go`）
+- frp v2 协议正式启用（`wireProtocol = "v2"`）
+
+### 📦 部署变更
+
+| 变更项 | 旧方案 | 新方案 |
+|--------|--------|--------|
+| 挂载点 | `-v ${DEPLOY_DIR}:/app` | `-v ${DEPLOY_DIR}/data:/app/data` |
+| 数据库路径 | `/app/frpc-console.db` | `/app/data/frpc-console.db` |
+| 配置文件 | `/app/frpc.toml` | `/app/data/frpc.toml` |
+| 版本文件 | 编译时注入 `-ldflags` | 部署时写入 `version.ini` |
+
+### 🐛 修复
+
+- 修复 `main` 分支因挂载覆盖导致二进制文件不可用的问题
+- 修复 `ps | grep` 进程检测在容器环境不可靠的问题
+- 修复旧版本升级时数据库路径不兼容的问题
+
+---
+
+## 🚀 2.3-preview (2026-07-28)
+
+> **技术预览版** —— 在 LTS 稳定核心（2.0）基础上，集成 2.1 与 2.2 的新特性，并完成基础设施层的全面加固。
+
+### ✨ 新增特性
+
+- **Ping 延迟检测** —— 顶部导航实时显示 frpc 到 frps 的延迟，状态图标 + ms 值，直观反映网络质量（2.1）
+- **用户配置页独立** —— 账户管理与全局配置分离，用户信息与 frpc 配置各自独立管理（2.1）
+- **声明式数据库迁移引擎** —— 基于 `db-history.go` 的 Schema 版本声明，对比新旧差异自动决定迁移路径（2.2）
+
+### 🔧 改进与优化
+
+- **401 统一拦截** —— API 请求返回 401 时自动清除认证状态并跳转登录页，避免页面卡死（2.1）
+- **数据库路径统一** —— 数据库文件固定为 `./frpc-console.db`，Docker 部署时挂载整个 `/app` 目录，所有运行时文件（db / toml / log / pid）完整持久化
+- **`deploy.sh` 部署逻辑重构** —— 备份 → 拉代码 → 停容器 → 构建 → 启动，顺序闭环；移除宿主机编译，全部交由 Docker 多阶段构建处理
+- **Dockerfile 多阶段构建** —— 自动处理 `go.mod` 降级兼容，安装 `sqlite` 辅助工具，便于部署脚本验证数据库状态
+- **前端加载状态管理** —— 新增 `authLoading` 状态，首次访问时先完成用户检查再渲染页面，彻底解决刷新后登录/注册页状态错乱的竞态问题
+- **`schema_version` 兜底写入** —— `InitDB()` 末尾强制补写 Schema 版本，确保每次启动都能识别已有数据，彻底解决升级后反复跳转注册页的问题
+- **`docker-compose.yml` 配套工具** —— 简化开发调试流程，支持快速重建容器
+
+### 🐛 修复
+
+- 修复 `ExportTomlHandler` 模板渲染时缺少 `WireProtocolLine` 字段的问题
+- 修复 `deploy.sh` 升级时用空文件覆盖旧数据库的问题
+- 修复 Docker 镜像中 `sqlite3` 包名错误导致 `deploy.sh` 无法验证数据库的问题
+- 修复首次访问刷新时登录/注册页显示异常的前端竞态问题
+
+### 📦 部署变更
+
+- 挂载方式：`-v ${DEPLOY_DIR}:/app`（整个 `/app` 目录）
+- 数据库位置：`/opt/frpc-console/frpc-console.db`
+- 备份目录：`/tmp/frpc-console/db-backups`
+- 容器内工具：`sqlite` 已预装，便于调试
+
+---
+
+## ✅ 2.0-lts (2026-07-27)
+
+> **首个 LTS 正式版** —— 与 frps-console 2.0-lts 同步发布，共享版本号与 LTS 维护周期。
+
+- 🚀 **frp v2 协议正式启用** —— `wireProtocol = "v2"` 配置项可用，实测稳定
+- 🔒 **数据库迁移引擎完整实现** —— 版本驱动的增量迁移 + 迁移前自动全量备份 + 失败可回滚
+- 🧩 **frps-console 同步发布** —— 同一套设计哲学，一个管理 frpc，一个管理 frps
+
+---
+
+## 🧪 1.5-release (2026-07-25) (non-LTS)
+
+> 非长期支持版本，建议用于尝鲜测试，生产环境请使用 2.0-lts 及后续 LTS 版本。
+
+- ✨ 全局配置页面卡片式重构（服务器连接 / 传输配置 / 日志配置）
+- ✨ 新增运行日志面板（8 秒轮询，最大 200 行）
+- ✨ frp v2 配置占位（UI 灰标禁用，为 2.0 铺路）
+- 🔩 数据库 Schema 迁移框架（启动时自动补全缺失列）
+- 🔐 默认配置脱敏（通用占位符，避免开箱即连他人服务器）
+- 🎨 样式拆分与优化（style-3.css / style-4.css）
+
+---
+
+## 🎉 1.0-release (2026-07-24) (non-LTS)
+
+> 首次公开发布，核心功能全部就绪。
+
+- 🎉 首次发布
+- 📋 隧道全生命周期管理（增删改查 + 启用/禁用）
+- 📦 TOML 导入/导出（无缝迁移现有 frpc 配置）
+- 🔄 配置热加载（修改即生效，无需重启 frpc）
+- 🔐 首次启动 Web 注册（无需命令行交互）
+- 🖥️ 多平台支持（Windows / Linux / ARM 全平台）
+- 🐳 容器化就绪（Docker 镜像，开箱即用）
+- 🎨 深色磨砂玻璃 UI

version.ini

@@ -0,0 +1,6 @@
+; frpc-console 版本声明文件
+; 格式: {语义版本号} [{LTS发布日期}]
+; 示例:
+;   2.4              # Preview 版本，无日期
+;   2.5 20260729     # LTS 版本，带发布日期
+2.7