Boonlive_RD_Web/Web_BLS_ProjectConsole
8
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: 重构项目心跳为Redis LIST并更新相关文档

Browse Source 
重构项目心跳数据结构为Redis LIST，更新相关文档和OpenSpec规范。主要变更包括：
- 将项目心跳从STRING改为LIST类型
- 更新后端服务以支持LIST操作
- 同步更新文档和OpenSpec规范
- 统一后端端口为3001
- 添加部署指南和Windows部署文档

修复前端API请求路径，移除硬编码的localhost地址。添加PM2和Nginx配置文件模板，完善部署流程文档。更新Redis集成协议文档，明确LIST数据结构和外部项目对接规范。
This commit is contained in:
徐
2026-01-17 18:36:52 +08:00
parent a8faa7dcaa
commit 7ac3949dfa
40 changed files with 4179 additions and 323 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
.env.example
View File

@@ -5,7 +5,7 @@
REDIS_HOST=10.8.8.109 # Redis host (default: localhost) REDIS_HOST=10.8.8.109 # Redis host (default: localhost)
REDIS_PORT=6379 # Redis port (default: 6379) REDIS_PORT=6379 # Redis port (default: 6379)
REDIS_PASSWORD= # Redis password (leave empty if not set) REDIS_PASSWORD= # Redis password (leave empty if not set)
REDIS_DB=0 # Redis database number (default: 0) REDIS_DB=15 # Redis database number (fixed: 15)
REDIS_CONNECT_TIMEOUT_MS=2000 # Connection timeout in ms (default: 2000) REDIS_CONNECT_TIMEOUT_MS=2000 # Connection timeout in ms (default: 2000)
# Command control (HTTP) # Command control (HTTP)

4
.gitignore vendored
View File

@@ -38,4 +38,6 @@ coverage/
# Temporary files # Temporary files
*.tmp *.tmp
*.temp *.temp
/release
/docs/模版项目文件

109
.trae/documents/对齐心跳LIST与文档规范.md Normal file
View File

@@ -0,0 +1,109 @@
## 现状差异（需要补齐的点）
* `项目心跳` 目前在代码/文档/测试里都按 STRING（JSON 数组）读取与写入：见 [migrateHeartbeatData.js](file:///e:/Project_Class/BLS/Web_BLS_ProjectConsole/src/backend/services/migrateHeartbeatData.js)、[projects.js](file:///e:/Project_Class/BLS/Web_BLS_ProjectConsole/src/backend/routes/projects.js)、[redis-data-structure.md](file:///e:/Project_Class/BLS/Web_BLS_ProjectConsole/docs/redis-data-structure.md)。与你的需求“改成 Redis LIST”不一致。
* 后端端口存在不一致：源码后端固定 19910（[server.js](file:///e:/Project_Class/BLS/Web_BLS_ProjectConsole/src/backend/server.js)），但 Vite 代理与 OpenAPI/README 默认指向 3001（[vite.config.js](file:///e:/Project_Class/BLS/Web_BLS_ProjectConsole/vite.config.js)、[openapi.yaml](file:///e:/Project_Class/BLS/Web_BLS_ProjectConsole/docs/openapi.yaml)），而实际上后端是19070。
* OpenSpec/文档存在历史漂移：command capability 仍描述“发命令到 Redis 队列”，而当前实现为 HTTP 调用（[openspec/specs/command/spec.md](file:///e:/Project_Class/BLS/Web_BLS_ProjectConsole/openspec/specs/command/spec.md)、[commands.js](file:///e:/Project_Class/BLS/Web_BLS_ProjectConsole/src/backend/routes/commands.js)）。
## 目标（按你的新需求对齐）
* 外部项目把心跳写入 Redis DB15 的 `项目心跳`（**LIST**）。
* 心跳记录结构为：`{"projectName":"...","apiBaseUrl":"...","lastActiveAt":1768566165572}`；后端读取后形成数组视图（逻辑上的 `[{...}]`）。
* 外部项目把日志写入 `${projectName}_项目控制台`（LIST），本项目 console 界面展示这些内容（现已实现轮询 `/api/logs` + `LRANGE`，只需确保心跳/项目列表读写契约一致）。
* 任何与上述不符的 OpenSpec / 文档 / 代码统一修改并保持一致。
## 设计决策（LIST 语义）
* `项目心跳`（LIST）中**每个元素**为“一个项目的一条心跳记录”的 JSON 字符串。
* 为兼容你给出的 `[{...}]` 这种数组表达，后端解析时将支持两种元素格式：
* 元素是对象 JSON：`{"projectName":...}`
* 元素是数组 JSON：`[{"projectName":...}]`（会被 flatten）
* 若多个外部项目反复 `RPUSH` 会产生重复记录：后端在读取时会按 `projectName` 去重，保留 `lastActiveAt` 最新的一条。
* 过渡期兼容：不允许有 `项目心跳` 仍为 STRING（旧格式），后端不可读取，所有文档/OpenSpec/实际代码修改为 将以 LIST 为唯一指定。
## OpenSpec 调整方案
* 新建一个 change（建议 change-id：`update-heartbeat-key-to-list`），在 `openspec/changes/` 下补齐 proposal/tasks/specs delta。
* 修改 capabilities：
* `openspec/specs/redis-connection/spec.md`：把 `项目心跳` 数据类型从 STRING 改为 LIST，并补充“去重/解析”场景。
* `openspec/specs/logging/spec.md`：确认日志读取来自 `${projectName}_项目控制台`（LIST），并在 API 响应中保持现有字段。
* `openspec/specs/command/spec.md`：把“发送到 Redis 控制队列”的描述改为“通过 HTTP 调用目标项目 API”（与当前实现一致），避免规范漂移。
## 代码改造方案（后端为主）
* 统一端口：将 [src/backend/server.js](file:///e:/Project_Class/BLS/Web_BLS_ProjectConsole/src/backend/server.js) 改为 `process.env.PORT || 3001`，与 Vite 代理/OpenAPI/README 对齐。
* `getProjectsList()`：
* 先用 `TYPE 项目心跳` 判断类型：
* list → `LRANGE 0 -1` 并解析每个元素 JSON（支持对象/数组），再去重。
* string → `GET` 并解析 JSON 数组（旧格式兼容），再去重。
* none/其他 → 返回 \[]。
* `migrateHeartbeatData()`：
* 不从 `*_项目心跳`（STRING）读取，改为从 `项目心跳`（LIST）读取每条心跳记录 JSON。
* 必须彻底删除`*_项目心跳`相关的所有内容，包括项目文档和代码逻辑，全面改为用`项目心跳`（**LIST**）里的值。
* `updateProjectHeartbeat()`：改为写入 LIST（实现为：读取→去重→重建 LIST；用于内部工具/未来扩展）。
* 相关路由（[projects.js](file:///e:/Project_Class/BLS/Web_BLS_ProjectConsole/src/backend/routes/projects.js)、[logs.js](file:///e:/Project_Class/BLS/Web_BLS_ProjectConsole/src/backend/routes/logs.js)、[commands.js](file:///e:/Project_Class/BLS/Web_BLS_ProjectConsole/src/backend/routes/commands.js)）无需改 API 形状，只要底层心跳读取逻辑更新即可。
## 前端调整方案
* 预计不需要改动：前端只依赖 `/api/projects` 与 `/api/logs`，后端适配 LIST 后前端会自动工作。
* 如需更明确提示，可在 ProjectSelector 里优化“暂无连接/Redis 未就绪”的文案，但这不是必须项。
## 文档对齐方案
* 更新 [docs/redis-integration-protocol.md](file:///e:/Project_Class/BLS/Web_BLS_ProjectConsole/docs/redis-integration-protocol.md)：
* 将 `项目心跳` 类型改为 LIST，并给出外部项目写入示例（`RPUSH 项目心跳 '<json>'`）。
* 明确 DB 固定 15。
* 删除/改写“STRING 覆盖风险/WATCH”段落，替换为“LIST 可能重复，控制台会按 projectName 去重”。
* 更新 [docs/redis-data-structure.md](file:///e:/Project_Class/BLS/Web_BLS_ProjectConsole/docs/redis-data-structure.md)：
* 同步 `项目心跳` 为 LIST。
* 将“项目控制指令 `{projectName}_控制`”标注为历史/不再使用（当前实现为 HTTP 调用）。
* 同步 [docs/openapi.yaml](file:///e:/Project_Class/BLS/Web_BLS_ProjectConsole/docs/openapi.yaml) 的 server URL/示例端口（与 3001 保持一致）。
* README 与 `openspec/project.md` 中如有测试框架/端口等描述漂移，一并纠正。
## 测试与验证方案
* 更新 fake redis（[fakeRedis.js](file:///e:/Project_Class/BLS/Web_BLS_ProjectConsole/src/backend/test/fakeRedis.js)）以支持 `RPUSH/LPUSH/LRANGE/DEL` 的 list 存储。
* 更新集成测试（[projects.integration.test.js](file:///e:/Project_Class/BLS/Web_BLS_ProjectConsole/src/backend/routes/projects.integration.test.js)）：
* `GET /api/projects` 场景改为基于 LIST 的 `项目心跳`。
* `POST /api/projects/migrate` 场景验证迁移写入 LIST。
* 本地跑 `npm test`，并做一次手工冒烟：启动前后端后，往 Redis DB15 写入一条心跳 + 一条日志，确认 UI 能看到项目与日志。
***
如果你确认这个计划，我将按上述顺序：先补 OpenSpec change 与 specs 对齐，再改后端读取/迁移逻辑与端口，最后更新文档与测试，保证“需求=规范=实现=文档”一致。

26
README.md
View File

@@ -138,11 +138,11 @@ Web_BLS_ProjectConsole/
### 日志记录展示 ### 日志记录展示
日志记录展示模块负责从Redis队列读取日志记录，并以友好的格式展示在控制台界面中。 日志记录展示模块负责从 Redis LIST 读取日志记录，并以友好的格式展示在控制台界面中。
#### 主要功能 #### 主要功能
- 实时读取Redis队列中的日志记录 - 实时读取 Redis LIST 中的日志记录
- 以列表形式展示日志记录，包含时间戳、日志级别和消息内容 - 以列表形式展示日志记录，包含时间戳、日志级别和消息内容
- 支持按日志级别和时间范围过滤日志 - 支持按日志级别和时间范围过滤日志
- 自动滚动到最新日志（可选） - 自动滚动到最新日志（可选）
@@ -151,24 +151,24 @@ Web_BLS_ProjectConsole/
#### 技术实现 #### 技术实现
- 使用Redis List作为日志队列 - 使用Redis List作为日志队列
- 使用Server-Sent Events（SSE）实现实时更新 - 使用轮询方式拉取最新日志
- 前端使用Vue组件化开发，实现日志列表和过滤功能 - 前端使用Vue组件化开发，实现日志列表和过滤功能
### 控制台指令发送 ### 控制台指令发送
控制台指令发送模块允许用户发送控制台指令到Redis队列，供其他程序读取和执行。 控制台指令发送模块允许用户发送控制台指令到目标项目的 HTTP API（由心跳中的 `apiBaseUrl` 提供基地址）。
#### 主要功能 #### 主要功能
- 提供指令输入框，允许用户输入控制台指令 - 提供指令输入框，允许用户输入控制台指令
- 支持指令验证，确保指令格式正确 - 支持指令验证，确保指令格式正确
- 支持发送指令到Redis队列 - 支持发送指令到目标项目 API
- 显示指令发送状态和结果 - 显示指令发送状态和结果
- 维护指令历史记录，支持重新发送历史指令 - 维护指令历史记录，支持重新发送历史指令
#### 技术实现 #### 技术实现
- 使用Redis List作为指令队列 - 后端根据项目心跳解析目标项目 `apiBaseUrl` 并转发调用
- 前端使用Vue组件化开发，实现指令表单和历史记录功能 - 前端使用Vue组件化开发，实现指令表单和历史记录功能
- 后端实现指令验证和发送逻辑 - 后端实现指令验证和发送逻辑
@@ -218,22 +218,16 @@ git push origin feature/feature-name
### 测试指南 ### 测试指南
#### 单元测试 #### 测试
```bash ```bash
npm run test:unit npm test
``` ```
#### 集成测试 #### 开发时 watch
```bash ```bash
npm run test:integration npm run test:watch
```
#### 端到端测试
```bash
npm run test:e2e
``` ```
#### 代码质量检查 #### 代码质量检查

2
deploy/docker/docker-compose.backend.yml
View File

@@ -12,7 +12,7 @@ services:
REDIS_HOST: 10.8.8.109 REDIS_HOST: 10.8.8.109
REDIS_PORT: 6379 REDIS_PORT: 6379
REDIS_PASSWORD: "" REDIS_PASSWORD: ""
REDIS_DB: 0 REDIS_DB: 15
HEARTBEAT_OFFLINE_THRESHOLD_MS: 10000 HEARTBEAT_OFFLINE_THRESHOLD_MS: 10000
COMMAND_API_TIMEOUT_MS: 5000 COMMAND_API_TIMEOUT_MS: 5000
command: ["node", "src/backend/server.js"] command: ["node", "src/backend/server.js"]

210
docs/ai-deployment-request-guide.md Normal file
View File

@@ -0,0 +1,210 @@
# 如何向AI助手提出部署需求
## 一、部署需求的标准格式
当你需要AI助手帮你生成部署文件并说明部署流程时，请按照以下格式提供信息：
### 必需信息
1. **部署环境**
- 操作系统类型（如：Linux、Windows）
- 容器化环境（如：Docker、Kubernetes）
- 服务器类型（如：NAS、云服务器、本地服务器）
2. **访问信息**
- 前端访问地址（域名或IP + 端口）
- 后端API地址（如果与前端不同）
3. **文件路径**
- 项目文件在服务器上的存储路径
- 配置文件在服务器上的存储路径
- 日志文件存储路径（如果需要）
4. **现有配置参考**
- 如果服务器上已有类似项目的配置，请提供配置文件内容
- 这样可以让AI助手了解你的配置风格和规范
5. **项目类型**
- 前端框架（如：Vue、React、Angular）
- 后端框架（如：Express、Koa、NestJS）
- 构建工具（如：Vite、Webpack）
6. **进程管理方式**
- 是否使用进程管理工具（如：PM2、systemd、supervisor）
- 如果使用，请说明具体工具
7. **特殊要求**
- 端口映射需求
- 反向代理需求
- WebSocket支持
- 文件上传大小限制
- 超时时间设置
- 其他特殊配置
### 可选信息
- 数据库连接信息
- Redis连接信息
- 第三方服务集成
- 环境变量配置
- SSL/HTTPS证书配置
## 二、示例模板
你可以直接复制以下模板，填写你的具体信息：
```
我需要在【部署环境】上部署一个【项目类型】项目。
【环境信息】
- 操作系统：【Linux/Windows/macOS】
- 容器化：【Docker/Kubernetes/无】
- 服务器类型：【NAS/云服务器/本地服务器】
【访问信息】
- 前端访问地址：【域名或IP:端口】
- 后端API地址：【域名或IP:端口】
【文件路径】
- 项目文件目录：【服务器上的绝对路径】
- 配置文件目录：【服务器上的绝对路径】
- Systemd服务目录：【/etc/systemd/system/】
【现有配置参考】
【如果有现有配置文件，请粘贴内容】
【项目类型】
- 前端框架：【Vue3/React/Angular】
- 后端框架：【Express/Koa/NestJS】
- 构建工具：【Vite/Webpack】
【进程管理】
- 使用【systemd/PM2/无】管理后端进程
【特殊要求】
- 【列出你的特殊需求】
请帮我生成部署文件并说明完整的部署流程。
```
## 三、实际案例
以下是一个完整的实际案例：
```
我在飞牛OS的NAS系统上的Docker里部署了一个Nginx，现在需要发布项目。
【环境信息】
- 操作系统：Linux（飞牛OS）
- 容器化：Docker
- 服务器类型：NAS
【访问信息】
- 前端访问地址：blv-rd.tech:20001
- 后端API地址：http://127.0.0.1:3001
【文件路径】
- 项目文件目录：/vol1/1000/Docker/nginx/project/bls/bls_project_console
- 配置文件目录：/vol1/1000/Docker/nginx/conf.d
- Systemd服务目录：/etc/systemd/system/
【现有配置参考】
现在配置文件路径下有一个文件：weknora.conf，内容是：
server {
listen 80;
server_name bais.blv-oa.tech;
client_max_body_size 100M;
location / {
proxy_pass http://host.docker.internal:19998;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
proxy_connect_timeout 60s;
proxy_send_timeout 60s;
proxy_read_timeout 300s;
}
location /api/ {
proxy_pass http://host.docker.internal:19996;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
proxy_connect_timeout 60s;
proxy_send_timeout 60s;
proxy_read_timeout 300s;
}
}
【项目类型】
- 前端框架：Vue3
- 后端框架：Express
- 构建工具：Vite
【进程管理】
- 使用systemd管理后端进程
【特殊要求】
- 需要支持文件上传，限制100M
- 需要反向代理API请求到后端
- 需要支持Vue Router的history模式
- 编译工作在本地完成，只需要复制文件到服务器
- 后端需要通过systemd服务管理，支持开机自启
请帮我生成部署文件并说明完整的部署流程。
```
## 四、AI助手会做什么
根据你提供的信息，AI助手会：
1. **分析项目结构**
- 识别前端和后端文件
- 确定构建配置
2. **生成配置文件**
- Nginx配置文件
- Systemd服务配置文件（如果需要）
- 其他必要的配置文件
3. **编写部署文档**
- 详细的部署步骤
- 前端部署流程
- 后端部署流程
- 验证方法
- 常见问题排查
4. **提供后续更新流程**
- 如何更新前端
- 如何更新后端
- 如何重启服务
- 如何管理systemd服务
## 五、注意事项
1. **提供准确信息**：确保提供的路径、端口、域名等信息准确无误
2. **说明限制条件**：如果有任何限制（如只能复制文件、不能在服务器上编译等），请明确说明
3. **提供现有配置**：如果有现有配置文件，请提供内容，这样AI助手可以保持配置风格一致
4. **明确特殊需求**：如果有特殊要求（如WebSocket、文件上传、超时设置等），请详细说明
## 六、快速参考
如果你只是想更新现有项目，可以简化需求：
```
我需要更新【项目名称】的部署配置。
【变更内容】
- 【说明需要变更的地方】
【现有配置】
【提供现有配置文件内容】
请帮我更新配置文件并说明如何应用变更。
```
---
**提示**：将此文件保存到项目的 `docs/` 目录下，方便随时查阅和参考。

18
docs/bls-project-console.service Normal file
View File

@@ -0,0 +1,18 @@
[Unit]
Description=BLS Project Console Backend Service
After=network.target redis.service
[Service]
Type=simple
User=root
WorkingDirectory=/vol1/1000/Docker/nginx/project/bls/bls_project_console/backend
ExecStart=/usr/bin/node /vol1/1000/Docker/nginx/project/bls/bls_project_console/backend/server.js
Restart=on-failure
RestartSec=10
StandardOutput=append:/vol1/1000/Docker/nginx/project/bls/bls_project_console/backend/logs/systemd-out.log
StandardError=append:/vol1/1000/Docker/nginx/project/bls/bls_project_console/backend/logs/systemd-err.log
Environment=NODE_ENV=production
Environment=PORT=19910
[Install]
WantedBy=multi-user.target

476
docs/configuration-check-report.md Normal file
View File

@@ -0,0 +1,476 @@
# 配置文件检查报告
## 一、检查概述
本文档记录了BLS Project Console项目所有配置文件的检查结果，确保配置项正确无误、格式规范、无语法错误，符合当前部署架构的要求。
**检查日期**: 2026-01-16
**部署架构**: Nginx（Docker容器）+ Express后端（systemd管理）
**前端访问地址**: blv-rd.tech:20100
**后端API地址**: http://127.0.0.1:19910
## 二、配置文件清单
### 1. Nginx配置文件
**文件路径**: `docs/nginx-deployment.conf`
**检查结果**: ✅ 通过
**配置内容**:
```nginx
server {
listen 20001;
server_name blv-rd.tech;
root /var/www/bls_project_console;
index index.html;
client_max_body_size 100M;
location /api/ {
proxy_pass http://host.docker.internal:3001;
proxy_http_version 1.1;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
proxy_connect_timeout 60s;
proxy_send_timeout 60s;
proxy_read_timeout 300s;
}
location / {
try_files $uri $uri/ /index.html;
}
access_log /var/log/nginx-custom/access.log;
error_log /var/log/nginx-custom/error.log warn;
}
```
**检查项**:
- ✅ 监听端口: 20100（正确）
- ✅ 服务器名称: blv-rd.tech（正确）
- ✅ 静态文件根目录: /var/www/bls_project_console（正确）
- ✅ API代理地址: http://host.docker.internal:19910（正确，Nginx在Docker容器中）
- ✅ 文件上传大小限制: 100M（正确）
- ✅ Vue Router history模式支持: try_files $uri $uri/ /index.html（正确）
- ✅ 超时设置: 连接60s、发送60s、读取300s（正确）
- ✅ 日志配置: access.log和error.log（正确）
**说明**:
- 使用 `host.docker.internal` 是因为Nginx运行在Docker容器中，需要通过这个特殊域名访问宿主机上的后端服务
- `try_files $uri $uri/ /index.html` 配置支持Vue Router的history模式
---
### 2. Systemd服务配置文件
**文件路径**: `docs/bls-project-console.service`
**检查结果**: ✅ 通过
**配置内容**:
```ini
[Unit]
Description=BLS Project Console Backend Service
After=network.target redis.service
[Service]
Type=simple
User=root
WorkingDirectory=/vol1/1000/Docker/nginx/project/bls/bls_project_console/backend
ExecStart=/usr/bin/node /vol1/1000/Docker/nginx/project/bls/bls_project_console/backend/server.js
Restart=on-failure
RestartSec=10
StandardOutput=append:/vol1/1000/Docker/nginx/project/bls/bls_project_console/backend/logs/systemd-out.log
StandardError=append:/vol1/1000/Docker/nginx/project/bls/bls_project_console/backend/logs/systemd-err.log
Environment=NODE_ENV=production
Environment=PORT=3001
[Install]
WantedBy=multi-user.target
```
**检查项**:
- ✅ 服务描述: 清晰明确（正确）
- ✅ 依赖关系: network.target和redis.service（正确）
- ✅ 服务类型: simple（正确，适合Node.js应用）
- ✅ 工作目录: /vol1/1000/Docker/nginx/project/bls/bls_project_console/backend（正确）
- ✅ 启动命令: /usr/bin/node server.js（正确）
- ✅ 重启策略: on-failure（正确）
- ✅ 重启延迟: 10秒（合理）
- ✅ 日志输出: 标准输出和错误日志分离（正确）
- ✅ 环境变量: NODE_ENV=production, PORT=19910（正确）
- ✅ 开机自启: WantedBy=multi-user.target（正确）
**说明**:
- 服务会在网络和Redis服务启动后自动启动
- 失败后会在10秒后自动重启
- 日志会追加到指定文件，不会覆盖旧日志
---
### 3. 后端服务器配置
**文件路径**: `src/backend/server.js`
**检查结果**: ✅ 通过
**关键配置**:
```javascript
const PORT = 19910;
app.use(cors());
app.use(express.json());
app.use('/api/logs', logRoutes);
app.use('/api/commands', commandRoutes);
app.use('/api/projects', projectRoutes);
app.get('/api/health', (req, res) => {
res.status(200).json({ status: 'ok' });
});
```
**检查项**:
- ✅ 端口配置: 19910（与systemd配置一致）
- ✅ CORS中间件: 已启用（正确）
- ✅ JSON解析: 已启用（正确）
- ✅ API路由: /api/logs, /api/commands, /api/projects（正确）
- ✅ 健康检查端点: /api/health（正确）
- ✅ Redis连接: 在启动时连接（正确）
- ✅ 优雅关闭: 处理SIGINT信号（正确）
**说明**:
- 端口19910与systemd服务配置中的PORT环境变量一致
- 提供健康检查端点便于监控
- 支持优雅关闭，确保Redis连接正确关闭
---
### 4. Vite构建配置
**文件路径**: `vite.config.js`
**检查结果**: ✅ 通过
**关键配置**:
```javascript
export default defineConfig({
plugins: [vue()],
root: 'src/frontend',
build: {
outDir: '../../dist',
emptyOutDir: true,
},
server: {
port: 3000,
proxy: {
'/api': {
target: 'http://localhost:3001',
changeOrigin: true,
},
},
},
resolve: {
alias: {
'@': resolve(__dirname, 'src/frontend'),
},
},
});
```
**检查项**:
- ✅ Vue插件: 已启用（正确）
- ✅ 源码根目录: src/frontend（正确）
- ✅ 输出目录: ../../dist（正确）
- ✅ 开发服务器端口: 3000（正确）
- ✅ API代理: /api -> http://localhost:3001（正确，仅用于开发环境）
- ✅ 路径别名: @ -> src/frontend（正确）
**说明**:
- 开发环境使用代理转发API请求到后端
- 生产环境由Nginx处理API请求代理
- 输出目录为项目根目录下的dist文件夹
---
### 5. Vue Router配置
**文件路径**: `src/frontend/router/index.js`
**检查结果**: ✅ 通过
**关键配置**:
```javascript
const router = createRouter({
history: createWebHistory(),
routes,
});
```
**检查项**:
- ✅ 路由模式: createWebHistory()（正确，使用HTML5 History模式）
- ✅ 路由配置: 包含主页路由（正确）
**说明**:
- 使用HTML5 History模式，需要Nginx配置支持
- Nginx配置中的 `try_files $uri $uri/ /index.html` 已正确配置
---
### 6. 前端入口文件
**文件路径**: `src/frontend/main.js`
**检查结果**: ✅ 通过
**配置内容**:
```javascript
import { createApp } from 'vue';
import App from './App.vue';
import router from './router';
const app = createApp(App);
app.use(router);
app.mount('#app');
```
**检查项**:
- ✅ Vue应用创建: 正确（正确）
- ✅ 路由插件: 已安装（正确）
- ✅ 挂载点: #app（正确）
---
## 三、配置一致性检查
### 端口配置一致性
| 配置项 | 端口 | 状态 |
| -------------------------- | ----- | --------------- |
| 后端服务器 (server.js) | 19910 | ✅ |
| Systemd服务 (PORT环境变量) | 19910 | ✅ |
| Nginx代理目标 | 19910 | ✅ |
| Nginx监听端口 | 20100 | ✅ |
| Vite开发服务器 | 3000 | ✅ (仅开发环境) |
### 路径配置一致性
| 配置项 | 路径 | 状态 |
| ------------------- | -------------------------------------------------------------------- | ---- |
| Nginx静态文件根目录 | /var/www/bls_project_console | ✅ |
| Systemd工作目录 | /vol1/1000/Docker/nginx/project/bls/bls_project_console/backend | ✅ |
| Systemd日志目录 | /vol1/1000/Docker/nginx/project/bls/bls_project_console/backend/logs | ✅ |
| Vite输出目录 | ../../dist | ✅ |
### API路由一致性
| 配置项 | 路由前缀 | 状态 |
| --------- | --------------------------------------- | --------------- |
| 后端路由 | /api/logs, /api/commands, /api/projects | ✅ |
| Nginx代理 | /api/ | ✅ |
| Vite代理 | /api | ✅ (仅开发环境) |
---
## 四、部署架构验证
### 前端部署流程
1. ✅ 本地编译: `npm run build` 生成dist文件夹
2. ✅ 上传dist文件夹内容到: /vol1/1000/Docker/nginx/project/bls/bls_project_console
3. ✅ 上传Nginx配置到: /vol1/1000/Docker/nginx/conf.d/bls_project_console.conf
4. ✅ 重启Nginx容器: `docker restart nginx`
5. ✅ 访问地址: http://blv-rd.tech:20100
### 后端部署流程
1. ✅ 上传后端文件到: /vol1/1000/Docker/nginx/project/bls/bls_project_console/backend
2. ✅ 安装依赖: `npm install --production`
3. ✅ 上传systemd配置到: /etc/systemd/system/bls-project-console.service
4. ✅ 创建日志目录: `mkdir -p /vol1/1000/Docker/nginx/project/bls/bls_project_console/backend/logs`
5. ✅ 重新加载systemd: `systemctl daemon-reload`
6. ✅ 启用开机自启: `systemctl enable bls-project-console.service`
7. ✅ 启动服务: `systemctl start bls-project-console.service`
---
## 五、潜在问题和建议
### 1. Nginx容器网络配置
**问题**: Nginx容器需要能够访问宿主机的3001端口
**建议**:
- 确保Docker容器配置了 `extra_hosts` 或使用 `host.docker.internal`
- 如果使用Linux，需要在docker-compose.yml中添加：
```yaml
extra_hosts:
- 'host.docker.internal:host-gateway'
```
### 2. Redis服务依赖
**问题**: Systemd服务配置依赖redis.service
**建议**:
- 确保系统中有名为redis.service的systemd服务
- 如果Redis服务名称不同，需要修改After=redis.service为正确的服务名
- 如果Redis不在systemd管理下，可以移除redis.service依赖
### 3. 文件权限
**问题**: Systemd服务以root用户运行
**建议**:
- 考虑创建专用的系统用户运行Node.js应用
- 设置适当的文件权限，避免安全风险
### 4. 日志轮转
**问题**: 日志文件会持续增长
**建议**:
- 配置logrotate定期轮转日志文件
- 参考deployment-guide-systemd.md中的日志轮转配置
### 5. 环境变量管理
**问题**: 环境变量硬编码在systemd配置中
**建议**:
- 考虑使用.env文件管理环境变量
- 在systemd配置中使用EnvironmentFile加载环境变量
---
## 六、验证步骤
### 部署前验证
```bash
# 1. 检查Node.js版本
node --version
# 2. 检查npm版本
npm --version
# 3. 检查Redis服务
redis-cli ping
# 4. 检查端口占用
netstat -tlnp | grep 3001
netstat -tlnp | grep 20001
```
### 部署后验证
```bash
# 1. 检查systemd服务状态
systemctl status bls-project-console.service
# 2. 检查后端服务
curl http://localhost:3001/api/health
# 3. 检查Nginx容器
docker ps | grep nginx
# 4. 检查前端访问
curl http://blv-rd.tech:20001
# 5. 检查API代理
curl http://blv-rd.tech:20001/api/health
```
---
## 七、配置文件位置总结
### 本地文件（需要上传）
```
Web_BLS_ProjectConsole/
├── dist/ # 前端编译产物
├── src/backend/ # 后端源码
│ ├── app.js
│ ├── server.js
│ ├── routes/
│ └── services/
├── package.json # 依赖配置
├── package-lock.json # 依赖锁定
└── docs/
├── nginx-deployment.conf # Nginx配置
└── bls-project-console.service # Systemd配置
```
### NAS文件（部署目标）
```
/vol1/1000/Docker/nginx/
├── conf.d/
│ └── bls_project_console.conf # Nginx配置
└── project/bls/bls_project_console/
├── index.html # 前端入口
├── assets/ # 前端资源
└── backend/
├── app.js
├── server.js
├── routes/
├── services/
├── package.json
├── package-lock.json
├── node_modules/
└── logs/
├── systemd-out.log
└── systemd-err.log
/etc/systemd/system/
└── bls-project-console.service # Systemd配置
```
---
## 八、总结
所有配置文件已通过检查，配置项正确无误、格式规范、无语法错误，符合当前部署架构的要求。
**检查结果**: ✅ 全部通过
**下一步**:
1. 按照deployment-guide-systemd.md中的步骤进行部署
2. 部署完成后按照验证步骤进行检查
3. 定期检查日志和服务状态
---
**检查人员**: AI助手
**检查日期**: 2026-01-16
**文档版本**: 1.0

888
docs/deployment-guide-systemd.md Normal file
View File

@@ -0,0 +1,888 @@
# BLS Project Console 部署指南（Systemd版本）
## 一、部署架构说明
- **前端**：Nginx作为Web服务器，提供静态文件服务
- **后端**：Express应用，通过systemd服务管理
- **部署环境**：飞牛OS NAS系统
- **容器化**：Nginx运行在Docker容器中，后端运行在宿主机上
## 二、环境信息
- **前端访问地址**: blv-rd.tech:20100
- **后端API地址**: http://127.0.0.1:19910
- **NAS项目文件目录**: `/vol1/1000/Docker/nginx/project/bls/bls_project_console`
- **NAS配置文件目录**: `/vol1/1000/Docker/nginx/conf.d`
- **Systemd服务目录**: `/etc/systemd/system/`
## 三、部署前环境检查
### 1. 检查Node.js环境
```bash
# 检查Node.js版本（需要 >= 14.x）
node --version
# 检查npm版本
npm --version
# 如果未安装，请先安装Node.js
```
### 2. 检查Nginx容器状态
```bash
# 查看Nginx容器是否运行
docker ps | grep nginx
# 查看Nginx容器日志
docker logs nginx
# 检查Nginx容器端口映射
docker port nginx
```
### 3. 检查端口占用
```bash
# 检查后端端口19910是否被占用
netstat -tlnp | grep 19910
# 检查前端端口20100是否被占用
netstat -tlnp | grep 20100
```
### 4. 检查Redis服务
```bash
# 检查Redis是否运行
redis-cli ping
# 如果Redis未运行，请先启动Redis服务
```
### 5. 检查文件权限
```bash
# 检查项目目录权限
ls -la /vol1/1000/Docker/nginx/project/bls/bls_project_console
# 确保有读写权限，如果没有则修改
chmod -R 755 /vol1/1000/Docker/nginx/project/bls/bls_project_console
```
## 四、前端部署步骤
### 步骤1：本地编译前端
```bash
# 在本地项目根目录执行
npm install
npm run build
```
编译成功后，会在项目根目录生成 `dist` 文件夹。
### 步骤2：上传前端文件到NAS
将本地编译生成的 `dist` 文件夹内的所有文件上传到NAS：
```
NAS路径: /vol1/1000/Docker/nginx/project/bls/bls_project_console
```
**上传方式**：
- 使用SFTP工具（如FileZilla、WinSCP）
- 使用NAS提供的Web管理界面上传
- 使用rsync命令同步
**注意**:
- 上传的是 `dist` 文件夹内的文件，不是 `dist` 文件夹本身
- 确保上传后，NAS目录结构如下：
```
/vol1/1000/Docker/nginx/project/bls/bls_project_console/
├── index.html
├── assets/
│ ├── index-xxx.js
│ └── index-xxx.css
└── ...
```
### 步骤3：上传Nginx配置文件
将项目中的 `docs/nginx-deployment.conf` 文件上传到NAS：
```
NAS路径: /vol1/1000/Docker/nginx/conf.d/bls_project_console.conf
```
### 步骤4：验证Nginx配置
在NAS上执行以下命令验证Nginx配置：
```bash
# 测试Nginx配置文件语法
docker exec nginx nginx -t
# 如果配置正确，会显示：
# nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
# nginx: configuration file /etc/nginx/nginx.conf test is successful
```
如果配置测试失败，检查配置文件语法错误：
```bash
# 查看Nginx错误日志
docker logs nginx --tail 50
# 进入容器查看详细错误
docker exec -it nginx bash
nginx -t
```
### 步骤5：重启Nginx容器
```bash
# 重启Nginx容器
docker restart nginx
# 等待容器启动
sleep 5
# 检查容器状态
docker ps | grep nginx
```
或者只重新加载配置（不重启容器）：
```bash
docker exec nginx nginx -s reload
```
### 步骤6：验证前端部署
在浏览器中访问：
```
http://blv-rd.tech:20100
```
应该能看到项目的前端页面。
如果无法访问，检查以下内容：
```bash
# 检查Nginx容器日志
docker logs nginx --tail 100
# 检查Nginx访问日志
docker exec nginx tail -f /var/log/nginx-custom/access.log
# 检查Nginx错误日志
docker exec nginx tail -f /var/log/nginx-custom/error.log
```
## 五、后端部署步骤
### 步骤1：准备后端文件（本地）
需要上传的后端文件包括：
- `src/backend/app.js`
- `src/backend/server.js`
- `src/backend/routes/` （整个目录）
- `src/backend/services/` （整个目录）
- `package.json`
- `package-lock.json`
### 步骤2：上传后端文件到NAS
将上述文件上传到NAS：
```
NAS路径: /vol1/1000/Docker/nginx/project/bls/bls_project_console/backend/
```
上传后的目录结构：
```
/vol1/1000/Docker/nginx/project/bls/bls_project_console/backend/
├── app.js
├── server.js
├── package.json
├── package-lock.json
├── routes/
│ ├── commands.js
│ ├── logs.js
│ └── projects.js
└── services/
├── migrateHeartbeatData.js
├── redisClient.js
└── redisKeys.js
```
### 步骤3：安装Node.js依赖
登录NAS，执行以下命令：
```bash
# 进入后端目录
cd /vol1/1000/Docker/nginx/project/bls/bls_project_console/backend
# 安装生产环境依赖
npm install --production
# 验证依赖安装成功
ls node_modules
```
如果安装失败，检查以下内容：
```bash
# 检查npm配置
npm config list
# 检查网络连接
ping registry.npmjs.org
# 清除npm缓存后重试
npm cache clean --force
npm install --production
```
### 步骤4：创建环境变量文件（可选）
如果需要配置环境变量，创建 `.env` 文件：
```bash
cd /vol1/1000/Docker/nginx/project/bls/bls_project_console/backend
nano .env
```
添加以下内容：
```env
NODE_ENV=production
PORT=19910
REDIS_HOST=localhost
REDIS_PORT=6379
```
保存并退出（Ctrl+O，Enter，Ctrl+X）。
### 步骤5：测试后端服务启动
在启动systemd服务之前，先手动测试后端服务是否能正常启动：
```bash
cd /vol1/1000/Docker/nginx/project/bls/bls_project_console/backend
# 启动后端服务（前台运行）
node server.js
# 如果看到类似以下输出，说明启动成功：
# BLS Project Console backend server is running on port 19910
```
如果启动失败，查看错误信息并修复：
```bash
# 检查Redis连接
redis-cli ping
# 检查端口占用
netstat -tlnp | grep 19910
# 查看详细错误日志
node server.js 2>&1 | tee startup.log
```
测试成功后，按 Ctrl+C 停止服务。
### 步骤6：创建systemd服务配置文件
将项目中的 `docs/bls-project-console.service` 文件上传到NAS：
```
NAS路径: /etc/systemd/system/bls-project-console.service
```
或者直接在NAS上创建：
```bash
sudo nano /etc/systemd/system/bls-project-console.service
```
添加以下内容：
```ini
[Unit]
Description=BLS Project Console Backend Service
After=network.target redis.service
[Service]
Type=simple
User=root
WorkingDirectory=/vol1/1000/Docker/nginx/project/bls/bls_project_console/backend
ExecStart=/usr/bin/node /vol1/1000/Docker/nginx/project/bls/bls_project_console/backend/server.js
Restart=on-failure
RestartSec=10
StandardOutput=append:/vol1/1000/Docker/nginx/project/bls/bls_project_console/backend/logs/systemd-out.log
StandardError=append:/vol1/1000/Docker/nginx/project/bls/bls_project_console/backend/logs/systemd-err.log
Environment=NODE_ENV=production
Environment=PORT=19910
[Install]
WantedBy=multi-user.target
```
保存并退出（Ctrl+O，Enter，Ctrl+X）。
### 步骤7：创建日志目录
```bash
# 创建日志目录
mkdir -p /vol1/1000/Docker/nginx/project/bls/bls_project_console/backend/logs
# 设置日志目录权限
chmod 755 /vol1/1000/Docker/nginx/project/bls/bls_project_console/backend/logs
```
### 步骤8：重新加载systemd配置
```bash
# 重新加载systemd配置
sudo systemctl daemon-reload
# 启用服务开机自启
sudo systemctl enable bls-project-console.service
```
### 步骤9：启动systemd服务
```bash
# 启动服务
sudo systemctl start bls-project-console.service
# 查看服务状态
sudo systemctl status bls-project-console.service
```
如果服务启动成功，会看到类似以下输出：
```
● bls-project-console.service - BLS Project Console Backend Service
Loaded: loaded (/etc/systemd/system/bls-project-console.service; enabled; vendor preset: enabled)
Active: active (running) since Mon 2026-01-16 10:00:00 CST; 5s ago
Main PID: 12345 (node)
Tasks: 6 (limit: 4915)
Memory: 45.2M
CGroup: /system.slice/bls-project-console.service
└─12345 /usr/bin/node /vol1/1000/Docker/nginx/project/bls/bls_project_console/backend/server.js
```
如果服务启动失败，查看详细错误：
```bash
# 查看服务状态
sudo systemctl status bls-project-console.service -l
# 查看服务日志
sudo journalctl -u bls-project-console.service -n 50 --no-pager
# 查看应用日志
tail -f /vol1/1000/Docker/nginx/project/bls/bls_project_console/backend/logs/systemd-out.log
tail -f /vol1/1000/Docker/nginx/project/bls/bls_project_console/backend/logs/systemd-err.log
```
### 步骤10：验证后端服务
```bash
# 检查端口监听
netstat -tlnp | grep 19910
# 测试API接口
curl http://localhost:19910/api/projects
# 查看服务进程
ps aux | grep "node server.js"
```
在浏览器中访问：
```
http://blv-rd.tech:20100/api/projects
```
应该能返回JSON数据。
## 六、Systemd服务管理命令
### 基本服务管理
```bash
# 启动服务
sudo systemctl start bls-project-console.service
# 停止服务
sudo systemctl stop bls-project-console.service
# 重启服务
sudo systemctl restart bls-project-console.service
# 重新加载配置
sudo systemctl reload bls-project-console.service
# 查看服务状态
sudo systemctl status bls-project-console.service
```
### 日志查看
```bash
# 查看实时日志
sudo journalctl -u bls-project-console.service -f
# 查看最近50行日志
sudo journalctl -u bls-project-console.service -n 50
# 查看今天的日志
sudo journalctl -u bls-project-console.service --since today
# 查看应用输出日志
tail -f /vol1/1000/Docker/nginx/project/bls/bls_project_console/backend/logs/systemd-out.log
# 查看应用错误日志
tail -f /vol1/1000/Docker/nginx/project/bls/bls_project_console/backend/logs/systemd-err.log
```
### 开机自启管理
```bash
# 启用开机自启
sudo systemctl enable bls-project-console.service
# 禁用开机自启
sudo systemctl disable bls-project-console.service
# 查看是否启用开机自启
sudo systemctl is-enabled bls-project-console.service
```
### 服务配置管理
```bash
# 重新加载systemd配置
sudo systemctl daemon-reload
# 重启服务（应用新配置）
sudo systemctl restart bls-project-console.service
# 查看服务配置文件
cat /etc/systemd/system/bls-project-console.service
```
## 七、后续更新流程
### 更新前端
```bash
# 1. 本地编译
npm run build
# 2. 上传新的 dist 文件夹内容到NAS
# 删除NAS上的旧文件，上传新文件
# 3. 重启Nginx容器
docker restart nginx
# 4. 刷新浏览器（Ctrl + F5）
```
### 更新后端
```bash
# 1. 上传修改后的后端文件到NAS
# 2. 如果有新依赖，执行：
cd /vol1/1000/Docker/nginx/project/bls/bls_project_console/backend
npm install --production
# 3. 重启systemd服务
sudo systemctl restart bls-project-console.service
# 4. 查看服务状态
sudo systemctl status bls-project-console.service
# 5. 查看日志确认启动成功
sudo journalctl -u bls-project-console.service -n 50
```
### 更新配置文件
```bash
# 1. 更新Nginx配置
# 上传新的配置文件到 /vol1/1000/Docker/nginx/conf.d/bls_project_console.conf
# 2. 测试Nginx配置
docker exec nginx nginx -t
# 3. 重新加载Nginx配置
docker exec nginx nginx -s reload
# 4. 更新systemd服务配置
# 上传新的服务文件到 /etc/systemd/system/bls-project-console.service
# 5. 重新加载systemd配置
sudo systemctl daemon-reload
# 6. 重启服务
sudo systemctl restart bls-project-console.service
```
## 八、常见问题排查
### 问题1：前端页面404
**可能原因**:
- 前端文件未正确上传
- Nginx配置中的 `root` 路径不正确
- Nginx容器内的 `/var/www` 目录映射不正确
**解决方法**:
```bash
# 1. 检查NAS上的文件是否存在
ls -la /vol1/1000/Docker/nginx/project/bls/bls_project_console
# 2. 检查Nginx容器内的文件
docker exec nginx ls -la /var/www/bls_project_console
# 3. 检查Nginx配置
docker exec nginx cat /etc/nginx/conf.d/bls_project_console.conf
# 4. 查看Nginx错误日志
docker logs nginx --tail 100
```
### 问题2：API请求失败
**可能原因**:
- 后端服务未启动
- 后端端口不是19910
- Redis连接失败
- 防火墙阻止了连接
**解决方法**:
```bash
# 1. 检查systemd服务状态
sudo systemctl status bls-project-console.service
# 2. 检查后端端口
netstat -tlnp | grep 19910
# 3. 查看服务日志
sudo journalctl -u bls-project-console.service -n 50
# 4. 检查Redis连接
redis-cli ping
# 5. 测试后端API
curl http://localhost:19910/api/projects
# 6. 重启服务
sudo systemctl restart bls-project-console.service
```
### 问题3：Systemd服务启动失败
**可能原因**:
- 配置文件语法错误
- 依赖服务未启动（如Redis）
- 文件权限不足
- 端口被占用
**解决方法**:
```bash
# 1. 查看详细错误信息
sudo systemctl status bls-project-console.service -l
# 2. 查看服务日志
sudo journalctl -u bls-project-console.service -n 100 --no-pager
# 3. 检查配置文件语法
cat /etc/systemd/system/bls-project-console.service
# 4. 检查文件权限
ls -la /vol1/1000/Docker/nginx/project/bls/bls_project_console/backend
# 5. 检查端口占用
netstat -tlnp | grep 3001
# 6. 检查Redis服务
sudo systemctl status redis
redis-cli ping
# 7. 手动启动测试
cd /vol1/1000/Docker/nginx/project/bls/bls_project_console/backend
node server.js
```
### 问题4：Nginx配置加载失败
**可能原因**:
- 配置文件语法错误
- 端口20100已被占用
- 配置文件路径错误
**解决方法**:
```bash
# 1. 检查配置文件语法
docker exec nginx nginx -t
# 2. 检查端口占用
netstat -tlnp | grep 20100
# 3. 查看Nginx错误日志
docker logs nginx --tail 100
# 4. 检查配置文件内容
docker exec nginx cat /etc/nginx/conf.d/bls_project_console.conf
```
### 问题5：服务无法开机自启
**可能原因**:
- 服务未启用开机自启
- 依赖服务未启动
- 网络未就绪
**解决方法**:
```bash
# 1. 启用开机自启
sudo systemctl enable bls-project-console.service
# 2. 检查是否启用
sudo systemctl is-enabled bls-project-console.service
# 3. 检查依赖服务
sudo systemctl status redis
# 4. 查看启动失败日志
sudo journalctl -u bls-project-console.service --boot -n 100
```
## 九、目录结构总结
### 本地项目结构
```
Web_BLS_ProjectConsole/
├── dist/ # 编译后的前端文件（需要上传）
├── src/
│ ├── backend/ # 后端源码（需要上传）
│ │ ├── app.js
│ │ ├── server.js
│ │ ├── routes/
│ │ └── services/
│ └── frontend/ # 前端源码
├── docs/
│ ├── nginx-deployment.conf # Nginx配置文件（需要上传）
│ ├── bls-project-console.service # Systemd服务配置（需要上传）
│ ├── deployment-guide.md # 部署指南
│ └── ai-deployment-request-guide.md
├── package.json # 依赖配置（需要上传）
└── package-lock.json # 依赖锁定文件（需要上传）
```
### NAS部署结构
```
/vol1/1000/Docker/nginx/
├── conf.d/
│ ├── weknora.conf
│ └── bls_project_console.conf # 上传的Nginx配置
└── project/bls/bls_project_console/
├── index.html # 前端入口文件
├── assets/ # 前端静态资源
│ ├── index-xxx.js
│ └── index-xxx.css
└── backend/ # 后端文件
├── app.js
├── server.js
├── routes/
├── services/
├── package.json
├── package-lock.json
├── node_modules/ # npm install后生成
└── logs/ # 日志目录
├── systemd-out.log # systemd输出日志
└── systemd-err.log # systemd错误日志
/etc/systemd/system/
└── bls-project-console.service # Systemd服务配置
```
## 十、监控和维护
### 日常监控
```bash
# 1. 检查服务状态
sudo systemctl status bls-project-console.service
# 2. 检查Nginx状态
docker ps | grep nginx
# 3. 查看服务日志
sudo journalctl -u bls-project-console.service --since today
# 4. 查看Nginx日志
docker logs nginx --since 1h
# 5. 检查磁盘空间
df -h /vol1/1000/Docker/nginx/project/bls/bls_project_console
# 6. 检查内存使用
free -h
```
### 日志轮转
创建日志轮转配置：
```bash
sudo nano /etc/logrotate.d/bls-project-console
```
添加以下内容：
```
/vol1/1000/Docker/nginx/project/bls/bls_project_console/backend/logs/*.log {
daily
rotate 7
compress
delaycompress
missingok
notifempty
create 0644 root root
postrotate
systemctl reload bls-project-console.service > /dev/null 2>&1 || true
endscript
}
```
### 性能优化
```bash
# 1. 查看服务资源使用
systemctl show bls-project-console.service -p CPUUsage,MemoryCurrent
# 2. 查看进程资源使用
top -p $(pgrep -f "node server.js")
# 3. 调整systemd服务资源限制
sudo nano /etc/systemd/system/bls-project-console.service
```
添加资源限制：
```ini
[Service]
...
MemoryLimit=512M
CPUQuota=50%
```
重新加载并重启：
```bash
sudo systemctl daemon-reload
sudo systemctl restart bls-project-console.service
```
## 十一、备份和恢复
### 备份
```bash
# 1. 备份前端文件
tar -czf bls-project-console-frontend-$(date +%Y%m%d).tar.gz \
/vol1/1000/Docker/nginx/project/bls/bls_project_console
# 2. 备份后端文件
tar -czf bls-project-console-backend-$(date +%Y%m%d).tar.gz \
/vol1/1000/Docker/nginx/project/bls/bls_project_console/backend
# 3. 备份配置文件
tar -czf bls-project-console-config-$(date +%Y%m%d).tar.gz \
/vol1/1000/Docker/nginx/conf.d/bls_project_console.conf \
/etc/systemd/system/bls-project-console.service
```
### 恢复
```bash
# 1. 恢复前端文件
tar -xzf bls-project-console-frontend-YYYYMMDD.tar.gz -C /
# 2. 恢复后端文件
tar -xzf bls-project-console-backend-YYYYMMDD.tar.gz -C /
# 3. 恢复配置文件
tar -xzf bls-project-console-config-YYYYMMDD.tar.gz -C /
# 4. 重新加载systemd配置
sudo systemctl daemon-reload
# 5. 重启服务
sudo systemctl restart bls-project-console.service
docker restart nginx
```
## 十二、安全建议
1. **文件权限**
```bash
# 设置适当的文件权限
chmod 755 /vol1/1000/Docker/nginx/project/bls/bls_project_console
chmod 644 /vol1/1000/Docker/nginx/project/bls/bls_project_console/backend/*.js
```
2. **防火墙配置**
```bash
# 只允许必要的端口
sudo ufw allow 20100/tcp
sudo ufw allow 19910/tcp
sudo ufw enable
```
3. **定期更新**
```bash
# 定期更新Node.js和npm
npm install -g npm@latest
```
4. **日志监控**
- 定期检查日志文件大小
- 设置日志轮转
- 监控异常错误
5. **备份策略**
- 定期备份配置文件
- 定期备份重要数据
- 测试恢复流程

314
docs/deployment-guide-windows.md Normal file
View File

@@ -0,0 +1,314 @@
# Windows 部署指南
## 环境要求
- Windows Server
- Node.js (已安装)
- PM2 (已安装)
- Nginx (已安装)
- Redis 服务
## 部署步骤
### 1. 准备文件
将以下文件复制到测试服务器：
#### 必需文件清单
```
项目根目录/
├── src/backend/ # 后端源码
│ ├── server.js
│ ├── app.js
│ ├── routes/
│ └── services/
├── dist/ # 前端构建产物（已构建）
│ ├── index.html
│ └── assets/
├── package.json
├── package-lock.json
└── node_modules/ # 依赖包（需要在服务器上安装）
```
#### 配置文件
从 `docs/` 目录复制以下配置文件：
```
docs/
├── ecosystem.config.windows.js # PM2 配置文件
├── nginx.conf.windows # Nginx 配置文件
└── .env.example # 环境变量示例
```
### 2. 服务器目录结构
在测试服务器上创建以下目录结构：
```
E:/projects/bls_project_console/
├── src/backend/
├── dist/
├── logs/
├── node_modules/
├── package.json
├── package-lock.json
└── .env
```
### 3. 安装依赖
在服务器项目目录下运行：
```bash
cd E:/projects/bls_project_console
npm install --production
```
### 4. 配置环境变量
复制 `.env.example` 为 `.env`，并根据实际情况修改配置：
```bash
# Redis connection
REDIS_HOST=10.8.8.109 # 修改为实际的Redis服务器地址
REDIS_PORT=6379
REDIS_PASSWORD= # 如果有密码则填写
REDIS_DB=15
REDIS_CONNECT_TIMEOUT_MS=2000
# Command control (HTTP)
COMMAND_API_TIMEOUT_MS=5000
# Heartbeat liveness
HEARTBEAT_OFFLINE_THRESHOLD_MS=10000
# Node environment
NODE_ENV=production
```
### 5. 配置 PM2
修改 `ecosystem.config.windows.js` 中的路径配置：
```javascript
module.exports = {
apps: [
{
name: 'bls-project-console',
script: './src/backend/server.js',
cwd: 'E:/projects/bls_project_console', // 修改为实际部署路径
instances: 1,
autorestart: true,
watch: false,
max_memory_restart: '1G',
env: {
NODE_ENV: 'production',
PORT: 19910,
},
error_file: './logs/pm2-error.log',
out_file: './logs/pm2-out.log',
log_date_format: 'YYYY-MM-DD HH:mm:ss Z',
merge_logs: true,
},
],
};
```
### 6. 启动后端服务
使用 PM2 启动服务：
```bash
cd E:/projects/bls_project_console
pm2 start ecosystem.config.windows.js
pm2 save
pm2 startup
```
查看服务状态：
```bash
pm2 status
pm2 logs bls-project-console
```
### 7. 配置 Nginx
#### 7.1 部署前端静态文件
将 `dist/` 目录内容复制到 Nginx 静态文件目录：
```bash
# 创建静态文件目录
mkdir C:/nginx/sites/bls_project_console
# 复制前端文件
xcopy E:/projects/bls_project_console\dist\* C:/nginx/sites/bls_project_console /E /I /Y
```
#### 7.2 配置 Nginx
将 `nginx.conf.windows` 的内容添加到 Nginx 主配置文件中，或作为独立的站点配置文件：
```bash
# 复制配置文件到 Nginx 配置目录
copy docs\nginx.conf.windows C:/nginx/conf.d/bls_project_console.conf
```
#### 7.3 修改配置文件中的路径
根据实际部署路径修改 `nginx.conf.windows` 中的路径：
```nginx
root C:/nginx/sites/bls_project_console; # 修改为实际的静态文件路径
```
#### 7.4 测试并重启 Nginx
```bash
# 测试配置
nginx -t
# 重启 Nginx
nginx -s reload
```
### 8. 验证部署
#### 8.1 检查后端服务
```bash
# 检查 PM2 进程状态
pm2 status
# 查看日志
pm2 logs bls-project-console
# 测试健康检查接口
curl http://localhost:19910/api/health
```
#### 8.2 检查前端访问
在浏览器中访问：
- `http://localhost/` 或配置的域名
#### 8.3 检查 API 代理
```bash
curl http://localhost/api/health
```
## 常用命令
### PM2 命令
```bash
# 启动服务
pm2 start ecosystem.config.windows.js
# 停止服务
pm2 stop bls-project-console
# 重启服务
pm2 restart bls-project-console
# 查看日志
pm2 logs bls-project-console
# 查看状态
pm2 status
# 删除服务
pm2 delete bls-project-console
# 保存当前进程列表
pm2 save
```
### Nginx 命令
```bash
# 测试配置
nginx -t
# 重启 Nginx
nginx -s reload
# 停止 Nginx
nginx -s stop
# 查看 Nginx 版本
nginx -v
```
## 故障排查
### 后端无法启动
1. 检查端口是否被占用：
```bash
netstat -ano | findstr :19910
```
2. 检查 Redis 连接：
```bash
# 查看 .env 文件中的 Redis 配置
# 确保可以连接到 Redis 服务器
```
3. 查看日志：
```bash
pm2 logs bls-project-console
```
### 前端无法访问
1. 检查 Nginx 配置：
```bash
nginx -t
```
2. 检查静态文件目录：
```bash
dir C:/nginx/sites/bls_project_console
```
3. 查看 Nginx 错误日志：
```bash
type C:/nginx/logs/bls_project_console_error.log
```
### API 请求失败
1. 检查后端服务是否运行：
```bash
pm2 status
```
2. 检查 Nginx 代理配置：
```bash
# 确保 proxy_pass 指向正确的后端地址
curl http://localhost:19910/api/health
```
## 端口说明
- **19910**: 后端 API 服务端口
- **80**: Nginx HTTP 服务端口
## 注意事项
1. 确保 Redis 服务正常运行并可访问
2. 确保 Windows 防火墙允许相关端口访问
3. 生产环境建议使用 HTTPS
4. 定期备份 `.env` 配置文件
5. 监控 PM2 日志和 Nginx 日志

381
docs/deployment-guide.md Normal file
View File

@@ -0,0 +1,381 @@
# BLS Project Console 发布流程
## 一、环境信息
- **前端访问地址**: blv-rd.tech:20100
- **NAS项目文件目录**: `/vol1/1000/Docker/nginx/project/bls/bls_project_console`
- **NAS配置文件目录**: `/vol1/1000/Docker/nginx/conf.d`
- **项目类型**: Vue3前端 + Express后端
- **后端端口**: 19910
## 二、本地编译步骤
### 1. 安装依赖（首次执行）
```bash
npm install
```
### 2. 编译前端
```bash
npm run build
```
编译成功后，会在项目根目录生成 `dist` 文件夹，里面包含所有前端静态文件。
### 3. 准备后端文件
后端文件位于 `src/backend` 目录，需要上传的文件包括：
- `ecosystem.config.js` （PM2配置文件）
- `src/backend/app.js`
- `src/backend/server.js`
- `src/backend/routes/` （整个目录）
- `src/backend/services/` （整个目录）
- `package.json`
- `package-lock.json`
## 三、NAS端部署步骤
### 步骤1：上传前端文件到NAS
将本地编译生成的 `dist` 文件夹内的所有文件上传到NAS：
```
NAS路径: /vol1/1000/Docker/nginx/project/bls/bls_project_console
```
**注意**:
- 上传的是 `dist` 文件夹内的文件，不是 `dist` 文件夹本身
- 确保上传后，NAS目录结构如下：
```
/vol1/1000/Docker/nginx/project/bls/bls_project_console/
├── index.html
├── assets/
│ ├── index-xxx.js
│ └── index-xxx.css
└── ...
```
### 步骤2：上传后端文件到NAS
将后端文件上传到NAS的同一目录（或单独的目录）：
```
NAS路径: /vol1/1000/Docker/nginx/project/bls/bls_project_console/backend/
```
上传以下文件：
- `ecosystem.config.js` （PM2配置文件）
- `package.json`
- `package-lock.json`
- `src/backend/app.js` → `backend/app.js`
- `src/backend/server.js` → `backend/server.js`
- `src/backend/routes/` → `backend/routes/`
- `src/backend/services/` → `backend/services/`
### 步骤3：上传Nginx配置文件
将项目中的 `docs/nginx-deployment.conf` 文件上传到NAS：
```
NAS路径: /vol1/1000/Docker/nginx/conf.d/bls_project_console.conf
```
### 步骤4：安装后端依赖和PM2（首次部署时执行）
登录到NAS，执行以下命令：
```bash
# 进入后端目录
cd /vol1/1000/Docker/nginx/project/bls/bls_project_console/backend
# 安装Node.js依赖
npm install --production
# 全局安装PM2（如果尚未安装）
npm install -g pm2
```
### 步骤5：启动后端服务（使用PM2）
使用PM2启动后端服务，PM2会自动管理进程、自动重启、日志记录等：
```bash
# 进入后端目录
cd /vol1/1000/Docker/nginx/project/bls/bls_project_console/backend
# 使用PM2启动服务（根据配置文件）
pm2 start ecosystem.config.js
# 设置PM2开机自启
pm2 startup
pm2 save
```
**PM2常用命令**：
```bash
# 查看服务状态
pm2 status
# 查看日志
pm2 logs bls-project-console
# 重启服务
pm2 restart bls-project-console
# 停止服务
pm2 stop bls-project-console
# 删除服务
pm2 delete bls-project-console
```
**注意**:
- 后端服务会在宿主机上运行，端口为19910
- 确保Redis服务已启动并可访问
- PM2会自动管理进程崩溃重启
### 步骤6：重启Nginx容器（在NAS上执行）
重启Nginx容器以加载新的配置：
```bash
docker restart nginx
```
或者进入Nginx容器重新加载配置：
```bash
docker exec nginx nginx -s reload
```
### 步骤7：检查Nginx配置（可选）
检查Nginx配置是否正确：
```bash
docker exec nginx nginx -t
```
## 四、验证部署
### 1. 检查前端访问
在浏览器中访问：
```
http://blv-rd.tech:20100
```
应该能看到项目的前端页面。
### 2. 检查API接口
在浏览器中访问：
```
http://blv-rd.tech:20100/api/projects
```
应该能返回JSON数据（如果后端正常运行）。
### 3. 检查Nginx日志
查看Nginx访问日志和错误日志：
```bash
docker logs nginx
```
或查看容器内的日志文件：
```bash
docker exec nginx tail -f /var/log/nginx-custom/access.log
docker exec nginx tail -f /var/log/nginx-custom/error.log
```
## 五、常见问题排查
### 问题1：前端页面404
**可能原因**:
- 前端文件未正确上传到 `/vol1/1000/Docker/nginx/project/bls/bls_project_console`
- Nginx配置中的 `root` 路径不正确
- Nginx容器内的 `/var/www` 目录映射不正确
**解决方法**:
1. 检查NAS上的文件是否存在
2. 检查Nginx配置文件中的 `root` 路径是否正确
3. 检查Docker容器的挂载配置
### 问题2：API请求失败
**可能原因**:
- 后端服务未启动
- 后端端口不是19910
- `host.docker.internal` 无法解析
- 防火墙阻止了连接
**解决方法**:
1. 检查PM2服务状态：`pm2 status`
2. 检查后端端口：`netstat -tlnp | grep 19910`
3. 查看PM2日志：`pm2 logs bls-project-console`
4. 在Nginx容器内测试连接：`docker exec nginx ping host.docker.internal`
5. 检查防火墙规则
6. 重启PM2服务：`pm2 restart bls-project-console`
### 问题3：Nginx配置加载失败
**可能原因**:
- 配置文件语法错误
- 端口20100已被占用
- 配置文件路径错误
**解决方法**:
1. 检查配置文件语法：`docker exec nginx nginx -t`
2. 检查端口占用：`netstat -tlnp | grep 20100`
3. 查看Nginx错误日志：`docker logs nginx`
## 六、后续更新流程
当需要更新项目时，只需执行以下步骤：
1. **本地编译**:
```bash
npm run build
```
2. **上传前端文件**:
- 删除NAS上的旧文件
- 上传新的 `dist` 文件夹内容到 `/vol1/1000/Docker/nginx/project/bls/bls_project_console`
3. **上传后端文件**（如果有修改）:
- 上传修改后的后端文件到 `/vol1/1000/Docker/nginx/project/bls/bls_project_console/backend`
- 如果有新的依赖，需要重新运行 `npm install --production`
4. **重启后端服务**（使用PM2）:
```bash
cd /vol1/1000/Docker/nginx/project/bls/bls_project_console/backend
pm2 restart bls-project-console
```
5. **刷新浏览器缓存**:
- 在浏览器中按 `Ctrl + F5` 强制刷新
## 七、目录结构总结
### 本地项目结构
```
Web_BLS_ProjectConsole/
├── dist/ # 编译后的前端文件（需要上传）
├── src/
│ ├── backend/ # 后端源码（需要上传）
│ │ ├── app.js
│ │ ├── server.js
│ │ ├── routes/
│ │ └── services/
│ └── frontend/ # 前端源码
├── docs/
│ └── nginx-deployment.conf # Nginx配置文件（需要上传）
├── ecosystem.config.js # PM2配置文件（需要上传）
├── package.json # 依赖配置（需要上传）
└── package-lock.json # 依赖锁定文件（需要上传）
```
### NAS部署结构
```
/vol1/1000/Docker/nginx/
├── conf.d/
│ ├── weknora.conf
│ └── bls_project_console.conf # 上传的Nginx配置
└── project/bls/bls_project_console/
├── index.html # 前端入口文件
├── assets/ # 前端静态资源
│ ├── index-xxx.js
│ └── index-xxx.css
└── backend/ # 后端文件
├── app.js
├── server.js
├── ecosystem.config.js # PM2配置文件
├── routes/
├── services/
├── package.json
├── package-lock.json
├── node_modules/ # npm install后生成
└── logs/ # PM2日志目录（自动生成）
├── pm2-error.log # 错误日志
└── pm2-out.log # 输出日志
```
## 八、PM2进程管理说明
### PM2的优势
使用PM2管理Node.js进程有以下优势：
- **自动重启**: 进程崩溃时自动重启
- **开机自启**: 配置后系统重启自动启动服务
- **日志管理**: 自动记录和管理日志文件
- **进程监控**: 实时查看进程状态和资源使用情况
- **集群模式**: 支持多进程负载均衡（本项目配置为单进程）
### PM2配置文件说明
`ecosystem.config.js` 配置文件已包含以下设置：
- 应用名称：`bls-project-console`
- 工作目录：`/vol1/1000/Docker/nginx/project/bls/bls_project_console/backend`
- 启动脚本：`./server.js`
- 环境变量：`NODE_ENV=production`, `PORT=19910`
- 内存限制：1GB（超过自动重启）
- 日志文件：`./logs/pm2-error.log` 和 `./logs/pm2-out.log`
### PM2日志查看
```bash
# 实时查看日志
pm2 logs bls-project-console
# 查看错误日志
pm2 logs bls-project-console --err
# 查看输出日志
pm2 logs bls-project-console --out
# 清空日志
pm2 flush
```
### PM2监控
```bash
# 查看实时监控界面
pm2 monit
# 查看详细信息
pm2 show bls-project-console
```
## 九、注意事项
1. **端口映射**: 确保Nginx容器的20100端口已映射到宿主机的20100端口
2. **host.docker.internal**: 在Linux上，需要在Docker Compose中添加 `extra_hosts` 配置
3. **文件权限**: 确保上传的文件有正确的读写权限
4. **Redis连接**: 确保后端能连接到Redis服务
5. **日志监控**: 定期检查Nginx和后端日志，及时发现和解决问题

21
docs/ecosystem.config.windows.js Normal file
View File

@@ -0,0 +1,21 @@
module.exports = {
apps: [
{
name: 'bls-project-console',
script: './src/backend/server.js',
cwd: 'E:\\Project_Class\\BLS\\Web_BLS_ProjectConsole',
instances: 1,
autorestart: true,
watch: false,
max_memory_restart: '1G',
env: {
NODE_ENV: 'production',
PORT: 19910,
},
error_file: './logs/pm2-error.log',
out_file: './logs/pm2-out.log',
log_date_format: 'YYYY-MM-DD HH:mm:ss Z',
merge_logs: true,
},
],
};

30
docs/nginx-deployment.conf Normal file
View File

@@ -0,0 +1,30 @@
server {
listen 20100;
server_name blv-rd.tech;
root /var/www/bls_project_console;
index index.html;
client_max_body_size 100M;
location /api/ {
proxy_pass http://host.docker.internal:19910;
proxy_http_version 1.1;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
proxy_connect_timeout 60s;
proxy_send_timeout 60s;
proxy_read_timeout 300s;
}
location / {
try_files $uri $uri/ /index.html;
}
access_log /var/log/nginx-custom/access.log;
error_log /var/log/nginx-custom/error.log warn;
}

28
docs/nginx.conf.windows Normal file
View File

@@ -0,0 +1,28 @@
server {
listen 80;
server_name localhost;
root C:/nginx/sites/bls_project_console;
index index.html;
location /api/ {
proxy_pass http://127.0.0.1:19910;
proxy_http_version 1.1;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
proxy_connect_timeout 5s;
proxy_send_timeout 30s;
proxy_read_timeout 30s;
}
location / {
try_files $uri $uri/ /index.html;
}
access_log C:/nginx/logs/bls_project_console_access.log;
error_log C:/nginx/logs/bls_project_console_error.log warn;
}

49
docs/redis-data-structure.md
View File

@@ -10,19 +10,18 @@
**键名**: `项目心跳` **键名**: `项目心跳`
**类型**: String (JSON数组) **类型**: List
**描述**: 统一存储所有项目的心跳信息，替代原有的分散键结构。 **描述**: 统一存储所有项目的心跳信息，替代原有的分散键结构。
**数据格式**: **数据格式**: 每个列表元素是一个 JSON 字符串，表示一条心跳记录：
```json ```json
[ {
{ "projectName": "string",
"projectName": "string", "apiBaseUrl": "string",
"apiBaseUrl": "string", "lastActiveAt": "number"
"lastActiveAt": "number" }
}
]
``` ```
**字段说明**: **字段说明**:
@@ -32,20 +31,15 @@
**示例**: **示例**:
```json ```json
[ {
{ "projectName": "用户管理系统",
"projectName": "用户管理系统", "apiBaseUrl": "http://localhost:8080",
"apiBaseUrl": "http://localhost:8080", "lastActiveAt": 1704067200000
"lastActiveAt": 1704067200000 }
},
{
"projectName": "数据可视化平台",
"apiBaseUrl": "http://localhost:8081",
"lastActiveAt": 1704067260000
}
]
``` ```
说明：外部项目会周期性向 LIST 写入多条心跳记录；控制台后端按 `projectName` 去重，保留 `lastActiveAt` 最新的一条用于在线判定与项目列表展示。
### 2. 项目控制台日志 ### 2. 项目控制台日志
**键名**: `{projectName}_项目控制台` **键名**: `{projectName}_项目控制台`
@@ -94,7 +88,7 @@
**类型**: List **类型**: List
**描述**: 存储发送给项目的控制指令。 **描述**: 历史结构（已废弃）。当前命令下发通过 HTTP 调用目标项目 API，不再通过 Redis 存储控制指令。
**指令对象格式**: **指令对象格式**:
```json ```json
@@ -206,9 +200,8 @@
为确保平滑过渡，系统在读取项目心跳时采用以下策略： 为确保平滑过渡，系统在读取项目心跳时采用以下策略：
1. **优先读取新结构**: 首先尝试从`项目心跳`列表中查找项目 1. **只读取新结构**: 项目列表与在线判定只读取 `项目心跳`（LIST）
2. **回退到旧结构**: 如果新结构中未找到，则尝试从`{projectName}_项目心跳`键中读取 2. **旧结构仅用于迁移**: `{projectName}_项目心跳` 仅作为历史数据来源，通过 `POST /api/projects/migrate` 导入一次
3. **自动迁移**: 当检测到旧结构数据时，可以自动迁移到新结构
## 性能优化 ## 性能优化
@@ -224,8 +217,8 @@
### 3. 心跳更新 ### 3. 心跳更新
- 直接更新项目列表中的对应项目 - 外部项目持续向 `项目心跳`（LIST）追加心跳记录
- 避免频繁的键操作 - 建议外部项目结合 `LTRIM` 控制列表长度
## 监控和维护 ## 监控和维护
@@ -276,4 +269,4 @@
- [Redis数据类型](https://redis.io/docs/data-types/) - [Redis数据类型](https://redis.io/docs/data-types/)
- [项目OpenSpec规范](../openspec/specs/) - [项目OpenSpec规范](../openspec/specs/)
- [API文档](../docs/api-documentation.md) - [API文档](../docs/api-documentation.md)

157
docs/redis-integration-protocol.md
View File

@@ -1,12 +1,13 @@
# Redis 对接协议（供外部项目 AI 生成代码使用） # Redis 对接协议（供外部项目 AI 生成代码使用）
本文档定义“外部项目 ↔ BLS Project Console”之间通过 Redis 交互的 **Key 命名、数据类型、写入方式、读取方式与数据格式**。 本文档定义"外部项目 ↔ BLS Project Console"之间通过 Redis 交互的 **Key 命名、数据类型、写入方式、读取方式与数据格式**。
注：本仓库对外暴露的 Redis 连接信息如下（供对方直接连接以写入心跳/日志）： 注：本仓库对外暴露的 Redis 连接信息如下（供对方直接连接以写入心跳/日志）：
- 地址：`10.8.8.109` - 地址：`10.8.8.109`
- 端口：默认 `6379` - 端口：默认 `6379`
- 密码：无（空） - 密码：无（空）
- 数据库：固定 `15`
示例（环境变量）： 示例（环境变量）：
@@ -14,18 +15,20 @@
REDIS_HOST=10.8.8.109 REDIS_HOST=10.8.8.109
REDIS_PORT=6379 REDIS_PORT=6379
REDIS_PASSWORD= REDIS_PASSWORD=
REDIS_DB=15
``` ```
示例（redis-cli）： 示例（redis-cli）：
``` ```
redis-cli -h 10.8.8.109 -p 6379 redis-cli -h 10.8.8.109 -p 6379 -n 15
``` ```
> 约束：每个需要关联本控制台的外部项目，必须在本项目使用的同一个 Redis 实例中： > 约束：每个需要关联本控制台的外部项目，必须在同一个 Redis（DB15）中：
> - 写入 2 个 Key（心跳 + 控制台信息） > - 更新 `项目心跳`（项目列表 + 心跳信息）
> - 命令下发为 HTTP API 调用 > - 追加 `${projectName}_项目控制台`（日志队列）
> - 命令下发为 HTTP API 调用（不通过 Redis 下发命令）
## 1. 命名约定 ## 1. 命名约定
@@ -35,35 +38,45 @@ redis-cli -h 10.8.8.109 -p 6379
固定后缀： 固定后缀：
- 心跳：`${projectName}_项目心跳`
- 控制台：`${projectName}_项目控制台` - 控制台：`${projectName}_项目控制台`
示例（projectName = `订单系统`）： 示例（projectName = `订单系统`）：
- `订单系统_项目心跳`
- `订单系统_项目控制台` - `订单系统_项目控制台`
## 2. 外部项目需要写入的 2 个 Key ## 2. 外部项目需要写入的 2 个 Key
### 2.1 `${projectName}_项目心跳` 说明：当前控制台左侧“项目选择列表”只读取 `项目心跳`（LIST）。因此外部项目必须维护该 Key，否则项目不会出现在列表中。
- Redis 数据类型：**STRING** ### 2.1 `项目心跳`
- 写入方式：`SET ${projectName}_项目心跳 <json>`
- value：JSON 字符串，必须包含目标项目可被调用的 `apiBaseUrl`，以及活跃时间戳 `lastActiveAt`
推荐 JSON Schema： - Redis 数据类型：**LIST**
- 写入方式（推荐 FIFO）：`RPUSH 项目心跳 <json>`
- value：每个列表元素为“项目心跳记录”的 JSON 字符串
示例（与当前代码读取一致；下面示例表示“逻辑结构”）：
```json ```json
{ [
"apiBaseUrl": "http://127.0.0.1:4001", {
"lastActiveAt": 1760000000000 "projectName": "BLS主机心跳日志",
} "apiBaseUrl": "http://127.0.0.1:3000",
"lastActiveAt": 1768566165572
}
]
``` ```
字段说明： 示例（Redis 写入命令）：
```
RPUSH 项目心跳 "{\"projectName\":\"BLS主机心跳日志\",\"apiBaseUrl\":\"http://127.0.0.1:3000\",\"lastActiveAt\":1768566165572}"
```
字段说明（每条心跳记录）：
- `projectName`：项目名称（用于拼接日志 Key：`${projectName}_项目控制台`）
- `apiBaseUrl`：目标项目对外提供的 API 地址（基地址，后端将基于它拼接 `apiName`） - `apiBaseUrl`：目标项目对外提供的 API 地址（基地址，后端将基于它拼接 `apiName`）
- `lastActiveAt`：状态时间（活跃时间戳，毫秒）。建议每 **3 秒**刷新一次。 - `lastActiveAt`：活跃时间戳（毫秒）。建议每 **3 秒**刷新一次。
在线/离线判定（BLS Project Console 使用）： 在线/离线判定（BLS Project Console 使用）：
@@ -73,14 +86,19 @@ redis-cli -h 10.8.8.109 -p 6379
建议： 建议：
- `lastActiveAt` 使用 `Date.now()` 生成（毫秒） - `lastActiveAt` 使用 `Date.now()` 生成（毫秒）
- 可设置 TTL（可选）：例如 `SET key value EX 30` - 建议对 `项目心跳` 做长度控制（可选）：例如每次写入后执行 `LTRIM 项目心跳 -2000 -1` 保留最近 2000 条
去重提示：
- `项目心跳` 为 LIST 时，外部项目周期性 `RPUSH` 会产生多条重复记录
- BLS Project Console 后端会按 `projectName` 去重，保留 `lastActiveAt` 最新的一条作为项目状态
### 2.2 `${projectName}_项目控制台` ### 2.2 `${projectName}_项目控制台`
- Redis 数据类型：**LIST**（作为项目向控制台追加的“消息队列/日志队列”） - Redis 数据类型：**LIST**（作为项目向控制台追加的"消息队列/日志队列"）
- 写入方式（推荐 FIFO）：`RPUSH ${projectName}_项目控制台 <json>` - 写入方式（推荐 FIFO）：`RPUSH ${projectName}_项目控制台 <json>`
value（推荐格式）：一条 JSON 字符串，表示“错误/调试信息”或日志记录。 value（推荐格式）：一条 JSON 字符串，表示"错误/调试信息"或日志记录。
推荐 JSON Schema（字段尽量保持稳定，便于控制台解析）： 推荐 JSON Schema（字段尽量保持稳定，便于控制台解析）：
@@ -103,11 +121,39 @@ value（推荐格式）：一条 JSON 字符串，表示“错误/调试信息
- `message`：日志文本 - `message`：日志文本
- `metadata`：可选对象（附加信息） - `metadata`：可选对象（附加信息）
## 3. 命令下发方式（HTTP API 控制） ## 3. 项目列表管理（重要）
控制台不再通过 Redis 写入控制指令队列；改为由 BLS Project Console 后端根据目标项目心跳里的 `apiBaseUrl` 直接调用目标项目 HTTP API。 ### 3.1 项目列表结构
### 3.1 控制台输入格式 `项目心跳` 为 LIST，列表元素为 JSON 字符串；其“逻辑结构”如下：
```json
[
{
"projectName": "订单系统",
"apiBaseUrl": "http://127.0.0.1:4001",
"lastActiveAt": 1760000000000
},
{
"projectName": "用户服务",
"apiBaseUrl": "http://127.0.0.1:4002",
"lastActiveAt": 1760000000001
}
]
```
### 3.2 外部项目对接建议
外部项目应当：
1. 定期写入 `项目心跳`（RPUSH 自己的心跳记录；允许产生多条记录，由控制台按 projectName 去重）
2. 追加 `${projectName}_项目控制台` 日志
## 4. 命令下发方式（HTTP API 控制）
由 BLS Project Console 后端根据目标项目心跳里的 `apiBaseUrl` 直接调用目标项目 HTTP API。
### 4.1 控制台输入格式
一行文本按空格拆分： 一行文本按空格拆分：
@@ -120,7 +166,7 @@ value（推荐格式）：一条 JSON 字符串，表示“错误/调试信息
- `reload force` - `reload force`
- `user/refreshCache tenantA` - `user/refreshCache tenantA`
### 3.2 目标项目需要提供的 API ### 4.2 目标项目需要提供的 API
后端默认使用 `POST` 调用： 后端默认使用 `POST` 调用：
@@ -139,18 +185,69 @@ value（推荐格式）：一条 JSON 字符串，表示“错误/调试信息
} }
``` ```
字段说明：
- `commandId`：唯一命令标识符
- `timestamp`：命令发送时间（ISO-8601 格式）
- `source`：命令来源标识
- `apiName`：API 接口名
- `args`：参数数组
- `argsText`：参数文本（空格连接）
返回建议： 返回建议：
- 2xx 表示成功 - 2xx 表示成功
- 非 2xx 表示失败（控制台会展示 upstreamStatus 与部分返回内容） - 非 2xx 表示失败（控制台会展示 upstreamStatus 与部分返回内容）
## 4. 兼容与错误处理建议 ### 4.3 在线/离线判定
发送命令前，系统会检查项目在线状态：
- 从 `项目心跳` 列表读取 `lastActiveAt`
- 若 `now - lastActiveAt > 10_000ms`，则认为该应用 **离线**，拒绝发送命令
- 否则认为 **在线**，允许发送命令
## 5. 与本项目代码的对应关系
- **后端 `/api/projects`**：只从 `项目心跳`（LIST）读取项目列表，返回所有项目及其在线状态
- **后端 `/api/commands`**：从 `项目心跳` 中查找目标项目的 `apiBaseUrl/lastActiveAt`，在线时调用目标项目 API
- **后端 `/api/logs`**：读取 `${projectName}_项目控制台`（LIST）；并基于 `项目心跳` 中该项目的 `lastActiveAt` 计算在线/离线与 API 地址信息
## 6. 兼容与错误处理建议
- JSON 解析失败：外部项目应记录错误，并丢弃该条消息（避免死循环阻塞消费）。 - JSON 解析失败：外部项目应记录错误，并丢弃该条消息（避免死循环阻塞消费）。
- 消息过长：建议控制单条消息大小（例如 < 64KB）。 - 消息过长：建议控制单条消息大小（例如 < 64KB）。
- 字符编码：统一 UTF-8。 - 字符编码：统一 UTF-8。
- 心跳超时：建议外部项目每 3 秒更新一次心跳，避免被误判为离线。
## 5. 与本项目代码的对应关系（实现中） ## 7. 数据迁移工具（旧数据导入）
- 后端通过 `/api/commands`：从 `${targetProjectName}_项目心跳` 读取 `apiBaseUrl` 与 `lastActiveAt`，在线时调用目标项目 API。 如果需要从旧格式迁移到新格式，可使用以下 API：
- 后端通过 `/api/logs`：读取 `${projectName}_项目控制台`；并基于 `${projectName}_项目心跳` 返回在线/离线与 API 地址信息。
```bash
POST /api/projects/migrate
Content-Type: application/json
{
"deleteOldKeys": false,
"dryRun": false
}
```
参数说明：
- `deleteOldKeys`：是否删除旧格式键（默认 false）
- `dryRun`：是否仅模拟运行（默认 false）
返回示例：
```json
{
"success": true,
"message": "数据迁移完成",
"migrated": 2,
"projects": [...],
"listKey": "项目心跳",
"deleteOldKeys": false
}
```

21
ecosystem.config.js Normal file
View File

@@ -0,0 +1,21 @@
module.exports = {
apps: [
{
name: 'bls-project-console',
script: './server.js',
cwd: '/vol1/1000/Docker/nginx/project/bls/bls_project_console/backend',
instances: 1,
autorestart: true,
watch: false,
max_memory_restart: '1G',
env: {
NODE_ENV: 'production',
PORT: 3001,
},
error_file: './logs/pm2-error.log',
out_file: './logs/pm2-out.log',
log_date_format: 'YYYY-MM-DD HH:mm:ss Z',
merge_logs: true,
},
],
};

28
openspec/changes/update-heartbeat-key-to-list/proposal.md Normal file
View File

@@ -0,0 +1,28 @@
# Change: Store project heartbeats as Redis LIST
## Why
当前项目将 `项目心跳` 存为 Redis STRING（JSON 数组），与外部项目的写入方式和并发更新场景不匹配；同时规范、文档与实现存在漂移（例如命令下发已改为 HTTP 调用，但规范仍描述 Redis 控制队列）。
## What Changes
- **BREAKING**：`项目心跳` 的 Redis 数据类型从 STRING 变更为 **LIST**。
- 心跳记录以 JSON 字符串写入 LIST，每条元素表示一个项目的心跳记录：`{ projectName, apiBaseUrl, lastActiveAt }`。
- 控制台后端按 `projectName` 去重，保留 `lastActiveAt` 最新的一条，作为项目列表/在线状态计算依据。
- 对齐 OpenSpec 与文档：明确 DB 固定为 15；日志来自 `${projectName}_项目控制台`（LIST）；命令下发通过 HTTP API 转发。
## Impact
- Affected specs: redis-connection, logging, command
- Affected code:
- src/backend/services/migrateHeartbeatData.js
- src/backend/routes/projects.js
- src/backend/routes/logs.js
- src/backend/routes/commands.js
- src/backend/server.js
- Affected docs:
- docs/redis-integration-protocol.md
- docs/redis-data-structure.md
- docs/openapi.yaml
- README.md

12
openspec/changes/update-heartbeat-key-to-list/specs/command/spec.md Normal file
View File

@@ -0,0 +1,12 @@
## MODIFIED Requirements
### Requirement: Command Sending to Redis
The system SHALL send commands to a target project's HTTP API.
#### Scenario: Sending a command to target project API
- **WHEN** the user enters a command in the console
- **AND** clicks the "Send" button
- **THEN** the backend SHALL resolve `apiBaseUrl` from the project's heartbeat
- **AND** it SHALL call `POST {apiBaseUrl}/{apiName}` with a structured payload
- **AND** the user SHALL receive a success confirmation if upstream returns 2xx

10
openspec/changes/update-heartbeat-key-to-list/specs/logging/spec.md Normal file
View File

@@ -0,0 +1,10 @@
## MODIFIED Requirements
### Requirement: Log Reading from Redis
The system SHALL read log records from a Redis LIST `${projectName}_项目控制台`.
#### Scenario: Reading logs by polling
- **WHEN** the user is viewing a project console
- **THEN** the system SHALL read the latest log entries via `LRANGE`
- **AND** it SHALL return logs in a user-friendly structure

21
openspec/changes/update-heartbeat-key-to-list/specs/redis-connection/spec.md Normal file
View File

@@ -0,0 +1,21 @@
## MODIFIED Requirements
### Requirement: Redis Connection Configuration
The system SHALL allow configuration of Redis connection parameters.
#### Scenario: Configuring Redis connection via environment variables
- **WHEN** the server starts with Redis environment variables set
- **THEN** it SHALL use those variables to configure the Redis connection
- **AND** it SHALL use Redis database 15
## ADDED Requirements
### Requirement: Project Heartbeat List Retrieval
The system SHALL read project heartbeats from Redis key `项目心跳` stored as a LIST.
#### Scenario: Reading projects list from Redis LIST
- **WHEN** the client requests the projects list
- **THEN** the system SHALL read `LRANGE 项目心跳 0 -1`
- **AND** it SHALL parse each list element as JSON heartbeat record
- **AND** it SHALL deduplicate by `projectName` and keep the latest `lastActiveAt`

9
openspec/changes/update-heartbeat-key-to-list/tasks.md Normal file
View File

@@ -0,0 +1,9 @@
## 1. Implementation
- [ ] 1.1 Update OpenSpec specs for redis-connection/logging/command
- [ ] 1.2 Update backend to read `项目心跳` as Redis LIST and dedupe projects
- [ ] 1.3 Update backend to write migrated heartbeats into LIST
- [ ] 1.4 Align backend port with Vite proxy/OpenAPI (default 3001)
- [ ] 1.5 Update docs to match new Redis protocol and current behavior
- [ ] 1.6 Update tests and validate with `npm test`

12
openspec/project.md
View File

@@ -39,7 +39,7 @@ BLS Project Console是一个前后端分离的Node.js项目，用于从Redis队
- **单元测试**: 对核心功能模块进行单元测试 - **单元测试**: 对核心功能模块进行单元测试
- **集成测试**: 测试API接口和Redis交互 - **集成测试**: 测试API接口和Redis交互
- **端到端测试**: 测试完整的用户流程 - **端到端测试**: 测试完整的用户流程
- **测试框架**: Jest (后端), Vitest (前端) - **测试框架**: Vitest + Supertest
### Git Workflow ### Git Workflow
@@ -59,10 +59,10 @@ BLS Project Console是一个前后端分离的Node.js项目，用于从Redis队
## Domain Context ## Domain Context
- **Redis队列**: 用于存储日志记录和控制台指令的消息队列 - **Redis 数据结构**: DB15 中使用 `项目心跳`（LIST）与 `${projectName}_项目控制台`（LIST）
- **日志记录**: 其他程序写入Redis队列的日志信息，包含时间戳、日志级别和消息内容 - **日志记录**: 外部程序向 `${projectName}_项目控制台` 追加日志 JSON；控制台轮询读取并展示
- **控制台指令**: 从控制台发送到Redis队列的命令，供其他程序读取和执行 - **项目心跳**: 外部程序向 `项目心跳` 追加心跳 JSON；控制台按 projectName 去重并判定在线状态
- **实时更新**: 控制台需要实时从Redis队列获取新的日志记录 - **控制台指令**: 控制台通过 HTTP 调用目标项目 API（由心跳中的 `apiBaseUrl` 提供）
## Important Constraints ## Important Constraints
@@ -77,4 +77,4 @@ BLS Project Console是一个前后端分离的Node.js项目，用于从Redis队
- **Redis**: 用于存储日志记录和控制台指令的消息队列服务 - **Redis**: 用于存储日志记录和控制台指令的消息队列服务
- 版本: 6.x+ - 版本: 6.x+
- 连接方式: Redis客户端(redis@^4.6.10) - 连接方式: Redis客户端(redis@^4.6.10)
- 主要用途: 日志队列和指令队列 - 主要用途: 心跳列表与日志队列

26
openspec/specs/command/spec.md
View File

@@ -1,34 +1,35 @@
# Command Capability Specification # Command Capability Specification
## Overview ## Overview
This specification defines the command capability for the BLS Project Console, which allows users to send console commands to Redis queues for other programs to read and execute. This specification defines the command capability for the BLS Project Console, which allows users to send console commands to target project HTTP APIs.
## Requirements ## Requirements
### Requirement: Command Sending to Redis ### Requirement: Command Sending to Redis
The system SHALL send commands to a Redis queue. The system SHALL send commands to a target project's HTTP API.
#### Scenario: Sending a command to Redis queue #### Scenario: Sending a command to target project API
- **WHEN** the user enters a command in the console - **WHEN** the user enters a command in the console
- **AND** clicks the "Send" button - **AND** clicks the "Send" button
- **THEN** the command SHALL be sent to the Redis queue - **THEN** the backend SHALL resolve `apiBaseUrl` from the project's heartbeat
- **AND** the user SHALL receive a success confirmation - **AND** it SHALL call `POST {apiBaseUrl}/{apiName}` with a structured payload
- **AND** the user SHALL receive a success confirmation if upstream returns 2xx
### Requirement: Command Validation ### Requirement: Command Validation
The system SHALL validate commands before sending them to Redis. The system SHALL validate commands before sending them to target project API.
#### Scenario: Validating an empty command #### Scenario: Validating an empty command
- **WHEN** the user tries to send an empty command - **WHEN** the user tries to send an empty command
- **THEN** the system SHALL display an error message - **THEN** the system SHALL display an error message
- **AND** the command SHALL NOT be sent to Redis - **AND** the command SHALL NOT be sent
#### Scenario: Validating a command with invalid characters #### Scenario: Validating a command with invalid characters
- **WHEN** the user tries to send a command with invalid characters - **WHEN** the user tries to send a command with invalid characters
- **THEN** the system SHALL display an error message - **THEN** the system SHALL display an error message
- **AND** the command SHALL NOT be sent to Redis - **AND** the command SHALL NOT be sent
### Requirement: Command History ### Requirement: Command History
The system SHALL maintain a history of sent commands. The system SHALL maintain a history of sent commands in the console UI.
#### Scenario: Viewing command history #### Scenario: Viewing command history
- **WHEN** the user opens the command history - **WHEN** the user opens the command history
@@ -36,12 +37,11 @@ The system SHALL maintain a history of sent commands.
- **AND** the user SHALL be able to select a command from the history to resend - **AND** the user SHALL be able to select a command from the history to resend
### Requirement: Command Response Handling ### Requirement: Command Response Handling
The system SHALL handle responses from commands sent to Redis. The system SHALL handle responses from commands sent to target project API.
#### Scenario: Receiving a command response #### Scenario: Receiving a command response
- **WHEN** a command response is received from Redis - **WHEN** the target project API responds
- **THEN** the system SHALL display the response in the console - **THEN** the system SHALL display the response status in the console
- **AND** the response SHALL be associated with the original command
## Data Model ## Data Model

17
openspec/specs/logging/spec.md
View File

@@ -1,18 +1,17 @@
# Logging Capability Specification # Logging Capability Specification
## Overview ## Overview
This specification defines the logging capability for the BLS Project Console, which allows the system to read log records from Redis queues and display them in the console interface. This specification defines the logging capability for the BLS Project Console, which allows the system to read log records from Redis lists and display them in the console interface.
## Requirements ## Requirements
### Requirement: Log Reading from Redis ### Requirement: Log Reading from Redis
The system SHALL read log records from a Redis queue. The system SHALL read log records from a Redis LIST `${projectName}_项目控制台`.
#### Scenario: Reading logs from Redis queue #### Scenario: Reading logs by polling
- **WHEN** the server starts - **WHEN** the user is viewing a project console
- **THEN** it SHALL establish a connection to the Redis queue - **THEN** the system SHALL read the latest log entries via `LRANGE`
- **AND** it SHALL begin listening for new log records - **AND** it SHALL return logs in a user-friendly structure
- **AND** it SHALL store log records in memory for display
### Requirement: Log Display in Console ### Requirement: Log Display in Console
The system SHALL display log records in a user-friendly format. The system SHALL display log records in a user-friendly format.
@@ -83,7 +82,3 @@ The system SHALL automatically refresh logs in real-time.
} }
} }
``` ```
### GET /api/logs/live
- **Description**: Establish a WebSocket connection for real-time log updates
- **Response**: Continuous stream of log records

18
openspec/specs/redis-connection/spec.md
View File

@@ -1,7 +1,7 @@
# Redis Connection Capability Specification # Redis Connection Capability Specification
## Overview ## Overview
This specification defines the Redis connection capability for the BLS Project Console, which manages the connection between the system and the Redis server for reading logs and sending commands. This specification defines the Redis connection capability for the BLS Project Console, which manages the connection between the system and the Redis server for reading logs and retrieving project heartbeats.
## Requirements ## Requirements
@@ -20,6 +20,7 @@ The system SHALL allow configuration of Redis connection parameters.
- **WHEN** the server starts with Redis environment variables set - **WHEN** the server starts with Redis environment variables set
- **THEN** it SHALL use those variables to configure the Redis connection - **THEN** it SHALL use those variables to configure the Redis connection
- **AND** it SHALL override default values - **AND** it SHALL override default values
- **AND** it SHALL use Redis database 15
### Requirement: Redis Connection Reconnection ### Requirement: Redis Connection Reconnection
The system SHALL automatically reconnect to Redis if the connection is lost. The system SHALL automatically reconnect to Redis if the connection is lost.
@@ -47,6 +48,15 @@ The system SHALL monitor the Redis connection status.
- **THEN** the system SHALL update the connection status in the UI - **THEN** the system SHALL update the connection status in the UI
- **AND** it SHALL log the status change - **AND** it SHALL log the status change
### Requirement: Project Heartbeat List Retrieval
The system SHALL read project heartbeats from Redis key `项目心跳` stored as a LIST.
#### Scenario: Reading projects list from Redis LIST
- **WHEN** the client requests the projects list
- **THEN** the system SHALL read `LRANGE 项目心跳 0 -1`
- **AND** it SHALL parse each list element as JSON heartbeat record
- **AND** it SHALL deduplicate by `projectName` and keep the latest `lastActiveAt`
## Data Model ## Data Model
### Redis Connection Configuration ### Redis Connection Configuration
@@ -139,3 +149,9 @@ The system SHALL monitor the Redis connection status.
"deleteOldKeys": false "deleteOldKeys": false
} }
``` ```
## Redis Data Structures
### Key: 项目心跳
- **Type**: LIST
- **Element**: JSON string `{"projectName":"...","apiBaseUrl":"...","lastActiveAt":1768566165572}`

2
package.json
View File

@@ -11,7 +11,7 @@
"start:dev": "nodemon src/backend/server.js", "start:dev": "nodemon src/backend/server.js",
"test": "vitest run", "test": "vitest run",
"test:watch": "vitest", "test:watch": "vitest",
"lint": "eslint . --ext .js,.vue --config .eslintrc.cjs", "lint": "eslint src --ext .js,.vue --config .eslintrc.cjs",
"format": "prettier --write ." "format": "prettier --write ."
}, },
"dependencies": { "dependencies": {

50
src/backend/routes/commands.js
View File

@@ -53,14 +53,15 @@ function buildTargetUrl(apiBaseUrl, apiName) {
function truncateForLog(value, maxLen = 2000) { function truncateForLog(value, maxLen = 2000) {
if (value == null) return value; if (value == null) return value;
if (typeof value === 'string') return value.length > maxLen ? `${value.slice(0, maxLen)}…` : value; if (typeof value === 'string')
return value.length > maxLen ? `${value.slice(0, maxLen)}…` : value;
return value; return value;
} }
async function getProjectHeartbeat(redis, projectName) { async function getProjectHeartbeat(redis, projectName) {
try { try {
const projectsList = await getProjectsList(); const projectsList = await getProjectsList(redis);
const project = projectsList.find(p => p.projectName === projectName); const project = projectsList.find((p) => p.projectName === projectName);
if (project) { if (project) {
return { return {
@@ -69,18 +70,11 @@ async function getProjectHeartbeat(redis, projectName) {
}; };
} }
} catch (err) { } catch (err) {
console.error('[getProjectHeartbeat] Failed to get from projects list:', err); console.error(
'[getProjectHeartbeat] Failed to get from projects list:',
err,
);
} }
const heartbeatRaw = await redis.get(projectHeartbeatKey(projectName));
if (heartbeatRaw) {
try {
return JSON.parse(heartbeatRaw);
} catch {
return null;
}
}
return null; return null;
} }
@@ -133,7 +127,10 @@ router.post('/', async (req, res) => {
} }
const heartbeatKey = projectHeartbeatKey(targetProjectName.trim()); const heartbeatKey = projectHeartbeatKey(targetProjectName.trim());
const heartbeat = await getProjectHeartbeat(redis, targetProjectName.trim()); const heartbeat = await getProjectHeartbeat(
redis,
targetProjectName.trim(),
);
if (!heartbeat) { if (!heartbeat) {
return res.status(503).json({ return res.status(503).json({
@@ -142,7 +139,10 @@ router.post('/', async (req, res) => {
}); });
} }
const apiBaseUrl = typeof heartbeat.apiBaseUrl === 'string' ? heartbeat.apiBaseUrl.trim() : ''; const apiBaseUrl =
typeof heartbeat.apiBaseUrl === 'string'
? heartbeat.apiBaseUrl.trim()
: '';
const lastActiveAt = parseLastActiveAt(heartbeat?.lastActiveAt); const lastActiveAt = parseLastActiveAt(heartbeat?.lastActiveAt);
if (!apiBaseUrl) { if (!apiBaseUrl) {
@@ -152,9 +152,16 @@ router.post('/', async (req, res) => {
}); });
} }
const offlineThresholdMs = Number.parseInt(process.env.HEARTBEAT_OFFLINE_THRESHOLD_MS || '10000', 10); const offlineThresholdMs = Number.parseInt(
process.env.HEARTBEAT_OFFLINE_THRESHOLD_MS || '10000',
10,
);
const now = Date.now(); const now = Date.now();
if (!lastActiveAt || (Number.isFinite(offlineThresholdMs) && now - lastActiveAt > offlineThresholdMs)) { if (
!lastActiveAt ||
(Number.isFinite(offlineThresholdMs) &&
now - lastActiveAt > offlineThresholdMs)
) {
return res.status(503).json({ return res.status(503).json({
success: false, success: false,
message: '目标项目已离线（心跳超时）', message: '目标项目已离线（心跳超时）',
@@ -170,7 +177,10 @@ router.post('/', async (req, res) => {
}); });
} }
const timeoutMs = Number.parseInt(process.env.COMMAND_API_TIMEOUT_MS || '5000', 10); const timeoutMs = Number.parseInt(
process.env.COMMAND_API_TIMEOUT_MS || '5000',
10,
);
const resp = await axios.post(targetUrl, payload, { const resp = await axios.post(targetUrl, payload, {
timeout: Number.isFinite(timeoutMs) ? timeoutMs : 5000, timeout: Number.isFinite(timeoutMs) ? timeoutMs : 5000,
validateStatus: () => true, validateStatus: () => true,
@@ -209,4 +219,4 @@ router.post('/', async (req, res) => {
} }
}); });
export default router; export default router;

268
src/backend/routes/logs.js
View File

@@ -3,15 +3,102 @@ import express from 'express';
const router = express.Router(); const router = express.Router();
import { getRedisClient } from '../services/redisClient.js'; import { getRedisClient } from '../services/redisClient.js';
import { projectConsoleKey, projectHeartbeatKey } from '../services/redisKeys.js'; import { projectConsoleKey } from '../services/redisKeys.js';
import { getProjectsList } from '../services/migrateHeartbeatData.js'; import { getProjectsList } from '../services/migrateHeartbeatData.js';
const LOGS_MAX_LEN = 1000;
const LOG_TTL_MS = 24 * 60 * 60 * 1000;
function parsePositiveInt(value, defaultValue) { function parsePositiveInt(value, defaultValue) {
const num = Number.parseInt(String(value), 10); const num = Number.parseInt(String(value), 10);
if (!Number.isFinite(num) || num <= 0) return defaultValue; if (!Number.isFinite(num) || num <= 0) return defaultValue;
return num; return num;
} }
function parseDurationMs(value, defaultMs) {
if (value == null) return defaultMs;
if (typeof value === 'number' && Number.isFinite(value)) {
if (value >= 60_000) return value;
return defaultMs;
}
const str = String(value).trim();
if (!str) return defaultMs;
const plain = Number(str);
if (Number.isFinite(plain)) {
if (plain >= 60_000) return plain;
return defaultMs;
}
const match = /^(\d+(?:\.\d+)?)\s*(ms|s|m|h|d)$/i.exec(str);
if (!match) return defaultMs;
const amount = Number(match[1]);
if (!Number.isFinite(amount) || amount <= 0) return defaultMs;
const unit = match[2].toLowerCase();
const unitMs =
unit === 'ms'
? 1
: unit === 's'
? 1000
: unit === 'm'
? 60_000
: unit === 'h'
? 3_600_000
: 86_400_000;
const ms = Math.round(amount * unitMs);
if (!Number.isFinite(ms) || ms < 60_000) return defaultMs;
return ms;
}
function safeJsonParse(value) {
try {
return JSON.parse(String(value));
} catch {
return null;
}
}
function parseLogTimestampMs(value) {
if (typeof value === 'number' && Number.isFinite(value)) {
let ts = value;
while (Math.abs(ts) > 1e15) ts = Math.trunc(ts / 1000);
if (Math.abs(ts) > 0 && Math.abs(ts) < 1e11) ts *= 1000;
const now = Date.now();
if (ts < 946_684_800_000 || ts > now + 7 * 86_400_000) return null;
return ts;
}
if (typeof value === 'string') {
const asNum = Number(value);
if (Number.isFinite(asNum)) {
let ts = asNum;
while (Math.abs(ts) > 1e15) ts = Math.trunc(ts / 1000);
if (Math.abs(ts) > 0 && Math.abs(ts) < 1e11) ts *= 1000;
const now = Date.now();
if (ts < 946_684_800_000 || ts > now + 7 * 86_400_000) return null;
return ts;
}
const asDate = Date.parse(value);
if (Number.isFinite(asDate)) {
const now = Date.now();
if (asDate < 946_684_800_000 || asDate > now + 7 * 86_400_000) return null;
return asDate;
}
}
return null;
}
function shouldKeepRawLog(raw, cutoffMs) {
const parsed = safeJsonParse(raw);
if (!parsed || typeof parsed !== 'object') return true;
const tsMs = parseLogTimestampMs(parsed.timestamp);
if (!tsMs) return true;
return tsMs >= cutoffMs;
}
function parseLastActiveAt(value) { function parseLastActiveAt(value) {
if (typeof value === 'number' && Number.isFinite(value)) return value; if (typeof value === 'number' && Number.isFinite(value)) return value;
if (typeof value === 'string') { if (typeof value === 'string') {
@@ -25,8 +112,8 @@ function parseLastActiveAt(value) {
async function getProjectHeartbeat(redis, projectName) { async function getProjectHeartbeat(redis, projectName) {
try { try {
const projectsList = await getProjectsList(); const projectsList = await getProjectsList(redis);
const project = projectsList.find(p => p.projectName === projectName); const project = projectsList.find((p) => p.projectName === projectName);
if (project) { if (project) {
return { return {
@@ -35,25 +122,61 @@ async function getProjectHeartbeat(redis, projectName) {
}; };
} }
} catch (err) { } catch (err) {
console.error('[getProjectHeartbeat] Failed to get from projects list:', err); console.error(
'[getProjectHeartbeat] Failed to get from projects list:',
err,
);
} }
return null;
}
const heartbeatRaw = await redis.get(projectHeartbeatKey(projectName)); async function pruneAndReadLogsAtomically(redis, key, limit) {
if (heartbeatRaw) { const maxLen = LOGS_MAX_LEN;
const MIN_TTL_MS = 3_600_000;
const configuredTtlMs = parseDurationMs(process.env.LOG_TTL_MS, LOG_TTL_MS);
const effectiveTtlMs = Math.max(configuredTtlMs, MIN_TTL_MS);
const cutoffMs = Date.now() - effectiveTtlMs;
const effectiveLimit = Math.min(Math.max(1, limit), maxLen);
for (let attempt = 0; attempt < 5; attempt += 1) {
try { try {
return JSON.parse(heartbeatRaw); await redis.watch(key);
} catch { const rawItems = await redis.lRange(key, 0, -1);
return null;
const kept = rawItems
.filter((raw) => shouldKeepRawLog(raw, cutoffMs))
.slice(-maxLen);
const needsRewrite = rawItems.length !== kept.length || rawItems.length > maxLen;
if (!needsRewrite) return kept.slice(-effectiveLimit);
if (kept.length === 0) return kept.slice(-effectiveLimit);
const multi = redis.multi();
multi.del(key);
multi.rPush(key, ...kept);
const execResult = await multi.exec();
if (execResult === null) continue;
return kept.slice(-effectiveLimit);
} finally {
if (typeof redis.unwatch === 'function') {
await redis.unwatch();
}
} }
} }
return null; const rawItems = await redis.lRange(key, -effectiveLimit, -1);
return rawItems;
} }
// 获取日志列表 // 获取日志列表
router.get('/', async (req, res) => { router.get('/', async (req, res) => {
const projectName = typeof req.query.projectName === 'string' ? req.query.projectName.trim() : ''; const projectName =
const limit = parsePositiveInt(req.query.limit, 200); typeof req.query.projectName === 'string'
? req.query.projectName.trim()
: '';
const limit = parsePositiveInt(req.query.limit, LOGS_MAX_LEN);
if (!projectName) { if (!projectName) {
return res.status(200).json({ return res.status(200).json({
@@ -73,52 +196,63 @@ router.get('/', async (req, res) => {
} }
const key = projectConsoleKey(projectName); const key = projectConsoleKey(projectName);
const list = await redis.lRange(key, -limit, -1); const list = await pruneAndReadLogsAtomically(redis, key, limit);
const logs = list const logs = list.map((raw, idx) => {
.map((raw, idx) => { try {
try { const parsed = JSON.parse(raw);
const parsed = JSON.parse(raw); const timestamp = parsed.timestamp || new Date().toISOString();
const timestamp = parsed.timestamp || new Date().toISOString(); const level = (parsed.level || 'info').toString().toLowerCase();
const level = (parsed.level || 'info').toString().toLowerCase(); const message = parsed.message != null ? String(parsed.message) : '';
const message = parsed.message != null ? String(parsed.message) : ''; return {
return { id: parsed.id || `log-${timestamp}-${idx}`,
id: parsed.id || `log-${timestamp}-${idx}`, timestamp,
timestamp, level,
level, message,
message, metadata:
metadata: parsed.metadata && typeof parsed.metadata === 'object' ? parsed.metadata : undefined, parsed.metadata && typeof parsed.metadata === 'object'
}; ? parsed.metadata
} catch { : undefined,
return { };
id: `log-${Date.now()}-${idx}`, } catch {
timestamp: new Date().toISOString(), return {
level: 'info', id: `log-${Date.now()}-${idx}`,
message: raw, timestamp: new Date().toISOString(),
}; level: 'info',
} message: raw,
}); };
}
});
const heartbeat = await getProjectHeartbeat(redis, projectName); const heartbeat = await getProjectHeartbeat(redis, projectName);
const offlineThresholdMs = Number.parseInt(process.env.HEARTBEAT_OFFLINE_THRESHOLD_MS || '10000', 10); const offlineThresholdMs = Number.parseInt(
process.env.HEARTBEAT_OFFLINE_THRESHOLD_MS || '10000',
10,
);
const now = Date.now(); const now = Date.now();
const lastActiveAt = parseLastActiveAt(heartbeat?.lastActiveAt); const lastActiveAt = parseLastActiveAt(heartbeat?.lastActiveAt);
const ageMs = lastActiveAt ? now - lastActiveAt : null; const ageMs = lastActiveAt ? now - lastActiveAt : null;
const isOnline = lastActiveAt && Number.isFinite(offlineThresholdMs) const isOnline =
? ageMs <= offlineThresholdMs lastActiveAt && Number.isFinite(offlineThresholdMs)
: Boolean(lastActiveAt); ? ageMs <= offlineThresholdMs
: Boolean(lastActiveAt);
const computedStatus = heartbeat ? (isOnline ? '在线' : '离线') : null; const computedStatus = heartbeat ? (isOnline ? '在线' : '离线') : null;
return res.status(200).json({ return res.status(200).json({
logs, logs,
projectStatus: computedStatus || null, projectStatus: computedStatus || null,
heartbeat: heartbeat ? { heartbeat: heartbeat
apiBaseUrl: typeof heartbeat.apiBaseUrl === 'string' ? heartbeat.apiBaseUrl : null, ? {
lastActiveAt: lastActiveAt || null, apiBaseUrl:
isOnline, typeof heartbeat.apiBaseUrl === 'string'
ageMs, ? heartbeat.apiBaseUrl
} : null, : null,
lastActiveAt: lastActiveAt || null,
isOnline,
ageMs,
}
: null,
}); });
} catch (err) { } catch (err) {
console.error('Failed to read logs', err); console.error('Failed to read logs', err);
@@ -130,4 +264,44 @@ router.get('/', async (req, res) => {
} }
}); });
export default router; router.post('/clear', async (req, res) => {
const projectName =
typeof req.body?.projectName === 'string'
? req.body.projectName.trim()
: '';
if (!projectName) {
return res.status(400).json({
success: false,
message: 'projectName 不能为空',
});
}
try {
const redis = req.app?.locals?.redis || (await getRedisClient());
if (!redis?.isReady) {
return res.status(503).json({
success: false,
message: 'Redis 未就绪',
});
}
const key = projectConsoleKey(projectName);
const removed = await redis.del(key);
const list = await redis.lRange(key, 0, -1);
return res.status(200).json({
success: true,
removed: Number.isFinite(removed) ? removed : 0,
logs: Array.isArray(list) ? list : [],
});
} catch (err) {
console.error('Failed to clear logs', err);
return res.status(500).json({
success: false,
message: '清空日志失败',
});
}
});
export default router;

311
src/backend/routes/projects.integration.test.js
View File

@@ -8,9 +8,13 @@ describe('projects API', () => {
it('GET /api/projects returns projects from unified list', async () => { it('GET /api/projects returns projects from unified list', async () => {
const now = Date.now(); const now = Date.now();
const redis = createFakeRedis({ const redis = createFakeRedis({
项目心跳: JSON.stringify([ 项目心跳: [
{ projectName: 'Demo', apiBaseUrl: 'http://localhost:8080', lastActiveAt: now }, JSON.stringify({
]), projectName: 'Demo',
apiBaseUrl: 'http://localhost:8080',
lastActiveAt: now,
}),
],
}); });
const app = createApp({ redis }); const app = createApp({ redis });
@@ -29,6 +33,35 @@ describe('projects API', () => {
); );
}); });
it('GET /api/projects prunes expired heartbeats from Redis list', async () => {
const now = Date.now();
const redis = createFakeRedis({
项目心跳: [
JSON.stringify({
projectName: 'Demo',
apiBaseUrl: 'http://localhost:8080',
lastActiveAt: now - 60_000,
}),
JSON.stringify({
projectName: 'Demo',
apiBaseUrl: 'http://localhost:8080',
lastActiveAt: now,
}),
],
});
const app = createApp({ redis });
const resp = await request(app).get('/api/projects');
expect(resp.status).toBe(200);
expect(resp.body.success).toBe(true);
expect(resp.body.count).toBe(1);
const listItems = await redis.lRange('项目心跳', 0, -1);
expect(listItems.length).toBe(1);
expect(JSON.parse(listItems[0]).lastActiveAt).toBe(now);
});
it('POST /api/projects/migrate migrates old *_项目心跳 keys into 项目心跳 list', async () => { it('POST /api/projects/migrate migrates old *_项目心跳 keys into 项目心跳 list', async () => {
const now = Date.now(); const now = Date.now();
const redis = createFakeRedis({ const redis = createFakeRedis({
@@ -47,11 +80,11 @@ describe('projects API', () => {
expect(resp.body.success).toBe(true); expect(resp.body.success).toBe(true);
expect(resp.body.migrated).toBe(1); expect(resp.body.migrated).toBe(1);
const listRaw = await redis.get('项目心跳'); const listItems = await redis.lRange('项目心跳', 0, -1);
expect(typeof listRaw).toBe('string'); expect(Array.isArray(listItems)).toBe(true);
const list = JSON.parse(listRaw); expect(listItems.length).toBe(1);
expect(Array.isArray(list)).toBe(true); const first = JSON.parse(listItems[0]);
expect(list[0]).toMatchObject({ expect(first).toMatchObject({
projectName: 'A', projectName: 'A',
apiBaseUrl: 'http://a', apiBaseUrl: 'http://a',
}); });
@@ -60,3 +93,265 @@ describe('projects API', () => {
expect(old).toBeNull(); expect(old).toBeNull();
}); });
}); });
describe('logs API', () => {
it('GET /api/logs uses LOG_TTL_MS=24h without wiping recent logs', async () => {
const prev = process.env.LOG_TTL_MS;
process.env.LOG_TTL_MS = '24h';
try {
const now = Date.now();
const projectName = 'Demo';
const key = `${projectName}_项目控制台`;
const redis = createFakeRedis({
[key]: [
JSON.stringify({
id: 'new',
timestamp: new Date(now - 60 * 60 * 1000).toISOString(),
level: 'info',
message: 'new',
}),
],
});
const app = createApp({ redis });
const resp = await request(app)
.get('/api/logs')
.query({ projectName, limit: 1000 });
expect(resp.status).toBe(200);
expect(resp.body.logs.length).toBe(1);
expect(resp.body.logs[0].id).toBe('new');
const listItems = await redis.lRange(key, 0, -1);
expect(listItems.length).toBe(1);
} finally {
process.env.LOG_TTL_MS = prev;
}
});
it('GET /api/logs ignores too-small LOG_TTL_MS to avoid mass deletion', async () => {
const prev = process.env.LOG_TTL_MS;
process.env.LOG_TTL_MS = '24';
try {
const now = Date.now();
const projectName = 'Demo';
const key = `${projectName}_项目控制台`;
const redis = createFakeRedis({
[key]: [
JSON.stringify({
id: 'new',
timestamp: new Date(now - 60 * 60 * 1000).toISOString(),
level: 'info',
message: 'new',
}),
],
});
const app = createApp({ redis });
const resp = await request(app)
.get('/api/logs')
.query({ projectName, limit: 1000 });
expect(resp.status).toBe(200);
expect(resp.body.logs.length).toBe(1);
expect(resp.body.logs[0].id).toBe('new');
const listItems = await redis.lRange(key, 0, -1);
expect(listItems.length).toBe(1);
} finally {
process.env.LOG_TTL_MS = prev;
}
});
it('GET /api/logs prunes logs older than 24h and returns latest', async () => {
const now = Date.now();
const projectName = 'Demo';
const key = `${projectName}_项目控制台`;
const redis = createFakeRedis({
[key]: [
JSON.stringify({
id: 'old',
timestamp: new Date(now - 25 * 60 * 60 * 1000).toISOString(),
level: 'info',
message: 'old',
}),
JSON.stringify({
id: 'new',
timestamp: new Date(now - 1000).toISOString(),
level: 'info',
message: 'new',
}),
],
});
const app = createApp({ redis });
const resp = await request(app).get('/api/logs').query({ projectName, limit: 1000 });
expect(resp.status).toBe(200);
expect(Array.isArray(resp.body.logs)).toBe(true);
expect(resp.body.logs.length).toBe(1);
expect(resp.body.logs[0]).toMatchObject({
id: 'new',
message: 'new',
});
const listItems = await redis.lRange(key, 0, -1);
expect(listItems.length).toBe(1);
expect(JSON.parse(listItems[0]).id).toBe('new');
});
it('GET /api/logs keeps unix-second timestamps and prunes correctly', async () => {
const now = Date.now();
const nowSec = Math.floor(now / 1000);
const projectName = 'Demo';
const key = `${projectName}_项目控制台`;
const redis = createFakeRedis({
[key]: [
JSON.stringify({
id: 'old',
timestamp: nowSec - 25 * 60 * 60,
level: 'info',
message: 'old',
}),
JSON.stringify({
id: 'new',
timestamp: nowSec - 1,
level: 'info',
message: 'new',
}),
],
});
const app = createApp({ redis });
const resp = await request(app)
.get('/api/logs')
.query({ projectName, limit: 1000 });
expect(resp.status).toBe(200);
expect(Array.isArray(resp.body.logs)).toBe(true);
expect(resp.body.logs.length).toBe(1);
expect(resp.body.logs[0]).toMatchObject({
id: 'new',
message: 'new',
});
const listItems = await redis.lRange(key, 0, -1);
expect(listItems.length).toBe(1);
expect(JSON.parse(listItems[0]).id).toBe('new');
});
it('GET /api/logs keeps numeric-string unix-second timestamps and prunes correctly', async () => {
const now = Date.now();
const nowSec = Math.floor(now / 1000);
const projectName = 'Demo';
const key = `${projectName}_项目控制台`;
const redis = createFakeRedis({
[key]: [
JSON.stringify({
id: 'old',
timestamp: String(nowSec - 25 * 60 * 60),
level: 'info',
message: 'old',
}),
JSON.stringify({
id: 'new',
timestamp: String(nowSec - 1),
level: 'info',
message: 'new',
}),
],
});
const app = createApp({ redis });
const resp = await request(app)
.get('/api/logs')
.query({ projectName, limit: 1000 });
expect(resp.status).toBe(200);
expect(Array.isArray(resp.body.logs)).toBe(true);
expect(resp.body.logs.length).toBe(1);
expect(resp.body.logs[0]).toMatchObject({
id: 'new',
message: 'new',
});
const listItems = await redis.lRange(key, 0, -1);
expect(listItems.length).toBe(1);
expect(JSON.parse(listItems[0]).id).toBe('new');
});
it('GET /api/logs does not delete plain-string log lines', async () => {
const projectName = 'Demo';
const key = `${projectName}_项目控制台`;
const redis = createFakeRedis({
[key]: [ 'plain log line' ],
});
const app = createApp({ redis });
const resp = await request(app)
.get('/api/logs')
.query({ projectName, limit: 1000 });
expect(resp.status).toBe(200);
expect(resp.body.logs.length).toBe(1);
expect(resp.body.logs[0].message).toBe('plain log line');
const listItems = await redis.lRange(key, 0, -1);
expect(listItems.length).toBe(1);
expect(listItems[0]).toBe('plain log line');
});
it('GET /api/logs does not delete logs with non-epoch numeric timestamps', async () => {
const projectName = 'Demo';
const key = `${projectName}_项目控制台`;
const redis = createFakeRedis({
[key]: [
JSON.stringify({
id: 'x',
timestamp: 12345,
level: 'info',
message: 'x',
}),
],
});
const app = createApp({ redis });
const resp = await request(app)
.get('/api/logs')
.query({ projectName, limit: 1000 });
expect(resp.status).toBe(200);
expect(resp.body.logs.length).toBe(1);
expect(resp.body.logs[0].message).toBe('x');
const listItems = await redis.lRange(key, 0, -1);
expect(listItems.length).toBe(1);
expect(JSON.parse(listItems[0]).id).toBe('x');
});
it('POST /api/logs/clear deletes all logs for project', async () => {
const projectName = 'Demo';
const key = `${projectName}_项目控制台`;
const redis = createFakeRedis({
[key]: [
JSON.stringify({
id: 'a',
timestamp: new Date().toISOString(),
level: 'info',
message: 'a',
}),
],
});
const app = createApp({ redis });
const resp = await request(app).post('/api/logs/clear').send({ projectName });
expect(resp.status).toBe(200);
expect(resp.body.success).toBe(true);
const listItems = await redis.lRange(key, 0, -1);
expect(listItems.length).toBe(0);
});
});

6
src/backend/routes/projects.js
View File

@@ -50,7 +50,7 @@ router.get('/', async (req, res) => {
}); });
} }
const projectsList = await getProjectsList(); const projectsList = await getProjectsList(redis);
const projects = projectsList.map(project => { const projects = projectsList.map(project => {
const statusInfo = computeProjectStatus(project); const statusInfo = computeProjectStatus(project);
return { return {
@@ -81,7 +81,9 @@ router.post('/migrate', async (req, res) => {
const { deleteOldKeys = false, dryRun = false } = req.body; const { deleteOldKeys = false, dryRun = false } = req.body;
try { try {
const redis = req.app?.locals?.redis || (await getRedisClient());
const result = await migrateHeartbeatData({ const result = await migrateHeartbeatData({
redis,
deleteOldKeys: Boolean(deleteOldKeys), deleteOldKeys: Boolean(deleteOldKeys),
dryRun: Boolean(dryRun), dryRun: Boolean(dryRun),
}); });
@@ -101,4 +103,4 @@ router.post('/migrate', async (req, res) => {
} }
}); });
export default router; export default router;

28
src/backend/server.js
View File

@@ -4,9 +4,16 @@ import logRoutes from './routes/logs.js';
import commandRoutes from './routes/commands.js'; import commandRoutes from './routes/commands.js';
import projectRoutes from './routes/projects.js'; import projectRoutes from './routes/projects.js';
import { getRedisClient } from './services/redisClient.js'; import { getRedisClient } from './services/redisClient.js';
import { pruneProjectsHeartbeatList } from './services/migrateHeartbeatData.js';
const app = express(); const app = express();
const PORT = 3001;
function parsePort(value, defaultPort) {
const parsed = Number.parseInt(String(value || ''), 10);
return Number.isFinite(parsed) ? parsed : defaultPort;
}
const PORT = parsePort(process.env.PORT, 3001);
app.use(cors()); app.use(cors());
app.use(express.json()); app.use(express.json());
@@ -19,7 +26,6 @@ app.get('/api/health', (req, res) => {
res.status(200).json({ status: 'ok' }); res.status(200).json({ status: 'ok' });
}); });
// 启动服务器
const server = app.listen(PORT, async () => { const server = app.listen(PORT, async () => {
console.log(`Server running on port ${PORT}`); console.log(`Server running on port ${PORT}`);
@@ -27,6 +33,15 @@ const server = app.listen(PORT, async () => {
const redis = await getRedisClient(); const redis = await getRedisClient();
app.locals.redis = redis; app.locals.redis = redis;
console.log('[redis] client attached to app.locals'); console.log('[redis] client attached to app.locals');
const intervalMs = 10_000;
app.locals.heartbeatPruneInterval = setInterval(async () => {
try {
await pruneProjectsHeartbeatList(redis);
} catch (err) {
void err;
}
}, intervalMs);
} catch (err) { } catch (err) {
console.error('[redis] failed to connect on startup', err); console.error('[redis] failed to connect on startup', err);
} }
@@ -34,12 +49,15 @@ const server = app.listen(PORT, async () => {
process.on('SIGINT', async () => { process.on('SIGINT', async () => {
try { try {
if (app.locals.heartbeatPruneInterval) {
clearInterval(app.locals.heartbeatPruneInterval);
}
if (app.locals.redis) { if (app.locals.redis) {
await app.locals.redis.quit(); await app.locals.redis.quit();
} }
} catch { } catch (err) {
// ignore void err;
} finally { } finally {
server.close(() => process.exit(0)); server.close(() => process.exit(0));
} }
}); });

265
src/backend/services/migrateHeartbeatData.js
View File

@@ -1,7 +1,10 @@
import { getRedisClient } from './redisClient.js'; import { getRedisClient } from './redisClient.js';
import { projectsListKey } from './redisKeys.js'; import { projectsListKey } from './redisKeys.js';
function parseLastActiveAt(value) { const HEARTBEAT_TTL_MS = 30_000;
const PROJECTS_LIST_MAX_LEN = 2000;
export function parseLastActiveAt(value) {
if (typeof value === 'number' && Number.isFinite(value)) return value; if (typeof value === 'number' && Number.isFinite(value)) return value;
if (typeof value === 'string') { if (typeof value === 'string') {
const asNum = Number(value); const asNum = Number(value);
@@ -12,10 +15,210 @@ function parseLastActiveAt(value) {
return null; return null;
} }
export async function migrateHeartbeatData(options = {}) { function safeJsonParse(value) {
const { deleteOldKeys = false, dryRun = false } = options; try {
return JSON.parse(String(value));
} catch {
return null;
}
}
const redis = await getRedisClient(); function normalizeHeartbeatRecord(input) {
if (!input || typeof input !== 'object') return null;
const projectName =
typeof input.projectName === 'string' ? input.projectName.trim() : '';
if (!projectName) return null;
const apiBaseUrl =
typeof input.apiBaseUrl === 'string' && input.apiBaseUrl.trim()
? input.apiBaseUrl.trim()
: null;
const lastActiveAt = parseLastActiveAt(input.lastActiveAt);
return {
projectName,
apiBaseUrl,
lastActiveAt: lastActiveAt || null,
};
}
export function normalizeProjectEntry(input) {
const normalized = normalizeHeartbeatRecord(input);
if (!normalized) return null;
return {
projectName: normalized.projectName,
apiBaseUrl: normalized.apiBaseUrl,
lastActiveAt: normalized.lastActiveAt,
};
}
function dedupeHeartbeatRecords(records) {
const map = new Map();
for (const record of records) {
if (!record?.projectName) continue;
const existing = map.get(record.projectName);
if (!existing) {
map.set(record.projectName, record);
continue;
}
const a = parseLastActiveAt(existing.lastActiveAt) || -Infinity;
const b = parseLastActiveAt(record.lastActiveAt) || -Infinity;
if (b > a) {
map.set(record.projectName, record);
continue;
}
if (b === a && !existing.apiBaseUrl && record.apiBaseUrl) {
map.set(record.projectName, record);
}
}
return Array.from(map.values());
}
export function normalizeProjectsList(list) {
const normalized = (list || [])
.map((item) => normalizeProjectEntry(item))
.filter(Boolean);
return dedupeHeartbeatRecords(normalized);
}
function isHeartbeatExpired(record, now) {
const normalized = normalizeHeartbeatRecord(record);
if (!normalized) return true;
const ts = parseLastActiveAt(normalized.lastActiveAt);
if (!ts) return true;
return now - ts > HEARTBEAT_TTL_MS;
}
async function pruneProjectsHeartbeatListRaw(redis) {
const listKey = projectsListKey();
if (typeof redis.lTrim === 'function') {
await redis.lTrim(listKey, -PROJECTS_LIST_MAX_LEN, -1);
}
const rawItems = await redis.lRange(listKey, 0, -1);
if (rawItems.length === 0) return { removed: 0, rawItems: [] };
const now = Date.now();
const staleRaw = new Set();
for (const raw of rawItems) {
const parsed = safeJsonParse(raw);
if (!parsed) {
staleRaw.add(raw);
continue;
}
if (Array.isArray(parsed)) {
const allExpired =
parsed.length === 0 ||
parsed.every((item) => isHeartbeatExpired(item, now));
if (allExpired) staleRaw.add(raw);
continue;
}
if (isHeartbeatExpired(parsed, now)) staleRaw.add(raw);
}
if (staleRaw.size === 0) return { removed: 0, rawItems };
const results = await Promise.all(
Array.from(staleRaw).map((raw) => redis.lRem(listKey, 0, raw)),
);
const removed = results.reduce(
(sum, value) => sum + (Number.isFinite(value) ? value : 0),
0,
);
return {
removed,
rawItems: rawItems.filter((raw) => !staleRaw.has(raw)),
};
}
export async function pruneProjectsHeartbeatList(injectedRedis) {
const redis = injectedRedis || (await getRedisClient());
if (!redis?.isReady) {
throw new Error('Redis 未就绪');
}
const listKey = projectsListKey();
const keyType = await redis.type(listKey);
if (keyType !== 'list') return { removed: 0 };
const result = await pruneProjectsHeartbeatListRaw(redis);
return { removed: result.removed };
}
async function readProjectsList(redis) {
const listKey = projectsListKey();
const keyType = await redis.type(listKey);
if (keyType === 'list') {
const { rawItems } = await pruneProjectsHeartbeatListRaw(redis);
const records = [];
for (const raw of rawItems) {
const parsed = safeJsonParse(raw);
if (!parsed) continue;
if (Array.isArray(parsed)) {
for (const item of parsed) {
const normalized = normalizeHeartbeatRecord(item);
if (normalized) records.push(normalized);
}
continue;
}
const normalized = normalizeHeartbeatRecord(parsed);
if (normalized) records.push(normalized);
}
return dedupeHeartbeatRecords(records);
}
if (keyType === 'string') {
const raw = await redis.get(listKey);
if (!raw) return [];
const parsed = safeJsonParse(raw);
if (!Array.isArray(parsed)) return [];
const records = parsed.map((item) => normalizeHeartbeatRecord(item)).filter(Boolean);
return dedupeHeartbeatRecords(records);
}
return [];
}
async function writeProjectsListAsList(redis, projectsList) {
const listKey = projectsListKey();
await redis.del(listKey);
const items = (projectsList || [])
.map((p) => normalizeHeartbeatRecord(p))
.filter(Boolean)
.map((p) => JSON.stringify(p));
if (items.length > 0) {
await redis.rPush(listKey, ...items);
}
if (typeof redis.lTrim === 'function') {
await redis.lTrim(listKey, -PROJECTS_LIST_MAX_LEN, -1);
}
return listKey;
}
export async function migrateHeartbeatData(options = {}) {
const { redis: injectedRedis, deleteOldKeys = false, dryRun = false } = options;
const redis = injectedRedis || (await getRedisClient());
if (!redis?.isReady) { if (!redis?.isReady) {
throw new Error('Redis 未就绪'); throw new Error('Redis 未就绪');
} }
@@ -35,11 +238,9 @@ export async function migrateHeartbeatData(options = {}) {
continue; continue;
} }
let heartbeat; const heartbeat = safeJsonParse(heartbeatRaw);
try { if (!heartbeat) {
heartbeat = JSON.parse(heartbeatRaw); console.error(`[migrate] 解析失败: ${key}`);
} catch (err) {
console.error(`[migrate] 解析失败: ${key}`, err.message);
continue; continue;
} }
@@ -62,21 +263,21 @@ export async function migrateHeartbeatData(options = {}) {
console.log(`[migrate] 添加项目: ${projectName}`); console.log(`[migrate] 添加项目: ${projectName}`);
} }
console.log(`[migrate] 共迁移 ${projectsList.length} 个项目`); const dedupedProjectsList = dedupeHeartbeatRecords(projectsList);
console.log(`[migrate] 共迁移 ${dedupedProjectsList.length} 个项目`);
if (dryRun) { if (dryRun) {
console.log('[migrate] 干运行模式，不写入数据'); console.log('[migrate] 干运行模式，不写入数据');
return { return {
success: true, success: true,
migrated: projectsList.length, migrated: dedupedProjectsList.length,
projects: projectsList, projects: dedupedProjectsList,
dryRun: true, dryRun: true,
}; };
} }
const listKey = projectsListKey(); const listKey = await writeProjectsListAsList(redis, dedupedProjectsList);
await redis.set(listKey, JSON.stringify(projectsList)); console.log(`[migrate] 已写入项目列表到: ${listKey} (LIST)`);
console.log(`[migrate] 已写入项目列表到: ${listKey}`);
if (deleteOldKeys) { if (deleteOldKeys) {
console.log('[migrate] 删除旧键...'); console.log('[migrate] 删除旧键...');
@@ -90,8 +291,8 @@ export async function migrateHeartbeatData(options = {}) {
return { return {
success: true, success: true,
migrated: projectsList.length, migrated: dedupedProjectsList.length,
projects: projectsList, projects: dedupedProjectsList,
listKey, listKey,
deleteOldKeys, deleteOldKeys,
}; };
@@ -101,35 +302,22 @@ export async function migrateHeartbeatData(options = {}) {
} }
} }
export async function getProjectsList() { export async function getProjectsList(injectedRedis) {
const redis = await getRedisClient(); const redis = injectedRedis || (await getRedisClient());
if (!redis?.isReady) { if (!redis?.isReady) {
throw new Error('Redis 未就绪'); throw new Error('Redis 未就绪');
} }
const listKey = projectsListKey(); return readProjectsList(redis);
const raw = await redis.get(listKey);
if (!raw) {
return [];
}
try {
const list = JSON.parse(raw);
return Array.isArray(list) ? list : [];
} catch (err) {
console.error('[getProjectsList] 解析项目列表失败:', err);
return [];
}
} }
export async function updateProjectHeartbeat(projectName, heartbeatData) { export async function updateProjectHeartbeat(projectName, heartbeatData, injectedRedis) {
const redis = await getRedisClient(); const redis = injectedRedis || (await getRedisClient());
if (!redis?.isReady) { if (!redis?.isReady) {
throw new Error('Redis 未就绪'); throw new Error('Redis 未就绪');
} }
const projectsList = await getProjectsList(); const projectsList = await getProjectsList(redis);
const existingIndex = projectsList.findIndex(p => p.projectName === projectName); const existingIndex = projectsList.findIndex(p => p.projectName === projectName);
const project = { const project = {
@@ -144,8 +332,7 @@ export async function updateProjectHeartbeat(projectName, heartbeatData) {
projectsList.push(project); projectsList.push(project);
} }
const listKey = projectsListKey(); await writeProjectsListAsList(redis, projectsList);
await redis.set(listKey, JSON.stringify(projectsList));
return project; return project;
} }

2
src/backend/services/redisClient.js
View File

@@ -17,7 +17,7 @@ export async function getRedisClient() {
const host = process.env.REDIS_HOST || '10.8.8.109'; const host = process.env.REDIS_HOST || '10.8.8.109';
const port = parseIntOrDefault(process.env.REDIS_PORT, 6379); const port = parseIntOrDefault(process.env.REDIS_PORT, 6379);
const password = process.env.REDIS_PASSWORD || undefined; const password = process.env.REDIS_PASSWORD || undefined;
const db = parseIntOrDefault(process.env.REDIS_DB, 0); const db = 15;
const url = `redis://${host}:${port}`; const url = `redis://${host}:${port}`;

171
src/backend/test/fakeRedis.js
View File

@@ -10,6 +10,25 @@ function globToRegex(glob) {
export function createFakeRedis(initial = {}) { export function createFakeRedis(initial = {}) {
const kv = new Map(Object.entries(initial)); const kv = new Map(Object.entries(initial));
const versions = new Map();
const watched = new Map();
function ensureList(key) {
const existing = kv.get(key);
if (Array.isArray(existing)) return existing;
const list = [];
kv.set(key, list);
versions.set(key, (versions.get(key) || 0) + 1);
return list;
}
function normalizeIndex(list, idx) {
return idx < 0 ? list.length + idx : idx;
}
function bumpVersion(key) {
versions.set(key, (versions.get(key) || 0) + 1);
}
return { return {
isReady: true, isReady: true,
@@ -20,11 +39,19 @@ export function createFakeRedis(initial = {}) {
async set(key, value) { async set(key, value) {
kv.set(key, String(value)); kv.set(key, String(value));
bumpVersion(key);
return 'OK'; return 'OK';
}, },
async type(key) {
if (!kv.has(key)) return 'none';
const value = kv.get(key);
return Array.isArray(value) ? 'list' : 'string';
},
async del(key) { async del(key) {
const existed = kv.delete(key); const existed = kv.delete(key);
if (existed) bumpVersion(key);
return existed ? 1 : 0; return existed ? 1 : 0;
}, },
@@ -33,18 +60,156 @@ export function createFakeRedis(initial = {}) {
return Array.from(kv.keys()).filter((k) => re.test(k)); return Array.from(kv.keys()).filter((k) => re.test(k));
}, },
async watch(...keys) {
for (const key of keys) {
watched.set(key, versions.get(key) || 0);
}
return 'OK';
},
async unwatch() {
watched.clear();
return 'OK';
},
multi() {
const commands = [];
const api = {
del(key) {
commands.push([ 'del', key ]);
return api;
},
rPush(key, ...values) {
commands.push([ 'rPush', key, ...values ]);
return api;
},
exec: async () => {
for (const [ key, version ] of watched.entries()) {
const current = versions.get(key) || 0;
if (current !== version) {
watched.clear();
return null;
}
}
watched.clear();
const results = [];
for (const [ cmd, ...args ] of commands) {
// eslint-disable-next-line no-await-in-loop
const result = await api._apply(cmd, args);
results.push(result);
}
return results;
},
_apply: async (cmd, args) => {
if (cmd === 'del') return this.del(args[0]);
if (cmd === 'rPush') return this.rPush(args[0], ...args.slice(1));
throw new Error(`Unsupported multi command: ${cmd}`);
},
};
api._apply = api._apply.bind(this);
api.del = api.del.bind(this);
api.rPush = api.rPush.bind(this);
return api;
},
async lLen(key) {
const raw = kv.get(key);
const list = Array.isArray(raw) ? raw : [];
return list.length;
},
async rPush(key, ...values) {
const list = ensureList(key);
for (const v of values) list.push(String(v));
bumpVersion(key);
return list.length;
},
async lPush(key, ...values) {
const list = ensureList(key);
for (const v of values) list.unshift(String(v));
bumpVersion(key);
return list.length;
},
// optional: used by logs route // optional: used by logs route
async lRange(key, start, stop) { async lRange(key, start, stop) {
const raw = kv.get(key); const raw = kv.get(key);
const list = Array.isArray(raw) ? raw : []; const list = Array.isArray(raw) ? raw : [];
const normalizeIndex = (idx) => (idx < 0 ? list.length + idx : idx); const s = normalizeIndex(list, start);
const s = normalizeIndex(start); const e = normalizeIndex(list, stop);
const e = normalizeIndex(stop);
return list.slice(Math.max(0, s), Math.min(list.length, e + 1)); return list.slice(Math.max(0, s), Math.min(list.length, e + 1));
}, },
async lTrim(key, start, stop) {
const raw = kv.get(key);
const list = Array.isArray(raw) ? raw : [];
const s = normalizeIndex(list, start);
const e = normalizeIndex(list, stop);
const next =
s > e
? []
: list.slice(Math.max(0, s), Math.min(list.length, e + 1));
kv.set(key, next);
bumpVersion(key);
return 'OK';
},
async lRem(key, count, value) {
const raw = kv.get(key);
const list = Array.isArray(raw) ? raw : [];
const needle = String(value);
const c = Number.parseInt(String(count), 10);
if (!Number.isFinite(c)) return 0;
let removed = 0;
if (c === 0) {
const next = list.filter((item) => {
const keep = item !== needle;
if (!keep) removed += 1;
return keep;
});
kv.set(key, next);
if (removed > 0) bumpVersion(key);
return removed;
}
if (c > 0) {
const next = [];
for (const item of list) {
if (removed < c && item === needle) {
removed += 1;
continue;
}
next.push(item);
}
kv.set(key, next);
if (removed > 0) bumpVersion(key);
return removed;
}
const target = Math.abs(c);
const next = [];
for (let i = list.length - 1; i >= 0; i -= 1) {
const item = list[i];
if (removed < target && item === needle) {
removed += 1;
continue;
}
next.push(item);
}
next.reverse();
kv.set(key, next);
if (removed > 0) bumpVersion(key);
return removed;
},
// helper for tests // helper for tests
_dump() { _dump() {
return Object.fromEntries(kv.entries()); return Object.fromEntries(kv.entries());

2
src/frontend/App.vue
View File

@@ -57,7 +57,7 @@ const checkServiceHealth = async () => {
try { try {
console.log('=== 开始检查服务健康状态 ==='); console.log('=== 开始检查服务健康状态 ===');
const response = await fetch('http://localhost:3001/api/health', { const response = await fetch('/api/health', {
method: 'GET', method: 'GET',
credentials: 'omit', credentials: 'omit',
referrerPolicy: 'no-referrer', referrerPolicy: 'no-referrer',

502
src/frontend/components/Console.vue
View File

@@ -47,17 +47,62 @@
<!-- 日志显示区域 --> <!-- 日志显示区域 -->
<div ref="logsContainer" class="logs-container"> <div ref="logsContainer" class="logs-container">
<div v-if="timelineMarkers.length" class="timeline-bar">
<div class="timeline-header">
<div class="timeline-title">
时间轴
</div>
<div class="timeline-range">
范围: {{ formatTimeRange(timelineData.timeRange) }}
</div>
<div class="timeline-spacer" />
<div class="timeline-legend">
<div class="legend-item">
<div class="legend-dot legend-dot-error" />
<span class="legend-text">ERROR</span>
</div>
<div class="legend-item">
<div class="legend-dot legend-dot-warn" />
<span class="legend-text">WARN</span>
</div>
<div class="legend-item">
<div class="legend-dot legend-dot-info" />
<span class="legend-text">INFO</span>
</div>
<div class="legend-item">
<div class="legend-dot legend-dot-debug" />
<span class="legend-text">DEBUG</span>
</div>
</div>
</div>
<div class="timeline-track">
<div v-for="marker in timelineMarkers" :key="marker.id" class="timeline-marker-group"
:style="{ left: `${marker.position}%` }" @click="scrollToLog(marker.id)">
<div class="timeline-marker" :class="`marker-${marker.level}`"
:title="`${formatTimestamp(marker.timestamp)}: ${marker.message}`" />
<div class="timeline-tooltip">
<div class="tooltip-time">
{{ formatTimestamp(marker.timestamp) }}
</div>
<div class="tooltip-message">
{{ marker.message }}
</div>
</div>
</div>
</div>
</div>
<div ref="logTableWrapper" class="log-table-wrapper" @scroll="handleScroll"> <div ref="logTableWrapper" class="log-table-wrapper" @scroll="handleScroll">
<table class="log-table"> <table class="log-table">
<tbody> <tbody>
<tr v-for="log in filteredLogs" :key="log.id" :class="`log-item log-level-${log.level}`"> <tr v-for="log in filteredLogs" :key="log.id" :data-log-id="log.id"
:class="['log-item', `log-level-${log.level}`, { 'log-active': activeLogId === log.id }]">
<td class="log-meta"> <td class="log-meta">
<div class="log-timestamp"> <div class="log-timestamp">
{{ formatTimestamp(log.timestamp) }} {{ formatTimestamp(log.timestamp) }}
</div> </div>
<div class="log-level-badge" :class="`level-${log.level}`">
{{ log.level.toUpperCase() }}
</div>
</td> </td>
<td class="log-message"> <td class="log-message">
{{ log.message }} {{ log.message }}
@@ -113,7 +158,7 @@ const isAtBottom = ref(true);
let pollTimer = null; let pollTimer = null;
const mergedLogs = computed(() => { const mergedLogs = computed(() => {
const combined = [...remoteLogs.value, ...uiLogs.value] const combined = remoteLogs.value.concat(uiLogs.value)
.filter(Boolean) .filter(Boolean)
.sort((a, b) => new Date(a.timestamp) - new Date(b.timestamp)); .sort((a, b) => new Date(a.timestamp) - new Date(b.timestamp));
if (combined.length <= MAX_LOGS) return combined; if (combined.length <= MAX_LOGS) return combined;
@@ -128,6 +173,55 @@ const filteredLogs = computed(() => {
return mergedLogs.value.filter(log => log.level === selectedLogLevel.value); return mergedLogs.value.filter(log => log.level === selectedLogLevel.value);
}); });
const activeLogId = ref('');
const timelineData = computed(() => {
if (!filteredLogs.value.length) {
return {
minTime: 0,
maxTime: 0,
timeRange: 0,
};
}
const times = filteredLogs.value
.map((log) => Date.parse(log.timestamp))
.filter((t) => Number.isFinite(t));
if (!times.length) {
return {
minTime: 0,
maxTime: 0,
timeRange: 0,
};
}
const minTime = Math.min(...times);
const maxTime = Math.max(...times);
const timeRange = maxTime - minTime || 1;
return { minTime, maxTime, timeRange };
});
const timelineMarkers = computed(() => {
if (!filteredLogs.value.length || !timelineData.value.timeRange) return [];
return filteredLogs.value.map((log) => {
const timeMs = Date.parse(log.timestamp);
const position = Number.isFinite(timeMs)
? ((timeMs - timelineData.value.minTime) / timelineData.value.timeRange) * 100
: 0;
return {
id: log.id,
level: (log.level || 'info').toString().toLowerCase(),
timestamp: log.timestamp,
message: String(log.message || '').slice(0, 80),
position: Math.max(0, Math.min(100, position)),
};
});
});
function scrollTableToBottom() { function scrollTableToBottom() {
if (!logTableWrapper.value) return; if (!logTableWrapper.value) return;
setTimeout(() => { setTimeout(() => {
@@ -135,6 +229,36 @@ function scrollTableToBottom() {
}, 60); }, 60);
} }
function scrollToLog(logId) {
if (!logId || !logTableWrapper.value) return;
const row = logTableWrapper.value.querySelector(`[data-log-id="${logId}"]`);
if (!row) return;
const nextActiveId = String(logId);
activeLogId.value = nextActiveId;
setTimeout(() => {
if (activeLogId.value === nextActiveId) {
activeLogId.value = '';
}
}, 800);
const top = row.offsetTop;
logTableWrapper.value.scrollTop = Math.max(0, top - 12);
}
const formatTimeRange = (timeRangeMs) => {
const ms = Number(timeRangeMs) || 0;
if (ms <= 0) return '0s';
const seconds = ms / 1000;
if (seconds < 60) return `${seconds.toFixed(1)}s`;
const minutes = seconds / 60;
if (minutes < 60) return `${minutes.toFixed(1)}m`;
const hours = minutes / 60;
return `${hours.toFixed(1)}h`;
};
const sendCommand = async () => { const sendCommand = async () => {
if (!commandInput.value.trim()) return; if (!commandInput.value.trim()) return;
@@ -203,9 +327,28 @@ const addLog = (logData) => {
}; };
// 清空日志 // 清空日志
const clearLogs = () => { const clearLogs = async () => {
remoteLogs.value = []; const projectName = props.projectName;
uiLogs.value = []; uiLogs.value = [];
remoteLogs.value = [];
if (!projectName) return;
try {
const resp = await axios.post('/api/logs/clear', { projectName });
if (resp?.status !== 200 || !resp?.data?.success) {
const msg = resp?.data?.message || `清空失败 (${resp?.status})`;
addLog({ level: 'error', message: msg });
return;
}
await fetchRemoteLogs();
scrollTableToBottom();
} catch (err) {
const msg = err?.response?.data?.message || err?.message || '清空失败';
addLog({ level: 'error', message: msg });
}
}; };
// 格式化时间戳 // 格式化时间戳
@@ -250,7 +393,7 @@ async function fetchRemoteLogs() {
const resp = await axios.get('/api/logs', { const resp = await axios.get('/api/logs', {
params: { params: {
projectName, projectName,
limit: Math.min(500, MAX_LOGS), limit: MAX_LOGS,
}, },
}); });
@@ -301,7 +444,6 @@ watch(() => props.projectName, async () => {
height: 100%; height: 100%;
min-height: 0; min-height: 0;
color: #d4d4d4; color: #d4d4d4;
font-family: 'Consolas', 'Monaco', 'Courier New', monospace;
font-size: 0.9rem; font-size: 0.9rem;
} }
@@ -345,8 +487,8 @@ watch(() => props.projectName, async () => {
background-color: #3c3c3c; background-color: #3c3c3c;
color: #d4d4d4; color: #d4d4d4;
border: 1px solid #555; border: 1px solid #555;
border-radius: 3px; border-radius: 6px;
padding: 0.3rem 0.5rem; padding: 0.35rem 0.75rem;
font-size: 0.85rem; font-size: 0.85rem;
cursor: pointer; cursor: pointer;
transition: all 0.2s; transition: all 0.2s;
@@ -380,6 +522,41 @@ watch(() => props.projectName, async () => {
.toggle-checkbox { .toggle-checkbox {
cursor: pointer; cursor: pointer;
appearance: none;
width: 34px;
height: 18px;
border-radius: 999px;
border: 1px solid #555;
background: #3c3c3c;
position: relative;
transition: background-color 0.2s, border-color 0.2s;
}
.toggle-checkbox::after {
content: '';
position: absolute;
top: 1px;
left: 1px;
width: 14px;
height: 14px;
background: #d4d4d4;
border-radius: 999px;
transition: transform 0.2s, background-color 0.2s;
}
.toggle-checkbox:checked {
background: #0078d4;
border-color: #0078d4;
}
.toggle-checkbox:checked::after {
transform: translateX(16px);
background: #ffffff;
}
.toggle-checkbox:focus-visible {
outline: none;
box-shadow: 0 0 0 2px rgba(0, 120, 212, 0.2);
} }
/* 日志清理按钮 */ /* 日志清理按钮 */
@@ -387,8 +564,8 @@ watch(() => props.projectName, async () => {
background-color: #3c3c3c; background-color: #3c3c3c;
color: #d4d4d4; color: #d4d4d4;
border: 1px solid #555; border: 1px solid #555;
border-radius: 3px; border-radius: 6px;
padding: 0.3rem 0.8rem; padding: 0.35rem 0.75rem;
font-size: 0.85rem; font-size: 0.85rem;
cursor: pointer; cursor: pointer;
transition: all 0.2s; transition: all 0.2s;
@@ -416,20 +593,185 @@ watch(() => props.projectName, async () => {
display: flex; display: flex;
flex-direction: column; flex-direction: column;
overflow: hidden; overflow: hidden;
padding: 1rem; padding: 0;
background-color: #000000; background-color: #000000;
line-height: 1.5; line-height: 1.5;
scroll-behavior: smooth; scroll-behavior: smooth;
min-height: 0; min-height: 0;
} }
.timeline-bar {
background-color: #252526;
border-bottom: 1px solid #3e3e42;
flex-shrink: 0;
}
.timeline-header {
display: flex;
align-items: center;
gap: 0.75rem;
padding: 0.5rem 1rem;
}
.timeline-title {
font-size: 0.75rem;
color: #969696;
}
.timeline-range {
font-size: 0.75rem;
color: #6b6b6b;
}
.timeline-spacer {
flex: 1;
}
.timeline-legend {
display: flex;
align-items: center;
gap: 0.75rem;
font-size: 0.75rem;
}
.legend-item {
display: flex;
align-items: center;
gap: 0.35rem;
}
.legend-dot {
width: 8px;
height: 8px;
}
.legend-text {
color: #969696;
}
.legend-dot-error {
background: #f14c4c;
}
.legend-dot-warn {
background: #d7ba7d;
}
.legend-dot-info {
background: #d4d4d4;
}
.legend-dot-debug {
background: #9aa0a6;
}
.timeline-track {
position: relative;
height: 16px;
background-color: #3c3c3c;
margin: 0 1rem 0.5rem;
overflow: visible;
}
.timeline-marker-group {
position: absolute;
top: 0;
bottom: 0;
width: 2px;
cursor: pointer;
}
.timeline-marker {
width: 100%;
height: 100%;
transition: width 0.15s ease;
}
.timeline-marker-group:hover {
width: 4px;
}
.marker-error {
background: #f14c4c;
}
.marker-warn {
background: #d7ba7d;
}
.marker-info {
background: #d4d4d4;
}
.marker-debug {
background: #9aa0a6;
}
.timeline-tooltip {
position: absolute;
left: 50%;
bottom: 100%;
transform: translateX(-50%);
opacity: 0;
pointer-events: none;
transition: opacity 0.15s ease;
z-index: 20;
margin-bottom: 8px;
padding: 0.35rem 0.5rem;
background: #1e1e1e;
border: 1px solid #3e3e42;
box-shadow: 0 10px 24px rgba(0, 0, 0, 0.35);
border-radius: 6px;
max-width: 320px;
min-width: 220px;
}
.timeline-tooltip::after {
content: '';
width: 8px;
height: 8px;
background: #1e1e1e;
border-right: 1px solid #3e3e42;
border-bottom: 1px solid #3e3e42;
position: absolute;
top: 100%;
left: 50%;
transform: translateX(-50%) rotate(45deg);
margin-top: -4px;
}
.timeline-marker-group:hover .timeline-tooltip {
opacity: 1;
}
.tooltip-time {
font-size: 0.75rem;
color: #d4d4d4;
font-weight: 600;
}
.tooltip-message {
font-size: 0.75rem;
color: #969696;
white-space: nowrap;
overflow: hidden;
text-overflow: ellipsis;
}
.log-table-wrapper { .log-table-wrapper {
flex: 1; flex: 1;
min-height: 0; min-height: 0;
height: 100%;
overflow: auto;
overflow-y: auto; overflow-y: auto;
overflow-x: hidden; overflow-x: hidden;
/* 兜底：当父容器高度不受约束时，限制日志区域最大高度，避免把输入框顶出视口 */ -webkit-overflow-scrolling: touch;
scrollbar-width: auto;
-ms-overflow-style: auto;
max-height: min(80vh, calc(100dvh - 240px)); max-height: min(80vh, calc(100dvh - 240px));
padding: 1rem;
font-family: 'Consolas', 'Monaco', 'Courier New', monospace;
font-size: 0.875rem;
} }
/* 日志表格 */ /* 日志表格 */
@@ -437,91 +779,92 @@ watch(() => props.projectName, async () => {
width: 100%; width: 100%;
border-collapse: collapse; border-collapse: collapse;
table-layout: fixed; table-layout: fixed;
overflow: auto;
} }
/* 日志项 */ /* 日志项 */
.log-item { .log-item {
border-bottom: 1px solid rgba(255, 255, 255, 0.12); background: transparent;
/* 浅灰色分割线 */
} }
.log-item:last-child { .log-active {
border-bottom: none; background: rgba(0, 120, 212, 0.12);
} }
.log-meta { .log-meta {
vertical-align: top; vertical-align: top;
padding: 0.1rem 0.2rem 0.1rem 0; padding: 0 0.75rem 0.25rem 0;
white-space: nowrap; white-space: nowrap;
width: 100px; width: 80px;
min-width: 100px; min-width: 80px;
max-width: 100px; max-width: 80px;
} }
.log-timestamp { .log-timestamp {
color: #608b4e; color: #608b4e;
font-size: 0.8rem; font-size: 0.75rem;
margin-bottom: 0.2rem; line-height: 1.25rem;
}
.log-level-badge {
color: #fff;
font-size: 0.7rem;
font-weight: 600;
padding: 0.1rem 0.5rem;
border-radius: 10px;
text-transform: uppercase;
min-width: 60px;
text-align: center;
display: inline-block;
}
/* 日志级别样式 */
.log-level-info .log-level-badge.level-info {
background-color: #0078d4;
}
.log-level-warn .log-level-badge.level-warn {
background-color: #d7ba7d;
color: #000;
}
.log-level-error .log-level-badge.level-error {
background-color: #f14c4c;
}
.log-level-debug .log-level-badge.level-debug {
background-color: #569cd6;
} }
.log-message { .log-message {
vertical-align: top; vertical-align: top;
padding: 0.1rem 0; padding: 0 0 0.25rem 0;
word-break: break-word; word-break: break-word;
white-space: pre-wrap;
line-height: 1.5;
}
.log-level-error .log-message {
color: #f14c4c;
}
.log-level-warn .log-message {
color: #d7ba7d;
}
.log-level-info .log-message {
color: #d4d4d4;
}
.log-level-debug .log-message {
color: #9aa0a6;
} }
/* 响应式日志布局 */ /* 响应式日志布局 */
@media (max-width: 768px) { @media (max-width: 768px) {
.timeline-header {
padding: 0.5rem 0.75rem;
}
.timeline-track {
margin: 0 0.75rem 0.5rem;
}
.timeline-legend {
display: none;
}
.log-meta { .log-meta {
width: 120px; width: 72px;
min-width: 120px; min-width: 72px;
max-width: 120px; max-width: 72px;
padding-right: 0.5rem; padding-right: 0.5rem;
} }
.log-timestamp { .log-timestamp {
font-size: 0.75rem; font-size: 0.7rem;
margin-bottom: 0.1rem;
}
.log-level-badge {
min-width: 50px;
font-size: 0.65rem;
} }
/* 移动端：比默认再小 10px */ /* 移动端：比默认再小 10px */
.log-table-wrapper { .log-table-wrapper {
max-height: min(70vh, calc(100dvh - 200px)); max-height: min(70vh, calc(100dvh - 200px));
padding: 0.75rem;
}
}
@media (max-width: 420px) {
.log-table-wrapper {
max-height: min(60vh, calc(100dvh - 180px));
} }
} }
@@ -543,6 +886,7 @@ watch(() => props.projectName, async () => {
width: 100%; width: 100%;
box-sizing: border-box; box-sizing: border-box;
overflow: hidden; overflow: hidden;
font-family: 'Consolas', 'Monaco', 'Courier New', monospace;
} }
.command-prompt { .command-prompt {
@@ -574,7 +918,7 @@ watch(() => props.projectName, async () => {
background-color: #0078d4; background-color: #0078d4;
color: white; color: white;
border: none; border: none;
border-radius: 3px; border-radius: 6px;
padding: 0.4rem 1rem; padding: 0.4rem 1rem;
font-size: 0.85rem; font-size: 0.85rem;
cursor: pointer; cursor: pointer;
@@ -592,21 +936,21 @@ watch(() => props.projectName, async () => {
} }
/* 滚动条样式 */ /* 滚动条样式 */
.logs-container::-webkit-scrollbar { .log-table-wrapper::-webkit-scrollbar {
width: 8px; width: 8px;
height: 8px; height: 8px;
} }
.logs-container::-webkit-scrollbar-track { .log-table-wrapper::-webkit-scrollbar-track {
background: #1e1e1e; background: #1e1e1e;
} }
.logs-container::-webkit-scrollbar-thumb { .log-table-wrapper::-webkit-scrollbar-thumb {
background: #424242; background: #424242;
border-radius: 4px; border-radius: 4px;
} }
.logs-container::-webkit-scrollbar-thumb:hover { .log-table-wrapper::-webkit-scrollbar-thumb:hover {
background: #4e4e4e; background: #4e4e4e;
} }
@@ -638,19 +982,7 @@ watch(() => props.projectName, async () => {
} }
.logs-container { .logs-container {
padding: 0.5rem; padding: 0;
}
.log-timestamp {
min-width: 105px;
font-size: 0.75rem;
margin-right: 0.5rem;
}
.log-level-badge {
min-width: 50px;
font-size: 0.65rem;
margin-right: 0.5rem;
} }
.command-input-container { .command-input-container {
@@ -665,4 +997,4 @@ watch(() => props.projectName, async () => {
max-height: min(80vh, calc(100dvh - 200px)); max-height: min(80vh, calc(100dvh - 200px));
} }
} }
</style> </style>

2
src/frontend/components/ProjectSelector.vue
View File

@@ -62,7 +62,7 @@ defineProps({
}, },
}); });
const emit = defineEmits(['project-selected']); const emit = defineEmits([ 'project-selected' ]);
const loading = ref(false); const loading = ref(false);
const error = ref(''); const error = ref('');

2
src/frontend/views/CommandView.vue
View File

@@ -74,7 +74,7 @@ const sendCommand = async () => {
response.value = null; response.value = null;
try { try {
const resp = await axios.post('http://localhost:3001/api/commands', { const resp = await axios.post('/api/commands', {
targetProjectName: props.projectName, targetProjectName: props.projectName,
command: command.value.trim(), command: command.value.trim(),
}); });

2
src/frontend/views/LogView.vue
View File

@@ -70,7 +70,7 @@ const fetchLogs = async () => {
error.value = null; error.value = null;
try { try {
const response = await axios.get(`http://localhost:3001/api/logs?projectName=${encodeURIComponent(props.projectName)}`); const response = await axios.get(`/api/logs?projectName=${encodeURIComponent(props.projectName)}`);
logs.value = response.data.logs || []; logs.value = response.data.logs || [];
projectStatus.value = response.data.projectStatus; projectStatus.value = response.data.projectStatus;
} catch (err) { } catch (err) {