diff --git a/.env.example b/.env.example
index 85bddb1..4551aa9 100644
--- a/.env.example
+++ b/.env.example
@@ -5,7 +5,7 @@
 REDIS_HOST=10.8.8.109          # Redis host (default: localhost)
 REDIS_PORT=6379               # Redis port (default: 6379)
 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)
 
 # Command control (HTTP)
diff --git a/.gitignore b/.gitignore
index 7404935..f47a73d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -38,4 +38,6 @@ coverage/
 
 # Temporary files
 *.tmp
-*.temp
\ No newline at end of file
+*.temp
+/release
+/docs/模版项目文件
diff --git a/.trae/documents/对齐心跳LIST与文档规范.md b/.trae/documents/对齐心跳LIST与文档规范.md
new file mode 100644
index 0000000..1c1a350
--- /dev/null
+++ b/.trae/documents/对齐心跳LIST与文档规范.md
@@ -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 对齐，再改后端读取/迁移逻辑与端口，最后更新文档与测试，保证“需求=规范=实现=文档”一致。
diff --git a/README.md b/README.md
index c1bd26f..3dad7d3 100644
--- a/README.md
+++ b/README.md
@@ -138,11 +138,11 @@ Web_BLS_ProjectConsole/
 
 ### 日志记录展示
 
-日志记录展示模块负责从Redis队列读取日志记录，并以友好的格式展示在控制台界面中。
+日志记录展示模块负责从 Redis LIST 读取日志记录，并以友好的格式展示在控制台界面中。
 
 #### 主要功能
 
-- 实时读取Redis队列中的日志记录
+- 实时读取 Redis LIST 中的日志记录
 - 以列表形式展示日志记录，包含时间戳、日志级别和消息内容
 - 支持按日志级别和时间范围过滤日志
 - 自动滚动到最新日志（可选）
@@ -151,24 +151,24 @@ Web_BLS_ProjectConsole/
 #### 技术实现
 
 - 使用Redis List作为日志队列
-- 使用Server-Sent Events（SSE）实现实时更新
+- 使用轮询方式拉取最新日志
 - 前端使用Vue组件化开发，实现日志列表和过滤功能
 
 ### 控制台指令发送
 
-控制台指令发送模块允许用户发送控制台指令到Redis队列，供其他程序读取和执行。
+控制台指令发送模块允许用户发送控制台指令到目标项目的 HTTP API（由心跳中的 `apiBaseUrl` 提供基地址）。
 
 #### 主要功能
 
 - 提供指令输入框，允许用户输入控制台指令
 - 支持指令验证，确保指令格式正确
-- 支持发送指令到Redis队列
+- 支持发送指令到目标项目 API
 - 显示指令发送状态和结果
 - 维护指令历史记录，支持重新发送历史指令
 
 #### 技术实现
 
-- 使用Redis List作为指令队列
+- 后端根据项目心跳解析目标项目 `apiBaseUrl` 并转发调用
 - 前端使用Vue组件化开发，实现指令表单和历史记录功能
 - 后端实现指令验证和发送逻辑
 
@@ -218,22 +218,16 @@ git push origin feature/feature-name
 
 ### 测试指南
 
-#### 单元测试
+#### 测试
 
 ```bash
-npm run test:unit
+npm test
 ```
 
-#### 集成测试
+#### 开发时 watch
 
 ```bash
-npm run test:integration
-```
-
-#### 端到端测试
-
-```bash
-npm run test:e2e
+npm run test:watch
 ```
 
 #### 代码质量检查
diff --git a/deploy/docker/docker-compose.backend.yml b/deploy/docker/docker-compose.backend.yml
index dca8267..bf2709c 100644
--- a/deploy/docker/docker-compose.backend.yml
+++ b/deploy/docker/docker-compose.backend.yml
@@ -12,7 +12,7 @@ services:
       REDIS_HOST: 10.8.8.109
       REDIS_PORT: 6379
       REDIS_PASSWORD: ""
-      REDIS_DB: 0
+      REDIS_DB: 15
       HEARTBEAT_OFFLINE_THRESHOLD_MS: 10000
       COMMAND_API_TIMEOUT_MS: 5000
     command: ["node", "src/backend/server.js"]
diff --git a/docs/ai-deployment-request-guide.md b/docs/ai-deployment-request-guide.md
new file mode 100644
index 0000000..3488969
--- /dev/null
+++ b/docs/ai-deployment-request-guide.md
@@ -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/` 目录下，方便随时查阅和参考。
diff --git a/docs/bls-project-console.service b/docs/bls-project-console.service
new file mode 100644
index 0000000..58a5619
--- /dev/null
+++ b/docs/bls-project-console.service
@@ -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
diff --git a/docs/configuration-check-report.md b/docs/configuration-check-report.md
new file mode 100644
index 0000000..9cec046
--- /dev/null
+++ b/docs/configuration-check-report.md
@@ -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
diff --git a/docs/deployment-guide-systemd.md b/docs/deployment-guide-systemd.md
new file mode 100644
index 0000000..dff1c69
--- /dev/null
+++ b/docs/deployment-guide-systemd.md
@@ -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. **备份策略**
+   - 定期备份配置文件
+   - 定期备份重要数据
+   - 测试恢复流程
diff --git a/docs/deployment-guide-windows.md b/docs/deployment-guide-windows.md
new file mode 100644
index 0000000..3788a70
--- /dev/null
+++ b/docs/deployment-guide-windows.md
@@ -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 日志
diff --git a/docs/deployment-guide.md b/docs/deployment-guide.md
new file mode 100644
index 0000000..c39d3e2
--- /dev/null
+++ b/docs/deployment-guide.md
@@ -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和后端日志，及时发现和解决问题
diff --git a/docs/ecosystem.config.windows.js b/docs/ecosystem.config.windows.js
new file mode 100644
index 0000000..54de1b2
--- /dev/null
+++ b/docs/ecosystem.config.windows.js
@@ -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,
+    },
+  ],
+};
diff --git a/docs/nginx-deployment.conf b/docs/nginx-deployment.conf
new file mode 100644
index 0000000..04537a1
--- /dev/null
+++ b/docs/nginx-deployment.conf
@@ -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;
+}
diff --git a/docs/nginx.conf.windows b/docs/nginx.conf.windows
new file mode 100644
index 0000000..c4afac2
--- /dev/null
+++ b/docs/nginx.conf.windows
@@ -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;
+}
diff --git a/docs/redis-data-structure.md b/docs/redis-data-structure.md
index 621ea66..763c123 100644
--- a/docs/redis-data-structure.md
+++ b/docs/redis-data-structure.md
@@ -10,19 +10,18 @@
 
 **键名**: `项目心跳`
 
-**类型**: String (JSON数组)
+**类型**: List
 
 **描述**: 统一存储所有项目的心跳信息，替代原有的分散键结构。
 
-**数据格式**:
+**数据格式**: 每个列表元素是一个 JSON 字符串，表示一条心跳记录：
+
 ```json
-[
-  {
-    "projectName": "string",
-    "apiBaseUrl": "string",
-    "lastActiveAt": "number"
-  }
-]
+{
+  "projectName": "string",
+  "apiBaseUrl": "string",
+  "lastActiveAt": "number"
+}
 ```
 
 **字段说明**:
@@ -32,20 +31,15 @@
 
 **示例**:
 ```json
-[
-  {
-    "projectName": "用户管理系统",
-    "apiBaseUrl": "http://localhost:8080",
-    "lastActiveAt": 1704067200000
-  },
-  {
-    "projectName": "数据可视化平台",
-    "apiBaseUrl": "http://localhost:8081",
-    "lastActiveAt": 1704067260000
-  }
-]
+{
+  "projectName": "用户管理系统",
+  "apiBaseUrl": "http://localhost:8080",
+  "lastActiveAt": 1704067200000
+}
 ```
 
+说明：外部项目会周期性向 LIST 写入多条心跳记录；控制台后端按 `projectName` 去重，保留 `lastActiveAt` 最新的一条用于在线判定与项目列表展示。
+
 ### 2. 项目控制台日志
 
 **键名**: `{projectName}_项目控制台`
@@ -94,7 +88,7 @@
 
 **类型**: List
 
-**描述**: 存储发送给项目的控制指令。
+**描述**: 历史结构（已废弃）。当前命令下发通过 HTTP 调用目标项目 API，不再通过 Redis 存储控制指令。
 
 **指令对象格式**:
 ```json
@@ -206,9 +200,8 @@
 
 为确保平滑过渡，系统在读取项目心跳时采用以下策略：
 
-1. **优先读取新结构**: 首先尝试从`项目心跳`列表中查找项目
-2. **回退到旧结构**: 如果新结构中未找到，则尝试从`{projectName}_项目心跳`键中读取
-3. **自动迁移**: 当检测到旧结构数据时，可以自动迁移到新结构
+1. **只读取新结构**: 项目列表与在线判定只读取 `项目心跳`（LIST）
+2. **旧结构仅用于迁移**: `{projectName}_项目心跳` 仅作为历史数据来源，通过 `POST /api/projects/migrate` 导入一次
 
 ## 性能优化
 
@@ -224,8 +217,8 @@
 
 ### 3. 心跳更新
 
-- 直接更新项目列表中的对应项目
-- 避免频繁的键操作
+- 外部项目持续向 `项目心跳`（LIST）追加心跳记录
+- 建议外部项目结合 `LTRIM` 控制列表长度
 
 ## 监控和维护
 
@@ -276,4 +269,4 @@
 
 - [Redis数据类型](https://redis.io/docs/data-types/)
 - [项目OpenSpec规范](../openspec/specs/)
-- [API文档](../docs/api-documentation.md)
\ No newline at end of file
+- [API文档](../docs/api-documentation.md)
diff --git a/docs/redis-integration-protocol.md b/docs/redis-integration-protocol.md
index 2fffa80..092dff3 100644
--- a/docs/redis-integration-protocol.md
+++ b/docs/redis-integration-protocol.md
@@ -1,12 +1,13 @@
 # Redis 对接协议（供外部项目 AI 生成代码使用）
 
-本文档定义“外部项目 ↔ BLS Project Console”之间通过 Redis 交互的 **Key 命名、数据类型、写入方式、读取方式与数据格式**。
+本文档定义"外部项目 ↔ BLS Project Console"之间通过 Redis 交互的 **Key 命名、数据类型、写入方式、读取方式与数据格式**。
 
 注：本仓库对外暴露的 Redis 连接信息如下（供对方直接连接以写入心跳/日志）：
 
 - 地址：`10.8.8.109`
 - 端口：默认 `6379`
 - 密码：无（空）
+- 数据库：固定 `15`
 
 示例（环境变量）：
 
@@ -14,18 +15,20 @@
 REDIS_HOST=10.8.8.109
 REDIS_PORT=6379
 REDIS_PASSWORD=
+REDIS_DB=15
 ```
 
 示例（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. 命名约定
 
@@ -35,35 +38,45 @@ redis-cli -h 10.8.8.109 -p 6379
 
 固定后缀：
 
-- 心跳：`${projectName}_项目心跳`
 - 控制台：`${projectName}_项目控制台`
 
 示例（projectName = `订单系统`）：
 
-- `订单系统_项目心跳`
 - `订单系统_项目控制台`
 
 ## 2. 外部项目需要写入的 2 个 Key
 
-### 2.1 `${projectName}_项目心跳`
+说明：当前控制台左侧“项目选择列表”只读取 `项目心跳`（LIST）。因此外部项目必须维护该 Key，否则项目不会出现在列表中。
 
-- Redis 数据类型：**STRING**
-- 写入方式：`SET ${projectName}_项目心跳 <json>`
-- value：JSON 字符串，必须包含目标项目可被调用的 `apiBaseUrl`，以及活跃时间戳 `lastActiveAt`
+### 2.1 `项目心跳`
 
-推荐 JSON Schema：
+- Redis 数据类型：**LIST**
+- 写入方式（推荐 FIFO）：`RPUSH 项目心跳 <json>`
+- value：每个列表元素为“项目心跳记录”的 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`）
-- `lastActiveAt`：状态时间（活跃时间戳，毫秒）。建议每 **3 秒**刷新一次。
+- `lastActiveAt`：活跃时间戳（毫秒）。建议每 **3 秒**刷新一次。
 
 在线/离线判定（BLS Project Console 使用）：
 
@@ -73,14 +86,19 @@ redis-cli -h 10.8.8.109 -p 6379
 建议：
 
 - `lastActiveAt` 使用 `Date.now()` 生成（毫秒）
-- 可设置 TTL（可选）：例如 `SET key value EX 30`
+- 建议对 `项目心跳` 做长度控制（可选）：例如每次写入后执行 `LTRIM 项目心跳 -2000 -1` 保留最近 2000 条
+
+去重提示：
+
+- `项目心跳` 为 LIST 时，外部项目周期性 `RPUSH` 会产生多条重复记录
+- BLS Project Console 后端会按 `projectName` 去重，保留 `lastActiveAt` 最新的一条作为项目状态
 
 ### 2.2 `${projectName}_项目控制台`
 
-- Redis 数据类型：**LIST**（作为项目向控制台追加的“消息队列/日志队列”）
+- Redis 数据类型：**LIST**（作为项目向控制台追加的"消息队列/日志队列"）
 - 写入方式（推荐 FIFO）：`RPUSH ${projectName}_项目控制台 <json>`
 
-value（推荐格式）：一条 JSON 字符串，表示“错误/调试信息”或日志记录。
+value（推荐格式）：一条 JSON 字符串，表示"错误/调试信息"或日志记录。
 
 推荐 JSON Schema（字段尽量保持稳定，便于控制台解析）：
 
@@ -103,11 +121,39 @@ value（推荐格式）：一条 JSON 字符串，表示“错误/调试信息
 - `message`：日志文本
 - `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`
 - `user/refreshCache tenantA`
 
-### 3.2 目标项目需要提供的 API
+### 4.2 目标项目需要提供的 API
 
 后端默认使用 `POST` 调用：
 
@@ -139,18 +185,69 @@ value（推荐格式）：一条 JSON 字符串，表示“错误/调试信息
 }
 ```
 
+字段说明：
+
+- `commandId`：唯一命令标识符
+- `timestamp`：命令发送时间（ISO-8601 格式）
+- `source`：命令来源标识
+- `apiName`：API 接口名
+- `args`：参数数组
+- `argsText`：参数文本（空格连接）
+
 返回建议：
 
 - 2xx 表示成功
 - 非 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 解析失败：外部项目应记录错误，并丢弃该条消息（避免死循环阻塞消费）。
 - 消息过长：建议控制单条消息大小（例如 < 64KB）。
 - 字符编码：统一 UTF-8。
+- 心跳超时：建议外部项目每 3 秒更新一次心跳，避免被误判为离线。
 
-## 5. 与本项目代码的对应关系（实现中）
+## 7. 数据迁移工具（旧数据导入）
 
-- 后端通过 `/api/commands`：从 `${targetProjectName}_项目心跳` 读取 `apiBaseUrl` 与 `lastActiveAt`，在线时调用目标项目 API。
-- 后端通过 `/api/logs`：读取 `${projectName}_项目控制台`；并基于 `${projectName}_项目心跳` 返回在线/离线与 API 地址信息。
+如果需要从旧格式迁移到新格式，可使用以下 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
+}
+```
diff --git a/ecosystem.config.js b/ecosystem.config.js
new file mode 100644
index 0000000..e927389
--- /dev/null
+++ b/ecosystem.config.js
@@ -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,
+    },
+  ],
+};
diff --git a/openspec/changes/update-heartbeat-key-to-list/proposal.md b/openspec/changes/update-heartbeat-key-to-list/proposal.md
new file mode 100644
index 0000000..a0c0757
--- /dev/null
+++ b/openspec/changes/update-heartbeat-key-to-list/proposal.md
@@ -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
+
diff --git a/openspec/changes/update-heartbeat-key-to-list/specs/command/spec.md b/openspec/changes/update-heartbeat-key-to-list/specs/command/spec.md
new file mode 100644
index 0000000..d307a20
--- /dev/null
+++ b/openspec/changes/update-heartbeat-key-to-list/specs/command/spec.md
@@ -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
+
diff --git a/openspec/changes/update-heartbeat-key-to-list/specs/logging/spec.md b/openspec/changes/update-heartbeat-key-to-list/specs/logging/spec.md
new file mode 100644
index 0000000..9f3ea88
--- /dev/null
+++ b/openspec/changes/update-heartbeat-key-to-list/specs/logging/spec.md
@@ -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
+
diff --git a/openspec/changes/update-heartbeat-key-to-list/specs/redis-connection/spec.md b/openspec/changes/update-heartbeat-key-to-list/specs/redis-connection/spec.md
new file mode 100644
index 0000000..6532870
--- /dev/null
+++ b/openspec/changes/update-heartbeat-key-to-list/specs/redis-connection/spec.md
@@ -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`
+
diff --git a/openspec/changes/update-heartbeat-key-to-list/tasks.md b/openspec/changes/update-heartbeat-key-to-list/tasks.md
new file mode 100644
index 0000000..b856b87
--- /dev/null
+++ b/openspec/changes/update-heartbeat-key-to-list/tasks.md
@@ -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`
+
diff --git a/openspec/project.md b/openspec/project.md
index 20f9eeb..4f81e74 100644
--- a/openspec/project.md
+++ b/openspec/project.md
@@ -39,7 +39,7 @@ BLS Project Console是一个前后端分离的Node.js项目，用于从Redis队
 - **单元测试**: 对核心功能模块进行单元测试
 - **集成测试**: 测试API接口和Redis交互
 - **端到端测试**: 测试完整的用户流程
-- **测试框架**: Jest (后端), Vitest (前端)
+- **测试框架**: Vitest + Supertest
 
 ### Git Workflow
 
@@ -59,10 +59,10 @@ BLS Project Console是一个前后端分离的Node.js项目，用于从Redis队
 
 ## Domain Context
 
-- **Redis队列**: 用于存储日志记录和控制台指令的消息队列
-- **日志记录**: 其他程序写入Redis队列的日志信息，包含时间戳、日志级别和消息内容
-- **控制台指令**: 从控制台发送到Redis队列的命令，供其他程序读取和执行
-- **实时更新**: 控制台需要实时从Redis队列获取新的日志记录
+- **Redis 数据结构**: DB15 中使用 `项目心跳`（LIST）与 `${projectName}_项目控制台`（LIST）
+- **日志记录**: 外部程序向 `${projectName}_项目控制台` 追加日志 JSON；控制台轮询读取并展示
+- **项目心跳**: 外部程序向 `项目心跳` 追加心跳 JSON；控制台按 projectName 去重并判定在线状态
+- **控制台指令**: 控制台通过 HTTP 调用目标项目 API（由心跳中的 `apiBaseUrl` 提供）
 
 ## Important Constraints
 
@@ -77,4 +77,4 @@ BLS Project Console是一个前后端分离的Node.js项目，用于从Redis队
 - **Redis**: 用于存储日志记录和控制台指令的消息队列服务
   - 版本: 6.x+
   - 连接方式: Redis客户端(redis@^4.6.10)
-  - 主要用途: 日志队列和指令队列
+  - 主要用途: 心跳列表与日志队列
diff --git a/openspec/specs/command/spec.md b/openspec/specs/command/spec.md
index 6d08ad7..4aada5b 100644
--- a/openspec/specs/command/spec.md
+++ b/openspec/specs/command/spec.md
@@ -1,34 +1,35 @@
 # Command Capability Specification
 
 ## 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
 
 ### 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
 - **AND** clicks the "Send" button
-- **THEN** the command SHALL be sent to the Redis queue
-- **AND** the user SHALL receive a success confirmation
+- **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
 
 ### 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
 - **WHEN** the user tries to send an empty command
 - **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
 - **WHEN** the user tries to send a command with invalid characters
 - **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
-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
 - **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
 
 ### 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
-- **WHEN** a command response is received from Redis
-- **THEN** the system SHALL display the response in the console
-- **AND** the response SHALL be associated with the original command
+- **WHEN** the target project API responds
+- **THEN** the system SHALL display the response status in the console
 
 ## Data Model
 
diff --git a/openspec/specs/logging/spec.md b/openspec/specs/logging/spec.md
index dd8a64b..91aa3dd 100644
--- a/openspec/specs/logging/spec.md
+++ b/openspec/specs/logging/spec.md
@@ -1,18 +1,17 @@
 # Logging Capability Specification
 
 ## 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
 
 ### 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
-- **WHEN** the server starts
-- **THEN** it SHALL establish a connection to the Redis queue
-- **AND** it SHALL begin listening for new log records
-- **AND** it SHALL store log records in memory for display
+#### 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
 
 ### Requirement: Log Display in Console
 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
diff --git a/openspec/specs/redis-connection/spec.md b/openspec/specs/redis-connection/spec.md
index b84a5ca..8f528e3 100644
--- a/openspec/specs/redis-connection/spec.md
+++ b/openspec/specs/redis-connection/spec.md
@@ -1,7 +1,7 @@
 # Redis Connection Capability Specification
 
 ## 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
 
@@ -20,6 +20,7 @@ The system SHALL allow configuration of Redis connection parameters.
 - **WHEN** the server starts with Redis environment variables set
 - **THEN** it SHALL use those variables to configure the Redis connection
 - **AND** it SHALL override default values
+- **AND** it SHALL use Redis database 15
 
 ### Requirement: Redis Connection Reconnection
 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
 - **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
 
 ### Redis Connection Configuration
@@ -139,3 +149,9 @@ The system SHALL monitor the Redis connection status.
     "deleteOldKeys": false
   }
   ```
+
+## Redis Data Structures
+
+### Key: 项目心跳
+- **Type**: LIST
+- **Element**: JSON string `{"projectName":"...","apiBaseUrl":"...","lastActiveAt":1768566165572}`
diff --git a/package.json b/package.json
index 190d6f3..3184afe 100644
--- a/package.json
+++ b/package.json
@@ -11,7 +11,7 @@
     "start:dev": "nodemon src/backend/server.js",
     "test": "vitest run",
     "test:watch": "vitest",
-    "lint": "eslint . --ext .js,.vue --config .eslintrc.cjs",
+    "lint": "eslint src --ext .js,.vue --config .eslintrc.cjs",
     "format": "prettier --write ."
   },
   "dependencies": {
diff --git a/src/backend/routes/commands.js b/src/backend/routes/commands.js
index 7b134db..7e3a18e 100644
--- a/src/backend/routes/commands.js
+++ b/src/backend/routes/commands.js
@@ -53,14 +53,15 @@ function buildTargetUrl(apiBaseUrl, apiName) {
 
 function truncateForLog(value, maxLen = 2000) {
   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;
 }
 
 async function getProjectHeartbeat(redis, projectName) {
   try {
-    const projectsList = await getProjectsList();
-    const project = projectsList.find(p => p.projectName === projectName);
+    const projectsList = await getProjectsList(redis);
+    const project = projectsList.find((p) => p.projectName === projectName);
 
     if (project) {
       return {
@@ -69,18 +70,11 @@ async function getProjectHeartbeat(redis, projectName) {
       };
     }
   } 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;
 }
 
@@ -133,7 +127,10 @@ router.post('/', async (req, res) => {
     }
 
     const heartbeatKey = projectHeartbeatKey(targetProjectName.trim());
-    const heartbeat = await getProjectHeartbeat(redis, targetProjectName.trim());
+    const heartbeat = await getProjectHeartbeat(
+      redis,
+      targetProjectName.trim(),
+    );
 
     if (!heartbeat) {
       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);
 
     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();
-    if (!lastActiveAt || (Number.isFinite(offlineThresholdMs) && now - lastActiveAt > offlineThresholdMs)) {
+    if (
+      !lastActiveAt ||
+      (Number.isFinite(offlineThresholdMs) &&
+        now - lastActiveAt > offlineThresholdMs)
+    ) {
       return res.status(503).json({
         success: false,
         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, {
       timeout: Number.isFinite(timeoutMs) ? timeoutMs : 5000,
       validateStatus: () => true,
@@ -209,4 +219,4 @@ router.post('/', async (req, res) => {
   }
 });
 
-export default router;
\ No newline at end of file
+export default router;
diff --git a/src/backend/routes/logs.js b/src/backend/routes/logs.js
index e32be45..7436c61 100644
--- a/src/backend/routes/logs.js
+++ b/src/backend/routes/logs.js
@@ -3,15 +3,102 @@ import express from 'express';
 const router = express.Router();
 
 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';
 
+const LOGS_MAX_LEN = 1000;
+const LOG_TTL_MS = 24 * 60 * 60 * 1000;
+
 function parsePositiveInt(value, defaultValue) {
   const num = Number.parseInt(String(value), 10);
   if (!Number.isFinite(num) || num <= 0) return defaultValue;
   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) {
   if (typeof value === 'number' && Number.isFinite(value)) return value;
   if (typeof value === 'string') {
@@ -25,8 +112,8 @@ function parseLastActiveAt(value) {
 
 async function getProjectHeartbeat(redis, projectName) {
   try {
-    const projectsList = await getProjectsList();
-    const project = projectsList.find(p => p.projectName === projectName);
+    const projectsList = await getProjectsList(redis);
+    const project = projectsList.find((p) => p.projectName === projectName);
 
     if (project) {
       return {
@@ -35,25 +122,61 @@ async function getProjectHeartbeat(redis, projectName) {
       };
     }
   } 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));
-  if (heartbeatRaw) {
+async function pruneAndReadLogsAtomically(redis, key, limit) {
+  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 {
-      return JSON.parse(heartbeatRaw);
-    } catch {
-      return null;
+      await redis.watch(key);
+      const rawItems = await redis.lRange(key, 0, -1);
+
+      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) => {
-  const projectName = typeof req.query.projectName === 'string' ? req.query.projectName.trim() : '';
-  const limit = parsePositiveInt(req.query.limit, 200);
+  const projectName =
+    typeof req.query.projectName === 'string'
+      ? req.query.projectName.trim()
+      : '';
+  const limit = parsePositiveInt(req.query.limit, LOGS_MAX_LEN);
 
   if (!projectName) {
     return res.status(200).json({
@@ -73,52 +196,63 @@ router.get('/', async (req, res) => {
     }
 
     const key = projectConsoleKey(projectName);
-    const list = await redis.lRange(key, -limit, -1);
+    const list = await pruneAndReadLogsAtomically(redis, key, limit);
 
-    const logs = list
-      .map((raw, idx) => {
-        try {
-          const parsed = JSON.parse(raw);
-          const timestamp = parsed.timestamp || new Date().toISOString();
-          const level = (parsed.level || 'info').toString().toLowerCase();
-          const message = parsed.message != null ? String(parsed.message) : '';
-          return {
-            id: parsed.id || `log-${timestamp}-${idx}`,
-            timestamp,
-            level,
-            message,
-            metadata: parsed.metadata && typeof parsed.metadata === 'object' ? parsed.metadata : undefined,
-          };
-        } catch {
-          return {
-            id: `log-${Date.now()}-${idx}`,
-            timestamp: new Date().toISOString(),
-            level: 'info',
-            message: raw,
-          };
-        }
-      });
+    const logs = list.map((raw, idx) => {
+      try {
+        const parsed = JSON.parse(raw);
+        const timestamp = parsed.timestamp || new Date().toISOString();
+        const level = (parsed.level || 'info').toString().toLowerCase();
+        const message = parsed.message != null ? String(parsed.message) : '';
+        return {
+          id: parsed.id || `log-${timestamp}-${idx}`,
+          timestamp,
+          level,
+          message,
+          metadata:
+            parsed.metadata && typeof parsed.metadata === 'object'
+              ? parsed.metadata
+              : undefined,
+        };
+      } catch {
+        return {
+          id: `log-${Date.now()}-${idx}`,
+          timestamp: new Date().toISOString(),
+          level: 'info',
+          message: raw,
+        };
+      }
+    });
     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 lastActiveAt = parseLastActiveAt(heartbeat?.lastActiveAt);
     const ageMs = lastActiveAt ? now - lastActiveAt : null;
-    const isOnline = lastActiveAt && Number.isFinite(offlineThresholdMs)
-      ? ageMs <= offlineThresholdMs
-      : Boolean(lastActiveAt);
+    const isOnline =
+      lastActiveAt && Number.isFinite(offlineThresholdMs)
+        ? ageMs <= offlineThresholdMs
+        : Boolean(lastActiveAt);
 
     const computedStatus = heartbeat ? (isOnline ? '在线' : '离线') : null;
 
     return res.status(200).json({
       logs,
       projectStatus: computedStatus || null,
-      heartbeat: heartbeat ? {
-        apiBaseUrl: typeof heartbeat.apiBaseUrl === 'string' ? heartbeat.apiBaseUrl : null,
-        lastActiveAt: lastActiveAt || null,
-        isOnline,
-        ageMs,
-      } : null,
+      heartbeat: heartbeat
+        ? {
+          apiBaseUrl:
+              typeof heartbeat.apiBaseUrl === 'string'
+                ? heartbeat.apiBaseUrl
+                : null,
+          lastActiveAt: lastActiveAt || null,
+          isOnline,
+          ageMs,
+        }
+        : null,
     });
   } catch (err) {
     console.error('Failed to read logs', err);
@@ -130,4 +264,44 @@ router.get('/', async (req, res) => {
   }
 });
 
-export default router;
\ No newline at end of file
+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;
diff --git a/src/backend/routes/projects.integration.test.js b/src/backend/routes/projects.integration.test.js
index 3176440..45856fd 100644
--- a/src/backend/routes/projects.integration.test.js
+++ b/src/backend/routes/projects.integration.test.js
@@ -8,9 +8,13 @@ describe('projects API', () => {
   it('GET /api/projects returns projects from unified list', async () => {
     const now = Date.now();
     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 });
@@ -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 () => {
     const now = Date.now();
     const redis = createFakeRedis({
@@ -47,11 +80,11 @@ describe('projects API', () => {
     expect(resp.body.success).toBe(true);
     expect(resp.body.migrated).toBe(1);
 
-    const listRaw = await redis.get('项目心跳');
-    expect(typeof listRaw).toBe('string');
-    const list = JSON.parse(listRaw);
-    expect(Array.isArray(list)).toBe(true);
-    expect(list[0]).toMatchObject({
+    const listItems = await redis.lRange('项目心跳', 0, -1);
+    expect(Array.isArray(listItems)).toBe(true);
+    expect(listItems.length).toBe(1);
+    const first = JSON.parse(listItems[0]);
+    expect(first).toMatchObject({
       projectName: 'A',
       apiBaseUrl: 'http://a',
     });
@@ -60,3 +93,265 @@ describe('projects API', () => {
     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);
+  });
+});
diff --git a/src/backend/routes/projects.js b/src/backend/routes/projects.js
index 5896264..3d752d6 100644
--- a/src/backend/routes/projects.js
+++ b/src/backend/routes/projects.js
@@ -50,7 +50,7 @@ router.get('/', async (req, res) => {
       });
     }
 
-    const projectsList = await getProjectsList();
+    const projectsList = await getProjectsList(redis);
     const projects = projectsList.map(project => {
       const statusInfo = computeProjectStatus(project);
       return {
@@ -81,7 +81,9 @@ router.post('/migrate', async (req, res) => {
   const { deleteOldKeys = false, dryRun = false } = req.body;
 
   try {
+    const redis = req.app?.locals?.redis || (await getRedisClient());
     const result = await migrateHeartbeatData({
+      redis,
       deleteOldKeys: Boolean(deleteOldKeys),
       dryRun: Boolean(dryRun),
     });
@@ -101,4 +103,4 @@ router.post('/migrate', async (req, res) => {
   }
 });
 
-export default router;
\ No newline at end of file
+export default router;
diff --git a/src/backend/server.js b/src/backend/server.js
index 80d6243..e27d199 100644
--- a/src/backend/server.js
+++ b/src/backend/server.js
@@ -4,9 +4,16 @@ import logRoutes from './routes/logs.js';
 import commandRoutes from './routes/commands.js';
 import projectRoutes from './routes/projects.js';
 import { getRedisClient } from './services/redisClient.js';
+import { pruneProjectsHeartbeatList } from './services/migrateHeartbeatData.js';
 
 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(express.json());
@@ -19,7 +26,6 @@ app.get('/api/health', (req, res) => {
   res.status(200).json({ status: 'ok' });
 });
 
-// 启动服务器
 const server = app.listen(PORT, async () => {
   console.log(`Server running on port ${PORT}`);
 
@@ -27,6 +33,15 @@ const server = app.listen(PORT, async () => {
     const redis = await getRedisClient();
     app.locals.redis = redis;
     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) {
     console.error('[redis] failed to connect on startup', err);
   }
@@ -34,12 +49,15 @@ const server = app.listen(PORT, async () => {
 
 process.on('SIGINT', async () => {
   try {
+    if (app.locals.heartbeatPruneInterval) {
+      clearInterval(app.locals.heartbeatPruneInterval);
+    }
     if (app.locals.redis) {
       await app.locals.redis.quit();
     }
-  } catch {
-    // ignore
+  } catch (err) {
+    void err;
   } finally {
     server.close(() => process.exit(0));
   }
-});
\ No newline at end of file
+});
diff --git a/src/backend/services/migrateHeartbeatData.js b/src/backend/services/migrateHeartbeatData.js
index 632bf8f..1f34d10 100644
--- a/src/backend/services/migrateHeartbeatData.js
+++ b/src/backend/services/migrateHeartbeatData.js
@@ -1,7 +1,10 @@
 import { getRedisClient } from './redisClient.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 === 'string') {
     const asNum = Number(value);
@@ -12,10 +15,210 @@ function parseLastActiveAt(value) {
   return null;
 }
 
-export async function migrateHeartbeatData(options = {}) {
-  const { deleteOldKeys = false, dryRun = false } = options;
+function safeJsonParse(value) {
+  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) {
     throw new Error('Redis 未就绪');
   }
@@ -35,11 +238,9 @@ export async function migrateHeartbeatData(options = {}) {
         continue;
       }
 
-      let heartbeat;
-      try {
-        heartbeat = JSON.parse(heartbeatRaw);
-      } catch (err) {
-        console.error(`[migrate] 解析失败: ${key}`, err.message);
+      const heartbeat = safeJsonParse(heartbeatRaw);
+      if (!heartbeat) {
+        console.error(`[migrate] 解析失败: ${key}`);
         continue;
       }
 
@@ -62,21 +263,21 @@ export async function migrateHeartbeatData(options = {}) {
       console.log(`[migrate] 添加项目: ${projectName}`);
     }
 
-    console.log(`[migrate] 共迁移 ${projectsList.length} 个项目`);
+    const dedupedProjectsList = dedupeHeartbeatRecords(projectsList);
+    console.log(`[migrate] 共迁移 ${dedupedProjectsList.length} 个项目`);
 
     if (dryRun) {
       console.log('[migrate] 干运行模式，不写入数据');
       return {
         success: true,
-        migrated: projectsList.length,
-        projects: projectsList,
+        migrated: dedupedProjectsList.length,
+        projects: dedupedProjectsList,
         dryRun: true,
       };
     }
 
-    const listKey = projectsListKey();
-    await redis.set(listKey, JSON.stringify(projectsList));
-    console.log(`[migrate] 已写入项目列表到: ${listKey}`);
+    const listKey = await writeProjectsListAsList(redis, dedupedProjectsList);
+    console.log(`[migrate] 已写入项目列表到: ${listKey} (LIST)`);
 
     if (deleteOldKeys) {
       console.log('[migrate] 删除旧键...');
@@ -90,8 +291,8 @@ export async function migrateHeartbeatData(options = {}) {
 
     return {
       success: true,
-      migrated: projectsList.length,
-      projects: projectsList,
+      migrated: dedupedProjectsList.length,
+      projects: dedupedProjectsList,
       listKey,
       deleteOldKeys,
     };
@@ -101,35 +302,22 @@ export async function migrateHeartbeatData(options = {}) {
   }
 }
 
-export async function getProjectsList() {
-  const redis = await getRedisClient();
+export async function getProjectsList(injectedRedis) {
+  const redis = injectedRedis || (await getRedisClient());
   if (!redis?.isReady) {
     throw new Error('Redis 未就绪');
   }
 
-  const listKey = projectsListKey();
-  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 [];
-  }
+  return readProjectsList(redis);
 }
 
-export async function updateProjectHeartbeat(projectName, heartbeatData) {
-  const redis = await getRedisClient();
+export async function updateProjectHeartbeat(projectName, heartbeatData, injectedRedis) {
+  const redis = injectedRedis || (await getRedisClient());
   if (!redis?.isReady) {
     throw new Error('Redis 未就绪');
   }
 
-  const projectsList = await getProjectsList();
+  const projectsList = await getProjectsList(redis);
   const existingIndex = projectsList.findIndex(p => p.projectName === projectName);
 
   const project = {
@@ -144,8 +332,7 @@ export async function updateProjectHeartbeat(projectName, heartbeatData) {
     projectsList.push(project);
   }
 
-  const listKey = projectsListKey();
-  await redis.set(listKey, JSON.stringify(projectsList));
+  await writeProjectsListAsList(redis, projectsList);
 
   return project;
-}
\ No newline at end of file
+}
diff --git a/src/backend/services/redisClient.js b/src/backend/services/redisClient.js
index c054da3..abd0da2 100644
--- a/src/backend/services/redisClient.js
+++ b/src/backend/services/redisClient.js
@@ -17,7 +17,7 @@ export async function getRedisClient() {
   const host = process.env.REDIS_HOST || '10.8.8.109';
   const port = parseIntOrDefault(process.env.REDIS_PORT, 6379);
   const password = process.env.REDIS_PASSWORD || undefined;
-  const db = parseIntOrDefault(process.env.REDIS_DB, 0);
+  const db = 15;
 
   const url = `redis://${host}:${port}`;
 
diff --git a/src/backend/test/fakeRedis.js b/src/backend/test/fakeRedis.js
index 8dad399..6f75290 100644
--- a/src/backend/test/fakeRedis.js
+++ b/src/backend/test/fakeRedis.js
@@ -10,6 +10,25 @@ function globToRegex(glob) {
 
 export function createFakeRedis(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 {
     isReady: true,
@@ -20,11 +39,19 @@ export function createFakeRedis(initial = {}) {
 
     async set(key, value) {
       kv.set(key, String(value));
+      bumpVersion(key);
       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) {
       const existed = kv.delete(key);
+      if (existed) bumpVersion(key);
       return existed ? 1 : 0;
     },
 
@@ -33,18 +60,156 @@ export function createFakeRedis(initial = {}) {
       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
     async lRange(key, start, stop) {
       const raw = kv.get(key);
       const list = Array.isArray(raw) ? raw : [];
 
-      const normalizeIndex = (idx) => (idx < 0 ? list.length + idx : idx);
-      const s = normalizeIndex(start);
-      const e = normalizeIndex(stop);
+      const s = normalizeIndex(list, start);
+      const e = normalizeIndex(list, stop);
 
       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
     _dump() {
       return Object.fromEntries(kv.entries());
diff --git a/src/frontend/App.vue b/src/frontend/App.vue
index 3fcf41f..6199028 100644
--- a/src/frontend/App.vue
+++ b/src/frontend/App.vue
@@ -57,7 +57,7 @@ const checkServiceHealth = async () => {
   try {
     console.log('=== 开始检查服务健康状态 ===');
 
-    const response = await fetch('http://localhost:3001/api/health', {
+    const response = await fetch('/api/health', {
       method: 'GET',
       credentials: 'omit',
       referrerPolicy: 'no-referrer',
diff --git a/src/frontend/components/Console.vue b/src/frontend/components/Console.vue
index e970179..113e9c4 100644
--- a/src/frontend/components/Console.vue
+++ b/src/frontend/components/Console.vue
@@ -47,17 +47,62 @@
 
     <!-- 日志显示区域 -->
     <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">
         <table class="log-table">
           <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">
                 <div class="log-timestamp">
                   {{ formatTimestamp(log.timestamp) }}
                 </div>
-                <div class="log-level-badge" :class="`level-${log.level}`">
-                  {{ log.level.toUpperCase() }}
-                </div>
               </td>
               <td class="log-message">
                 {{ log.message }}
@@ -113,7 +158,7 @@ const isAtBottom = ref(true);
 let pollTimer = null;
 
 const mergedLogs = computed(() => {
-  const combined = [...remoteLogs.value, ...uiLogs.value]
+  const combined = remoteLogs.value.concat(uiLogs.value)
     .filter(Boolean)
     .sort((a, b) => new Date(a.timestamp) - new Date(b.timestamp));
   if (combined.length <= MAX_LOGS) return combined;
@@ -128,6 +173,55 @@ const filteredLogs = computed(() => {
   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() {
   if (!logTableWrapper.value) return;
   setTimeout(() => {
@@ -135,6 +229,36 @@ function scrollTableToBottom() {
   }, 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 () => {
   if (!commandInput.value.trim()) return;
 
@@ -203,9 +327,28 @@ const addLog = (logData) => {
 };
 
 // 清空日志
-const clearLogs = () => {
-  remoteLogs.value = [];
+const clearLogs = async () => {
+  const projectName = props.projectName;
+
   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', {
       params: {
         projectName,
-        limit: Math.min(500, MAX_LOGS),
+        limit: MAX_LOGS,
       },
     });
 
@@ -301,7 +444,6 @@ watch(() => props.projectName, async () => {
   height: 100%;
   min-height: 0;
   color: #d4d4d4;
-  font-family: 'Consolas', 'Monaco', 'Courier New', monospace;
   font-size: 0.9rem;
 }
 
@@ -345,8 +487,8 @@ watch(() => props.projectName, async () => {
   background-color: #3c3c3c;
   color: #d4d4d4;
   border: 1px solid #555;
-  border-radius: 3px;
-  padding: 0.3rem 0.5rem;
+  border-radius: 6px;
+  padding: 0.35rem 0.75rem;
   font-size: 0.85rem;
   cursor: pointer;
   transition: all 0.2s;
@@ -380,6 +522,41 @@ watch(() => props.projectName, async () => {
 
 .toggle-checkbox {
   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;
   color: #d4d4d4;
   border: 1px solid #555;
-  border-radius: 3px;
-  padding: 0.3rem 0.8rem;
+  border-radius: 6px;
+  padding: 0.35rem 0.75rem;
   font-size: 0.85rem;
   cursor: pointer;
   transition: all 0.2s;
@@ -416,20 +593,185 @@ watch(() => props.projectName, async () => {
   display: flex;
   flex-direction: column;
   overflow: hidden;
-  padding: 1rem;
+  padding: 0;
   background-color: #000000;
   line-height: 1.5;
   scroll-behavior: smooth;
   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 {
   flex: 1;
   min-height: 0;
+  height: 100%;
+  overflow: auto;
   overflow-y: auto;
   overflow-x: hidden;
-  /* 兜底：当父容器高度不受约束时，限制日志区域最大高度，避免把输入框顶出视口 */
+  -webkit-overflow-scrolling: touch;
+  scrollbar-width: auto;
+  -ms-overflow-style: auto;
   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%;
   border-collapse: collapse;
   table-layout: fixed;
+  overflow: auto;
 }
 
 /* 日志项 */
 .log-item {
-  border-bottom: 1px solid rgba(255, 255, 255, 0.12);
-  /* 浅灰色分割线 */
+  background: transparent;
 }
 
-.log-item:last-child {
-  border-bottom: none;
+.log-active {
+  background: rgba(0, 120, 212, 0.12);
 }
 
 .log-meta {
   vertical-align: top;
-  padding: 0.1rem 0.2rem 0.1rem 0;
+  padding: 0 0.75rem 0.25rem 0;
   white-space: nowrap;
-  width: 100px;
-  min-width: 100px;
-  max-width: 100px;
+  width: 80px;
+  min-width: 80px;
+  max-width: 80px;
 }
 
 .log-timestamp {
   color: #608b4e;
-  font-size: 0.8rem;
-  margin-bottom: 0.2rem;
-}
-
-.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;
+  font-size: 0.75rem;
+  line-height: 1.25rem;
 }
 
 .log-message {
   vertical-align: top;
-  padding: 0.1rem 0;
+  padding: 0 0 0.25rem 0;
   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) {
+  .timeline-header {
+    padding: 0.5rem 0.75rem;
+  }
+
+  .timeline-track {
+    margin: 0 0.75rem 0.5rem;
+  }
+
+  .timeline-legend {
+    display: none;
+  }
+
   .log-meta {
-    width: 120px;
-    min-width: 120px;
-    max-width: 120px;
+    width: 72px;
+    min-width: 72px;
+    max-width: 72px;
     padding-right: 0.5rem;
   }
 
   .log-timestamp {
-    font-size: 0.75rem;
-    margin-bottom: 0.1rem;
-  }
-
-  .log-level-badge {
-    min-width: 50px;
-    font-size: 0.65rem;
+    font-size: 0.7rem;
   }
 
   /* 移动端：比默认再小 10px */
   .log-table-wrapper {
     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%;
   box-sizing: border-box;
   overflow: hidden;
+  font-family: 'Consolas', 'Monaco', 'Courier New', monospace;
 }
 
 .command-prompt {
@@ -574,7 +918,7 @@ watch(() => props.projectName, async () => {
   background-color: #0078d4;
   color: white;
   border: none;
-  border-radius: 3px;
+  border-radius: 6px;
   padding: 0.4rem 1rem;
   font-size: 0.85rem;
   cursor: pointer;
@@ -592,21 +936,21 @@ watch(() => props.projectName, async () => {
 }
 
 /* 滚动条样式 */
-.logs-container::-webkit-scrollbar {
+.log-table-wrapper::-webkit-scrollbar {
   width: 8px;
   height: 8px;
 }
 
-.logs-container::-webkit-scrollbar-track {
+.log-table-wrapper::-webkit-scrollbar-track {
   background: #1e1e1e;
 }
 
-.logs-container::-webkit-scrollbar-thumb {
+.log-table-wrapper::-webkit-scrollbar-thumb {
   background: #424242;
   border-radius: 4px;
 }
 
-.logs-container::-webkit-scrollbar-thumb:hover {
+.log-table-wrapper::-webkit-scrollbar-thumb:hover {
   background: #4e4e4e;
 }
 
@@ -638,19 +982,7 @@ watch(() => props.projectName, async () => {
   }
 
   .logs-container {
-    padding: 0.5rem;
-  }
-
-  .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;
+    padding: 0;
   }
 
   .command-input-container {
@@ -665,4 +997,4 @@ watch(() => props.projectName, async () => {
     max-height: min(80vh, calc(100dvh - 200px));
   }
 }
-</style>
\ No newline at end of file
+</style>
diff --git a/src/frontend/components/ProjectSelector.vue b/src/frontend/components/ProjectSelector.vue
index 3c6c024..08b15a1 100644
--- a/src/frontend/components/ProjectSelector.vue
+++ b/src/frontend/components/ProjectSelector.vue
@@ -62,7 +62,7 @@ defineProps({
   },
 });
 
-const emit = defineEmits(['project-selected']);
+const emit = defineEmits([ 'project-selected' ]);
 
 const loading = ref(false);
 const error = ref('');
diff --git a/src/frontend/views/CommandView.vue b/src/frontend/views/CommandView.vue
index dedbc38..0c98840 100644
--- a/src/frontend/views/CommandView.vue
+++ b/src/frontend/views/CommandView.vue
@@ -74,7 +74,7 @@ const sendCommand = async () => {
   response.value = null;
 
   try {
-    const resp = await axios.post('http://localhost:3001/api/commands', {
+    const resp = await axios.post('/api/commands', {
       targetProjectName: props.projectName,
       command: command.value.trim(),
     });
diff --git a/src/frontend/views/LogView.vue b/src/frontend/views/LogView.vue
index a527e2f..8cff95f 100644
--- a/src/frontend/views/LogView.vue
+++ b/src/frontend/views/LogView.vue
@@ -70,7 +70,7 @@ const fetchLogs = async () => {
   error.value = null;
 
   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 || [];
     projectStatus.value = response.data.projectStatus;
   } catch (err) {