diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index de4ac15c2..f8679078b 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -184,7 +184,7 @@ jobs:
# 默认不启用 voice feature（包含 whisper-rs，编译很慢）
args: --target ${{ matrix.target }}
- - name: Build Tauri app (Windows)
+ - name: Build Tauri app (Windows online)
if: matrix.platform == 'windows-2022'
uses: tauri-apps/tauri-action@v0
env:
@@ -204,6 +204,33 @@ jobs:
releaseBody: ${{ env.RELEASE_BODY }}
releaseDraft: false
prerelease: false
+ # 默认推荐在线小包，安装时按需拉取 WebView2
+ releaseAssetNamePattern: "[name]_[version]_[arch]-online[setup][ext]"
+ # 默认不启用 voice feature（包含 whisper-rs，编译很慢）
+ args: --target ${{ matrix.target }} --config tauri.windows.online.conf.json
+
+ - name: Build Tauri app (Windows offline)
+ if: matrix.platform == 'windows-2022'
+ uses: tauri-apps/tauri-action@v0
+ env:
+ GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+ # 禁用 LTO 加速编译（正式发布可改为 thin）
+ CARGO_PROFILE_RELEASE_LTO: "off"
+ # 增加并行编译单元
+ CARGO_PROFILE_RELEASE_CODEGEN_UNITS: 32
+ CARGO_INCREMENTAL: 0
+ SCCACHE_GHA_ENABLED: "true"
+ RUSTC_WRAPPER: sccache
+ with:
+ tauriScript: npx tauri
+ projectPath: src-tauri
+ tagName: ${{ github.event.inputs.version || github.ref_name }}
+ releaseName: "ProxyCast ${{ github.event.inputs.version || github.ref_name }}"
+ releaseBody: ${{ env.RELEASE_BODY }}
+ releaseDraft: false
+ prerelease: false
+ # 离线大包内置 WebView2 离线安装器，适用于无网环境
+ releaseAssetNamePattern: "[name]_[version]_[arch]-offline[setup][ext]"
# 默认不启用 voice feature（包含 whisper-rs，编译很慢）
args: --target ${{ matrix.target }} --config tauri.windows.conf.json
diff --git a/README.md b/README.md
index 0f08e1ca7..fd5788c24 100644
--- a/README.md
+++ b/README.md
@@ -1,112 +1,117 @@
-# ProxyCast 🚀
+# ProxyCast
-**创作类 AI Agent 平台**
+**以创作为中心的本地优先 AI Agent 交互工作台**
-一句话：把灵感、写作、出图、改稿、沉淀放进同一个工作台，让创作从“想到”直接走到“可发布”。
+一句话：用 Skills 组织经验与流程，用 MCP 接入标准能力，用 Claw 渠道把 Agent 带到飞书、Telegram 等入口，让创作、研究、执行与交付在同一个工作环境里闭合。
---
-## 👋 这是什么
+## 这是什么
-ProxyCast 是面向普通创作者的 AI Agent 平台。
-你不需要先懂复杂设置，只要带着一个想法进来，就可以在同一处完成：
+ProxyCast 是一个基于 Tauri 的桌面应用，面向创作者、内容团队与轻知识工作者。它把 Workspace、Agent、Skills、MCP、Claw 渠道和 Artifact 交付整合到同一个桌面环境里，让工作从输入需求直接走向可沉淀、可复用、可继续执行的结果。
-- 和 Agent 对话定方向
-- 生成内容与素材
-- 继续迭代修改
-- 把结果沉淀成可复用资产
+你可以在一个地方完成：
+
+- 在项目里与 Agent 协作
+- 生成和编辑文档、脚本、图文方案等产物
+- 使用浏览器、终端、MCP 和插件扩展执行空间
+- 让结果沉淀为可复用的记忆、风格和版本资产
---
-## 🧩 支持的创作主题
+## 产品核心
-你可以按创作目标选择主题，也可以跨主题组合使用。
+### 1. Workspace 是环境
-1. **通用对话**：灵感发散、问题梳理、快速头脑风暴
-2. **社媒内容**：选题、标题、正文、多平台改写
-3. **图文海报**：主视觉文案、配图方向、海报内容生成
-4. **歌词曲谱**：歌词起稿、段落续写、风格改编
-5. **知识探索**：知识点拆解、结构化总结、学习卡片
-6. **计划规划**：目标分解、执行节奏、阶段复盘
-7. **办公文档**：报告、方案、邮件、会议纪要整理
-8. **短视频**：脚本结构、分镜思路、口播文案生成
-9. **小说创作**：设定、章节推进、人物对白与续写
+- 项目、文件、会话、记忆、风格和人设围绕同一个工作区持续累积
+- 支持主题化工作台，覆盖通用对话、社媒内容、办公文档、视频、小说等场景
+
+### 2. Skills 是经验交互与流程编排
+
+- Skills 封装 prompt、references、scripts、assets 和调用规则
+- Skills 既定义如何交互，也定义任务如何推进
+- 它们是 ProxyCast 中经验复用、流程复用和领域方法沉淀的核心单元
+
+### 3. MCP 是标准能力层
+
+- 基于 MCP 接入 tools、resources、prompts 和工作边界
+- 让浏览器、文件、终端和外部服务成为 Agent 的标准化能力网络
+- 让 ProxyCast 的能力扩展建立在开放标准之上
+
+### 4. Claw 渠道是异步协作入口
+
+- 支持通过飞书、Telegram、Discord 等渠道与 Agent 持续协作
+- 支持远程触发、异步回流与渠道化交互
+- 让 Agent 不只存在于桌面窗口中
+
+### 5. Artifact 是交付物
+
+- 持续产出文档、脚本、草稿、海报方案与版本结果
+- 通过画布与工作流把过程沉淀到项目内，形成可复用的项目资产
+
+### 6. Agent Runtime 负责执行与编排
+
+- 基于 Aster Agent Runtime
+- 支持会话、流式执行、技能调用、子任务接力与长期运行
+- 底层保留多 Provider 接入、凭证池、路由与协议兼容能力
---
-## 📖 创作场景（不止一种）
+## 适合谁
-### 场景 1：社媒日更
-
-- 场景：每天都要稳定发内容，但选题和表达容易重复。
-- 动作：先让 Agent 给出 3 个方向，再选一个生成多版文案与配图思路。
-- 结果：当天可直接发布，同时保留素材供后续复用。
-
-### 场景 2：短视频起号
-
-- 场景：有想法但脚本总是“有点散”。
-- 动作：用主题工作流先拆结构，再生成口播稿和镜头节奏。
-- 结果：从模糊创意变成可拍摄脚本，沟通成本显著降低。
-
-### 场景 3：小说连载
-
-- 场景：长期连载容易设定冲突、节奏断档。
-- 动作：在同一项目里持续积累世界观、人物设定和章节草稿。
-- 结果：剧情连贯性更强，更新更稳定。
-
-### 场景 4：活动海报与图文
-
-- 场景：活动上线前要快速产出多套视觉方向。
-- 动作：先生成文案方向，再出图并按参考图持续迭代。
-- 结果：方案选择更快，历史版本可追溯、可复用。
-
-### 场景 5：歌词创作
-
-- 场景：有旋律或主题，但歌词总卡在中段。
-- 动作：让 Agent 先给主副歌框架，再逐段续写与改写。
-- 结果：成稿速度更快，风格更统一。
-
-### 场景 6：知识内容输出
-
-- 场景：学了很多但难以整理成可分享内容。
-- 动作：把资料整理成结构化要点，再输出为卡片或长文。
-- 结果：输入和输出形成闭环，知识更容易长期积累。
-
-### 场景 7：计划执行
-
-- 场景：目标很大，但每天不知道先做什么。
-- 动作：把目标拆成周计划与日任务，并按进度复盘调整。
-- 结果：执行路径清晰，可持续推进。
-
-### 场景 8：办公写作
-
-- 场景：报告、邮件、方案反复改，耗时高。
-- 动作：先生成初稿，再按受众快速改成不同版本。
-- 结果：沟通更顺，交付更快。
+- 内容创作者
+- 品牌与运营团队
+- 研究与知识整理型工作者
+- 需要本地优先、结果可追溯的小团队
---
-## 🎨 3 步开始创作
+## 典型场景
-1. **选主题**：按目标进入对应创作主题
-2. **给输入**：一句需求、一个方向或一份素材都可以
-3. **持续迭代**：边聊边改边沉淀，最终得到可发布结果
+### 场景 1：内容创作闭环
+
+- 从选题、研究、写作、改稿到最终成稿
+- Skills 驱动任务推进，对话、版本和风格资产持续沉淀在项目中
+
+### 场景 2：研究整理
+
+- 从网页资料、笔记、素材到提纲、报告和长文输出
+- 通过 Skills 与 MCP 把零散信息整理成结构化交付物
+
+### 场景 3：渠道化协作
+
+- 通过飞书、Telegram、Discord 等 Claw 渠道接收结果、触发任务、继续协作
+- 让 Agent 进入真实使用的消息入口，而不只停留在桌面端
+
+### 场景 4：浏览器与标准能力执行
+
+- 在同一个 Agent 会话里接入浏览器、文件、终端和外部服务
+- 让 MCP 成为标准能力层，而不是零散工具调用
+
+### 场景 5：批量与长期运行
+
+- 针对多条素材、模板或重复流程批量执行
+- 结合心跳、调度与渠道回流形成长期可运行的 Agent 流程
---
-## ❤️ 为什么好用
+## 如何工作
-- **一个地方完成全流程**：从想法到成品不用来回切工具
-- **结果自动沉淀**：历史对话、素材、版本都可回看
-- **越用越顺手**：每个项目都有自己的上下文记忆
+ProxyCast 的核心工作方式是：
+
+1. 在 Workspace 内组织项目、素材、记忆和风格
+2. 用 Skills 定义经验交互与流程推进
+3. 通过 MCP 接入标准化外部能力
+4. 通过 Claw 渠道把协作延伸到飞书、Telegram、Discord 等入口
+5. 让结果沉淀为文档、脚本、版本和后续任务输入
---
-## 🚀 快速开始
+## 快速开始
### 安装
@@ -121,27 +126,18 @@ brew install --cask proxycast
从 [Releases](https://github.com/aiclientproxy/proxycast/releases) 下载对应平台安装包。
-- Windows 用户优先下载 `ProxyCast_*_x64-setup.exe`（NSIS 安装器）
-- 该安装器已内置 WebView2 Offline Installer，弱网/离线环境成功率更高
+- Windows 用户默认优先下载 `ProxyCast_*_x64-online-setup.exe`（NSIS 在线安装器，体积更小）
+- 如果处于离线、内网或受限网络环境，请改用 `ProxyCast_*_x64-offline-setup.exe`
- 如被 SmartScreen 拦截，属于未签名或签名信誉不足的 Windows 常见提示，不代表安装包必然损坏
---
-## 🧭 适合谁
+## 文档与开发
-- 自媒体创作者
-- 短视频团队
-- 小说与剧情创作者
-- 运营与品牌内容团队
-- 需要长期沉淀创作资产的个人与小团队
-
----
-
-## 📚 文档与开发（可选）
-
-如果你是开发者，可查看：
+如果你是开发者，可查看以下文档：
- 项目文档：`docs/aiprompts/`
+- 官网定位 PRD：`docs/PRD/website-positioning-prd.md`
- Agent 指南：`AGENTS.md`
开发命令：
@@ -157,11 +153,11 @@ npm run tauri build
---
-## 📄 开源协议
+## 开源协议
[GNU General Public License v3 (GPLv3)](https://www.gnu.org/licenses/gpl-3.0)
-## ⚠️ 免责声明
+## 免责声明
本项目仅供学习研究使用，用户需自行承担使用风险。
本项目不直接提供 AI 模型服务，模型能力由第三方提供商提供。
diff --git a/RELEASE_NOTES.md b/RELEASE_NOTES.md
index 704269f10..e121f503a 100644
--- a/RELEASE_NOTES.md
+++ b/RELEASE_NOTES.md
@@ -1,46 +1,52 @@
-## ProxyCast v0.87.0
+## ProxyCast v0.88.0
### ✨ 新功能
-- **浏览器协助运行时**：新增 `browser-runtime` crate、Tauri 命令与调试页，支持在 Agent 会话内拉起浏览器协助能力
-- **Browser Assist 产物渲染**：新增 Browser Assist Artifact 渲染器，可在 General 会话中直接承接浏览器协助状态与操作
-- **画布工作台布局**：新增 `CanvasWorkbenchLayout`，支持预览 / 文件 / 差异 / 工作台联动，以及分栏与堆叠两种布局模式
-- **技能显式选择器**：新增 `SkillSelector` 与相关 harness skill 聚合逻辑，提升技能发现、点选与触发体验
-- **新任务入口模式**：新增 `new-task` 入口、空状态页与会话恢复控制，梳理 Claw / 新任务两类进入路径
+- **自动化任务中心**：新增 `automation` 命令、服务、DAO 与设置页，支持定时任务、计划预览、健康检查、运行历史，以及 `Agent 对话任务 / 浏览器会话任务` 两种执行形态
+- **浏览器资料与环境预设**：新增 Browser Profile / Browser Environment Preset 管理，支持托管浏览器与附着当前 Chrome 两种资料模式，并可直接复用于浏览器运行时
+- **浏览器现有会话接管**：补齐 existing session attach、页签切换、桥接状态同步与 Browser Runtime 工作区协同链路
+- **Agent Chat 决策与空状态升级**：新增 `DecisionPanel`、空状态 Hero / Quick Actions、A2UI 预览卡、线程分组与消息轮次分组，强化新任务入口与浏览器协助预热
### 🔧 优化与重构
-- **General Chat 主流程重构**：重写 Agent Chat 页的大量 General 场景逻辑，统一画布、Artifact、Workbench 与浏览器协助状态
-- **Webview / Browser Runtime 协调增强**：扩展 `webview_cmd`、窗口服务与前端 API，补齐浏览器运行时会话、窗口与控制链路
-- **Settings v2 大规模重排**：重构外观、快捷键、频道、Chrome Relay、环境、安全性能、账户统计等设置页
-- **项目与记忆工作区升级**：重构内容列表、内容编辑器、项目选择器及多类 Memory 面板，统一信息架构与交互密度
-- **导航与侧栏收敛**：调整应用侧栏、任务侧栏、资源与工作区导航，移除部分旧页面与冗余入口
+- **执行系统收敛**：移除旧 `batch` 页面/API 与 `heartbeat` 命令/设置入口，统一收口到 `automation` 与 `execution tracker`
+- **OpenClaw 工作台重做**：重排安装、配置、运行、Dashboard 与进度页，补强 Windows 环境检测、修复引导与诊断复制
+- **Settings v2 持续整理**：合并媒体服务设置，重构 Chrome Relay、Execution Tracker、About、Appearance 等页面，统一导航与信息架构
+- **资源与创作工作台更新**：重构资源页、图像生成、视频画布、项目选择器与多处内容创作界面，提升工作区一致性
### 🐛 修复
-- **前端 Hooks 依赖修复**：补齐 `useCallback` 依赖，消除 `npm run lint` 中的 `react-hooks/exhaustive-deps` 警告
-- **Rust Clippy 清理**：移除浏览器运行时客户端中的冗余类型转换，保持 `cargo clippy` 输出干净
-- **日志测试并发污染修复**：将日志诊断测试切到独立临时目录，避免并行测试互相删除 `raw_response` 工件
-- **Workspace 错误态兜底**：补强任务侧栏与相关页面的 workspace 异常显示与恢复路径
+- **插件兼容与更新提示补强**：插件管理页新增 Windows 主程序升级入口和最低版本提示，降低插件与主程序版本错配的排障成本
+- **Browser Runtime / DevBridge 稳定性提升**：补齐浏览器会话启动参数、流诊断、桥接 mock 与状态同步，减少运行时偏差
+- **Provider 配置读写修复**：完善 API Key Provider 的 `api_version`、`project` 等配置项读写与表单校验
+- **Windows 启动与安装诊断改进**：补充安装说明、常见问题与构建文档，降低受限网络与依赖缺失场景下的排障摩擦
+
+### ⚠️ 兼容性调整
+
+- 旧 `Batch` / `Heartbeat` 相关前端入口与后端命令已下线；既有流程请迁移到新的 `Automation` 设置页与统一执行记录
### 🧪 测试
-- 新增 Browser Assist、Canvas Workbench、Skill Selector、General Resource Sync、Harness Skills 等前端测试
-- 补充项目页、设置页、统计页、内存面板等多处 UI / 交互测试
+- 新增 Automation、Browser Profile / Environment Preset、Existing Session Attach、Agent Chat 分组与插件版本提示等测试覆盖
+- 补充 Browser Runtime、OpenClaw、Execution Tracker、Chrome Relay 与多处设置页交互测试
- 发布前已执行：`cargo fmt --all`、`cargo test`、`cargo clippy`、`npm run lint`
### 📝 文档
-- 补充 Agent Chat / Components 文档说明
-- 新增 `docs/research/` 研究资料目录
-- 更新发布流程相关说明，覆盖 headless Tauri 配置版本同步
+- 更新 README、架构概览、安装、故障排查、构建与运维文档
+- 补充 NextBrowser 相关研究资料与浏览器自动化设计记录
### 🛠️ 开发体验
-- **版本一致性检查增强**：`check-app-version-consistency.mjs` 现覆盖 `tauri.conf.headless.json`
-- **Release Workflow 补强**：GitHub Release 工作流现同步标准与 headless 两份 Tauri 配置版本
-- **跨端发布一致性提升**：统一 `package.json`、Cargo workspace、Tauri 配置与 release notes 的版本入口
+- **Windows 发布流程增强**：Release Workflow 现同时产出在线 / 离线两个 Windows 安装包
+- **版本源保持一致**：统一 `package.json`、Cargo workspace、两份 Tauri 配置与 `RELEASE_NOTES.md` 的发布版本入口
+
+### 📦 Windows 下载说明
+
+- `ProxyCast_*_x64-online-setup.exe`：默认推荐，体积更小，安装时按需下载 WebView2
+- `ProxyCast_*_x64-offline-setup.exe`：适用于离线、内网或受限网络环境
+- 如果在线安装失败，请改用离线安装包
---
-**完整变更**: v0.86.0...v0.87.0
+**完整变更**: v0.87.0...v0.88.0
diff --git a/docs/aiprompts/overview.md b/docs/aiprompts/overview.md
index b6a355a01..115decca7 100644
--- a/docs/aiprompts/overview.md
+++ b/docs/aiprompts/overview.md
@@ -2,7 +2,25 @@
## 概述
-ProxyCast 是一个 Tauri 桌面应用，作为 LLM API 代理网关，支持多 Provider 凭证池管理、协议转换、流量监控等功能。
+ProxyCast 是一个以创作为中心的本地优先 AI Agent 交互工作台，基于 Tauri 桌面应用构建，面向创作者、内容团队与轻知识工作者。系统由 Workspace、Skills 编排层、MCP 标准能力层、Claw 渠道层、Artifact 交付层与多模型接入能力共同组成。
+
+可以把它理解为三层结构：
+
+1. **产品层**：Workspace、主题工作台、Agent 对话、Skills、Artifact/Canvas、记忆与风格
+2. **能力层**：MCP、浏览器运行时、终端、插件、批量/心跳、Claw 渠道
+3. **基础设施层**：Aster Agent、Provider 凭证池、协议兼容、路由、服务器、数据库与监控
+
+其中，Provider 接入、协议兼容与运行时服务共同构成底层能力底座。
+
+同时，术语上应与当前 Agent 生态保持一致：
+
+- **Sessions**：长期会话与协作上下文
+- **Handoffs**：任务接力与多阶段编排
+- **Guardrails**：权限边界、审批与调用限制
+- **Tracing**：时间线、步骤与调用轨迹可观测
+- **MCP**：tools / resources / prompts / roots 的标准能力接入
+
+在 ProxyCast 中，Skills 处于比 MCP 更贴近产品的一层：它不是底层原语，而是将领域经验、交互方式和执行流程打包后的编排单元。
## 项目结构
@@ -26,51 +44,106 @@ proxycast/
└── docs/ # 文档
```
-## 核心模块
+## 架构分层
-### 后端 (src-tauri/src/)
+### 产品层
| 模块 | 说明 |
|------|------|
+| `workspace/` | 工作区与项目边界，承载文件、会话与配置上下文 |
+| `components/agent/` | Agent 对话主入口，负责会话、流式事件与交互 |
+| `components/content-creator/` | 主题化创作工作台与画布联动 |
+| `skills/` | 技能加载、标准校验与经验编排能力 |
+| `lib/artifact/` | Artifact 解析、状态与轻量渲染器 |
+| `memory / style / personas` | 项目记忆、风格策略与人设沉淀 |
+
+### 能力层
+
+| 模块 | 说明 |
+|------|------|
+| `src/features/browser-runtime/` | 浏览器协助运行时与调试工作区 |
+| `src-tauri/src/terminal/` | 内置终端与 PTY 会话 |
+| `src-tauri/src/services/heartbeat_service/` | 异步调度、周期任务与投递 |
+| `src-tauri/src/plugin/` | 插件系统 |
+| `src-tauri/src/services/mcp_service.rs` | MCP 服务器与工具管理 |
+| `src-tauri/src/commands/gateway_channel_cmd.rs` | Telegram / Feishu / Discord Claw 渠道运行时 |
+| `src-tauri/src/commands/telegram_remote_cmd.rs` | Telegram 远程触发入口 |
+
+### 基础设施层
+
+| 模块 | 说明 |
+|------|------|
+| `src-tauri/src/agent/` | Aster Agent 集成、会话、工具注册与流式桥接 |
| `providers/` | LLM Provider 认证和 API 实现 |
| `services/` | 业务服务层 |
-| `converter/` | 协议转换 (OpenAI ↔ CW/Claude) |
+| `converter/` | 协议转换与兼容层 |
| `server/` | HTTP API 服务器 |
| `credential/` | 凭证池管理 |
| `flow_monitor/` | 流量监控 |
-| `terminal/` | 内置终端 |
+| `database/` | 数据持久化与 DAO |
-### 前端 (src/)
+## 核心模块视图
+
+### 后端（`src-tauri/src/`）
| 模块 | 说明 |
|------|------|
-| `components/` | React 组件 |
+| `agent/` | Aster Agent 运行时桥接与会话管理 |
+| `skills/` | Skills 标准集成、动态加载与执行回调 |
+| `providers/` | 多 Provider 认证与请求发送 |
+| `services/` | 心跳、OpenClaw、浏览器窗口、MCP 等业务服务 |
+| `converter/` | 协议兼容与转换 |
+| `server/` | HTTP Server 与 REST 能力 |
+| `terminal/` | 终端与 PTY |
+| `plugin/` | 插件加载与运行时 |
+| `voice/` | 语音输入输出与 ASR 流程 |
+
+### 前端（`src/`）
+
+| 模块 | 说明 |
+|------|------|
+| `components/` | 主 UI 组件与主题工作台 |
+| `features/` | 浏览器运行时等较独立特性域 |
| `hooks/` | 业务逻辑 Hooks |
-| `lib/` | 工具函数和 API 封装 |
-| `pages/` | 页面组件 |
+| `lib/api/` | Tauri API 与运行时封装 |
+| `lib/artifact/` | Artifact 状态与解析 |
+| `pages/` | 独立窗口与页面入口 |
## 数据流
```
┌─────────────────────────────────────────────────────────────────┐
-│ 客户端请求 (Cursor/Continue) │
+│ 用户请求（工作台 / 对话 / Skills / 飞书 / Telegram） │
└─────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────┐
-│ HTTP Server │
+│ Workspace / Project / Memory Layer │
+│ 项目路径、工作区配置、主题、记忆、人设、风格、产物上下文 │
+└─────────┬───────────────────────────────────────────────────────┘
+ │
+ ▼
+┌─────────────────────────────────────────────────────────────────┐
+│ Skills / Orchestration Layer │
+│ 经验规则、references、scripts、流程推进、任务接力与阶段切换 │
+└─────────┬───────────────────────────────────────────────────────┘
+ │
+ ▼
+┌─────────────────────────────────────────────────────────────────┐
+│ Agent Runtime │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────────────────┐ │
-│ │ OpenAI API │ │ Claude API │ │ Flow Monitor │ │
-│ │ 兼容端点 │ │ 兼容端点 │ │ (请求拦截) │ │
+│ │ Aster Agent │ │ Session │ │ Stream / Action │ │
+│ │ 执行 │ │ 状态 │ │ Request │ │
│ └──────┬──────┘ └──────┬──────┘ └───────────┬─────────────┘ │
└─────────┼────────────────┼─────────────────────┼────────────────┘
│ │ │
▼ ▼ ▼
┌─────────────────────────────────────────────────────────────────┐
-│ Router / Processor │
+│ Execution Surface │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────────────────┐ │
-│ │ 模型路由 │ │ 协议转换 │ │ 弹性策略 │ │
-│ │ (规则匹配) │ │ (Converter) │ │ (重试/超时) │ │
+│ │ MCP Tools / │ │ Browser / │ │ Claw Channels / │ │
+│ │ Resources / │ │ Terminal / │ │ Heartbeat / Plugins │ │
+│ │ Prompts │ │ Files │ │ │ │
│ └──────┬──────┘ └──────┬──────┘ └───────────┬─────────────┘ │
└─────────┼────────────────┼─────────────────────┼────────────────┘
│ │ │
@@ -89,50 +162,73 @@ proxycast/
│ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ │
│ │ Kiro │ │ Gemini │ │ Claude │ │ OpenAI │ ... │
│ └─────────┘ └─────────┘ └─────────┘ └─────────┘ │
+└─────────────────────────────────────────────────────────────────┘
+ │
+ ▼
+┌─────────────────────────────────────────────────────────────────┐
+│ Artifact / Canvas Layer │
+│ 文档、脚本、海报、版本链、画布状态、导出结果与任务沉淀 │
└─────────────────────────────────────────────────────────────────┘
```
## 关键特性
-### 1. 多 Provider 支持
-- OAuth: Kiro, Gemini, Qwen, Claude, Antigravity
-- API Key: OpenAI, Claude, 自定义
+### 1. Workspace 驱动
+- Workspace 既是文件边界，也是 context 边界和配置边界
+- 项目、会话、记忆、风格和 Artifact 围绕同一工作区组织
-### 2. 凭证池管理
-- 多凭证轮询负载均衡
-- 自动健康检查和剔除
-- Token 自动刷新
+### 2. Skills 驱动
+- Skills 是经验交互、流程编排与领域方法沉淀的核心单元
+- Skills 可封装 prompt、references、scripts、assets 与调用规则
+- Agent 运行时可动态加载、自动发现与调用 Skills
-### 3. 协议转换
-- OpenAI ↔ CodeWhisperer
-- OpenAI ↔ Claude
-- OpenAI ↔ Antigravity
+### 3. MCP 标准能力层
+- 基于 MCP 管理 tools、resources、prompts 与读取边界
+- 为 Agent 提供标准化能力发现、调用与上下文共享方式
-### 4. 流量监控
-- 请求/响应拦截
-- Token 统计
-- 历史查询
+### 4. Claw 渠道协作
+- 支持 Telegram / Feishu / Discord 等渠道运行时
+- 支持远程触发、异步协作、消息回流与外部入口接入
+
+### 5. Agent Runtime
+- 基于 Aster Agent，支持会话、流式事件、工具调用与多模型配置
+- 支持任务接力、会话持续化、步骤可观测与长期运行
+
+### 6. Artifact First
+- 输出不止是聊天文本，还包括文档、草稿、脚本、版本链与画布产物
+- `write_file`、画布联动与主题工作流负责把过程沉淀成交付物
+
+### 7. 多 Provider 与兼容层
+- OAuth 与 API Key Provider 并存
+- 凭证池、模型路由、协议兼容与 HTTP Server 作为底层支撑
+
+### 8. 本地优先与可扩展
+- 桌面应用、本地工作区、插件与外部工具扩展
+- 允许在不改变产品主形态的前提下向更多执行环境延展
## 文档索引
-### 核心系统
+### 产品与工作台
+- [workspace.md](workspace.md) - Workspace 边界与工作区设计
+- [content-creator.md](content-creator.md) - 主题化创作工作台
+- [../../src-tauri/src/skills/README.md](../../src-tauri/src/skills/README.md) - Skills 标准与集成
+- [terminal.md](terminal.md) - 终端能力
+- [mcp.md](mcp.md) - MCP 服务器
+- [plugins.md](plugins.md) - 插件系统
+- [aster-integration.md](aster-integration.md) - Agent Runtime 集成
+
+### 基础设施
- [providers.md](providers.md) - Provider 系统
- [credential-pool.md](credential-pool.md) - 凭证池管理
- [converter.md](converter.md) - 协议转换
- [server.md](server.md) - HTTP 服务器
-### 前端模块
+### 前端与公共模块
- [components.md](components.md) - 组件系统
- [hooks.md](hooks.md) - React Hooks
- [lib.md](lib.md) - 工具库
-### 功能模块
-- [flow-monitor.md](flow-monitor.md) - 流量监控
-- [terminal.md](terminal.md) - 内置终端
-- [mcp.md](mcp.md) - MCP 服务器
-- [plugins.md](plugins.md) - 插件系统
-
-### 配置与服务
+### 配置、服务与数据
- [commands.md](commands.md) - Tauri 命令
- [services.md](services.md) - 业务服务
- [database.md](database.md) - 数据库层
diff --git a/docs/content/01.introduction/2.installation.md b/docs/content/01.introduction/2.installation.md
index 3e0356cd0..3397a9f96 100644
--- a/docs/content/01.introduction/2.installation.md
+++ b/docs/content/01.introduction/2.installation.md
@@ -16,16 +16,17 @@ navigation:
## 下载
-从 GitHub Releases/Tags 下载最新版本安装包：
+从 GitHub Releases 下载最新版本安装包：
-[下载 ProxyCast](https://github.com/aiclientproxy/proxycast/tags)
+[下载 ProxyCast](https://github.com/aiclientproxy/proxycast/releases)
### 安装包
| 平台 | 文件名 | 说明 |
|------|--------|------|
| macOS | `ProxyCast_x.x.x_aarch64.dmg` | Apple Silicon Mac |
-| Windows | `ProxyCast_x.x.x_x64-setup.exe` | Windows 64位 |
+| Windows | `ProxyCast_x.x.x_x64-online-setup.exe` | 默认推荐，体积更小，安装时按需下载 WebView2 |
+| Windows | `ProxyCast_x.x.x_x64-offline-setup.exe` | 离线、内网或受限网络环境使用 |
## macOS 安装
@@ -40,11 +41,15 @@ navigation:
## Windows 安装
-1. 下载 `.exe` 安装程序
+1. 优先下载 `ProxyCast_x.x.x_x64-online-setup.exe`
2. 双击运行安装程序
3. 按照安装向导完成安装
4. 从开始菜单启动 ProxyCast
+::alert{type="info"}
+如果设备处于离线、内网或受限网络环境，请改用 `ProxyCast_x.x.x_x64-offline-setup.exe`。
+::
+
## 验证安装
启动 ProxyCast 后，你应该看到：
diff --git a/docs/content/05.troubleshooting/1.common-issues.md b/docs/content/05.troubleshooting/1.common-issues.md
index f7cfa805d..410c441a2 100644
--- a/docs/content/05.troubleshooting/1.common-issues.md
+++ b/docs/content/05.troubleshooting/1.common-issues.md
@@ -107,10 +107,11 @@ navigation:
### 处理建议
-1. 优先重新下载安装 `ProxyCast_*_x64-setup.exe`
+1. 优先重新下载安装 `ProxyCast_*_x64-online-setup.exe`
2. 确认 `%APPDATA%\proxycast\` 与 `%USERPROFILE%\.proxycast\` 可写
3. 如被 SmartScreen 拦截，确认来源可信后再继续
-4. 如有条件，运行一键收集脚本后再反馈
+4. 如果处于离线、内网或受限网络环境，改用 `ProxyCast_*_x64-offline-setup.exe`
+5. 如有条件，运行一键收集脚本后再反馈
详见 [Windows 启动与安装问题](/troubleshooting/windows-startup-issues)。
diff --git a/docs/content/05.troubleshooting/4.windows-startup-issues.md b/docs/content/05.troubleshooting/4.windows-startup-issues.md
index 0ac14a942..af6cbff0a 100644
--- a/docs/content/05.troubleshooting/4.windows-startup-issues.md
+++ b/docs/content/05.troubleshooting/4.windows-startup-issues.md
@@ -20,7 +20,7 @@ navigation:
推荐优先使用：
-- `ProxyCast_*_x64-setup.exe`
+- `ProxyCast_*_x64-online-setup.exe`
不建议优先分发：
@@ -29,8 +29,8 @@ navigation:
原因：
-- `setup.exe` 会一并处理 WebView2 Offline Installer
-- 在弱网、离线或新系统环境下成功率更高
+- 在线安装包体积更小，适合大多数 Windows 10/11 用户
+- 如果处于离线、内网或受限网络环境，请改用 `ProxyCast_*_x64-offline-setup.exe`
## 常见症状与处理
@@ -40,14 +40,14 @@ navigation:
1. 确认下载来源可信
2. 如果被 SmartScreen 拦截，点击“更多信息”后再确认是否继续
-3. 重新运行 `setup.exe` 覆盖安装
+3. 重新运行 Windows setup 安装包覆盖安装
4. 安装后从开始菜单再次启动
### 启动后白屏
处理建议：
-1. 优先重装 `setup.exe`，补齐 WebView2 Runtime
+1. 优先重装 Windows setup 安装包，补齐 WebView2 Runtime
2. 检查系统是否禁用了 Edge WebView2 Runtime
3. 再确认本地目录是否可写
@@ -56,7 +56,7 @@ navigation:
处理建议：
1. 不要先手动找旧版运行时
-2. 先重新运行 `setup.exe`
+2. 先重新运行 Windows setup 安装包
3. 如仍失败，再单独检查 WebView2 Runtime 是否安装完整
## 目录权限检查
diff --git a/docs/content/06.development/3.building.md b/docs/content/06.development/3.building.md
index fa4992755..4734d7e73 100644
--- a/docs/content/06.development/3.building.md
+++ b/docs/content/06.development/3.building.md
@@ -50,7 +50,7 @@ xcode-select --install
**Windows:**
- 安装 Visual Studio Build Tools
-- 安装 WebView2（开发模式必需；对外分发时建议使用带离线 WebView2 的 NSIS 安装器）
+- 安装 WebView2（开发模式必需；对外分发时默认推荐在线小包，离线或受限网络环境再提供离线大包）
**Linux:**
@@ -141,11 +141,14 @@ pnpm tauri build --target universal-apple-darwin
#### Windows 构建
```bash
-# 构建 64 位 Windows 安装包（NSIS setup.exe，内置离线 WebView2 安装器）
+# 构建 64 位 Windows 在线安装包（推荐，体积更小，安装时按需下载 WebView2）
+pnpm tauri build --target x86_64-pc-windows-msvc --config src-tauri/tauri.windows.online.conf.json
+
+# 构建 64 位 Windows 离线安装包（体积更大，内置离线 WebView2 安装器）
pnpm tauri build --target x86_64-pc-windows-msvc --config src-tauri/tauri.windows.conf.json
```
-> 建议对外分发 `-setup.exe`，不要把默认 `.msi` 作为首选下载项。
+> 建议默认对外分发在线小包；只有内网、离线或受限网络环境，再提供离线大包。
#### Linux 构建
diff --git a/docs/content/06.development/4.operations.md b/docs/content/06.development/4.operations.md
index 01df37d30..5f0e3b2df 100644
--- a/docs/content/06.development/4.operations.md
+++ b/docs/content/06.development/4.operations.md
@@ -42,8 +42,8 @@ navigation:
## Windows 启动失败排查
-- 优先确认用户安装的是 `ProxyCast_*_x64-setup.exe`，不要默认分发便携包或旧的 `.msi`
-- 首次启动若提示缺少运行时，优先重新运行 `setup.exe`，它会一并安装 WebView2 Offline Installer
+- 优先确认用户安装的是 `ProxyCast_*_x64-online-setup.exe`；离线、内网或受限网络环境再提供 `ProxyCast_*_x64-offline-setup.exe`
+- 首次启动若提示缺少运行时，优先重新运行 Windows setup 安装包；如果在线安装失败，再切换到 offline 安装包
- 检查 `%APPDATA%\proxycast\` 与 `%USERPROFILE%\.proxycast\` 是否可写；数据库、日志与部分运行时状态依赖这两个目录
- 收集 `%USERPROFILE%\.proxycast\logs\` 与 `%USERPROFILE%\.proxycast\request_logs\` 作为一线排障材料
- 若前端出现 Windows 启动自检提示，按提示项优先检查目录权限、数据库可访问性、WebView2 与 Shell 可用性
diff --git a/docs/research/nextbrowser-features-analysis.md b/docs/research/nextbrowser-features-analysis.md
index 788419984..b07a0c5c3 100644
--- a/docs/research/nextbrowser-features-analysis.md
+++ b/docs/research/nextbrowser-features-analysis.md
@@ -1608,3 +1608,474 @@ Proxycast 已经具备了 CDP 基础设施,采用**渐进式增强**策略:
- ✅ Screencast 优先,Screenshot fallback
- ✅ 单 page target 先行,多 tab 后续
- ✅ 高层 action API,原始 CDP 仅调试用
+
+---
+
+## 九、基于当前代码库的差距复盘（截至 2026-03-15）
+
+> 本节用于校正文档前文的“规划态”描述，按当前仓库真实实现判断 Proxycast 已做到什么、还缺什么，以及后续应如何按基础设施优先推进。
+
+### 9.1 当前已经具备的能力底座
+
+#### A. 实时画面与 CDP 会话底座：已具备，可继续加固
+- 已有 `BrowserRuntimeManager`、`CdpSessionState`、事件缓冲区、人工接管状态机：
+ - `src-tauri/crates/browser-runtime/src/manager.rs`
+ - `src-tauri/crates/browser-runtime/src/types.rs`
+- 已支持 `Page.startScreencast`，失败时自动回退到 `Page.captureScreenshot` 轮询：
+ - `src-tauri/crates/browser-runtime/src/manager.rs`
+- 已暴露 Tauri 命令与前端调试页：
+ - `src-tauri/src/commands/browser_runtime_cmd.rs`
+ - `src-tauri/src/commands/webview_cmd.rs`
+ - `src/features/browser-runtime/BrowserRuntimeWorkspace.tsx`
+ - `src/features/browser-runtime/BrowserRuntimeDebugPanel.tsx`
+
+#### B. 浏览器 Profile 隔离：已具备基础，但还不是产品级“个人资料”
+- 已支持按 `profile_key` 启动独立 Chrome 用户目录，天然保留 cookies / localStorage / 登录态：
+ - `src-tauri/src/commands/webview_cmd.rs`
+- 已支持列出和关闭运行中的 Profile 会话：
+ - `get_chrome_profile_sessions`
+ - `close_chrome_profile_session`
+- 现状问题：
+ - 只有“运行中的 Chrome profile 目录”概念，没有“可管理的 Profile 实体”概念
+ - 没有名称、标签、站点、最后使用时间、描述、导入/导出、锁定策略、加密策略
+ - 没有“保存当前登录为资料”的明确工作流
+
+#### C. 调度引擎：已具备通用能力，但不是浏览器任务编排
+- 已有调度器、轮询执行器、Cron/At/Every 调度计算与健康治理：
+ - `src-tauri/crates/scheduler/src/*`
+ - `src-tauri/src/app/scheduler_service.rs`
+ - `src-tauri/src/services/heartbeat_service/*`
+ - `src-tauri/src/commands/heartbeat_cmd.rs`
+- 现状问题：
+ - 当前主要服务于 Heartbeat/通用任务，不是浏览器自动化任务模板
+ - 缺少“任务绑定哪个 browser profile / 环境预设 / 输出 schema / 人工检查点”的模型
+
+#### D. 浏览器动作与输出：已具备最小可用能力
+- 已支持 `navigate / click / type / scroll / read_page / read_console_messages / read_network_requests`
+- 已有统一的 `browser_execute_action` 多后端编排：
+ - `src-tauri/src/commands/webview_cmd.rs`
+ - `src-tauri/crates/browser-runtime/src/action.rs`
+- 现状问题：
+ - 输出仍偏底层：`markdown / page_info / console / network event`
+ - 没有任务级结构化输出合同，例如 `json schema / table / csv / fields mapping`
+
+### 9.2 与截图功能的差距矩阵
+
+| 功能 | 当前状态 | 结论 |
+|------|----------|------|
+| 实时画面 | 已有 CDP 帧流、回退截图、调试页、人工接管 | 已做基础版，需稳定化和产品化 |
+| 个人资料（已保存的登录信息） | 已有独立 Chrome profile 目录和会话复用 | 部分完成，缺产品级资料管理 |
+| 计划任务 | 已有通用调度器、Heartbeat、Cron 校验 | 部分完成，缺浏览器任务模型与 UI |
+| 输入和输出 | 已有页面信息、控制台、网络事件、动作执行结果 | 部分完成，缺结构化 I/O 层 |
+| 位置定制 | 未见浏览器级代理、地理位置、时区、语言、UA、指纹预设 | 未实现 |
+| 证书 | 未见浏览器级客户端证书/站点证书选择与存储模型 | 未实现 |
+| 自动验证码求解器 | 仅支持人工接管，没有 solver 抽象与供应商接入 | 未实现 |
+| 连接 | 现有 `connection_cmd` 是终端/SSH/WSL 连接，不是外部业务连接器 | 未实现截图语义下的连接器 |
+
+### 9.3 架构判断：先不要直接堆功能页
+
+如果现在直接开始补“位置定制 / 计划任务 / 连接 / 输入和输出”这些页面，仓库会出现新的平行概念：
+- 一套运行中 session 概念
+- 一套 Chrome profile 目录概念
+- 一套 Heartbeat 任务概念
+- 一套未来的浏览器任务概念
+
+这会导致三类问题：
+- 状态源分裂：Profile、Session、Task、Connector 各自一套 id 和生命周期
+- 配置不可复用：位置定制、登录资料、任务调度之间无法组合
+- 上层功能失去稳定锚点：定时任务、验证码、人机接管都需要先有稳定的会话装配模型
+
+因此正确顺序不是“按截图逐个做页面”，而是先补一层浏览器控制面（control plane）。
+
+### 9.4 建议新增的统一域模型
+
+#### 1. Browser Profile
+表示一个“可复用的登录资料容器”，而不是当前仅存在的目录。
+
+建议字段：
+- `id`
+- `key`
+- `name`
+- `description`
+- `site_scope`
+- `storage_mode`：`persistent | ephemeral`
+- `profile_dir`
+- `last_used_at`
+- `created_at`
+- `updated_at`
+- `archived_at`
+
+#### 2. Browser Environment Preset
+承载“位置定制”能力，后续任务和 Profile 都引用它。
+
+建议字段：
+- `id`
+- `name`
+- `proxy_type`
+- `proxy_server`
+- `proxy_auth_ref`
+- `country`
+- `region`
+- `city`
+- `timezone_id`
+- `locale`
+- `accept_language`
+- `geolocation_lat`
+- `geolocation_lng`
+- `geolocation_accuracy_m`
+- `user_agent`
+- `viewport_width`
+- `viewport_height`
+- `device_scale_factor`
+- `platform`
+
+#### 3. Browser Task Template
+承载“计划任务”的可执行定义，复用现有 scheduler，而不是另起炉灶。
+
+建议字段：
+- `id`
+- `name`
+- `entry_url`
+- `profile_id`
+- `environment_preset_id`
+- `schedule_kind`
+- `schedule_payload`
+- `steps`
+- `requires_human_checkpoint`
+- `output_schema`
+- `output_destination`
+- `enabled`
+
+#### 4. Browser Connector
+承载“连接”能力，目标是把结果投递到外部系统，而不是终端连接。
+
+建议字段：
+- `id`
+- `type`：`google_sheets | gmail | webhook | drive | notion | ...`
+- `name`
+- `auth_kind`
+- `secret_ref`
+- `config_json`
+- `status`
+- `last_checked_at`
+
+#### 5. Browser Certificate Asset
+承载浏览器证书与站点绑定。
+
+建议字段：
+- `id`
+- `name`
+- `cert_kind`：`client_tls | custom_ca`
+- `file_ref`
+- `passphrase_ref`
+- `host_patterns`
+- `created_at`
+
+### 9.5 推荐实施优先级
+
+#### P0. 收口现有浏览器控制面（最高优先级）
+目标：把“运行时会话”变成后续一切能力的稳定底座。
+
+本阶段做什么：
+- 把当前 `profile_key` 升级为数据库中的 `Browser Profile` 实体
+- 给运行时 session 增加 `profile_id / environment_preset_id / task_id` 关联位
+- 把 `open_chrome_profile_window` 的启动参数抽象成 `LaunchBrowserSessionRequest`
+- 保持现有 `cdp_direct / extension_bridge / aster_compat` 编排不变，只收口输入模型
+- 给浏览器会话增加稳定审计日志：谁启动、带什么环境、来自哪个任务
+
+本阶段不做什么：
+- 不先做 CAPTCHA
+- 不先做连接器 UI
+- 不先做证书上传页
+
+原因：
+- 没有统一控制面，上层功能都会变成一次性参数拼装，后续很难维护
+
+#### P1. 个人资料产品化（高优先级）
+目标：让“保存的登录”从目录能力升级为可管理资产。
+
+本阶段做什么：
+- 新增 Profile 列表、创建、重命名、归档、删除、最近使用
+- 支持“从当前运行会话保存为资料”
+- 支持“打开资料并进入人工登录”
+- 支持资料与站点作用域绑定
+- 支持资料锁定策略和敏感信息隔离说明
+
+验收标准：
+- 用户可以明确看到哪些登录资料存在
+- 用户可以复用而不是记 `profile_key`
+- Agent 可以按 `profile_id` 复用资料
+
+#### P2. 位置定制（高优先级）
+目标：让 Profile 可以在不同地区/设备语境中稳定复用。
+
+本阶段做什么：
+- 浏览器启动参数支持 `--proxy-server`
+- CDP 注入 `Emulation.setGeolocationOverride`
+- CDP 注入 `Emulation.setTimezoneOverride`
+- CDP 注入 `Emulation.setUserAgentOverride`
+- 前端提供 Environment Preset 编辑页
+- Profile 与 Preset 解耦，可自由组合
+
+关键原则：
+- 位置定制必须是独立 Preset，不能直接塞进 Profile
+- 否则同一个登录资料无法复用到多个国家/城市场景
+
+### 9.6 当前已落地的基础层（截至 2026-03-15）
+
+#### 已完成
+- `P1 Browser Profile` 已完成第一版资产化：
+ - 已有 `browser_profiles` 表、DAO、Service、Tauri 命令、前端资料管理 UI
+ - 运行时会话仍以 `profile_key` 驱动，但新需求已经收口到 `Browser Profile` 实体
+- `P2 Browser Environment Preset` 已完成第一版基础落地：
+ - 已有 `browser_environment_presets` 表、DAO、Service、Tauri 命令、前端预设管理 UI
+ - 浏览器工作台支持“资料 + 环境预设”组合启动
+ - 启动链已支持：
+ - Chrome 启动参数 `--proxy-server`
+ - CDP 注入 `Emulation.setGeolocationOverride`
+ - CDP 注入 `Emulation.setTimezoneOverride`
+ - CDP 注入 `Emulation.setUserAgentOverride`
+ - CDP 注入 `Emulation.setLocaleOverride`
+ - CDP 注入 `Emulation.setDeviceMetricsOverride`
+ - 运行时 `session` 已增加 `environment_preset_id / environment_preset_name` 关联位
+- 浏览器运行时统一审计已接入基础层：
+ - 启动链与动作链统一写入同一浏览器运行时审计缓冲区
+ - `launch` 审计已覆盖 `profile/profile_id`、环境预设、`session_id/target_id`、URL、复用状态、窗口打开方式、流模式、浏览器来源、CDP 端口
+ - 调试面板高级区可以直接查看最近启动与动作审计
+- 浏览器启动请求已完成第一轮收口：
+ - 新增统一 `LaunchBrowserSessionRequest`
+ - `profile_id` 与 `profile_key` 启动都收口到同一 session 启动边界
+ - `BrowserProfileManager`、浏览器工作台恢复链、Chrome Relay、Agent Chat 浏览器协助都已切到统一启动请求
+
+#### 当前限制
+- 代理属于浏览器启动参数；若资料对应的 Chrome 进程已在运行，切换代理前必须先关闭该资料会话
+- Locale override 依赖目标 Chrome 版本；若方法不存在，当前实现按 best-effort 处理并保留日志告警
+- 当前 Environment Preset 只覆盖运行时真正可落地的字段：
+ - `proxy_server`
+ - `timezone_id`
+ - `locale`
+ - `accept_language`
+ - `geolocation_*`
+ - `user_agent`
+ - `platform`
+ - `viewport_*`
+ - `device_scale_factor`
+- 尚未实现：
+ - 地区标签字段的产品化筛选与统计
+ - 证书资产
+ - CAPTCHA solver
+ - 任务模板与 connector 组合编排
+
+#### 当前事实源分类
+- `current`
+ - `browser_profiles`
+ - `browser_environment_presets`
+ - `launch_browser_session + LaunchBrowserSessionRequest`
+ - `automation_job.payload.browser_session + Automation executor`
+ - `browser_profile_cmd`
+ - `browser_environment_cmd`
+ - `BrowserRuntimeAuditRecord` 统一浏览器运行时审计模型
+ - `BrowserProfileManager`
+ - `BrowserEnvironmentPresetManager`
+ - `BrowserRuntimeDebugPanel` 中的最近启动/动作审计面板
+- `compat`
+ - 旧的裸 `profile_key` / Chrome 目录启动链仍保留，但只允许委托到新控制面，不再承载新功能
+ - `launch_browser_runtime_assist`
+ - `launch_browser_profile_runtime_assist_cmd`
+ - `get_browser_action_audit_logs` 命名暂保留，但返回值已升级为统一运行时审计记录
+
+#### P3. 浏览器计划任务（中高优先级）
+目标：复用现有 scheduler/heartbeat 底座，做真正的浏览器自动化任务。
+
+当前进展（第一刀已落地）：
+- 不新增平行调度系统，先把浏览器任务收口为 `automation_jobs.payload.browser_session`
+- 调度执行时直接复用 `launch_browser_session`
+- profile / environment preset 在保存任务时就做存在性校验
+- 执行历史继续写现有 `ExecutionTracker`
+- 自动化详情页已直接嵌入现有 `BrowserRuntimeDebugPanel`，复用 `waiting_for_human / human_controlling / live` 状态机处理人工接管
+- 浏览器任务不再在启动成功后立即记为 `success`；现在会保持 `agent_runs=running`，并通过 `session_id -> automation_jobs / agent_runs` 回写 `waiting_for_human / human_controlling / agent_resuming`
+- 人工点击“恢复给 Agent”后，会在原链路内把自动化任务收口为成功并恢复下一次调度，不新增 `browser_task_runs` 一类旁路表
+- 自动化详情页、运行历史和风险任务面板开始直接消费 `agent_runs.metadata.human_reason`，等待人工/人工接管/恢复中的原因不再只藏在实时面板里
+- 自动化主列表开始直显 `当前阻塞 / 最近异常` 摘要，值守时无需进入详情页也能判断浏览器任务卡在什么环节
+- `delivery_json` 已扩成最小输出投递配置，支持 `output_format=text|json`
+- `delivery_json` 已继续扩展为最小输出契约，新增 `output_schema`
+- 当前 `output_schema` 第一版支持：
+ - `text`
+ - `json`
+ - `table`
+ - `csv`
+ - `links`
+- 第一批输出目标先落 `webhook / local_file`；`webhook` 会携带结构化 `output_data`，`local_file` 用于最小闭环落盘，`telegram` 继续只作为兼容通知通道
+- `telegram` 现在明确固定为文本提醒，不承诺结构化 output schema；结构化下游集成只允许继续收敛到 `webhook / local_file`
+- `automation_jobs` 已补最小 `last_delivery_json`，最近一次投递结果继续收敛在任务主记录里，不新增投递历史旁路表
+- 自动化详情页开始直接展示：
+ - 输出契约
+ - 最近一次投递结果
+- `best_effort=false` 的语义已收口为真实失败：
+ - 输出投递失败会把本次 job 最终状态记为 `error`
+ - 最近一次运行 metadata 会携带 `delivery` 摘要，运行历史与详情页不再各写一套投递状态
+
+本阶段做什么：
+- 第一阶段：继续基于 `automation_jobs` 承载浏览器任务模板
+- 调度执行时自动装配：`automation job -> profile -> environment preset -> browser session`
+- 支持一次性、周期性、cron
+- 支持“需要人工介入”的挂起态，与当前 `waiting_for_human / human_controlling` 状态机打通
+- 执行历史统一写入现有执行追踪体系
+
+原因：
+- 没有 P1/P2，任务就不可复现
+- 定时任务是对稳定会话装配能力的消费方，不应先于底座实现
+
+#### P4. 输入和输出 + 连接器（中优先级）
+目标：让浏览器任务结果可被下游系统稳定消费。
+
+本阶段做什么：
+- 定义 `output_schema`
+- 支持输出类型：`text / json / table / csv / links`
+- 支持输出目标：`download / local_file / webhook / connector`
+- 引入 Browser Connector 抽象
+- 第一批只做 `webhook` 和 `google_sheets`
+
+建议顺序：
+1. 先做结构化输出 schema
+2. 再做 connector 适配器
+
+当前进展（第三刀已落地）：
+- `delivery_json` 已同时承载：
+ - `output_schema`
+ - `output_format`
+- `output_schema` 负责表达语义契约，`output_format` 只负责投递编码
+- `webhook` 当前会稳定输出：
+ - `output_schema`
+ - `output_format`
+ - `output_data`
+- `local_file` 当前支持：
+ - text 模式按 schema 渲染
+ - json 模式落结构化 payload
+- `automation_jobs.last_delivery_json` 已承载最近一次投递结果，历史开关关闭时仍可直接在任务详情中观察
+- `agent_runs.metadata.delivery` 已补投递摘要，运行历史和详情页共用同一份运行态事实
+
+当前进展（第四刀已落地）：
+- 不新增 `browser_connectors` 表，也不引入独立 connector runtime
+- 第一个真正 connector 已继续收敛到现有 `delivery` 边界：
+ - `channel=google_sheets`
+ - 继续使用 `automation_jobs.delivery_json`
+ - 继续把最近一次投递结果写回 `automation_jobs.last_delivery_json`
+- `google_sheets` 当前采用最小 service account 直连模式：
+ - 目标串使用 `spreadsheet_id=...;sheet=...;credentials_file=...`
+ - 可选 `include_header=true`
+ - 可选 `value_input_option=RAW|USER_ENTERED`
+- 输出语义继续复用现有 `output_schema`：
+ - `table/csv` 直接按行追加
+ - `links` 追加为链接记录
+ - `text/json` 追加为单行摘要/JSON 记录
+- `telegram` 仍维持 `compat` 文本通知；结构化下游集成只允许继续收敛到 `webhook / local_file / google_sheets`
+
+当前进展（第五刀已落地）：
+- delivery 幂等与重试语义继续收敛在同一条事实源：
+ - `automation_service::delivery`
+ - `automation_jobs.last_delivery_json`
+ - `agent_runs.metadata.delivery`
+- 新增稳定 `delivery_attempt_id`：
+ - 有 `run_id` 时直接复用 `dlv-{run_id}`
+ - 无 history/run_id 时按 `job_id + started_at + execution_retry_count` 生成稳定哈希键
+- `webhook` 当前会输出并透传：
+ - payload 字段 `delivery_attempt_id`
+ - 请求头 `Idempotency-Key`
+ - 请求头 `X-Proxycast-Delivery-Attempt-Id`
+- `google_sheets` 当前会在每一行前置：
+ - `delivery_attempt_id`
+ - `run_id`
+ - `job_id`
+ - `execution_retry_count`
+- 网络型输出目标当前采用最小内建重试：
+ - `webhook`
+ - `google_sheets`
+ - 默认最多 3 次，保留同一个 `delivery_attempt_id`
+- `last_delivery_json` 与运行历史 metadata 当前会继续记录：
+ - `delivery_attempt_id`
+ - `run_id`
+ - `execution_retry_count`
+ - `delivery_attempts`
+
+下一刀不应继续堆通知通道，应该优先补：
+- 输出目标的能力边界说明
+- 连接器失败重试与幂等策略
+
+原因：
+- 没有统一输出 schema，连接器会各自解析页面结果，后续无法维护
+
+#### P5. 证书（中低优先级）
+目标：支持企业站点、银行类或需要 mTLS 的场景。
+
+本阶段做什么：
+- 先只支持 `client_tls` 证书资产管理
+- 支持证书与 host pattern 绑定
+- 启动浏览器时注入证书选择策略或使用平台能力完成匹配
+
+为什么不是更早：
+- 这是企业纵深能力，不是大多数浏览器任务的基础阻塞项
+
+#### P6. 自动验证码求解器（低优先级）
+目标：减少人工介入，但不破坏当前可用的人机协同链路。
+
+本阶段做什么：
+- 先定义 `CaptchaSolver` 抽象
+- 再接第三方供应商
+- 最后支持策略：自动求解失败后回退人工接管
+
+为什么最后做：
+- 当前已有人工接管 + 实时画面，可满足可用性底线
+- CAPTCHA 成本高、供应商不稳定、风控强，不应先于 Profile/Preset/Task/I-O
+
+### 9.6 建议的数据库与模块落点
+
+建议新增表：
+- `browser_profiles`
+- `browser_environment_presets`
+- `browser_profile_bindings`
+- `browser_task_templates`
+- `browser_task_runs`
+- `browser_connectors`
+- `browser_certificate_assets`
+
+建议新增模块：
+- `src-tauri/src/browser_control/`
+ - `profile_service.rs`
+ - `environment_preset_service.rs`
+ - `task_template_service.rs`
+ - `connector_service.rs`
+ - `certificate_service.rs`
+
+建议保持不动的模块：
+- `src-tauri/crates/browser-runtime/`
+ - 继续只做运行时与 CDP 交互
+- `src-tauri/src/commands/webview_cmd.rs`
+ - 继续做命令入口，但逐步改为调用新 service
+- `src-tauri/src/app/scheduler_service.rs`
+ - 继续复用，不重新发明调度器
+
+### 9.7 结论
+
+从代码现状看，Proxycast 并不是“还没有浏览器底座”，而是已经跨过了最难的第一步：
+- 已有实时画面
+- 已有 CDP 会话
+- 已有人工接管
+- 已有独立 Chrome profile
+- 已有通用调度器
+
+真正缺的是中间那层“浏览器控制面产品模型”：
+- Profile 还是目录，不是资产
+- 调度器还是通用任务，不是浏览器任务
+- 输出还是原始事件，不是结构化结果
+- 连接还是终端连接，不是业务连接器
+
+所以后续路线必须是：
+1. 先收口控制面
+2. 再做个人资料
+3. 再做位置定制
+4. 再做浏览器定时任务
+5. 再做输入和输出与连接器
+6. 最后补证书与自动验证码
+
+这条路线最符合当前仓库状态，也最符合 KISS / YAGNI / DRY：先把已有底座变成稳定平台，再让上层功能自然长出来。
diff --git a/extensions/proxycast-chrome/README.md b/extensions/proxycast-chrome/README.md
index 85e521068..279671fd1 100644
--- a/extensions/proxycast-chrome/README.md
+++ b/extensions/proxycast-chrome/README.md
@@ -6,7 +6,7 @@
- Observer 通道自动连接：`/proxycast-chrome-observer/Proxycast_Key=...`
- 页面信息上报：标题、URL、Markdown
-- 远程指令执行：`open_url` / `click` / `type` / `scroll` / `switch_tab` / `go_back` 等
+- 远程指令执行：`open_url` / `click` / `type` / `scroll` / `switch_tab` / `list_tabs` / `go_back` 等
- 弹窗配置：`serverUrl`、`bridgeKey`、`profileKey`、监控开关、手动抓取
## 安装
diff --git a/extensions/proxycast-chrome/background.js b/extensions/proxycast-chrome/background.js
index 12e37461f..cbf117cfb 100644
--- a/extensions/proxycast-chrome/background.js
+++ b/extensions/proxycast-chrome/background.js
@@ -235,6 +235,11 @@ async function executeRemoteCommand(commandData) {
return;
}
+ if (command === "list_tabs") {
+ await handleListTabs(commandData);
+ return;
+ }
+
const tabId = await resolveTargetTabId();
if (!tabId) {
sendCommandResult({
@@ -389,6 +394,41 @@ async function handleSwitchTab(commandData, waitForPageInfo) {
}
}
+async function handleListTabs(commandData) {
+ const requestId = commandData.requestId;
+ const sourceClientId = commandData.sourceClientId;
+
+ try {
+ const tabs = await chrome.tabs.query({ currentWindow: true });
+ const normalizedTabs = tabs
+ .filter((tab) => Number.isInteger(tab.id) && Number.isInteger(tab.index))
+ .map((tab) => ({
+ id: tab.id,
+ index: tab.index,
+ active: tab.active === true,
+ title: tab.title || "",
+ url: tab.url || "",
+ }));
+
+ sendCommandResult({
+ requestId,
+ sourceClientId,
+ status: "success",
+ message: `已读取 ${normalizedTabs.length} 个标签页`,
+ data: {
+ tabs: normalizedTabs,
+ },
+ });
+ } catch (error) {
+ sendCommandResult({
+ requestId,
+ sourceClientId,
+ status: "error",
+ error: error?.message || String(error),
+ });
+ }
+}
+
function sendCommandResult(data) {
sendObserverMessage({
type: "command_result",
diff --git a/package.json b/package.json
index 064ce98fa..12b0b469b 100644
--- a/package.json
+++ b/package.json
@@ -1,7 +1,7 @@
{
"name": "proxycast",
"private": true,
- "version": "0.87.0",
+ "version": "0.88.0",
"type": "module",
"engines": {
"node": ">=22.0.0"
diff --git a/scripts/report-legacy-surfaces.mjs b/scripts/report-legacy-surfaces.mjs
index 26448cd71..e70a7a909 100644
--- a/scripts/report-legacy-surfaces.mjs
+++ b/scripts/report-legacy-surfaces.mjs
@@ -70,6 +70,27 @@ const importSurfaceMonitors = [
targets: ["src/lib/api/agentCompat.ts"],
allowedPaths: [],
},
+ {
+ id: "heartbeat-api-gateway",
+ classification: "deprecated",
+ description: "旧 heartbeat 前端 API 入口",
+ targets: ["src/lib/api/heartbeat.ts"],
+ allowedPaths: [],
+ },
+ {
+ id: "heartbeat-settings-page-entry",
+ classification: "deprecated",
+ description: "旧 heartbeat 设置页入口",
+ targets: ["src/components/settings-v2/system/heartbeat/index.tsx"],
+ allowedPaths: [],
+ },
+ {
+ id: "assistant-settings-page-entry",
+ classification: "deprecated",
+ description: "旧助理服务设置页入口",
+ targets: ["src/components/settings-v2/agent/assistant/index.tsx"],
+ allowedPaths: [],
+ },
];
const commandSurfaceMonitors = [
@@ -117,6 +138,50 @@ const commandSurfaceMonitors = [
],
allowedPaths: [],
},
+ {
+ id: "heartbeat-legacy-commands",
+ classification: "deprecated",
+ description: "旧 heartbeat 命令前端边界",
+ commands: [
+ "get_heartbeat_config",
+ "update_heartbeat_config",
+ "get_heartbeat_status",
+ "get_heartbeat_tasks",
+ "add_heartbeat_task",
+ "delete_heartbeat_task",
+ "update_heartbeat_task",
+ "get_heartbeat_history",
+ "get_heartbeat_execution_detail",
+ "get_heartbeat_task_health",
+ "deliver_heartbeat_task_health_alerts",
+ "trigger_heartbeat_now",
+ "get_task_templates",
+ "apply_task_template",
+ "generate_content_creator_tasks",
+ "preview_heartbeat_schedule",
+ "validate_heartbeat_schedule",
+ ],
+ allowedPaths: [],
+ },
+];
+
+const frontendTextSurfaceMonitors = [
+ {
+ id: "frontend-assistant-settings-surfaces",
+ classification: "deprecated",
+ description: "前端助理服务设置页与配置面回流",
+ patterns: [
+ "SettingsTabs.Assistant",
+ "settings.tab.assistant",
+ "AssistantSettings",
+ "AssistantConfig",
+ "default_assistant_id",
+ "custom_assistants",
+ "show_suggestions",
+ "auto_select",
+ ],
+ allowedPaths: [],
+ },
];
const rustTextSurfaceMonitors = [
@@ -237,6 +302,38 @@ const rustTextSurfaceMonitors = [
],
allowedPaths: [],
},
+ {
+ id: "rust-heartbeat-business-surfaces",
+ classification: "deprecated",
+ description: "Rust 业务层 heartbeat 旧实现回流",
+ patterns: [
+ "crate::services::heartbeat_service::",
+ "services::heartbeat_service::",
+ "HeartbeatServiceState",
+ "heartbeat_service_adapter",
+ "proxycast_core::database::dao::heartbeat",
+ "heartbeat_tool",
+ "RunSource::Heartbeat",
+ "source = 'heartbeat'",
+ "source: \"heartbeat\".to_string()",
+ ],
+ allowedPaths: [],
+ },
+ {
+ id: "rust-assistant-config-surfaces",
+ classification: "deprecated",
+ description: "Rust 助理服务配置面回流",
+ patterns: [
+ "AssistantConfig",
+ "AssistantProfile",
+ "default_assistant_id",
+ "custom_assistants",
+ "show_suggestions",
+ "auto_select",
+ ],
+ includePathPrefixes: ["src-tauri/crates/core/src/config", "src-tauri/src/config"],
+ allowedPaths: [],
+ },
{
id: "rust-migration-setting-key-leak",
classification: "deprecated",
@@ -935,6 +1032,8 @@ function printTextCountReport(result) {
}
const { runtimeSources, testSources } = collectSources();
+const { runtimeSources: frontendRuntimeTextSources, testSources: frontendTestTextSources } =
+ collectTextSources(sourceRoots, sourceExtensions);
const { runtimeSources: rustRuntimeSources, testSources: rustTestSources } =
collectTextSources(rustSourceRoots, rustSourceExtensions);
const importResults = importSurfaceMonitors.map((monitor) =>
@@ -943,6 +1042,9 @@ const importResults = importSurfaceMonitors.map((monitor) =>
const commandResults = commandSurfaceMonitors.map((monitor) =>
evaluateCommandMonitor(monitor, runtimeSources, testSources),
);
+const frontendTextResults = frontendTextSurfaceMonitors.map((monitor) =>
+ evaluateTextMonitor(monitor, frontendRuntimeTextSources, frontendTestTextSources),
+);
const rustTextResults = rustTextSurfaceMonitors.map((monitor) =>
evaluateTextMonitor(monitor, rustRuntimeSources, rustTestSources),
);
@@ -963,6 +1065,9 @@ const violations = [
...commandResults.flatMap((result) =>
result.violations.map((item) => `${result.id} -> ${item}`),
),
+ ...frontendTextResults.flatMap((result) =>
+ result.violations.map((item) => `${result.id} -> ${item}`),
+ ),
...rustTextResults.flatMap((result) =>
result.violations.map((item) => `${result.id} -> ${item}`),
),
@@ -984,6 +1089,12 @@ for (const result of commandResults) {
printCommandReport(result);
}
+console.log("");
+console.log("## 前端护栏");
+for (const result of frontendTextResults) {
+ printTextReport(result);
+}
+
console.log("");
console.log("## Rust 护栏");
for (const result of rustTextResults) {
diff --git a/src-tauri/Cargo.lock b/src-tauri/Cargo.lock
index fba0905cf..967c5a2d1 100644
--- a/src-tauri/Cargo.lock
+++ b/src-tauri/Cargo.lock
@@ -6982,7 +6982,7 @@ dependencies = [
[[package]]
name = "proxycast"
-version = "0.87.0"
+version = "0.88.0"
dependencies = [
"anyhow",
"arboard",
@@ -7008,13 +7008,13 @@ dependencies = [
"hex",
"if-addrs",
"indexmap 2.13.0",
+ "jsonwebtoken",
"md5",
"mouse_position",
"notify 6.1.1",
"objc",
"once_cell",
"open",
- "openssl",
"parking_lot",
"portable-pty",
"proptest",
@@ -7085,7 +7085,7 @@ dependencies = [
[[package]]
name = "proxycast-agent"
-version = "0.87.0"
+version = "0.88.0"
dependencies = [
"aster-core",
"async-trait",
@@ -7110,7 +7110,7 @@ dependencies = [
[[package]]
name = "proxycast-browser-runtime"
-version = "0.87.0"
+version = "0.88.0"
dependencies = [
"chrono",
"futures",
@@ -7127,7 +7127,7 @@ dependencies = [
[[package]]
name = "proxycast-config"
-version = "0.87.0"
+version = "0.88.0"
dependencies = [
"async-trait",
"parking_lot",
@@ -7143,7 +7143,7 @@ dependencies = [
[[package]]
name = "proxycast-core"
-version = "0.87.0"
+version = "0.88.0"
dependencies = [
"aster-models",
"async-trait",
@@ -7183,7 +7183,7 @@ dependencies = [
[[package]]
name = "proxycast-credential"
-version = "0.87.0"
+version = "0.88.0"
dependencies = [
"axum 0.7.9",
"base64 0.22.1",
@@ -7218,7 +7218,7 @@ dependencies = [
[[package]]
name = "proxycast-gateway"
-version = "0.87.0"
+version = "0.88.0"
dependencies = [
"axum 0.7.9",
"chrono",
@@ -7239,7 +7239,7 @@ dependencies = [
[[package]]
name = "proxycast-infra"
-version = "0.87.0"
+version = "0.88.0"
dependencies = [
"chrono",
"dashmap 5.5.3",
@@ -7259,7 +7259,7 @@ dependencies = [
[[package]]
name = "proxycast-mcp"
-version = "0.87.0"
+version = "0.88.0"
dependencies = [
"async-trait",
"dirs 5.0.1",
@@ -7291,7 +7291,7 @@ dependencies = [
[[package]]
name = "proxycast-processor"
-version = "0.87.0"
+version = "0.88.0"
dependencies = [
"async-trait",
"parking_lot",
@@ -7310,7 +7310,7 @@ dependencies = [
[[package]]
name = "proxycast-providers"
-version = "0.87.0"
+version = "0.88.0"
dependencies = [
"anyhow",
"async-stream",
@@ -7364,7 +7364,7 @@ dependencies = [
[[package]]
name = "proxycast-server"
-version = "0.87.0"
+version = "0.88.0"
dependencies = [
"aster-core",
"async-stream",
@@ -7409,7 +7409,7 @@ dependencies = [
[[package]]
name = "proxycast-server-utils"
-version = "0.87.0"
+version = "0.88.0"
dependencies = [
"axum 0.7.9",
"futures",
@@ -7424,7 +7424,7 @@ dependencies = [
[[package]]
name = "proxycast-services"
-version = "0.87.0"
+version = "0.88.0"
dependencies = [
"anyhow",
"aster-core",
@@ -7466,7 +7466,7 @@ dependencies = [
[[package]]
name = "proxycast-skills"
-version = "0.87.0"
+version = "0.88.0"
dependencies = [
"async-trait",
"dirs 5.0.1",
@@ -7484,7 +7484,7 @@ dependencies = [
[[package]]
name = "proxycast-terminal"
-version = "0.87.0"
+version = "0.88.0"
dependencies = [
"async-trait",
"base64 0.22.1",
@@ -7511,7 +7511,7 @@ dependencies = [
[[package]]
name = "proxycast-websocket"
-version = "0.87.0"
+version = "0.88.0"
dependencies = [
"axum 0.7.9",
"chrono",
diff --git a/src-tauri/Cargo.toml b/src-tauri/Cargo.toml
index 8f22e6c33..c91cdbd3f 100644
--- a/src-tauri/Cargo.toml
+++ b/src-tauri/Cargo.toml
@@ -3,7 +3,7 @@ members = ["crates/*"]
resolver = "2"
[workspace.package]
-version = "0.87.0"
+version = "0.88.0"
edition = "2021"
authors = ["coso"]
repository = "https://github.com/aiclientproxy/proxycast"
@@ -78,6 +78,7 @@ cron = "0.15"
dirs = "5"
regex = "1"
md5 = "0.7"
+jsonwebtoken = "9.3.1"
urlencoding = "2"
subtle = "2.5"
flate2 = "1"
@@ -113,8 +114,7 @@ rustls-pemfile = "2"
portable-pty = "0.8"
# SSH
-ssh2 = "0.9"
-openssl = { version = "0.10", features = ["vendored"] }
+ssh2 = { version = "0.9", features = ["vendored-openssl"] }
# 系统交互
mouse_position = "0.1.4"
@@ -191,7 +191,7 @@ version = "2.4"
[package]
name = "proxycast"
-version = "0.87.0"
+version = "0.88.0"
description = "AI API Proxy Desktop App"
authors = ["you"]
edition = "2021"
@@ -283,6 +283,7 @@ cron.workspace = true
dirs.workspace = true
regex.workspace = true
md5.workspace = true
+jsonwebtoken.workspace = true
urlencoding.workspace = true
subtle.workspace = true
flate2.workspace = true
@@ -314,7 +315,6 @@ portable-pty.workspace = true
# SSH
ssh2.workspace = true
-openssl.workspace = true
# 系统交互
mouse_position.workspace = true
diff --git a/src-tauri/crates/agent/src/tools/heartbeat_tool.rs b/src-tauri/crates/agent/src/tools/heartbeat_tool.rs
deleted file mode 100644
index a97f84649..000000000
--- a/src-tauri/crates/agent/src/tools/heartbeat_tool.rs
+++ /dev/null
@@ -1,763 +0,0 @@
-//! Heartbeat Tool
-//!
-//! 为 Aster Agent 提供心跳任务管理能力，允许 AI 通过工具调用管理心跳系统。
-
-use aster::tools::{Tool, ToolContext, ToolError, ToolResult};
-use async_trait::async_trait;
-use serde::{Deserialize, Serialize};
-use serde_json::{json, Value};
-use std::path::PathBuf;
-use std::sync::Arc;
-use thiserror::Error;
-
-/// Heartbeat 工具错误类型
-#[derive(Debug, Error)]
-pub enum HeartbeatToolError {
- #[error("服务未初始化")]
- ServiceNotInitialized,
-
- #[error("参数错误: {0}")]
- InvalidParams(String),
-
- #[error("执行失败: {0}")]
- ExecutionFailed(String),
-
- #[error("IO 错误: {0}")]
- IoError(String),
-}
-
-/// 心跳任务预览
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct HeartbeatTaskPreview {
- pub description: String,
- pub priority: Option,
- pub timeout_secs: Option,
- pub once: bool,
- pub model: Option,
-}
-
-/// 心跳执行记录
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct HeartbeatExecutionRecord {
- pub id: i64,
- pub task_description: String,
- pub status: String,
- pub started_at: String,
- pub completed_at: Option,
- pub duration_ms: Option,
- pub output: Option,
- pub retry_count: u32,
-}
-
-/// 心跳状态
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct HeartbeatStatus {
- pub running: bool,
- pub last_run: Option,
- pub next_run: Option,
- pub last_task_count: usize,
- pub total_executions: u64,
- pub schedule_description: Option,
-}
-
-/// 心跳周期结果
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct HeartbeatCycleResult {
- pub task_count: usize,
- pub success_count: usize,
- pub failed_count: usize,
- pub timeout_count: usize,
-}
-
-/// Heartbeat 服务抽象 trait
-///
-/// 这样可以在测试时 mock，也可以避免直接依赖 Tauri 类型
-#[async_trait]
-pub trait HeartbeatService: Send + Sync {
- /// 获取心跳状态
- fn get_status(&self) -> Result;
-
- /// 获取应用数据目录
- fn get_app_data_dir(&self) -> Result;
-
- /// 预览任务列表
- fn preview_tasks(&self) -> Result, HeartbeatToolError>;
-
- /// 添加任务
- fn add_task(
- &self,
- description: String,
- priority: Option,
- timeout_secs: Option,
- once: Option,
- model: Option,
- ) -> Result<(), HeartbeatToolError>;
-
- /// 删除任务
- fn delete_task(&self, index: usize) -> Result<(), HeartbeatToolError>;
-
- /// 更新任务
- fn update_task(
- &self,
- index: usize,
- description: String,
- priority: Option,
- timeout_secs: Option,
- once: Option,
- model: Option,
- ) -> Result<(), HeartbeatToolError>;
-
- /// 获取执行历史
- fn get_history(
- &self,
- limit: usize,
- ) -> Result, HeartbeatToolError>;
-
- /// 获取执行详情
- fn get_execution_detail(
- &self,
- id: i64,
- ) -> Result, HeartbeatToolError>;
-
- /// 手动触发执行
- async fn trigger_now(&self) -> Result;
-}
-
-/// Heartbeat Tool 实现
-pub struct HeartbeatTool {
- service: Arc,
-}
-
-impl HeartbeatTool {
- /// 创建新的 HeartbeatTool
- pub fn new(service: Arc) -> Self {
- Self { service }
- }
-
- /// 格式化任务列表为可读文本
- fn format_tasks(tasks: &[HeartbeatTaskPreview]) -> String {
- if tasks.is_empty() {
- return "当前没有心跳任务".to_string();
- }
-
- let mut lines = vec!["心跳任务列表:".to_string()];
- for (i, task) in tasks.iter().enumerate() {
- lines.push(format!(" [{}] {}", i, task.description));
- if let Some(priority) = task.priority {
- lines.push(format!(" 优先级: {}", priority));
- }
- if let Some(timeout) = task.timeout_secs {
- lines.push(format!(" 超时: {}秒", timeout));
- }
- if task.once {
- lines.push(" 类型: 一次性任务".to_string());
- }
- if let Some(ref model) = task.model {
- lines.push(format!(" 模型: {}", model));
- }
- }
- lines.join("\n")
- }
-
- /// 格式化执行历史为可读文本
- fn format_history(records: &[HeartbeatExecutionRecord]) -> String {
- if records.is_empty() {
- return "暂无执行历史".to_string();
- }
-
- let mut lines = vec![
- format!("执行历史 (共 {} 条):", records.len()),
- String::new(),
- ];
-
- for record in records {
- lines.push(format!("[{}] {}", record.id, record.task_description));
- lines.push(format!(" 状态: {}", record.status));
- lines.push(format!(" 开始: {}", record.started_at));
-
- if let Some(ref completed) = record.completed_at {
- lines.push(format!(" 完成: {}", completed));
- }
-
- if let Some(duration) = record.duration_ms {
- lines.push(format!(" 耗时: {}ms", duration));
- }
-
- if let Some(ref output) = record.output {
- let output_preview = if output.len() > 100 {
- format!("{}...", &output[..100])
- } else {
- output.clone()
- };
- lines.push(format!(" 输出: {}", output_preview));
- }
-
- if record.retry_count > 0 {
- lines.push(format!(" 重试: {} 次", record.retry_count));
- }
-
- lines.push(String::new());
- }
-
- lines.join("\n")
- }
-
- /// 格式化心跳状态为可读文本
- fn format_status(status: &HeartbeatStatus) -> String {
- let mut lines = vec!["心跳引擎状态:".to_string()];
-
- lines.push(format!(
- " 运行中: {}",
- if status.running { "是" } else { "否" }
- ));
-
- if let Some(ref last_run) = status.last_run {
- lines.push(format!(" 上次运行: {}", last_run));
- }
-
- if let Some(ref next_run) = status.next_run {
- lines.push(format!(" 下次运行: {}", next_run));
- }
-
- if let Some(ref desc) = status.schedule_description {
- lines.push(format!(" 调度: {}", desc));
- }
-
- lines.push(format!(" 总执行次数: {}", status.total_executions));
- lines.push(format!(" 上次任务数: {}", status.last_task_count));
-
- lines.join("\n")
- }
-
- /// 格式化周期结果为可读文本
- fn format_cycle_result(result: &HeartbeatCycleResult) -> String {
- format!(
- "心跳周期完成: 共 {} 个任务, 成功 {}, 失败 {}, 超时 {}",
- result.task_count, result.success_count, result.failed_count, result.timeout_count
- )
- }
-}
-
-#[async_trait]
-impl Tool for HeartbeatTool {
- fn name(&self) -> &str {
- "heartbeat"
- }
-
- fn description(&self) -> &str {
- "管理心跳任务系统。支持查看/添加/更新/删除任务、查看执行历史、手动触发执行等操作。"
- }
-
- fn input_schema(&self) -> Value {
- json!({
- "type": "object",
- "description": "心跳任务管理工具",
- "properties": {
- "action": {
- "type": "string",
- "description": "要执行的操作",
- "enum": [
- "list_tasks",
- "add_task",
- "update_task",
- "delete_task",
- "get_history",
- "get_detail",
- "get_status",
- "trigger"
- ],
- "default": "list_tasks"
- },
- "index": {
- "type": "number",
- "description": "任务索引 (用于 update_task, delete_task)"
- },
- "description": {
- "type": "string",
- "description": "任务描述 (用于 add_task, update_task)"
- },
- "priority": {
- "type": "number",
- "description": "任务优先级 1-10 (可选，用于 add_task, update_task)"
- },
- "timeout_secs": {
- "type": "number",
- "description": "超时时间秒数 (可选，用于 add_task, update_task)"
- },
- "once": {
- "type": "boolean",
- "description": "是否为一次性任务 (可选，用于 add_task, update_task)"
- },
- "model": {
- "type": "string",
- "description": "指定模型 (可选，用于 add_task, update_task)"
- },
- "execution_id": {
- "type": "number",
- "description": "执行记录 ID (用于 get_detail)"
- },
- "limit": {
- "type": "number",
- "description": "历史记录数量限制 (可选，用于 get_history，默认 50)"
- }
- },
- "required": ["action"]
- })
- }
-
- async fn execute(
- &self,
- params: Value,
- _context: &ToolContext,
- ) -> Result {
- let action = params
- .get("action")
- .and_then(|v| v.as_str())
- .unwrap_or("list_tasks");
-
- match action {
- "list_tasks" => {
- let tasks = self
- .service
- .preview_tasks()
- .map_err(|e| ToolError::execution_failed(format!("获取任务列表失败: {}", e)))?;
-
- let output = Self::format_tasks(&tasks);
-
- Ok(ToolResult::success(output)
- .with_metadata("task_count", json!(tasks.len()))
- .with_metadata(
- "tasks",
- json!(tasks.iter().map(|t| &t.description).collect::>()),
- ))
- }
-
- "add_task" => {
- let description = params
- .get("description")
- .and_then(|v| v.as_str())
- .ok_or_else(|| ToolError::invalid_params("缺少 description 参数"))?;
-
- let priority = params
- .get("priority")
- .and_then(|v| v.as_u64())
- .map(|v| v as u8);
- let timeout_secs = params.get("timeout_secs").and_then(|v| v.as_u64());
- let once = params.get("once").and_then(|v| v.as_bool());
- let model = params
- .get("model")
- .and_then(|v| v.as_str())
- .map(|s| s.to_string());
-
- self.service
- .add_task(description.to_string(), priority, timeout_secs, once, model)
- .map_err(|e| ToolError::execution_failed(format!("添加任务失败: {}", e)))?;
-
- Ok(ToolResult::success(format!("已添加任务: {}", description)))
- }
-
- "update_task" => {
- let index = params
- .get("index")
- .and_then(|v| v.as_u64())
- .ok_or_else(|| ToolError::invalid_params("缺少 index 参数"))?
- as usize;
-
- let description = params
- .get("description")
- .and_then(|v| v.as_str())
- .ok_or_else(|| ToolError::invalid_params("缺少 description 参数"))?;
-
- let priority = params
- .get("priority")
- .and_then(|v| v.as_u64())
- .map(|v| v as u8);
- let timeout_secs = params.get("timeout_secs").and_then(|v| v.as_u64());
- let once = params.get("once").and_then(|v| v.as_bool());
- let model = params
- .get("model")
- .and_then(|v| v.as_str())
- .map(|s| s.to_string());
-
- self.service
- .update_task(
- index,
- description.to_string(),
- priority,
- timeout_secs,
- once,
- model,
- )
- .map_err(|e| ToolError::execution_failed(format!("更新任务失败: {}", e)))?;
-
- Ok(ToolResult::success(format!(
- "已更新任务 [{}]: {}",
- index, description
- )))
- }
-
- "delete_task" => {
- let index = params
- .get("index")
- .and_then(|v| v.as_u64())
- .ok_or_else(|| ToolError::invalid_params("缺少 index 参数"))?
- as usize;
-
- // 先获取要删除的任务描述用于确认
- let tasks = self
- .service
- .preview_tasks()
- .map_err(|e| ToolError::execution_failed(format!("获取任务列表失败: {}", e)))?;
-
- let deleted_desc = tasks
- .get(index)
- .map(|t| t.description.clone())
- .unwrap_or_else(|| "未知任务".to_string());
-
- self.service
- .delete_task(index)
- .map_err(|e| ToolError::execution_failed(format!("删除任务失败: {}", e)))?;
-
- Ok(ToolResult::success(format!(
- "已删除任务 [{}]: {}",
- index, deleted_desc
- )))
- }
-
- "get_history" => {
- let limit = params.get("limit").and_then(|v| v.as_u64()).unwrap_or(50) as usize;
-
- let records = self
- .service
- .get_history(limit)
- .map_err(|e| ToolError::execution_failed(format!("获取历史失败: {}", e)))?;
-
- let output = Self::format_history(&records);
-
- Ok(ToolResult::success(output).with_metadata("record_count", json!(records.len())))
- }
-
- "get_detail" => {
- let execution_id = params
- .get("execution_id")
- .and_then(|v| v.as_i64())
- .ok_or_else(|| ToolError::invalid_params("缺少 execution_id 参数"))?;
-
- let record = self
- .service
- .get_execution_detail(execution_id)
- .map_err(|e| ToolError::execution_failed(format!("获取详情失败: {}", e)))?;
-
- match record {
- Some(record) => {
- let output = format!(
- "执行记录详情:\n\
- \n ID: {}\n 任务: {}\n 状态: {}\n 开始: {}\n 完成: {}\n 耗时: {}ms\n \
- 重试: {}\n 输出: {}",
- record.id,
- record.task_description,
- record.status,
- record.started_at,
- record.completed_at.as_deref().unwrap_or("未完成"),
- record.duration_ms.unwrap_or(0),
- record.retry_count,
- record.output.as_deref().unwrap_or("无")
- );
- Ok(ToolResult::success(output))
- }
- None => Ok(ToolResult::success(format!(
- "未找到执行记录 ID: {}",
- execution_id
- ))),
- }
- }
-
- "get_status" => {
- let status = self
- .service
- .get_status()
- .map_err(|e| ToolError::execution_failed(format!("获取状态失败: {}", e)))?;
-
- let output = Self::format_status(&status);
-
- Ok(ToolResult::success(output))
- }
-
- "trigger" => {
- let result = self
- .service
- .trigger_now()
- .await
- .map_err(|e| ToolError::execution_failed(format!("触发执行失败: {}", e)))?;
-
- let output = Self::format_cycle_result(&result);
-
- Ok(ToolResult::success(output)
- .with_metadata("task_count", json!(result.task_count))
- .with_metadata("success_count", json!(result.success_count))
- .with_metadata("failed_count", json!(result.failed_count)))
- }
-
- _ => Ok(ToolResult::error(format!("未知操作: {}", action))),
- }
- }
-}
-
-#[cfg(test)]
-mod tests {
- use super::*;
-
- // Mock service for testing
- struct MockHeartbeatService;
-
- #[async_trait]
- impl HeartbeatService for MockHeartbeatService {
- fn get_status(&self) -> Result {
- Ok(HeartbeatStatus {
- running: true,
- last_run: Some("2024-01-01T12:00:00Z".to_string()),
- next_run: Some("2024-01-01T13:00:00Z".to_string()),
- last_task_count: 5,
- total_executions: 100,
- schedule_description: Some("每 300 秒".to_string()),
- })
- }
-
- fn get_app_data_dir(&self) -> Result {
- Ok(PathBuf::from("/tmp"))
- }
-
- fn preview_tasks(&self) -> Result, HeartbeatToolError> {
- Ok(vec![
- HeartbeatTaskPreview {
- description: "检查系统状态".to_string(),
- priority: Some(8),
- timeout_secs: Some(60),
- once: false,
- model: None,
- },
- HeartbeatTaskPreview {
- description: "备份数据".to_string(),
- priority: Some(5),
- timeout_secs: Some(300),
- once: false,
- model: Some("claude-3-haiku".to_string()),
- },
- ])
- }
-
- fn add_task(
- &self,
- _description: String,
- _priority: Option,
- _timeout_secs: Option,
- _once: Option,
- _model: Option,
- ) -> Result<(), HeartbeatToolError> {
- Ok(())
- }
-
- fn delete_task(&self, _index: usize) -> Result<(), HeartbeatToolError> {
- Ok(())
- }
-
- fn update_task(
- &self,
- _index: usize,
- _description: String,
- _priority: Option,
- _timeout_secs: Option,
- _once: Option,
- _model: Option,
- ) -> Result<(), HeartbeatToolError> {
- Ok(())
- }
-
- fn get_history(
- &self,
- _limit: usize,
- ) -> Result, HeartbeatToolError> {
- Ok(vec![HeartbeatExecutionRecord {
- id: 1,
- task_description: "检查系统状态".to_string(),
- status: "success".to_string(),
- started_at: "2024-01-01T12:00:00Z".to_string(),
- completed_at: Some("2024-01-01T12:00:05Z".to_string()),
- duration_ms: Some(5000),
- output: Some("系统正常".to_string()),
- retry_count: 0,
- }])
- }
-
- fn get_execution_detail(
- &self,
- _id: i64,
- ) -> Result, HeartbeatToolError> {
- Ok(Some(HeartbeatExecutionRecord {
- id: 1,
- task_description: "检查系统状态".to_string(),
- status: "success".to_string(),
- started_at: "2024-01-01T12:00:00Z".to_string(),
- completed_at: Some("2024-01-01T12:00:05Z".to_string()),
- duration_ms: Some(5000),
- output: Some("系统正常".to_string()),
- retry_count: 0,
- }))
- }
-
- async fn trigger_now(&self) -> Result {
- Ok(HeartbeatCycleResult {
- task_count: 2,
- success_count: 2,
- failed_count: 0,
- timeout_count: 0,
- })
- }
- }
-
- #[test]
- fn test_tool_name() {
- let tool = HeartbeatTool::new(Arc::new(MockHeartbeatService));
- assert_eq!(tool.name(), "heartbeat");
- }
-
- #[test]
- fn test_tool_description() {
- let tool = HeartbeatTool::new(Arc::new(MockHeartbeatService));
- assert!(!tool.description().is_empty());
- }
-
- #[test]
- fn test_input_schema() {
- let tool = HeartbeatTool::new(Arc::new(MockHeartbeatService));
- let schema = tool.input_schema();
- assert!(schema.is_object());
- assert!(schema["properties"].is_object());
- assert!(schema["properties"]["action"].is_object());
- }
-
- #[test]
- fn test_format_tasks() {
- let tasks = vec![
- HeartbeatTaskPreview {
- description: "任务1".to_string(),
- priority: Some(5),
- timeout_secs: Some(60),
- once: false,
- model: None,
- },
- HeartbeatTaskPreview {
- description: "一次性任务".to_string(),
- priority: None,
- timeout_secs: None,
- once: true,
- model: Some("claude-3-haiku".to_string()),
- },
- ];
-
- let output = HeartbeatTool::format_tasks(&tasks);
- assert!(output.contains("任务1"));
- assert!(output.contains("一次性任务"));
- assert!(output.contains("优先级: 5"));
- assert!(output.contains("一次性任务"));
- }
-
- #[test]
- fn test_format_empty_tasks() {
- let tasks: Vec = vec![];
- let output = HeartbeatTool::format_tasks(&tasks);
- assert_eq!(output, "当前没有心跳任务");
- }
-
- #[test]
- fn test_format_status() {
- let status = HeartbeatStatus {
- running: true,
- last_run: Some("2024-01-01T12:00:00Z".to_string()),
- next_run: Some("2024-01-01T13:00:00Z".to_string()),
- last_task_count: 5,
- total_executions: 100,
- schedule_description: Some("每 300 秒".to_string()),
- };
-
- let output = HeartbeatTool::format_status(&status);
- assert!(output.contains("运行中: 是"));
- assert!(output.contains("总执行次数: 100"));
- assert!(output.contains("上次任务数: 5"));
- }
-
- #[test]
- fn test_format_history() {
- let records = vec![HeartbeatExecutionRecord {
- id: 1,
- task_description: "测试任务".to_string(),
- status: "success".to_string(),
- started_at: "2024-01-01T12:00:00Z".to_string(),
- completed_at: Some("2024-01-01T12:00:05Z".to_string()),
- duration_ms: Some(5000),
- output: Some("测试输出".to_string()),
- retry_count: 0,
- }];
-
- let output = HeartbeatTool::format_history(&records);
- assert!(output.contains("测试任务"));
- assert!(output.contains("success"));
- assert!(output.contains("测试输出"));
- }
-
- #[tokio::test]
- async fn test_execute_list_tasks() {
- let tool = HeartbeatTool::new(Arc::new(MockHeartbeatService));
- let params = json!({ "action": "list_tasks" });
- let result = tool.execute(params, &ToolContext::default()).await.unwrap();
- assert!(result.is_success());
- let content = result.content();
- assert!(content.contains("检查系统状态"));
- assert!(content.contains("备份数据"));
- }
-
- #[tokio::test]
- async fn test_execute_get_status() {
- let tool = HeartbeatTool::new(Arc::new(MockHeartbeatService));
- let params = json!({ "action": "get_status" });
- let result = tool.execute(params, &ToolContext::default()).await.unwrap();
- assert!(result.is_success());
- let content = result.content();
- assert!(content.contains("运行中: 是"));
- }
-
- #[tokio::test]
- async fn test_execute_trigger() {
- let tool = HeartbeatTool::new(Arc::new(MockHeartbeatService));
- let params = json!({ "action": "trigger" });
- let result = tool.execute(params, &ToolContext::default()).await.unwrap();
- assert!(result.is_success());
- let content = result.content();
- assert!(content.contains("共 2 个任务"));
- assert!(content.contains("成功 2"));
- }
-
- #[tokio::test]
- async fn test_execute_add_task() {
- let tool = HeartbeatTool::new(Arc::new(MockHeartbeatService));
- let params = json!({
- "action": "add_task",
- "description": "新任务",
- "priority": 7
- });
- let result = tool.execute(params, &ToolContext::default()).await.unwrap();
- assert!(result.is_success());
- let content = result.content();
- assert!(content.contains("已添加任务"));
- }
-
- #[tokio::test]
- async fn test_execute_invalid_action() {
- let tool = HeartbeatTool::new(Arc::new(MockHeartbeatService));
- let params = json!({ "action": "invalid_action" });
- let result = tool.execute(params, &ToolContext::default()).await.unwrap();
- assert!(result.is_error());
- let content = result.content();
- assert!(content.contains("未知操作"));
- }
-}
diff --git a/src-tauri/crates/agent/src/tools/mod.rs b/src-tauri/crates/agent/src/tools/mod.rs
index 9b3e81394..878c884e1 100644
--- a/src-tauri/crates/agent/src/tools/mod.rs
+++ b/src-tauri/crates/agent/src/tools/mod.rs
@@ -3,14 +3,9 @@
//! 提供各种工具的包装器和辅助函数
pub mod browser_tool;
-pub mod heartbeat_tool;
pub mod skill_tool_gate;
pub use browser_tool::{BrowserAction, BrowserTool, BrowserToolError, BrowserToolResult};
-pub use heartbeat_tool::{
- HeartbeatCycleResult, HeartbeatExecutionRecord, HeartbeatService, HeartbeatStatus,
- HeartbeatTaskPreview, HeartbeatTool, HeartbeatToolError,
-};
pub use skill_tool_gate::{
clear_skill_tool_session_access, set_skill_tool_session_access, ProxycastSkillTool,
};
diff --git a/src-tauri/crates/browser-runtime/src/manager.rs b/src-tauri/crates/browser-runtime/src/manager.rs
index 534e29006..685c0c6a6 100644
--- a/src-tauri/crates/browser-runtime/src/manager.rs
+++ b/src-tauri/crates/browser-runtime/src/manager.rs
@@ -36,6 +36,8 @@ pub struct OpenSessionRequest {
pub profile_key: String,
pub remote_debugging_port: u16,
pub target_id: Option,
+ pub environment_preset_id: Option,
+ pub environment_preset_name: Option,
}
pub struct BrowserRuntimeManager {
@@ -82,7 +84,13 @@ impl BrowserRuntimeManager {
request: OpenSessionRequest,
) -> Result {
if let Some(existing) = self.find_session_by_profile_key(&request.profile_key).await {
- return Ok(existing);
+ if existing.environment_preset_id == request.environment_preset_id {
+ return Ok(existing);
+ }
+ return Err(format!(
+ "浏览器资料 {} 已存在运行会话，当前环境预设与现有会话不同，请先关闭会话后再切换环境",
+ request.profile_key
+ ));
}
let target =
@@ -100,6 +108,8 @@ impl BrowserRuntimeManager {
let state = CdpSessionState {
session_id: session_id.clone(),
profile_key: request.profile_key.clone(),
+ environment_preset_id: request.environment_preset_id.clone(),
+ environment_preset_name: request.environment_preset_name.clone(),
target_id: target.id.clone(),
target_title: target.title.clone(),
target_url: target.url.clone(),
@@ -221,6 +231,26 @@ impl BrowserRuntimeManager {
.await)
}
+ pub async fn send_command(
+ &self,
+ session_id: &str,
+ method: &str,
+ params: Value,
+ timeout_ms: u64,
+ ) -> Result {
+ self.get_session(session_id)
+ .await?
+ .send_command(method, params, timeout_ms)
+ .await
+ }
+
+ pub async fn refresh_page_info(&self, session_id: &str) -> Result {
+ let session = self.get_session(session_id).await?;
+ let page_info = session.capture_page_info().await?;
+ session.update_page_info(page_info).await;
+ Ok(session.state().await)
+ }
+
pub async fn subscribe(
&self,
session_id: &str,
diff --git a/src-tauri/crates/browser-runtime/src/types.rs b/src-tauri/crates/browser-runtime/src/types.rs
index d8b35591c..5dd530636 100644
--- a/src-tauri/crates/browser-runtime/src/types.rs
+++ b/src-tauri/crates/browser-runtime/src/types.rs
@@ -163,6 +163,8 @@ pub struct CdpTargetInfo {
pub struct CdpSessionState {
pub session_id: String,
pub profile_key: String,
+ pub environment_preset_id: Option,
+ pub environment_preset_name: Option,
pub target_id: String,
pub target_title: String,
pub target_url: String,
diff --git a/src-tauri/crates/core/src/config/mod.rs b/src-tauri/crates/core/src/config/mod.rs
index 4318a19c5..f3c982244 100644
--- a/src-tauri/crates/core/src/config/mod.rs
+++ b/src-tauri/crates/core/src/config/mod.rs
@@ -21,7 +21,7 @@ pub use import::{ImportOptions, ImportService, ValidationResult};
pub use path_utils::{collapse_tilde, contains_tilde, expand_tilde};
pub use types::{
generate_secure_api_key, AmpConfig, AmpModelMapping, ApiKeyEntry, AsrCredentialEntry,
- AsrProviderType, AssistantConfig, AssistantProfile, BaiduConfig, ChannelsConfig,
+ AsrProviderType, AutomationExecutionMode, AutomationSettings, BaiduConfig, ChannelsConfig,
ChatAppearanceConfig, CloudflareTunnelConfig, Config, ContentCreatorConfig,
ConversationSettings, CrashReportingConfig, CredentialEntry, CredentialPoolConfig,
CustomProviderConfig, DeliveryConfig, DiscordAccountConfig, DiscordActionsConfig,
@@ -31,18 +31,17 @@ pub use types::{
DiscordVoiceAutoJoinConfig, DiscordVoiceConfig, EndpointProvidersConfig, EnvironmentConfig,
EnvironmentVariableOverride, ExperimentalFeatures, FeishuAccountConfig, FeishuBotConfig,
FeishuGroupConfig, GatewayConfig, GatewayTunnelConfig, GeminiApiKeyEntry,
- HeartbeatExecutionMode, HeartbeatSecurityConfig, HeartbeatSettings, HintRouteSettingsEntry,
- HintRouterSettings, ImageGenConfig, InjectionRuleConfig, InjectionSettings, LoggingConfig,
- MemoryAutoConfig, MemoryConfig, MemoryProfileConfig, MemoryResolveConfig, MemorySourcesConfig,
- ModelInfo, ModelsConfig, MultiSearchConfig, MultiSearchEngineEntryConfig, NativeAgentConfig,
- NavigationConfig, OpenAIAsrConfig, PairingSettings, ProviderConfig, ProviderModelsConfig,
- ProvidersConfig, QuotaExceededConfig, RateLimitSettings, RemoteManagementConfig,
- ResponseCacheSettings, RetrySettings, RoutingConfig, ScreenshotChatConfig, SearchEngine,
- ServerConfig, ShellEnvironmentImportConfig, TaskSchedule, TelegramAccountConfig,
- TelegramBotConfig, TelegramGroupConfig, TelegramTopicConfig, TlsConfig, ToolCallingConfig,
- UpdateCheckConfig, UserProfile, VertexApiKeyEntry, VertexModelAlias, VoiceConfig,
- VoiceInputConfig, VoiceInstruction, VoiceOutputConfig, VoiceOutputMode, VoiceProcessorConfig,
- WebSearchConfig, WebSearchProvider, WhisperLocalConfig, WhisperModelSize,
+ HintRouteSettingsEntry, HintRouterSettings, ImageGenConfig, InjectionRuleConfig,
+ InjectionSettings, LoggingConfig, MemoryAutoConfig, MemoryConfig, MemoryProfileConfig,
+ MemoryResolveConfig, MemorySourcesConfig, ModelInfo, ModelsConfig, MultiSearchConfig,
+ MultiSearchEngineEntryConfig, NativeAgentConfig, NavigationConfig, OpenAIAsrConfig,
+ PairingSettings, ProviderConfig, ProviderModelsConfig, ProvidersConfig, QuotaExceededConfig,
+ RateLimitSettings, RemoteManagementConfig, ResponseCacheSettings, RetrySettings, RoutingConfig,
+ ScreenshotChatConfig, SearchEngine, ServerConfig, ShellEnvironmentImportConfig, TaskSchedule,
+ TelegramAccountConfig, TelegramBotConfig, TelegramGroupConfig, TelegramTopicConfig, TlsConfig,
+ ToolCallingConfig, UpdateCheckConfig, UserProfile, VertexApiKeyEntry, VertexModelAlias,
+ VoiceConfig, VoiceInputConfig, VoiceInstruction, VoiceOutputConfig, VoiceOutputMode,
+ VoiceProcessorConfig, WebSearchConfig, WebSearchProvider, WhisperLocalConfig, WhisperModelSize,
WorkspaceSandboxConfig, XunfeiConfig, DEFAULT_API_KEY,
};
pub use yaml::{load_config, save_config, ConfigError, ConfigManager, YamlService};
diff --git a/src-tauri/crates/core/src/config/types.rs b/src-tauri/crates/core/src/config/types.rs
index 43064f7d1..b329f226a 100644
--- a/src-tauri/crates/core/src/config/types.rs
+++ b/src-tauri/crates/core/src/config/types.rs
@@ -416,9 +416,6 @@ pub struct Config {
/// 图像生成服务配置
#[serde(default)]
pub image_gen: ImageGenConfig,
- /// 助理配置
- #[serde(default)]
- pub assistant: AssistantConfig,
/// 用户资料
#[serde(default)]
pub user_profile: UserProfile,
@@ -437,9 +434,9 @@ pub struct Config {
/// 配对认证配置
#[serde(default)]
pub pairing: PairingSettings,
- /// 心跳引擎配置
+ /// 自动化调度配置
#[serde(default)]
- pub heartbeat: HeartbeatSettings,
+ pub automation: AutomationSettings,
/// Gateway 全局配置（隧道/公网接入）
#[serde(default)]
pub gateway: GatewayConfig,
@@ -560,6 +557,9 @@ impl Default for NativeAgentConfig {
/// 配置内容创作模式中显示的主题标签
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct ContentCreatorConfig {
+ /// 工作区主题默认值版本
+ #[serde(default)]
+ pub schema_version: u8,
/// 启用的主题列表
#[serde(default = "default_enabled_themes")]
pub enabled_themes: Vec,
@@ -568,20 +568,18 @@ pub struct ContentCreatorConfig {
pub media_defaults: MediaGenerationDefaultsConfig,
}
+fn current_workspace_preferences_schema_version() -> u8 {
+ 1
+}
+
fn default_enabled_themes() -> Vec {
- vec![
- "general".to_string(),
- "social-media".to_string(),
- "poster".to_string(),
- "music".to_string(),
- "video".to_string(),
- "novel".to_string(),
- ]
+ vec!["social-media".to_string(), "poster".to_string()]
}
impl Default for ContentCreatorConfig {
fn default() -> Self {
Self {
+ schema_version: current_workspace_preferences_schema_version(),
enabled_themes: default_enabled_themes(),
media_defaults: MediaGenerationDefaultsConfig::default(),
}
@@ -631,6 +629,9 @@ pub struct MediaGenerationDefaultsConfig {
/// 配置左侧导航栏中显示的功能模块
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct NavigationConfig {
+ /// 工作区导航默认值版本
+ #[serde(default)]
+ pub schema_version: u8,
/// 启用的导航模块列表
#[serde(default = "default_enabled_nav_items")]
pub enabled_items: Vec,
@@ -638,22 +639,98 @@ pub struct NavigationConfig {
fn default_enabled_nav_items() -> Vec {
vec![
- "agent".to_string(),
- "projects".to_string(),
+ "home-general".to_string(),
+ "claw".to_string(),
+ "video".to_string(),
"image-gen".to_string(),
- "api-server".to_string(),
- "provider-pool".to_string(),
+ "automation".to_string(),
+ "openclaw".to_string(),
+ "resources".to_string(),
+ "style-library".to_string(),
+ "memory".to_string(),
]
}
impl Default for NavigationConfig {
fn default() -> Self {
Self {
+ schema_version: current_workspace_preferences_schema_version(),
enabled_items: default_enabled_nav_items(),
}
}
}
+const LEGACY_DEFAULT_THEME_IDS: &[&str] = &[
+ "general",
+ "social-media",
+ "poster",
+ "music",
+ "video",
+ "novel",
+];
+
+const CURRENT_MAIN_NAV_ITEM_IDS: &[&str] = &[
+ "home-general",
+ "claw",
+ "video",
+ "image-gen",
+ "automation",
+ "terminal",
+ "plugins",
+];
+
+const CURRENT_FOOTER_NAV_ITEM_IDS: &[&str] = &[
+ "openclaw",
+ "settings",
+ "resources",
+ "tools",
+ "style-library",
+ "memory",
+];
+
+const LEGACY_ONLY_NAV_ITEM_IDS: &[&str] = &["agent", "projects", "api-server", "provider-pool"];
+
+const LEGACY_DEFAULT_NAV_ITEM_SETS: &[&[&str]] = &[
+ &["home-general", "claw", "video", "image-gen"],
+ &["home-general", "claw", "video", "image-gen", "automation"],
+ &["home-general", "video", "image-gen", "plugins"],
+ &["home-general", "video", "image-gen", "terminal", "plugins"],
+];
+
+fn has_same_members(items: &[String], expected: &[&str]) -> bool {
+ if items.len() != expected.len() {
+ return false;
+ }
+
+ let item_set: std::collections::HashSet<&str> = items.iter().map(String::as_str).collect();
+ expected.iter().all(|item| item_set.contains(item))
+}
+
+fn should_upgrade_legacy_navigation_defaults(items: &[String]) -> bool {
+ if items.is_empty() {
+ return true;
+ }
+
+ if LEGACY_DEFAULT_NAV_ITEM_SETS
+ .iter()
+ .any(|legacy_items| has_same_members(items, legacy_items))
+ {
+ return true;
+ }
+
+ let contains_footer_items = items
+ .iter()
+ .any(|item| CURRENT_FOOTER_NAV_ITEM_IDS.contains(&item.as_str()));
+ let contains_legacy_only_items = items
+ .iter()
+ .any(|item| LEGACY_ONLY_NAV_ITEM_IDS.contains(&item.as_str()));
+ let main_only_legacy_items = items
+ .iter()
+ .all(|item| CURRENT_MAIN_NAV_ITEM_IDS.contains(&item.as_str()));
+
+ contains_legacy_only_items || (main_only_legacy_items && !contains_footer_items)
+}
+
// ============ 实验室功能配置类型 ============
/// 截图对话功能配置
@@ -1998,20 +2075,51 @@ impl Default for Config {
memory: MemoryConfig::default(),
voice: VoiceConfig::default(),
image_gen: ImageGenConfig::default(),
- assistant: AssistantConfig::default(),
user_profile: UserProfile::default(),
rate_limit: RateLimitSettings::default(),
crash_reporting: CrashReportingConfig::default(),
conversation: ConversationSettings::default(),
hint_router: HintRouterSettings::default(),
pairing: PairingSettings::default(),
- heartbeat: HeartbeatSettings::default(),
+ automation: AutomationSettings::default(),
gateway: GatewayConfig::default(),
channels: ChannelsConfig::default(),
}
}
}
+impl Config {
+ pub fn normalize_workspace_preferences(&mut self) -> bool {
+ let mut changed = false;
+ let current_version = current_workspace_preferences_schema_version();
+
+ if self.content_creator.schema_version < current_version {
+ if self.content_creator.enabled_themes.is_empty()
+ || has_same_members(
+ &self.content_creator.enabled_themes,
+ LEGACY_DEFAULT_THEME_IDS,
+ )
+ {
+ self.content_creator.enabled_themes = default_enabled_themes();
+ }
+
+ self.content_creator.schema_version = current_version;
+ changed = true;
+ }
+
+ if self.navigation.schema_version < current_version {
+ if should_upgrade_legacy_navigation_defaults(&self.navigation.enabled_items) {
+ self.navigation.enabled_items = default_enabled_nav_items();
+ }
+
+ self.navigation.schema_version = current_version;
+ changed = true;
+ }
+
+ changed
+ }
+}
+
// ============ 设置页面配置类型 ============
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
@@ -2474,47 +2582,6 @@ pub struct ImageGenConfig {
pub image_search_pixabay_api_key: Option,
}
-/// 助理配置
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
-pub struct AssistantConfig {
- /// 默认助理 ID
- #[serde(default)]
- pub default_assistant_id: Option,
- /// 自定义助理列表
- #[serde(default)]
- pub custom_assistants: Option>,
- /// 启用助理自动选择
- #[serde(default)]
- pub auto_select: Option,
- /// 显示助理建议
- #[serde(default)]
- pub show_suggestions: Option,
-}
-
-/// 助理档案
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
-pub struct AssistantProfile {
- /// ID
- pub id: String,
- /// 名称
- pub name: String,
- /// 描述
- #[serde(default, skip_serializing_if = "Option::is_none")]
- pub description: Option,
- /// 模型
- #[serde(default, skip_serializing_if = "Option::is_none")]
- pub model: Option,
- /// 系统提示词
- #[serde(default, skip_serializing_if = "Option::is_none")]
- pub system_prompt: Option,
- /// 温度参数
- #[serde(default)]
- pub temperature: Option,
- /// 最大 token 数
- #[serde(default)]
- pub max_tokens: Option,
-}
-
/// 用户资料
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
pub struct UserProfile {
@@ -2567,6 +2634,105 @@ mod unit_tests {
assert_eq!(config.crash_reporting.environment, "production");
assert_eq!(config.crash_reporting.sample_rate, 1.0);
assert!(!config.crash_reporting.send_pii);
+ assert_eq!(config.content_creator.schema_version, 1);
+ assert_eq!(
+ config.content_creator.enabled_themes,
+ vec!["social-media".to_string(), "poster".to_string()]
+ );
+ assert_eq!(config.navigation.schema_version, 1);
+ assert_eq!(
+ config.navigation.enabled_items,
+ vec![
+ "home-general".to_string(),
+ "claw".to_string(),
+ "video".to_string(),
+ "image-gen".to_string(),
+ "automation".to_string(),
+ "openclaw".to_string(),
+ "resources".to_string(),
+ "style-library".to_string(),
+ "memory".to_string(),
+ ]
+ );
+ }
+
+ #[test]
+ fn test_normalize_workspace_preferences_upgrades_legacy_defaults() {
+ let mut config = Config::default();
+ config.content_creator.schema_version = 0;
+ config.content_creator.enabled_themes = vec![
+ "general".to_string(),
+ "social-media".to_string(),
+ "poster".to_string(),
+ "music".to_string(),
+ "video".to_string(),
+ "novel".to_string(),
+ ];
+ config.navigation.schema_version = 0;
+ config.navigation.enabled_items = vec![
+ "home-general".to_string(),
+ "claw".to_string(),
+ "video".to_string(),
+ "image-gen".to_string(),
+ ];
+
+ let changed = config.normalize_workspace_preferences();
+
+ assert!(changed);
+ assert_eq!(config.content_creator.schema_version, 1);
+ assert_eq!(
+ config.content_creator.enabled_themes,
+ vec!["social-media".to_string(), "poster".to_string()]
+ );
+ assert_eq!(config.navigation.schema_version, 1);
+ assert_eq!(
+ config.navigation.enabled_items,
+ vec![
+ "home-general".to_string(),
+ "claw".to_string(),
+ "video".to_string(),
+ "image-gen".to_string(),
+ "automation".to_string(),
+ "openclaw".to_string(),
+ "resources".to_string(),
+ "style-library".to_string(),
+ "memory".to_string(),
+ ]
+ );
+ }
+
+ #[test]
+ fn test_normalize_workspace_preferences_preserves_current_custom_values() {
+ let mut config = Config::default();
+ config.content_creator.schema_version = 0;
+ config.content_creator.enabled_themes =
+ vec!["social-media".to_string(), "video".to_string()];
+ config.navigation.schema_version = 0;
+ config.navigation.enabled_items = vec![
+ "home-general".to_string(),
+ "claw".to_string(),
+ "resources".to_string(),
+ "tools".to_string(),
+ ];
+
+ let changed = config.normalize_workspace_preferences();
+
+ assert!(changed);
+ assert_eq!(config.content_creator.schema_version, 1);
+ assert_eq!(
+ config.content_creator.enabled_themes,
+ vec!["social-media".to_string(), "video".to_string()]
+ );
+ assert_eq!(config.navigation.schema_version, 1);
+ assert_eq!(
+ config.navigation.enabled_items,
+ vec![
+ "home-general".to_string(),
+ "claw".to_string(),
+ "resources".to_string(),
+ "tools".to_string(),
+ ]
+ );
}
#[test]
@@ -3030,7 +3196,7 @@ impl Default for TaskSchedule {
}
}
-/// 通知投递配置
+/// 自动化输出/通知投递配置
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct DeliveryConfig {
/// 投递模式: "none" | "announce"
@@ -3045,12 +3211,22 @@ pub struct DeliveryConfig {
/// 投递失败是否算任务失败
#[serde(default)]
pub best_effort: bool,
+ /// 输出契约，留空时按旧任务结果自动推断
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub output_schema: Option,
+ /// 输出格式: "text" | "json"
+ #[serde(default = "default_delivery_output_format")]
+ pub output_format: String,
}
fn default_delivery_mode() -> String {
"none".to_string()
}
+fn default_delivery_output_format() -> String {
+ "text".to_string()
+}
+
impl Default for DeliveryConfig {
fn default() -> Self {
Self {
@@ -3058,14 +3234,16 @@ impl Default for DeliveryConfig {
channel: None,
target: None,
best_effort: true,
+ output_schema: None,
+ output_format: default_delivery_output_format(),
}
}
}
-/// 心跳执行模式
+/// 自动化执行模式
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
-pub enum HeartbeatExecutionMode {
+pub enum AutomationExecutionMode {
/// 智能模式：通过 AI Agent 执行任务
#[default]
Intelligent,
@@ -3075,77 +3253,33 @@ pub enum HeartbeatExecutionMode {
LogOnly,
}
-/// 心跳引擎配置
+/// 自动化调度配置
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
-pub struct HeartbeatSettings {
- /// 是否启用心跳引擎
+pub struct AutomationSettings {
+ /// 是否启用自动化调度
#[serde(default)]
pub enabled: bool,
- /// 心跳间隔（秒），最小 300（5分钟）- 向后兼容
- #[serde(default = "default_heartbeat_interval")]
- pub interval_secs: u64,
- /// 灵活调度配置（优先于 interval_secs）
- #[serde(default, skip_serializing_if = "Option::is_none")]
- pub schedule: Option,
- /// 任务文件名（相对于应用数据目录）
- #[serde(default = "default_heartbeat_task_file")]
- pub task_file: String,
- /// 执行模式
- #[serde(default)]
- pub execution_mode: HeartbeatExecutionMode,
- /// 是否启用任务历史记录
+ /// 后台轮询间隔（秒）
+ #[serde(default = "default_automation_poll_interval")]
+ pub poll_interval_secs: u64,
+ /// 是否启用运行历史
#[serde(default = "default_enable_history")]
pub enable_history: bool,
- /// 失败重试次数
- #[serde(default = "default_heartbeat_max_retries")]
- pub max_retries: u32,
- /// 通知投递配置
- #[serde(default)]
- pub delivery: DeliveryConfig,
- /// 安全策略配置
- #[serde(default)]
- pub security: HeartbeatSecurityConfig,
}
-/// 心跳安全策略配置
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
-pub struct HeartbeatSecurityConfig {
- /// 允许的命令白名单（仅适用于 shell 类任务）
- #[serde(default, skip_serializing_if = "Vec::is_empty")]
- pub allowed_commands: Vec,
- /// 允许的路径前缀（安全起见）
- #[serde(default, skip_serializing_if = "Vec::is_empty")]
- pub allowed_paths: Vec,
- /// 是否启用安全检查
- #[serde(default)]
- pub enabled: bool,
-}
-
-fn default_heartbeat_interval() -> u64 {
- 300
-}
-fn default_heartbeat_task_file() -> String {
- "HEARTBEAT.md".to_string()
+fn default_automation_poll_interval() -> u64 {
+ 30
}
fn default_enable_history() -> bool {
true
}
-fn default_heartbeat_max_retries() -> u32 {
- 3
-}
-impl Default for HeartbeatSettings {
+impl Default for AutomationSettings {
fn default() -> Self {
Self {
enabled: false,
- interval_secs: 300,
- schedule: None,
- task_file: "HEARTBEAT.md".to_string(),
- execution_mode: HeartbeatExecutionMode::default(),
+ poll_interval_secs: default_automation_poll_interval(),
enable_history: true,
- max_retries: default_heartbeat_max_retries(),
- delivery: DeliveryConfig::default(),
- security: HeartbeatSecurityConfig::default(),
}
}
}
diff --git a/src-tauri/crates/core/src/config/yaml.rs b/src-tauri/crates/core/src/config/yaml.rs
index 61c61efbd..7864d1c7f 100644
--- a/src-tauri/crates/core/src/config/yaml.rs
+++ b/src-tauri/crates/core/src/config/yaml.rs
@@ -664,13 +664,16 @@ pub fn load_config() -> Result> {
if yaml_path.exists() {
let content = std::fs::read_to_string(&yaml_path)?;
let mut config: Config = serde_yaml::from_str(&content)?;
+ let mut should_save = config.normalize_workspace_preferences();
// 如果配置中使用默认 API Key，生成强随机 Key 并保存
if is_default_api_key(&config.server.api_key) {
let new_key = generate_secure_api_key();
tracing::warn!("[CONFIG] 检测到默认 API Key，已自动生成强随机 Key");
config.server.api_key = new_key;
- // 保存更新后的配置
- if let Err(e) = save_config_yaml(&config) {
+ should_save = true;
+ }
+ if should_save {
+ if let Err(e) = save_config(&config) {
tracing::error!("[CONFIG] 保存配置失败: {}", e);
}
}
@@ -681,13 +684,16 @@ pub fn load_config() -> Result> {
if json_path.exists() {
let content = std::fs::read_to_string(&json_path)?;
let mut config: Config = serde_json::from_str(&content)?;
+ let mut should_save = config.normalize_workspace_preferences();
// 如果配置中使用默认 API Key，生成强随机 Key 并保存
if is_default_api_key(&config.server.api_key) {
let new_key = generate_secure_api_key();
tracing::warn!("[CONFIG] 检测到默认 API Key，已自动生成强随机 Key");
config.server.api_key = new_key;
- // 保存更新后的配置（迁移到 YAML）
- if let Err(e) = save_config_yaml(&config) {
+ should_save = true;
+ }
+ if should_save {
+ if let Err(e) = save_config(&config) {
tracing::error!("[CONFIG] 保存配置失败: {}", e);
}
}
diff --git a/src-tauri/crates/core/src/database/dao/agent_run.rs b/src-tauri/crates/core/src/database/dao/agent_run.rs
index c4f2c217e..9c01d72db 100644
--- a/src-tauri/crates/core/src/database/dao/agent_run.rs
+++ b/src-tauri/crates/core/src/database/dao/agent_run.rs
@@ -1,6 +1,6 @@
//! 统一执行追踪（agent_runs）数据访问对象
//!
-//! 提供跨 chat / skill / heartbeat 的执行摘要记录能力。
+//! 提供跨 chat / skill / automation 的执行摘要记录能力。
use rusqlite::{params, Connection};
use serde::{Deserialize, Serialize};
@@ -137,6 +137,26 @@ impl AgentRunDao {
Ok(changed > 0)
}
+ pub fn refresh_running_run(
+ conn: &Connection,
+ id: &str,
+ updated_at: &str,
+ session_id: Option<&str>,
+ metadata: Option<&str>,
+ ) -> Result {
+ let changed = conn.execute(
+ "UPDATE agent_runs
+ SET session_id = COALESCE(?1, session_id),
+ metadata = COALESCE(?2, metadata),
+ updated_at = ?3
+ WHERE id = ?4
+ AND finished_at IS NULL
+ AND status IN ('queued', 'running')",
+ params![session_id, metadata, updated_at, id],
+ )?;
+ Ok(changed > 0)
+ }
+
pub fn get_run(conn: &Connection, id: &str) -> Result, rusqlite::Error> {
let mut stmt = conn.prepare(
"SELECT id, source, source_ref, session_id, status, started_at, finished_at, duration_ms,
@@ -246,6 +266,46 @@ impl AgentRunDao {
iter.collect()
}
+ pub fn list_runs_by_source_ref(
+ conn: &Connection,
+ source: &str,
+ source_ref: &str,
+ limit: usize,
+ ) -> Result, rusqlite::Error> {
+ let mut stmt = conn.prepare(
+ "SELECT id, source, source_ref, session_id, status, started_at, finished_at, duration_ms,
+ error_code, error_message, metadata, created_at, updated_at
+ FROM agent_runs
+ WHERE source = ?1
+ AND source_ref = ?2
+ ORDER BY started_at DESC
+ LIMIT ?3",
+ )?;
+
+ let iter = stmt.query_map(params![source, source_ref, limit as i64], |row| {
+ let status_raw: String = row.get(4)?;
+ let status =
+ AgentRunStatus::try_from(status_raw.as_str()).unwrap_or(AgentRunStatus::Error);
+ Ok(AgentRun {
+ id: row.get(0)?,
+ source: row.get(1)?,
+ source_ref: row.get(2)?,
+ session_id: row.get(3)?,
+ status,
+ started_at: row.get(5)?,
+ finished_at: row.get(6)?,
+ duration_ms: row.get(7)?,
+ error_code: row.get(8)?,
+ error_message: row.get(9)?,
+ metadata: row.get(10)?,
+ created_at: row.get(11)?,
+ updated_at: row.get(12)?,
+ })
+ })?;
+
+ iter.collect()
+ }
+
pub fn list_terminal_runs_by_session(
conn: &Connection,
session_id: &str,
@@ -447,4 +507,34 @@ mod tests {
assert_eq!(second_page.len(), 1);
assert_eq!(second_page[0].id, "run-success");
}
+
+ #[test]
+ fn refresh_running_run_should_update_session_and_metadata() {
+ let conn = setup_conn();
+ let mut run = sample_run("run-refresh", AgentRunStatus::Running);
+ run.session_id = None;
+ AgentRunDao::create_run(&conn, &run).expect("写入 run 失败");
+
+ let updated_at = Utc::now().to_rfc3339();
+ let changed = AgentRunDao::refresh_running_run(
+ &conn,
+ "run-refresh",
+ &updated_at,
+ Some("session-refresh"),
+ Some("{\"browser_lifecycle_state\":\"waiting_for_human\"}"),
+ )
+ .expect("刷新运行中 run 失败");
+
+ assert!(changed);
+
+ let fetched = AgentRunDao::get_run(&conn, "run-refresh")
+ .expect("查询 run 失败")
+ .expect("run 不存在");
+ assert_eq!(fetched.session_id.as_deref(), Some("session-refresh"));
+ assert_eq!(
+ fetched.metadata.as_deref(),
+ Some("{\"browser_lifecycle_state\":\"waiting_for_human\"}")
+ );
+ assert_eq!(fetched.updated_at, updated_at);
+ }
}
diff --git a/src-tauri/crates/core/src/database/dao/automation_job.rs b/src-tauri/crates/core/src/database/dao/automation_job.rs
new file mode 100644
index 000000000..98aee2f7a
--- /dev/null
+++ b/src-tauri/crates/core/src/database/dao/automation_job.rs
@@ -0,0 +1,413 @@
+//! 自动化任务数据访问对象
+//!
+//! 负责结构化自动化任务的持久化与查询。
+
+use crate::config::{AutomationExecutionMode, DeliveryConfig, TaskSchedule};
+use rusqlite::{params, Connection};
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct AutomationJobLastDelivery {
+ pub success: bool,
+ pub message: String,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub channel: Option,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub target: Option,
+ pub output_kind: String,
+ pub output_schema: String,
+ pub output_format: String,
+ pub output_preview: String,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub delivery_attempt_id: Option,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub run_id: Option,
+ #[serde(default)]
+ pub execution_retry_count: u32,
+ #[serde(default)]
+ pub delivery_attempts: u32,
+ pub attempted_at: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct AutomationJob {
+ pub id: String,
+ pub name: String,
+ pub description: Option,
+ pub enabled: bool,
+ pub workspace_id: String,
+ pub execution_mode: AutomationExecutionMode,
+ pub schedule: TaskSchedule,
+ pub payload: Value,
+ pub delivery: DeliveryConfig,
+ pub timeout_secs: Option,
+ pub max_retries: u32,
+ pub next_run_at: Option,
+ pub last_status: Option,
+ pub last_error: Option,
+ pub last_run_at: Option,
+ pub last_finished_at: Option,
+ pub running_started_at: Option,
+ pub consecutive_failures: u32,
+ pub last_retry_count: u32,
+ pub auto_disabled_until: Option,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub last_delivery: Option,
+ pub created_at: String,
+ pub updated_at: String,
+}
+
+pub struct AutomationJobDao;
+
+impl AutomationJobDao {
+ pub fn create(conn: &Connection, job: &AutomationJob) -> Result<(), rusqlite::Error> {
+ let schedule_json = serde_json::to_string(&job.schedule)
+ .map_err(|e| rusqlite::Error::ToSqlConversionFailure(Box::new(e)))?;
+ let payload_json = serde_json::to_string(&job.payload)
+ .map_err(|e| rusqlite::Error::ToSqlConversionFailure(Box::new(e)))?;
+ let delivery_json = serde_json::to_string(&job.delivery)
+ .map_err(|e| rusqlite::Error::ToSqlConversionFailure(Box::new(e)))?;
+ let last_delivery_json = job
+ .last_delivery
+ .as_ref()
+ .map(serde_json::to_string)
+ .transpose()
+ .map_err(|e| rusqlite::Error::ToSqlConversionFailure(Box::new(e)))?;
+
+ conn.execute(
+ "INSERT INTO automation_jobs (
+ id, name, description, enabled, workspace_id, execution_mode,
+ schedule_json, payload_json, delivery_json, timeout_secs, max_retries,
+ next_run_at, last_status, last_error, last_run_at, last_finished_at,
+ running_started_at, consecutive_failures, last_retry_count,
+ auto_disabled_until, created_at, updated_at, last_delivery_json
+ ) VALUES (
+ ?1, ?2, ?3, ?4, ?5, ?6,
+ ?7, ?8, ?9, ?10, ?11,
+ ?12, ?13, ?14, ?15, ?16,
+ ?17, ?18, ?19, ?20, ?21, ?22, ?23
+ )",
+ params![
+ job.id,
+ job.name,
+ job.description,
+ if job.enabled { 1 } else { 0 },
+ job.workspace_id,
+ serde_json::to_string(&job.execution_mode)
+ .map_err(|e| rusqlite::Error::ToSqlConversionFailure(Box::new(e)))?,
+ schedule_json,
+ payload_json,
+ delivery_json,
+ job.timeout_secs.map(|v| v as i64),
+ job.max_retries as i64,
+ job.next_run_at,
+ job.last_status,
+ job.last_error,
+ job.last_run_at,
+ job.last_finished_at,
+ job.running_started_at,
+ job.consecutive_failures as i64,
+ job.last_retry_count as i64,
+ job.auto_disabled_until,
+ job.created_at,
+ job.updated_at,
+ last_delivery_json,
+ ],
+ )?;
+
+ Ok(())
+ }
+
+ pub fn get(conn: &Connection, id: &str) -> Result, rusqlite::Error> {
+ let mut stmt = conn.prepare(
+ "SELECT
+ id, name, description, enabled, workspace_id, execution_mode,
+ schedule_json, payload_json, delivery_json, timeout_secs, max_retries,
+ next_run_at, last_status, last_error, last_run_at, last_finished_at,
+ running_started_at, consecutive_failures, last_retry_count,
+ auto_disabled_until, created_at, updated_at, last_delivery_json
+ FROM automation_jobs
+ WHERE id = ?1",
+ )?;
+
+ let mut rows = stmt.query(params![id])?;
+ if let Some(row) = rows.next()? {
+ Ok(Some(Self::row_to_job(row)?))
+ } else {
+ Ok(None)
+ }
+ }
+
+ pub fn list(conn: &Connection) -> Result, rusqlite::Error> {
+ let mut stmt = conn.prepare(
+ "SELECT
+ id, name, description, enabled, workspace_id, execution_mode,
+ schedule_json, payload_json, delivery_json, timeout_secs, max_retries,
+ next_run_at, last_status, last_error, last_run_at, last_finished_at,
+ running_started_at, consecutive_failures, last_retry_count,
+ auto_disabled_until, created_at, updated_at, last_delivery_json
+ FROM automation_jobs
+ ORDER BY updated_at DESC, created_at DESC",
+ )?;
+
+ let rows = stmt.query_map([], Self::row_to_job)?;
+ rows.collect()
+ }
+
+ pub fn list_due(
+ conn: &Connection,
+ now_rfc3339: &str,
+ limit: usize,
+ ) -> Result, rusqlite::Error> {
+ let mut stmt = conn.prepare(
+ "SELECT
+ id, name, description, enabled, workspace_id, execution_mode,
+ schedule_json, payload_json, delivery_json, timeout_secs, max_retries,
+ next_run_at, last_status, last_error, last_run_at, last_finished_at,
+ running_started_at, consecutive_failures, last_retry_count,
+ auto_disabled_until, created_at, updated_at, last_delivery_json
+ FROM automation_jobs
+ WHERE enabled = 1
+ AND next_run_at IS NOT NULL
+ AND datetime(next_run_at) <= datetime(?1)
+ AND running_started_at IS NULL
+ AND (
+ auto_disabled_until IS NULL
+ OR datetime(auto_disabled_until) <= datetime(?1)
+ )
+ ORDER BY datetime(next_run_at) ASC
+ LIMIT ?2",
+ )?;
+
+ let rows = stmt.query_map(params![now_rfc3339, limit as i64], Self::row_to_job)?;
+ rows.collect()
+ }
+
+ pub fn update(conn: &Connection, job: &AutomationJob) -> Result<(), rusqlite::Error> {
+ let schedule_json = serde_json::to_string(&job.schedule)
+ .map_err(|e| rusqlite::Error::ToSqlConversionFailure(Box::new(e)))?;
+ let payload_json = serde_json::to_string(&job.payload)
+ .map_err(|e| rusqlite::Error::ToSqlConversionFailure(Box::new(e)))?;
+ let delivery_json = serde_json::to_string(&job.delivery)
+ .map_err(|e| rusqlite::Error::ToSqlConversionFailure(Box::new(e)))?;
+ let last_delivery_json = job
+ .last_delivery
+ .as_ref()
+ .map(serde_json::to_string)
+ .transpose()
+ .map_err(|e| rusqlite::Error::ToSqlConversionFailure(Box::new(e)))?;
+
+ conn.execute(
+ "UPDATE automation_jobs
+ SET name = ?1,
+ description = ?2,
+ enabled = ?3,
+ workspace_id = ?4,
+ execution_mode = ?5,
+ schedule_json = ?6,
+ payload_json = ?7,
+ delivery_json = ?8,
+ timeout_secs = ?9,
+ max_retries = ?10,
+ next_run_at = ?11,
+ last_status = ?12,
+ last_error = ?13,
+ last_run_at = ?14,
+ last_finished_at = ?15,
+ running_started_at = ?16,
+ consecutive_failures = ?17,
+ last_retry_count = ?18,
+ auto_disabled_until = ?19,
+ updated_at = ?20,
+ last_delivery_json = ?21
+ WHERE id = ?22",
+ params![
+ job.name,
+ job.description,
+ if job.enabled { 1 } else { 0 },
+ job.workspace_id,
+ serde_json::to_string(&job.execution_mode)
+ .map_err(|e| rusqlite::Error::ToSqlConversionFailure(Box::new(e)))?,
+ schedule_json,
+ payload_json,
+ delivery_json,
+ job.timeout_secs.map(|v| v as i64),
+ job.max_retries as i64,
+ job.next_run_at,
+ job.last_status,
+ job.last_error,
+ job.last_run_at,
+ job.last_finished_at,
+ job.running_started_at,
+ job.consecutive_failures as i64,
+ job.last_retry_count as i64,
+ job.auto_disabled_until,
+ job.updated_at,
+ last_delivery_json,
+ job.id,
+ ],
+ )?;
+
+ Ok(())
+ }
+
+ pub fn delete(conn: &Connection, id: &str) -> Result {
+ let rows = conn.execute("DELETE FROM automation_jobs WHERE id = ?1", params![id])?;
+ Ok(rows > 0)
+ }
+
+ fn row_to_job(row: &rusqlite::Row<'_>) -> Result {
+ let execution_mode_raw: String = row.get(5)?;
+ let schedule_json: String = row.get(6)?;
+ let payload_json: String = row.get(7)?;
+ let delivery_json: String = row.get(8)?;
+ let last_delivery_json: Option = row.get(22)?;
+
+ let execution_mode = serde_json::from_str(&execution_mode_raw).map_err(|e| {
+ rusqlite::Error::FromSqlConversionFailure(5, rusqlite::types::Type::Text, Box::new(e))
+ })?;
+ let schedule = serde_json::from_str(&schedule_json).map_err(|e| {
+ rusqlite::Error::FromSqlConversionFailure(6, rusqlite::types::Type::Text, Box::new(e))
+ })?;
+ let payload = serde_json::from_str(&payload_json).map_err(|e| {
+ rusqlite::Error::FromSqlConversionFailure(7, rusqlite::types::Type::Text, Box::new(e))
+ })?;
+ let delivery = serde_json::from_str(&delivery_json).map_err(|e| {
+ rusqlite::Error::FromSqlConversionFailure(8, rusqlite::types::Type::Text, Box::new(e))
+ })?;
+ let last_delivery = last_delivery_json
+ .map(|value| {
+ serde_json::from_str::(&value).map_err(|e| {
+ rusqlite::Error::FromSqlConversionFailure(
+ 22,
+ rusqlite::types::Type::Text,
+ Box::new(e),
+ )
+ })
+ })
+ .transpose()?;
+
+ Ok(AutomationJob {
+ id: row.get(0)?,
+ name: row.get(1)?,
+ description: row.get(2)?,
+ enabled: row.get::<_, i64>(3)? != 0,
+ workspace_id: row.get(4)?,
+ execution_mode,
+ schedule,
+ payload,
+ delivery,
+ timeout_secs: row.get::<_, Option>(9)?.map(|v| v as u64),
+ max_retries: row.get::<_, i64>(10)? as u32,
+ next_run_at: row.get(11)?,
+ last_status: row.get(12)?,
+ last_error: row.get(13)?,
+ last_run_at: row.get(14)?,
+ last_finished_at: row.get(15)?,
+ running_started_at: row.get(16)?,
+ consecutive_failures: row.get::<_, i64>(17)? as u32,
+ last_retry_count: row.get::<_, i64>(18)? as u32,
+ auto_disabled_until: row.get(19)?,
+ last_delivery,
+ created_at: row.get(20)?,
+ updated_at: row.get(21)?,
+ })
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use crate::database::schema::create_tables;
+ use rusqlite::Connection;
+ use serde_json::json;
+
+ #[test]
+ fn create_and_get_should_preserve_last_delivery() {
+ let conn = Connection::open_in_memory().expect("创建内存数据库失败");
+ create_tables(&conn).expect("创建数据表失败");
+
+ let job = AutomationJob {
+ id: "job-1".to_string(),
+ name: "巡检任务".to_string(),
+ description: Some("测试最近一次投递结果".to_string()),
+ enabled: true,
+ workspace_id: "workspace-1".to_string(),
+ execution_mode: AutomationExecutionMode::Intelligent,
+ schedule: TaskSchedule::Every { every_secs: 300 },
+ payload: json!({
+ "kind": "agent_turn",
+ "prompt": "汇总今日异常",
+ "web_search": false
+ }),
+ delivery: DeliveryConfig::default(),
+ timeout_secs: Some(120),
+ max_retries: 2,
+ next_run_at: Some("2026-03-16T00:10:00Z".to_string()),
+ last_status: Some("error".to_string()),
+ last_error: Some("写入本地文件失败".to_string()),
+ last_run_at: Some("2026-03-16T00:00:00Z".to_string()),
+ last_finished_at: Some("2026-03-16T00:00:05Z".to_string()),
+ running_started_at: None,
+ consecutive_failures: 1,
+ last_retry_count: 0,
+ auto_disabled_until: None,
+ last_delivery: Some(AutomationJobLastDelivery {
+ success: false,
+ message: "写入本地文件失败: permission denied".to_string(),
+ channel: Some("local_file".to_string()),
+ target: Some("/tmp/proxycast/output.json".to_string()),
+ output_kind: "json".to_string(),
+ output_schema: "json".to_string(),
+ output_format: "json".to_string(),
+ output_preview: "{\"status\":\"error\"}".to_string(),
+ delivery_attempt_id: Some("dlv-run-1".to_string()),
+ run_id: Some("run-1".to_string()),
+ execution_retry_count: 1,
+ delivery_attempts: 2,
+ attempted_at: "2026-03-16T00:00:04Z".to_string(),
+ }),
+ created_at: "2026-03-16T00:00:00Z".to_string(),
+ updated_at: "2026-03-16T00:00:05Z".to_string(),
+ };
+
+ AutomationJobDao::create(&conn, &job).expect("创建自动化任务失败");
+ let loaded = AutomationJobDao::get(&conn, "job-1")
+ .expect("读取自动化任务失败")
+ .expect("自动化任务不存在");
+
+ assert_eq!(
+ loaded
+ .last_delivery
+ .as_ref()
+ .and_then(|value| value.channel.as_deref()),
+ Some("local_file")
+ );
+ assert_eq!(
+ loaded.last_delivery.as_ref().map(|value| value.success),
+ Some(false)
+ );
+ assert_eq!(
+ loaded
+ .last_delivery
+ .as_ref()
+ .map(|value| value.output_preview.as_str()),
+ Some("{\"status\":\"error\"}")
+ );
+ assert_eq!(
+ loaded
+ .last_delivery
+ .as_ref()
+ .and_then(|value| value.delivery_attempt_id.as_deref()),
+ Some("dlv-run-1")
+ );
+ assert_eq!(
+ loaded
+ .last_delivery
+ .as_ref()
+ .map(|value| value.delivery_attempts),
+ Some(2)
+ );
+ }
+}
diff --git a/src-tauri/crates/core/src/database/dao/browser_environment_preset.rs b/src-tauri/crates/core/src/database/dao/browser_environment_preset.rs
new file mode 100644
index 000000000..6a13a7aed
--- /dev/null
+++ b/src-tauri/crates/core/src/database/dao/browser_environment_preset.rs
@@ -0,0 +1,416 @@
+use chrono::Utc;
+use rusqlite::{params, Connection, OptionalExtension};
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct BrowserEnvironmentPresetRecord {
+ pub id: String,
+ pub name: String,
+ pub description: Option,
+ pub proxy_server: Option,
+ pub timezone_id: Option,
+ pub locale: Option,
+ pub accept_language: Option,
+ pub geolocation_lat: Option,
+ pub geolocation_lng: Option,
+ pub geolocation_accuracy_m: Option,
+ pub user_agent: Option,
+ pub platform: Option,
+ pub viewport_width: Option,
+ pub viewport_height: Option,
+ pub device_scale_factor: Option,
+ pub created_at: String,
+ pub updated_at: String,
+ pub last_used_at: Option,
+ pub archived_at: Option,
+}
+
+#[derive(Debug, Clone)]
+pub struct UpsertBrowserEnvironmentPresetInput {
+ pub id: Option,
+ pub name: String,
+ pub description: Option,
+ pub proxy_server: Option,
+ pub timezone_id: Option,
+ pub locale: Option,
+ pub accept_language: Option,
+ pub geolocation_lat: Option,
+ pub geolocation_lng: Option,
+ pub geolocation_accuracy_m: Option,
+ pub user_agent: Option,
+ pub platform: Option,
+ pub viewport_width: Option,
+ pub viewport_height: Option,
+ pub device_scale_factor: Option,
+}
+
+pub struct BrowserEnvironmentPresetDao;
+
+impl BrowserEnvironmentPresetDao {
+ pub fn get_by_id(
+ conn: &Connection,
+ id: &str,
+ ) -> Result, rusqlite::Error> {
+ conn.query_row(
+ "SELECT
+ id,
+ name,
+ description,
+ proxy_server,
+ timezone_id,
+ locale,
+ accept_language,
+ geolocation_lat,
+ geolocation_lng,
+ geolocation_accuracy_m,
+ user_agent,
+ platform,
+ viewport_width,
+ viewport_height,
+ device_scale_factor,
+ created_at,
+ updated_at,
+ last_used_at,
+ archived_at
+ FROM browser_environment_presets
+ WHERE id = ?1",
+ [id],
+ map_browser_environment_preset_row,
+ )
+ .optional()
+ }
+
+ pub fn list(
+ conn: &Connection,
+ include_archived: bool,
+ ) -> Result, rusqlite::Error> {
+ let sql = if include_archived {
+ "SELECT
+ id,
+ name,
+ description,
+ proxy_server,
+ timezone_id,
+ locale,
+ accept_language,
+ geolocation_lat,
+ geolocation_lng,
+ geolocation_accuracy_m,
+ user_agent,
+ platform,
+ viewport_width,
+ viewport_height,
+ device_scale_factor,
+ created_at,
+ updated_at,
+ last_used_at,
+ archived_at
+ FROM browser_environment_presets
+ ORDER BY
+ CASE WHEN archived_at IS NULL THEN 0 ELSE 1 END,
+ COALESCE(last_used_at, updated_at) DESC,
+ name COLLATE NOCASE ASC"
+ } else {
+ "SELECT
+ id,
+ name,
+ description,
+ proxy_server,
+ timezone_id,
+ locale,
+ accept_language,
+ geolocation_lat,
+ geolocation_lng,
+ geolocation_accuracy_m,
+ user_agent,
+ platform,
+ viewport_width,
+ viewport_height,
+ device_scale_factor,
+ created_at,
+ updated_at,
+ last_used_at,
+ archived_at
+ FROM browser_environment_presets
+ WHERE archived_at IS NULL
+ ORDER BY
+ COALESCE(last_used_at, updated_at) DESC,
+ name COLLATE NOCASE ASC"
+ };
+ let mut stmt = conn.prepare(sql)?;
+ let rows = stmt.query_map([], map_browser_environment_preset_row)?;
+ rows.collect()
+ }
+
+ pub fn upsert(
+ conn: &Connection,
+ input: &UpsertBrowserEnvironmentPresetInput,
+ ) -> Result {
+ let now = Utc::now().to_rfc3339();
+ let id = input
+ .id
+ .clone()
+ .unwrap_or_else(|| Uuid::new_v4().to_string());
+ let created_at = Self::get_by_id(conn, &id)?
+ .map(|existing| existing.created_at)
+ .unwrap_or_else(|| now.clone());
+
+ conn.execute(
+ "INSERT INTO browser_environment_presets (
+ id,
+ name,
+ description,
+ proxy_server,
+ timezone_id,
+ locale,
+ accept_language,
+ geolocation_lat,
+ geolocation_lng,
+ geolocation_accuracy_m,
+ user_agent,
+ platform,
+ viewport_width,
+ viewport_height,
+ device_scale_factor,
+ created_at,
+ updated_at,
+ last_used_at,
+ archived_at
+ ) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13, ?14, ?15, ?16, ?17, NULL, NULL)
+ ON CONFLICT(id) DO UPDATE SET
+ name = excluded.name,
+ description = excluded.description,
+ proxy_server = excluded.proxy_server,
+ timezone_id = excluded.timezone_id,
+ locale = excluded.locale,
+ accept_language = excluded.accept_language,
+ geolocation_lat = excluded.geolocation_lat,
+ geolocation_lng = excluded.geolocation_lng,
+ geolocation_accuracy_m = excluded.geolocation_accuracy_m,
+ user_agent = excluded.user_agent,
+ platform = excluded.platform,
+ viewport_width = excluded.viewport_width,
+ viewport_height = excluded.viewport_height,
+ device_scale_factor = excluded.device_scale_factor,
+ updated_at = excluded.updated_at",
+ params![
+ id,
+ input.name,
+ input.description,
+ input.proxy_server,
+ input.timezone_id,
+ input.locale,
+ input.accept_language,
+ input.geolocation_lat,
+ input.geolocation_lng,
+ input.geolocation_accuracy_m,
+ input.user_agent,
+ input.platform,
+ input.viewport_width,
+ input.viewport_height,
+ input.device_scale_factor,
+ created_at,
+ now,
+ ],
+ )?;
+
+ Self::get_by_id(conn, &id)?.ok_or(rusqlite::Error::QueryReturnedNoRows)
+ }
+
+ pub fn archive(conn: &Connection, id: &str) -> Result {
+ let affected = conn.execute(
+ "UPDATE browser_environment_presets
+ SET archived_at = ?2, updated_at = ?2
+ WHERE id = ?1 AND archived_at IS NULL",
+ params![id, Utc::now().to_rfc3339()],
+ )?;
+ Ok(affected > 0)
+ }
+
+ pub fn restore(conn: &Connection, id: &str) -> Result {
+ let affected = conn.execute(
+ "UPDATE browser_environment_presets
+ SET archived_at = NULL, updated_at = ?2
+ WHERE id = ?1 AND archived_at IS NOT NULL",
+ params![id, Utc::now().to_rfc3339()],
+ )?;
+ Ok(affected > 0)
+ }
+
+ pub fn touch_last_used(conn: &Connection, id: &str) -> Result {
+ let now = Utc::now().to_rfc3339();
+ let affected = conn.execute(
+ "UPDATE browser_environment_presets
+ SET last_used_at = ?2, updated_at = ?2
+ WHERE id = ?1",
+ params![id, now],
+ )?;
+ Ok(affected > 0)
+ }
+}
+
+fn map_browser_environment_preset_row(
+ row: &rusqlite::Row<'_>,
+) -> Result {
+ Ok(BrowserEnvironmentPresetRecord {
+ id: row.get(0)?,
+ name: row.get(1)?,
+ description: row.get(2)?,
+ proxy_server: row.get(3)?,
+ timezone_id: row.get(4)?,
+ locale: row.get(5)?,
+ accept_language: row.get(6)?,
+ geolocation_lat: row.get(7)?,
+ geolocation_lng: row.get(8)?,
+ geolocation_accuracy_m: row.get(9)?,
+ user_agent: row.get(10)?,
+ platform: row.get(11)?,
+ viewport_width: row.get(12)?,
+ viewport_height: row.get(13)?,
+ device_scale_factor: row.get(14)?,
+ created_at: row.get(15)?,
+ updated_at: row.get(16)?,
+ last_used_at: row.get(17)?,
+ archived_at: row.get(18)?,
+ })
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ fn setup_db() -> Connection {
+ let conn = Connection::open_in_memory().unwrap();
+ conn.execute(
+ "CREATE TABLE browser_environment_presets (
+ id TEXT PRIMARY KEY,
+ name TEXT NOT NULL,
+ description TEXT,
+ proxy_server TEXT,
+ timezone_id TEXT,
+ locale TEXT,
+ accept_language TEXT,
+ geolocation_lat REAL,
+ geolocation_lng REAL,
+ geolocation_accuracy_m REAL,
+ user_agent TEXT,
+ platform TEXT,
+ viewport_width INTEGER,
+ viewport_height INTEGER,
+ device_scale_factor REAL,
+ created_at TEXT NOT NULL,
+ updated_at TEXT NOT NULL,
+ last_used_at TEXT,
+ archived_at TEXT
+ )",
+ [],
+ )
+ .unwrap();
+ conn
+ }
+
+ #[test]
+ fn should_insert_and_list_active_presets() {
+ let conn = setup_db();
+ let inserted = BrowserEnvironmentPresetDao::upsert(
+ &conn,
+ &UpsertBrowserEnvironmentPresetInput {
+ id: None,
+ name: "美区桌面".to_string(),
+ description: Some("美国住宅代理".to_string()),
+ proxy_server: Some("http://127.0.0.1:7890".to_string()),
+ timezone_id: Some("America/Los_Angeles".to_string()),
+ locale: Some("en-US".to_string()),
+ accept_language: Some("en-US,en;q=0.9".to_string()),
+ geolocation_lat: Some(37.7749),
+ geolocation_lng: Some(-122.4194),
+ geolocation_accuracy_m: Some(100.0),
+ user_agent: Some("Mozilla/5.0".to_string()),
+ platform: Some("MacIntel".to_string()),
+ viewport_width: Some(1440),
+ viewport_height: Some(900),
+ device_scale_factor: Some(2.0),
+ },
+ )
+ .unwrap();
+
+ let presets = BrowserEnvironmentPresetDao::list(&conn, false).unwrap();
+ assert_eq!(presets.len(), 1);
+ assert_eq!(presets[0], inserted);
+ }
+
+ #[test]
+ fn should_archive_and_restore_preset() {
+ let conn = setup_db();
+ let inserted = BrowserEnvironmentPresetDao::upsert(
+ &conn,
+ &UpsertBrowserEnvironmentPresetInput {
+ id: None,
+ name: "美区桌面".to_string(),
+ description: None,
+ proxy_server: None,
+ timezone_id: None,
+ locale: None,
+ accept_language: None,
+ geolocation_lat: None,
+ geolocation_lng: None,
+ geolocation_accuracy_m: None,
+ user_agent: None,
+ platform: None,
+ viewport_width: None,
+ viewport_height: None,
+ device_scale_factor: None,
+ },
+ )
+ .unwrap();
+
+ assert!(BrowserEnvironmentPresetDao::archive(&conn, &inserted.id).unwrap());
+ assert!(BrowserEnvironmentPresetDao::list(&conn, false)
+ .unwrap()
+ .is_empty());
+
+ let archived = BrowserEnvironmentPresetDao::get_by_id(&conn, &inserted.id)
+ .unwrap()
+ .unwrap();
+ assert!(archived.archived_at.is_some());
+
+ assert!(BrowserEnvironmentPresetDao::restore(&conn, &inserted.id).unwrap());
+ let restored = BrowserEnvironmentPresetDao::get_by_id(&conn, &inserted.id)
+ .unwrap()
+ .unwrap();
+ assert!(restored.archived_at.is_none());
+ }
+
+ #[test]
+ fn should_touch_last_used_timestamp() {
+ let conn = setup_db();
+ let inserted = BrowserEnvironmentPresetDao::upsert(
+ &conn,
+ &UpsertBrowserEnvironmentPresetInput {
+ id: None,
+ name: "美区桌面".to_string(),
+ description: None,
+ proxy_server: None,
+ timezone_id: None,
+ locale: None,
+ accept_language: None,
+ geolocation_lat: None,
+ geolocation_lng: None,
+ geolocation_accuracy_m: None,
+ user_agent: None,
+ platform: None,
+ viewport_width: None,
+ viewport_height: None,
+ device_scale_factor: None,
+ },
+ )
+ .unwrap();
+
+ assert!(BrowserEnvironmentPresetDao::touch_last_used(&conn, &inserted.id).unwrap());
+ let touched = BrowserEnvironmentPresetDao::get_by_id(&conn, &inserted.id)
+ .unwrap()
+ .unwrap();
+ assert!(touched.last_used_at.is_some());
+ }
+}
diff --git a/src-tauri/crates/core/src/database/dao/browser_profile.rs b/src-tauri/crates/core/src/database/dao/browser_profile.rs
new file mode 100644
index 000000000..c8d5df775
--- /dev/null
+++ b/src-tauri/crates/core/src/database/dao/browser_profile.rs
@@ -0,0 +1,434 @@
+use chrono::Utc;
+use rusqlite::{params, types::Type, Connection, OptionalExtension};
+use serde::{Deserialize, Serialize};
+use std::io;
+use uuid::Uuid;
+
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Default)]
+#[serde(rename_all = "snake_case")]
+pub enum BrowserProfileTransportKind {
+ #[default]
+ ManagedCdp,
+ ExistingSession,
+}
+
+impl BrowserProfileTransportKind {
+ fn as_str(self) -> &'static str {
+ match self {
+ Self::ManagedCdp => "managed_cdp",
+ Self::ExistingSession => "existing_session",
+ }
+ }
+
+ fn parse(value: String) -> Result {
+ match value.as_str() {
+ "managed_cdp" => Ok(Self::ManagedCdp),
+ "existing_session" => Ok(Self::ExistingSession),
+ _ => Err(rusqlite::Error::FromSqlConversionFailure(
+ 0,
+ Type::Text,
+ Box::new(io::Error::new(
+ io::ErrorKind::InvalidData,
+ format!("未知的浏览器资料传输模式: {value}"),
+ )),
+ )),
+ }
+ }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct BrowserProfileRecord {
+ pub id: String,
+ pub profile_key: String,
+ pub name: String,
+ pub description: Option,
+ pub site_scope: Option,
+ pub launch_url: Option,
+ pub transport_kind: BrowserProfileTransportKind,
+ pub profile_dir: String,
+ pub managed_profile_dir: Option,
+ pub created_at: String,
+ pub updated_at: String,
+ pub last_used_at: Option,
+ pub archived_at: Option,
+}
+
+#[derive(Debug, Clone)]
+pub struct UpsertBrowserProfileInput {
+ pub id: Option,
+ pub profile_key: String,
+ pub name: String,
+ pub description: Option,
+ pub site_scope: Option,
+ pub launch_url: Option,
+ pub transport_kind: BrowserProfileTransportKind,
+ pub profile_dir: String,
+ pub managed_profile_dir: Option,
+}
+
+pub struct BrowserProfileDao;
+
+impl BrowserProfileDao {
+ pub fn get_by_id(
+ conn: &Connection,
+ id: &str,
+ ) -> Result, rusqlite::Error> {
+ conn.query_row(
+ "SELECT
+ id,
+ profile_key,
+ name,
+ description,
+ site_scope,
+ launch_url,
+ transport_kind,
+ profile_dir,
+ managed_profile_dir,
+ created_at,
+ updated_at,
+ last_used_at,
+ archived_at
+ FROM browser_profiles
+ WHERE id = ?1",
+ [id],
+ map_browser_profile_row,
+ )
+ .optional()
+ }
+
+ pub fn get_by_profile_key(
+ conn: &Connection,
+ profile_key: &str,
+ ) -> Result, rusqlite::Error> {
+ conn.query_row(
+ "SELECT
+ id,
+ profile_key,
+ name,
+ description,
+ site_scope,
+ launch_url,
+ transport_kind,
+ profile_dir,
+ managed_profile_dir,
+ created_at,
+ updated_at,
+ last_used_at,
+ archived_at
+ FROM browser_profiles
+ WHERE profile_key = ?1",
+ [profile_key],
+ map_browser_profile_row,
+ )
+ .optional()
+ }
+
+ pub fn list(
+ conn: &Connection,
+ include_archived: bool,
+ ) -> Result, rusqlite::Error> {
+ let sql = if include_archived {
+ "SELECT
+ id,
+ profile_key,
+ name,
+ description,
+ site_scope,
+ launch_url,
+ transport_kind,
+ profile_dir,
+ managed_profile_dir,
+ created_at,
+ updated_at,
+ last_used_at,
+ archived_at
+ FROM browser_profiles
+ ORDER BY
+ CASE WHEN archived_at IS NULL THEN 0 ELSE 1 END,
+ COALESCE(last_used_at, updated_at) DESC,
+ name COLLATE NOCASE ASC"
+ } else {
+ "SELECT
+ id,
+ profile_key,
+ name,
+ description,
+ site_scope,
+ launch_url,
+ transport_kind,
+ profile_dir,
+ managed_profile_dir,
+ created_at,
+ updated_at,
+ last_used_at,
+ archived_at
+ FROM browser_profiles
+ WHERE archived_at IS NULL
+ ORDER BY
+ COALESCE(last_used_at, updated_at) DESC,
+ name COLLATE NOCASE ASC"
+ };
+ let mut stmt = conn.prepare(sql)?;
+ let rows = stmt.query_map([], map_browser_profile_row)?;
+ rows.collect()
+ }
+
+ pub fn upsert(
+ conn: &Connection,
+ input: &UpsertBrowserProfileInput,
+ ) -> Result {
+ let now = Utc::now().to_rfc3339();
+ let id = input
+ .id
+ .clone()
+ .unwrap_or_else(|| Uuid::new_v4().to_string());
+ let created_at = Self::get_by_id(conn, &id)?
+ .map(|existing| existing.created_at)
+ .unwrap_or_else(|| now.clone());
+
+ conn.execute(
+ "INSERT INTO browser_profiles (
+ id,
+ profile_key,
+ name,
+ description,
+ site_scope,
+ launch_url,
+ transport_kind,
+ profile_dir,
+ managed_profile_dir,
+ created_at,
+ updated_at,
+ last_used_at,
+ archived_at
+ ) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, NULL, NULL)
+ ON CONFLICT(id) DO UPDATE SET
+ name = excluded.name,
+ description = excluded.description,
+ site_scope = excluded.site_scope,
+ launch_url = excluded.launch_url,
+ transport_kind = excluded.transport_kind,
+ profile_dir = excluded.profile_dir,
+ managed_profile_dir = excluded.managed_profile_dir,
+ updated_at = excluded.updated_at",
+ params![
+ id,
+ input.profile_key,
+ input.name,
+ input.description,
+ input.site_scope,
+ input.launch_url,
+ input.transport_kind.as_str(),
+ input.profile_dir,
+ input.managed_profile_dir,
+ created_at,
+ now,
+ ],
+ )?;
+
+ Self::get_by_id(conn, &id)?.ok_or(rusqlite::Error::QueryReturnedNoRows)
+ }
+
+ pub fn archive(conn: &Connection, id: &str) -> Result {
+ let affected = conn.execute(
+ "UPDATE browser_profiles
+ SET archived_at = ?2, updated_at = ?2
+ WHERE id = ?1 AND archived_at IS NULL",
+ params![id, Utc::now().to_rfc3339()],
+ )?;
+ Ok(affected > 0)
+ }
+
+ pub fn restore(conn: &Connection, id: &str) -> Result {
+ let affected = conn.execute(
+ "UPDATE browser_profiles
+ SET archived_at = NULL, updated_at = ?2
+ WHERE id = ?1 AND archived_at IS NOT NULL",
+ params![id, Utc::now().to_rfc3339()],
+ )?;
+ Ok(affected > 0)
+ }
+
+ pub fn touch_last_used(conn: &Connection, id: &str) -> Result {
+ let now = Utc::now().to_rfc3339();
+ let affected = conn.execute(
+ "UPDATE browser_profiles
+ SET last_used_at = ?2, updated_at = ?2
+ WHERE id = ?1",
+ params![id, now],
+ )?;
+ Ok(affected > 0)
+ }
+}
+
+fn map_browser_profile_row(
+ row: &rusqlite::Row<'_>,
+) -> Result {
+ let transport_kind = BrowserProfileTransportKind::parse(row.get(6)?)?;
+ Ok(BrowserProfileRecord {
+ id: row.get(0)?,
+ profile_key: row.get(1)?,
+ name: row.get(2)?,
+ description: row.get(3)?,
+ site_scope: row.get(4)?,
+ launch_url: row.get(5)?,
+ transport_kind,
+ profile_dir: row.get(7)?,
+ managed_profile_dir: row.get(8)?,
+ created_at: row.get(9)?,
+ updated_at: row.get(10)?,
+ last_used_at: row.get(11)?,
+ archived_at: row.get(12)?,
+ })
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ fn setup_db() -> Connection {
+ let conn = Connection::open_in_memory().unwrap();
+ conn.execute(
+ "CREATE TABLE browser_profiles (
+ id TEXT PRIMARY KEY,
+ profile_key TEXT NOT NULL UNIQUE,
+ name TEXT NOT NULL,
+ description TEXT,
+ site_scope TEXT,
+ launch_url TEXT,
+ transport_kind TEXT NOT NULL DEFAULT 'managed_cdp',
+ profile_dir TEXT NOT NULL,
+ managed_profile_dir TEXT,
+ created_at TEXT NOT NULL,
+ updated_at TEXT NOT NULL,
+ last_used_at TEXT,
+ archived_at TEXT
+ )",
+ [],
+ )
+ .unwrap();
+ conn
+ }
+
+ #[test]
+ fn should_insert_and_list_active_profiles() {
+ let conn = setup_db();
+ let inserted = BrowserProfileDao::upsert(
+ &conn,
+ &UpsertBrowserProfileInput {
+ id: None,
+ profile_key: "shop_us".to_string(),
+ name: "美区店铺".to_string(),
+ description: Some("主账号".to_string()),
+ site_scope: Some("shop.example.com".to_string()),
+ launch_url: Some("https://shop.example.com".to_string()),
+ transport_kind: BrowserProfileTransportKind::ManagedCdp,
+ profile_dir: "/tmp/browser/shop_us".to_string(),
+ managed_profile_dir: Some("/tmp/browser/shop_us".to_string()),
+ },
+ )
+ .unwrap();
+
+ let profiles = BrowserProfileDao::list(&conn, false).unwrap();
+ assert_eq!(profiles.len(), 1);
+ assert_eq!(profiles[0], inserted);
+ assert_eq!(
+ profiles[0].transport_kind,
+ BrowserProfileTransportKind::ManagedCdp
+ );
+ assert_eq!(
+ profiles[0].managed_profile_dir.as_deref(),
+ Some("/tmp/browser/shop_us")
+ );
+ }
+
+ #[test]
+ fn should_archive_and_restore_profile() {
+ let conn = setup_db();
+ let inserted = BrowserProfileDao::upsert(
+ &conn,
+ &UpsertBrowserProfileInput {
+ id: None,
+ profile_key: "shop_us".to_string(),
+ name: "美区店铺".to_string(),
+ description: None,
+ site_scope: None,
+ launch_url: None,
+ transport_kind: BrowserProfileTransportKind::ManagedCdp,
+ profile_dir: "/tmp/browser/shop_us".to_string(),
+ managed_profile_dir: Some("/tmp/browser/shop_us".to_string()),
+ },
+ )
+ .unwrap();
+
+ assert!(BrowserProfileDao::archive(&conn, &inserted.id).unwrap());
+ assert!(BrowserProfileDao::list(&conn, false).unwrap().is_empty());
+
+ let archived = BrowserProfileDao::get_by_id(&conn, &inserted.id)
+ .unwrap()
+ .unwrap();
+ assert!(archived.archived_at.is_some());
+
+ assert!(BrowserProfileDao::restore(&conn, &inserted.id).unwrap());
+ let restored = BrowserProfileDao::get_by_id(&conn, &inserted.id)
+ .unwrap()
+ .unwrap();
+ assert!(restored.archived_at.is_none());
+ }
+
+ #[test]
+ fn should_touch_last_used_timestamp() {
+ let conn = setup_db();
+ let inserted = BrowserProfileDao::upsert(
+ &conn,
+ &UpsertBrowserProfileInput {
+ id: None,
+ profile_key: "shop_us".to_string(),
+ name: "美区店铺".to_string(),
+ description: None,
+ site_scope: None,
+ launch_url: None,
+ transport_kind: BrowserProfileTransportKind::ManagedCdp,
+ profile_dir: "/tmp/browser/shop_us".to_string(),
+ managed_profile_dir: Some("/tmp/browser/shop_us".to_string()),
+ },
+ )
+ .unwrap();
+
+ assert!(BrowserProfileDao::touch_last_used(&conn, &inserted.id).unwrap());
+ let touched = BrowserProfileDao::get_by_id(&conn, &inserted.id)
+ .unwrap()
+ .unwrap();
+ assert!(touched.last_used_at.is_some());
+ }
+
+ #[test]
+ fn should_round_trip_existing_session_transport() {
+ let conn = setup_db();
+ let inserted = BrowserProfileDao::upsert(
+ &conn,
+ &UpsertBrowserProfileInput {
+ id: None,
+ profile_key: "weibo_attach".to_string(),
+ name: "微博附着".to_string(),
+ description: Some("附着当前 Chrome".to_string()),
+ site_scope: Some("weibo.com".to_string()),
+ launch_url: Some("https://weibo.com".to_string()),
+ transport_kind: BrowserProfileTransportKind::ExistingSession,
+ profile_dir: String::new(),
+ managed_profile_dir: None,
+ },
+ )
+ .unwrap();
+
+ let fetched = BrowserProfileDao::get_by_id(&conn, &inserted.id)
+ .unwrap()
+ .unwrap();
+ assert_eq!(
+ fetched.transport_kind,
+ BrowserProfileTransportKind::ExistingSession
+ );
+ assert_eq!(fetched.profile_dir, "");
+ assert_eq!(fetched.managed_profile_dir, None);
+ }
+}
diff --git a/src-tauri/crates/core/src/database/dao/heartbeat.rs b/src-tauri/crates/core/src/database/dao/heartbeat.rs
deleted file mode 100644
index 6b9cd8f2a..000000000
--- a/src-tauri/crates/core/src/database/dao/heartbeat.rs
+++ /dev/null
@@ -1,137 +0,0 @@
-//! 心跳任务执行记录数据访问对象
-
-use rusqlite::{params, Connection};
-use serde::{Deserialize, Serialize};
-
-/// 心跳任务执行记录
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct HeartbeatExecution {
- pub id: i64,
- pub task_description: String,
- pub priority: Option,
- pub execution_mode: String,
- pub status: String,
- pub started_at: String,
- pub completed_at: Option,
- pub duration_ms: Option,
- pub output: Option,
- pub retry_count: u32,
- pub metadata: Option,
-}
-
-pub struct HeartbeatDao;
-
-impl HeartbeatDao {
- /// 创建执行记录，返回新记录 ID
- pub fn create_execution(
- conn: &Connection,
- exec: &HeartbeatExecution,
- ) -> Result {
- conn.execute(
- "INSERT INTO heartbeat_executions (task_description, priority, execution_mode, status, started_at, completed_at, duration_ms, output, retry_count, metadata)
- VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10)",
- params![
- exec.task_description,
- exec.priority,
- exec.execution_mode,
- exec.status,
- exec.started_at,
- exec.completed_at,
- exec.duration_ms,
- exec.output,
- exec.retry_count,
- exec.metadata,
- ],
- )?;
- Ok(conn.last_insert_rowid())
- }
-
- /// 更新执行记录状态和结果
- pub fn update_execution(
- conn: &Connection,
- id: i64,
- status: &str,
- output: Option<&str>,
- completed_at: &str,
- duration_ms: i64,
- ) -> Result<(), rusqlite::Error> {
- conn.execute(
- "UPDATE heartbeat_executions SET status = ?1, output = ?2, completed_at = ?3, duration_ms = ?4 WHERE id = ?5",
- params![status, output, completed_at, duration_ms, id],
- )?;
- Ok(())
- }
-
- /// 获取最近的执行记录
- pub fn get_recent_executions(
- conn: &Connection,
- limit: usize,
- ) -> Result, rusqlite::Error> {
- let mut stmt = conn.prepare(
- "SELECT id, task_description, priority, execution_mode, status, started_at, completed_at, duration_ms, output, retry_count, metadata
- FROM heartbeat_executions ORDER BY id DESC LIMIT ?1",
- )?;
-
- let rows = stmt.query_map(params![limit as i64], |row| {
- Ok(HeartbeatExecution {
- id: row.get(0)?,
- task_description: row.get(1)?,
- priority: row.get::<_, Option>(2)?,
- execution_mode: row.get(3)?,
- status: row.get(4)?,
- started_at: row.get(5)?,
- completed_at: row.get(6)?,
- duration_ms: row.get(7)?,
- output: row.get(8)?,
- retry_count: row.get::<_, u32>(9)?,
- metadata: row.get(10)?,
- })
- })?;
-
- rows.collect()
- }
-
- /// 根据 ID 获取执行记录
- pub fn get_execution_by_id(
- conn: &Connection,
- id: i64,
- ) -> Result, rusqlite::Error> {
- let mut stmt = conn.prepare(
- "SELECT id, task_description, priority, execution_mode, status, started_at, completed_at, duration_ms, output, retry_count, metadata
- FROM heartbeat_executions WHERE id = ?1",
- )?;
-
- let mut rows = stmt.query_map(params![id], |row| {
- Ok(HeartbeatExecution {
- id: row.get(0)?,
- task_description: row.get(1)?,
- priority: row.get::<_, Option>(2)?,
- execution_mode: row.get(3)?,
- status: row.get(4)?,
- started_at: row.get(5)?,
- completed_at: row.get(6)?,
- duration_ms: row.get(7)?,
- output: row.get(8)?,
- retry_count: row.get::<_, u32>(9)?,
- metadata: row.get(10)?,
- })
- })?;
-
- match rows.next() {
- Some(Ok(exec)) => Ok(Some(exec)),
- Some(Err(e)) => Err(e),
- None => Ok(None),
- }
- }
-
- /// 删除指定日期之前的旧记录
- pub fn delete_old_executions(
- conn: &Connection,
- before: &str,
- ) -> Result {
- conn.execute(
- "DELETE FROM heartbeat_executions WHERE started_at < ?1",
- params![before],
- )
- }
-}
diff --git a/src-tauri/crates/core/src/database/dao/mod.rs b/src-tauri/crates/core/src/database/dao/mod.rs
index 10081c157..759e2c22d 100644
--- a/src-tauri/crates/core/src/database/dao/mod.rs
+++ b/src-tauri/crates/core/src/database/dao/mod.rs
@@ -4,9 +4,11 @@ pub mod agent_run;
pub mod agent_runtime_queue;
pub mod agent_timeline;
pub mod api_key_provider;
+pub mod automation_job;
pub mod brand_persona_dao;
+pub mod browser_environment_preset;
+pub mod browser_profile;
pub mod chat;
-pub mod heartbeat;
pub mod installed_plugins;
pub mod material_dao;
pub mod mcp;
diff --git a/src-tauri/crates/core/src/database/schema.rs b/src-tauri/crates/core/src/database/schema.rs
index 2fa76aff9..3a382bcb6 100644
--- a/src-tauri/crates/core/src/database/schema.rs
+++ b/src-tauri/crates/core/src/database/schema.rs
@@ -649,6 +649,95 @@ pub fn create_tables(conn: &Connection) -> Result<(), rusqlite::Error> {
[],
)?;
+ // ============================================================================
+ // Browser Profile 相关表
+ // ============================================================================
+
+ conn.execute(
+ "CREATE TABLE IF NOT EXISTS browser_profiles (
+ id TEXT PRIMARY KEY,
+ profile_key TEXT NOT NULL UNIQUE,
+ name TEXT NOT NULL,
+ description TEXT,
+ site_scope TEXT,
+ launch_url TEXT,
+ transport_kind TEXT NOT NULL DEFAULT 'managed_cdp',
+ profile_dir TEXT NOT NULL,
+ managed_profile_dir TEXT,
+ created_at TEXT NOT NULL,
+ updated_at TEXT NOT NULL,
+ last_used_at TEXT,
+ archived_at TEXT
+ )",
+ [],
+ )?;
+
+ let _ = conn.execute(
+ "ALTER TABLE browser_profiles ADD COLUMN transport_kind TEXT NOT NULL DEFAULT 'managed_cdp'",
+ [],
+ );
+ let _ = conn.execute(
+ "ALTER TABLE browser_profiles ADD COLUMN managed_profile_dir TEXT",
+ [],
+ );
+ let _ = conn.execute(
+ "UPDATE browser_profiles
+ SET managed_profile_dir = profile_dir
+ WHERE transport_kind = 'managed_cdp'
+ AND (managed_profile_dir IS NULL OR managed_profile_dir = '')",
+ [],
+ );
+
+ conn.execute(
+ "CREATE INDEX IF NOT EXISTS idx_browser_profiles_key ON browser_profiles(profile_key)",
+ [],
+ )?;
+
+ conn.execute(
+ "CREATE INDEX IF NOT EXISTS idx_browser_profiles_archived ON browser_profiles(archived_at)",
+ [],
+ )?;
+
+ conn.execute(
+ "CREATE INDEX IF NOT EXISTS idx_browser_profiles_updated ON browser_profiles(updated_at)",
+ [],
+ )?;
+
+ conn.execute(
+ "CREATE TABLE IF NOT EXISTS browser_environment_presets (
+ id TEXT PRIMARY KEY,
+ name TEXT NOT NULL,
+ description TEXT,
+ proxy_server TEXT,
+ timezone_id TEXT,
+ locale TEXT,
+ accept_language TEXT,
+ geolocation_lat REAL,
+ geolocation_lng REAL,
+ geolocation_accuracy_m REAL,
+ user_agent TEXT,
+ platform TEXT,
+ viewport_width INTEGER,
+ viewport_height INTEGER,
+ device_scale_factor REAL,
+ created_at TEXT NOT NULL,
+ updated_at TEXT NOT NULL,
+ last_used_at TEXT,
+ archived_at TEXT
+ )",
+ [],
+ )?;
+
+ conn.execute(
+ "CREATE INDEX IF NOT EXISTS idx_browser_environment_presets_archived ON browser_environment_presets(archived_at)",
+ [],
+ )?;
+
+ conn.execute(
+ "CREATE INDEX IF NOT EXISTS idx_browser_environment_presets_updated ON browser_environment_presets(updated_at)",
+ [],
+ )?;
+
// Migration: 添加项目管理相关字段到 workspaces 表
let _ = conn.execute("ALTER TABLE workspaces ADD COLUMN icon TEXT", []);
let _ = conn.execute("ALTER TABLE workspaces ADD COLUMN color TEXT", []);
@@ -1267,29 +1356,49 @@ pub fn create_tables(conn: &Connection) -> Result<(), rusqlite::Error> {
[],
)?;
- // 心跳任务执行记录表
+ // 自动化任务表
conn.execute(
- "CREATE TABLE IF NOT EXISTS heartbeat_executions (
- id INTEGER PRIMARY KEY AUTOINCREMENT,
- task_description TEXT NOT NULL,
- priority INTEGER,
+ "CREATE TABLE IF NOT EXISTS automation_jobs (
+ id TEXT PRIMARY KEY,
+ name TEXT NOT NULL,
+ description TEXT,
+ enabled INTEGER NOT NULL DEFAULT 1,
+ workspace_id TEXT NOT NULL,
execution_mode TEXT NOT NULL,
- status TEXT NOT NULL,
- started_at TEXT NOT NULL,
- completed_at TEXT,
- duration_ms INTEGER,
- output TEXT,
- retry_count INTEGER NOT NULL DEFAULT 0,
- metadata TEXT
+ schedule_json TEXT NOT NULL,
+ payload_json TEXT NOT NULL,
+ delivery_json TEXT NOT NULL,
+ timeout_secs INTEGER,
+ max_retries INTEGER NOT NULL DEFAULT 3,
+ next_run_at TEXT,
+ last_status TEXT,
+ last_error TEXT,
+ last_run_at TEXT,
+ last_finished_at TEXT,
+ running_started_at TEXT,
+ consecutive_failures INTEGER NOT NULL DEFAULT 0,
+ last_retry_count INTEGER NOT NULL DEFAULT 0,
+ auto_disabled_until TEXT,
+ created_at TEXT NOT NULL,
+ updated_at TEXT NOT NULL,
+ last_delivery_json TEXT
)",
[],
)?;
+ let _ = conn.execute(
+ "ALTER TABLE automation_jobs ADD COLUMN last_delivery_json TEXT",
+ [],
+ );
conn.execute(
- "CREATE INDEX IF NOT EXISTS idx_heartbeat_executions_started_at ON heartbeat_executions(started_at)",
+ "CREATE INDEX IF NOT EXISTS idx_automation_jobs_next_run_at ON automation_jobs(next_run_at)",
[],
)?;
conn.execute(
- "CREATE INDEX IF NOT EXISTS idx_heartbeat_executions_status ON heartbeat_executions(status)",
+ "CREATE INDEX IF NOT EXISTS idx_automation_jobs_workspace_id ON automation_jobs(workspace_id)",
+ [],
+ )?;
+ conn.execute(
+ "CREATE INDEX IF NOT EXISTS idx_automation_jobs_enabled_updated_at ON automation_jobs(enabled, updated_at DESC)",
[],
)?;
@@ -1328,6 +1437,76 @@ pub fn create_tables(conn: &Connection) -> Result<(), rusqlite::Error> {
Ok(())
}
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn should_upgrade_legacy_browser_profile_table_with_transport_columns() {
+ let conn = Connection::open_in_memory().unwrap();
+ conn.execute(
+ "CREATE TABLE browser_profiles (
+ id TEXT PRIMARY KEY,
+ profile_key TEXT NOT NULL UNIQUE,
+ name TEXT NOT NULL,
+ description TEXT,
+ site_scope TEXT,
+ launch_url TEXT,
+ profile_dir TEXT NOT NULL,
+ created_at TEXT NOT NULL,
+ updated_at TEXT NOT NULL,
+ last_used_at TEXT,
+ archived_at TEXT
+ )",
+ [],
+ )
+ .unwrap();
+ conn.execute(
+ "INSERT INTO browser_profiles (
+ id, profile_key, name, description, site_scope, launch_url, profile_dir,
+ created_at, updated_at, last_used_at, archived_at
+ ) VALUES (?1, ?2, ?3, NULL, NULL, ?4, ?5, ?6, ?6, NULL, NULL)",
+ (
+ "profile-1",
+ "shop_us",
+ "美区资料",
+ "https://seller.example.com/",
+ "/tmp/proxycast/chrome_profiles/shop_us",
+ "2026-03-15T00:00:00Z",
+ ),
+ )
+ .unwrap();
+
+ create_tables(&conn).expect("应成功升级旧版 browser_profiles 表");
+
+ let mut columns = conn.prepare("PRAGMA table_info(browser_profiles)").unwrap();
+ let column_names = columns
+ .query_map([], |row| row.get::<_, String>(1))
+ .unwrap()
+ .collect::, _>>()
+ .unwrap();
+ assert!(column_names.iter().any(|name| name == "transport_kind"));
+ assert!(column_names
+ .iter()
+ .any(|name| name == "managed_profile_dir"));
+
+ let upgraded = conn
+ .query_row(
+ "SELECT transport_kind, managed_profile_dir
+ FROM browser_profiles
+ WHERE id = ?1",
+ ["profile-1"],
+ |row| Ok((row.get::<_, String>(0)?, row.get::<_, Option>(1)?)),
+ )
+ .unwrap();
+ assert_eq!(upgraded.0, "managed_cdp");
+ assert_eq!(
+ upgraded.1.as_deref(),
+ Some("/tmp/proxycast/chrome_profiles/shop_us")
+ );
+ }
+}
+
/// 迁移：添加proxy_url列到provider_pool_credentials表
/// 使用重建表结构的方式确保数据完整性
fn migrate_add_proxy_url_column(conn: &Connection) -> Result<(), rusqlite::Error> {
diff --git a/src-tauri/crates/core/src/plugin/types.rs b/src-tauri/crates/core/src/plugin/types.rs
index aac33afc3..d2cf32af2 100644
--- a/src-tauri/crates/core/src/plugin/types.rs
+++ b/src-tauri/crates/core/src/plugin/types.rs
@@ -445,6 +445,8 @@ pub struct PluginInfo {
pub path: PathBuf,
/// 支持的钩子
pub hooks: Vec,
+ /// 最低 ProxyCast 版本要求
+ pub min_proxycast_version: Option,
/// 配置 schema
pub config_schema: Option,
/// 当前配置
@@ -528,6 +530,7 @@ impl PluginInstance {
status: self.state.status,
path: self.path.clone(),
hooks: manifest.hooks.clone(),
+ min_proxycast_version: manifest.min_proxycast_version.clone(),
config_schema: manifest.config_schema.clone(),
config: self.config.clone(),
state: self.state.clone(),
diff --git a/src-tauri/crates/scheduler/src/batch.rs b/src-tauri/crates/scheduler/src/batch.rs
deleted file mode 100644
index 2543ff63d..000000000
--- a/src-tauri/crates/scheduler/src/batch.rs
+++ /dev/null
@@ -1,392 +0,0 @@
-//! 批量任务定义
-//!
-//! 定义批量任务相关的数据结构和状态
-
-use serde::{Deserialize, Serialize};
-use std::collections::HashMap;
-use uuid::Uuid;
-
-/// 批量任务选项
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct BatchOptions {
- /// 并发数量 (默认为 3)
- #[serde(default = "default_concurrency")]
- pub concurrency: usize,
-
- /// 失败后是否继续 (默认为 true)
- #[serde(default = "default_continue_on_error")]
- pub continue_on_error: bool,
-
- /// 重试次数 (默认为 0)
- #[serde(default)]
- pub retry_count: usize,
-
- /// 任务超时时间(秒) (默认为 120)
- #[serde(default = "default_timeout")]
- pub timeout_seconds: u64,
-}
-
-fn default_concurrency() -> usize {
- 3
-}
-
-fn default_continue_on_error() -> bool {
- true
-}
-
-fn default_timeout() -> u64 {
- 120
-}
-
-impl Default for BatchOptions {
- fn default() -> Self {
- Self {
- concurrency: default_concurrency(),
- continue_on_error: default_continue_on_error(),
- retry_count: 0,
- timeout_seconds: default_timeout(),
- }
- }
-}
-
-/// 单个任务定义
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct TaskDefinition {
- /// 任务 ID (可选,如果不提供则自动生成)
- #[serde(skip_serializing_if = "Option::is_none")]
- pub id: Option,
-
- /// 模板变量
- pub variables: HashMap,
-
- /// 任务元数据 (用于追踪和识别)
- #[serde(default)]
- pub metadata: HashMap,
-}
-
-/// 单个任务结果
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct TaskResult {
- /// 任务 ID
- pub task_id: Uuid,
-
- /// 任务状态
- pub status: TaskStatus,
-
- /// 响应内容 (如果成功)
- #[serde(skip_serializing_if = "Option::is_none")]
- pub content: Option,
-
- /// 错误信息 (如果失败)
- #[serde(skip_serializing_if = "Option::is_none")]
- pub error: Option,
-
- /// 使用 token 数
- #[serde(default)]
- pub usage: TokenUsage,
-
- /// 开始时间
- pub started_at: chrono::DateTime,
-
- /// 完成时间
- pub completed_at: Option>,
-}
-
-/// 任务状态
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "lowercase")]
-pub enum TaskStatus {
- /// 等待中
- Pending,
-
- /// 运行中
- Running,
-
- /// 已完成
- Completed,
-
- /// 失败
- Failed,
-
- /// 已取消
- Cancelled,
-}
-
-/// Token 使用统计
-#[derive(Debug, Clone, Copy, Default, Serialize, Deserialize)]
-pub struct TokenUsage {
- /// 输入 token 数
- #[serde(default)]
- pub prompt_tokens: u32,
-
- /// 输出 token 数
- #[serde(default)]
- pub completion_tokens: u32,
-
- /// 总 token 数
- #[serde(default)]
- pub total_tokens: u32,
-}
-
-impl TokenUsage {
- pub fn new(prompt_tokens: u32, completion_tokens: u32) -> Self {
- Self {
- prompt_tokens,
- completion_tokens,
- total_tokens: prompt_tokens + completion_tokens,
- }
- }
-}
-
-/// 批量任务
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct BatchTask {
- /// 批量任务 ID
- pub id: Uuid,
-
- /// 批量任务名称
- pub name: String,
-
- /// 任务模板 ID
- pub template_id: Uuid,
-
- /// 任务列表
- pub tasks: Vec,
-
- /// 批量任务选项
- #[serde(default)]
- pub options: BatchOptions,
-
- /// 批量任务状态
- pub status: BatchTaskStatus,
-
- /// 任务结果
- #[serde(default)]
- pub results: Vec,
-
- /// 创建时间
- pub created_at: chrono::DateTime,
-
- /// 开始时间
- #[serde(skip_serializing_if = "Option::is_none")]
- pub started_at: Option>,
-
- /// 完成时间
- #[serde(skip_serializing_if = "Option::is_none")]
- pub completed_at: Option>,
-}
-
-/// 批量任务状态
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "lowercase")]
-pub enum BatchTaskStatus {
- /// 等待中
- Pending,
-
- /// 运行中
- Running,
-
- /// 已完成
- Completed,
-
- /// 部分完成 (部分任务失败)
- PartiallyCompleted,
-
- /// 失败 (所有任务失败)
- Failed,
-
- /// 已取消
- Cancelled,
-}
-
-impl BatchTask {
- /// 创建新的批量任务
- pub fn new(
- name: String,
- template_id: Uuid,
- tasks: Vec,
- options: BatchOptions,
- ) -> Self {
- let now = chrono::Utc::now();
- Self {
- id: Uuid::new_v4(),
- name,
- template_id,
- tasks,
- options,
- status: BatchTaskStatus::Pending,
- results: Vec::new(),
- created_at: now,
- started_at: None,
- completed_at: None,
- }
- }
-
- /// 获取进度信息
- pub fn get_progress(&self) -> (usize, usize, usize) {
- // (总数, 成功数, 失败数)
- let total = self.tasks.len();
- let completed = self
- .results
- .iter()
- .filter(|r| r.status == TaskStatus::Completed)
- .count();
- let failed = self
- .results
- .iter()
- .filter(|r| r.status == TaskStatus::Failed)
- .count();
- (total, completed, failed)
- }
-
- /// 获取统计信息
- pub fn get_statistics(&self) -> BatchTaskStatistics {
- let (total, completed, failed) = self.get_progress();
- let running = self
- .results
- .iter()
- .filter(|r| r.status == TaskStatus::Running)
- .count();
- let total_tokens: TokenUsage =
- self.results
- .iter()
- .fold(TokenUsage::default(), |mut acc, r| {
- acc.prompt_tokens += r.usage.prompt_tokens;
- acc.completion_tokens += r.usage.completion_tokens;
- acc.total_tokens += r.usage.total_tokens;
- acc
- });
-
- BatchTaskStatistics {
- total_tasks: total,
- completed_tasks: completed,
- failed_tasks: failed,
- running_tasks: running,
- pending_tasks: total - completed - failed - running,
- total_tokens,
- }
- }
-}
-
-/// 批量任务统计信息
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct BatchTaskStatistics {
- /// 总任务数
- pub total_tasks: usize,
-
- /// 已完成任务数
- pub completed_tasks: usize,
-
- /// 失败任务数
- pub failed_tasks: usize,
-
- /// 运行中任务数
- pub running_tasks: usize,
-
- /// 等待中任务数
- pub pending_tasks: usize,
-
- /// 总 token 使用量
- pub total_tokens: TokenUsage,
-}
-
-#[cfg(test)]
-mod tests {
- use super::*;
-
- #[test]
- fn test_batch_options_default() {
- let options = BatchOptions::default();
- assert_eq!(options.concurrency, 3);
- assert_eq!(options.continue_on_error, true);
- assert_eq!(options.retry_count, 0);
- assert_eq!(options.timeout_seconds, 120);
- }
-
- #[test]
- fn test_batch_task_creation() {
- let tasks = vec![
- TaskDefinition {
- id: None,
- variables: {
- let mut map = HashMap::new();
- map.insert("content".to_string(), "测试1".to_string());
- map
- },
- metadata: HashMap::new(),
- },
- TaskDefinition {
- id: None,
- variables: {
- let mut map = HashMap::new();
- map.insert("content".to_string(), "测试2".to_string());
- map
- },
- metadata: HashMap::new(),
- },
- ];
-
- let batch_task = BatchTask::new(
- "测试批量任务".to_string(),
- Uuid::new_v4(),
- tasks,
- BatchOptions::default(),
- );
-
- assert_eq!(batch_task.name, "测试批量任务");
- assert_eq!(batch_task.tasks.len(), 2);
- assert_eq!(batch_task.status, BatchTaskStatus::Pending);
- }
-
- #[test]
- fn test_get_progress() {
- let mut batch_task = BatchTask::new(
- "测试".to_string(),
- Uuid::new_v4(),
- vec![
- TaskDefinition {
- id: Some(Uuid::new_v4()),
- variables: HashMap::new(),
- metadata: HashMap::new(),
- },
- TaskDefinition {
- id: Some(Uuid::new_v4()),
- variables: HashMap::new(),
- metadata: HashMap::new(),
- },
- TaskDefinition {
- id: Some(Uuid::new_v4()),
- variables: HashMap::new(),
- metadata: HashMap::new(),
- },
- ],
- BatchOptions::default(),
- );
-
- // 添加一些结果
- batch_task.results.push(TaskResult {
- task_id: batch_task.tasks[0].id.unwrap(),
- status: TaskStatus::Completed,
- content: Some("完成".to_string()),
- error: None,
- usage: TokenUsage::default(),
- started_at: chrono::Utc::now(),
- completed_at: Some(chrono::Utc::now()),
- });
-
- batch_task.results.push(TaskResult {
- task_id: batch_task.tasks[1].id.unwrap(),
- status: TaskStatus::Failed,
- content: None,
- error: Some("失败".to_string()),
- usage: TokenUsage::default(),
- started_at: chrono::Utc::now(),
- completed_at: Some(chrono::Utc::now()),
- });
-
- let (total, completed, failed) = batch_task.get_progress();
- assert_eq!(total, 3);
- assert_eq!(completed, 1);
- assert_eq!(failed, 1);
- }
-}
diff --git a/src-tauri/crates/scheduler/src/batch_dao.rs b/src-tauri/crates/scheduler/src/batch_dao.rs
deleted file mode 100644
index 003dbf035..000000000
--- a/src-tauri/crates/scheduler/src/batch_dao.rs
+++ /dev/null
@@ -1,526 +0,0 @@
-//! 批量任务数据访问对象 (DAO)
-//!
-//! 提供批量任务和模板的数据库操作
-
-use super::batch::{BatchTask, BatchTaskStatus};
-use super::template::TaskTemplate;
-use anyhow::{Context, Result};
-use proxycast_core::database::{lock_db, DbConnection};
-use rusqlite::{params, OptionalExtension};
-use uuid::Uuid;
-
-/// 批量任务 DAO
-pub struct BatchTaskDao;
-
-impl BatchTaskDao {
- /// 初始化数据库表
- pub fn init_tables(db: &DbConnection) -> Result<()> {
- let conn = lock_db(db).map_err(|e| anyhow::anyhow!(e))?;
-
- // 创建批量任务表
- conn.execute(
- "CREATE TABLE IF NOT EXISTS batch_tasks (
- id TEXT PRIMARY KEY,
- name TEXT NOT NULL,
- template_id TEXT NOT NULL,
- status TEXT NOT NULL,
- options_json TEXT NOT NULL,
- tasks_json TEXT NOT NULL,
- results_json TEXT,
- created_at TEXT NOT NULL,
- started_at TEXT,
- completed_at TEXT
- )",
- [],
- )
- .context("创建 batch_tasks 表失败")?;
-
- // 创建模板表
- conn.execute(
- "CREATE TABLE IF NOT EXISTS batch_templates (
- id TEXT PRIMARY KEY,
- name TEXT NOT NULL,
- description TEXT,
- model TEXT NOT NULL,
- system_prompt TEXT,
- user_message_template TEXT NOT NULL,
- temperature REAL,
- max_tokens INTEGER,
- created_at TEXT NOT NULL,
- updated_at TEXT NOT NULL
- )",
- [],
- )
- .context("创建 batch_templates 表失败")?;
-
- // 创建索引
- conn.execute(
- "CREATE INDEX IF NOT EXISTS idx_batch_tasks_status ON batch_tasks(status)",
- [],
- )?;
-
- conn.execute(
- "CREATE INDEX IF NOT EXISTS idx_batch_tasks_created_at ON batch_tasks(created_at DESC)",
- [],
- )?;
-
- Ok(())
- }
-
- /// 保存批量任务
- pub fn save(db: &DbConnection, batch_task: &BatchTask) -> Result<()> {
- let conn = lock_db(db).map_err(|e| anyhow::anyhow!(e))?;
-
- let options_json = serde_json::to_string(&batch_task.options)?;
- let tasks_json = serde_json::to_string(&batch_task.tasks)?;
- let results_json = if batch_task.results.is_empty() {
- None
- } else {
- Some(serde_json::to_string(&batch_task.results)?)
- };
-
- conn.execute(
- "INSERT OR REPLACE INTO batch_tasks
- (id, name, template_id, status, options_json, tasks_json, results_json,
- created_at, started_at, completed_at)
- VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10)",
- params![
- batch_task.id.to_string(),
- batch_task.name,
- batch_task.template_id.to_string(),
- serde_json::to_string(&batch_task.status)?,
- options_json,
- tasks_json,
- results_json,
- batch_task.created_at.to_rfc3339(),
- batch_task.started_at.map(|t| t.to_rfc3339()),
- batch_task.completed_at.map(|t| t.to_rfc3339()),
- ],
- )
- .context("保存批量任务失败")?;
-
- Ok(())
- }
-
- /// 根据 ID 查询批量任务
- pub fn get_by_id(db: &DbConnection, id: &Uuid) -> Result> {
- let conn = lock_db(db).map_err(|e| anyhow::anyhow!(e))?;
-
- let mut stmt = conn.prepare(
- "SELECT id, name, template_id, status, options_json, tasks_json, results_json,
- created_at, started_at, completed_at
- FROM batch_tasks WHERE id = ?1",
- )?;
-
- let result = stmt
- .query_row(params![id.to_string()], |row| {
- let id: String = row.get(0)?;
- let name: String = row.get(1)?;
- let template_id: String = row.get(2)?;
- let status_str: String = row.get(3)?;
- let options_json: String = row.get(4)?;
- let tasks_json: String = row.get(5)?;
- let results_json: Option = row.get(6)?;
- let created_at: String = row.get(7)?;
- let started_at: Option = row.get(8)?;
- let completed_at: Option = row.get(9)?;
-
- Ok((
- id,
- name,
- template_id,
- status_str,
- options_json,
- tasks_json,
- results_json,
- created_at,
- started_at,
- completed_at,
- ))
- })
- .optional()?;
-
- if let Some((
- id,
- name,
- template_id,
- status_str,
- options_json,
- tasks_json,
- results_json,
- created_at,
- started_at,
- completed_at,
- )) = result
- {
- let batch_task = BatchTask {
- id: Uuid::parse_str(&id)?,
- name,
- template_id: Uuid::parse_str(&template_id)?,
- status: serde_json::from_str(&status_str)?,
- options: serde_json::from_str(&options_json)?,
- tasks: serde_json::from_str(&tasks_json)?,
- results: results_json
- .as_deref()
- .map(|json| serde_json::from_str(json))
- .transpose()
- .unwrap_or_default()
- .unwrap_or_default(),
- created_at: chrono::DateTime::parse_from_rfc3339(&created_at)?.into(),
- started_at: started_at
- .as_deref()
- .map(|s| chrono::DateTime::parse_from_rfc3339(s).map(|dt| dt.into()))
- .transpose()?,
- completed_at: completed_at
- .as_deref()
- .map(|s| chrono::DateTime::parse_from_rfc3339(s).map(|dt| dt.into()))
- .transpose()?,
- };
-
- Ok(Some(batch_task))
- } else {
- Ok(None)
- }
- }
-
- /// 查询所有批量任务
- pub fn list_all(db: &DbConnection, limit: usize) -> Result> {
- let conn = lock_db(db).map_err(|e| anyhow::anyhow!(e))?;
-
- let mut stmt = conn.prepare(
- "SELECT id, name, template_id, status, options_json, tasks_json, results_json,
- created_at, started_at, completed_at
- FROM batch_tasks
- ORDER BY created_at DESC
- LIMIT ?1",
- )?;
-
- let rows = stmt.query_map(params![limit], |row| {
- let id: String = row.get(0)?;
- let name: String = row.get(1)?;
- let template_id: String = row.get(2)?;
- let status_str: String = row.get(3)?;
- let options_json: String = row.get(4)?;
- let tasks_json: String = row.get(5)?;
- let results_json: Option = row.get(6)?;
- let created_at: String = row.get(7)?;
- let started_at: Option = row.get(8)?;
- let completed_at: Option = row.get(9)?;
-
- Ok((
- id,
- name,
- template_id,
- status_str,
- options_json,
- tasks_json,
- results_json,
- created_at,
- started_at,
- completed_at,
- ))
- })?;
-
- let mut batch_tasks = Vec::new();
- for row in rows {
- let (
- id,
- name,
- template_id,
- status_str,
- options_json,
- tasks_json,
- results_json,
- created_at,
- started_at,
- completed_at,
- ) = row?;
-
- let batch_task = BatchTask {
- id: Uuid::parse_str(&id)?,
- name,
- template_id: Uuid::parse_str(&template_id)?,
- status: serde_json::from_str(&status_str)?,
- options: serde_json::from_str(&options_json)?,
- tasks: serde_json::from_str(&tasks_json)?,
- results: results_json
- .as_deref()
- .map(|json| serde_json::from_str(json))
- .transpose()
- .unwrap_or_default()
- .unwrap_or_default(),
- created_at: chrono::DateTime::parse_from_rfc3339(&created_at)?.into(),
- started_at: started_at
- .as_deref()
- .map(|s| chrono::DateTime::parse_from_rfc3339(s).map(|dt| dt.into()))
- .transpose()?,
- completed_at: completed_at
- .as_deref()
- .map(|s| chrono::DateTime::parse_from_rfc3339(s).map(|dt| dt.into()))
- .transpose()?,
- };
-
- batch_tasks.push(batch_task);
- }
-
- Ok(batch_tasks)
- }
-
- /// 删除批量任务
- pub fn delete(db: &DbConnection, id: &Uuid) -> Result {
- let conn = lock_db(db).map_err(|e| anyhow::anyhow!(e))?;
-
- let affected = conn.execute(
- "DELETE FROM batch_tasks WHERE id = ?1",
- params![id.to_string()],
- )?;
-
- Ok(affected > 0)
- }
-
- /// 更新批量任务状态
- pub fn update_status(db: &DbConnection, id: &Uuid, status: BatchTaskStatus) -> Result<()> {
- let conn = lock_db(db).map_err(|e| anyhow::anyhow!(e))?;
-
- conn.execute(
- "UPDATE batch_tasks SET status = ?1 WHERE id = ?2",
- params![serde_json::to_string(&status)?, id.to_string()],
- )?;
-
- Ok(())
- }
-
- /// 更新批量任务结果、状态和时间戳
- ///
- /// 用于执行器在每个子任务完成后实时更新数据库
- pub fn update_results(
- db: &DbConnection,
- id: &Uuid,
- status: BatchTaskStatus,
- results: &[super::batch::TaskResult],
- started_at: Option>,
- completed_at: Option>,
- ) -> Result<()> {
- let conn = lock_db(db).map_err(|e| anyhow::anyhow!(e))?;
-
- let results_json = if results.is_empty() {
- None
- } else {
- Some(serde_json::to_string(results)?)
- };
-
- conn.execute(
- "UPDATE batch_tasks SET status = ?1, results_json = ?2, started_at = ?3, completed_at = ?4 WHERE id = ?5",
- params![
- serde_json::to_string(&status)?,
- results_json,
- started_at.map(|t| t.to_rfc3339()),
- completed_at.map(|t| t.to_rfc3339()),
- id.to_string(),
- ],
- )?;
-
- Ok(())
- }
-}
-
-/// 模板 DAO
-pub struct TemplateDao;
-
-impl TemplateDao {
- /// 保存模板
- pub fn save(db: &DbConnection, template: &TaskTemplate) -> Result<()> {
- let conn = lock_db(db).map_err(|e| anyhow::anyhow!(e))?;
-
- conn.execute(
- "INSERT OR REPLACE INTO batch_templates
- (id, name, description, model, system_prompt, user_message_template,
- temperature, max_tokens, created_at, updated_at)
- VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10)",
- params![
- template.id.to_string(),
- template.name,
- template.description,
- template.model,
- template.system_prompt,
- template.user_message_template,
- template.temperature,
- template.max_tokens,
- template.created_at.to_rfc3339(),
- template.updated_at.to_rfc3339(),
- ],
- )
- .context("保存模板失败")?;
-
- Ok(())
- }
-
- /// 根据 ID 查询模板
- pub fn get_by_id(db: &DbConnection, id: &Uuid) -> Result> {
- let conn = lock_db(db).map_err(|e| anyhow::anyhow!(e))?;
-
- let mut stmt = conn.prepare(
- "SELECT id, name, description, model, system_prompt, user_message_template,
- temperature, max_tokens, created_at, updated_at
- FROM batch_templates WHERE id = ?1",
- )?;
-
- let result = stmt
- .query_row(params![id.to_string()], |row| {
- Ok(TaskTemplate {
- id: Uuid::parse_str(&row.get::<_, String>(0)?).unwrap(),
- name: row.get(1)?,
- description: row.get(2)?,
- model: row.get(3)?,
- system_prompt: row.get(4)?,
- user_message_template: row.get(5)?,
- temperature: row.get(6)?,
- max_tokens: row.get(7)?,
- created_at: chrono::DateTime::parse_from_rfc3339(&row.get::<_, String>(8)?)
- .unwrap()
- .into(),
- updated_at: chrono::DateTime::parse_from_rfc3339(&row.get::<_, String>(9)?)
- .unwrap()
- .into(),
- })
- })
- .optional()?;
-
- Ok(result)
- }
-
- /// 查询所有模板
- pub fn list_all(db: &DbConnection) -> Result> {
- let conn = lock_db(db).map_err(|e| anyhow::anyhow!(e))?;
-
- let mut stmt = conn.prepare(
- "SELECT id, name, description, model, system_prompt, user_message_template,
- temperature, max_tokens, created_at, updated_at
- FROM batch_templates
- ORDER BY created_at DESC",
- )?;
-
- let rows = stmt.query_map([], |row| {
- Ok(TaskTemplate {
- id: Uuid::parse_str(&row.get::<_, String>(0)?).unwrap(),
- name: row.get(1)?,
- description: row.get(2)?,
- model: row.get(3)?,
- system_prompt: row.get(4)?,
- user_message_template: row.get(5)?,
- temperature: row.get(6)?,
- max_tokens: row.get(7)?,
- created_at: chrono::DateTime::parse_from_rfc3339(&row.get::<_, String>(8)?)
- .unwrap()
- .into(),
- updated_at: chrono::DateTime::parse_from_rfc3339(&row.get::<_, String>(9)?)
- .unwrap()
- .into(),
- })
- })?;
-
- let mut templates = Vec::new();
- for row in rows {
- templates.push(row?);
- }
-
- Ok(templates)
- }
-
- /// 删除模板
- pub fn delete(db: &DbConnection, id: &Uuid) -> Result {
- let conn = lock_db(db).map_err(|e| anyhow::anyhow!(e))?;
-
- let affected = conn.execute(
- "DELETE FROM batch_templates WHERE id = ?1",
- params![id.to_string()],
- )?;
-
- Ok(affected > 0)
- }
-}
-
-#[cfg(test)]
-mod tests {
- use super::*;
- use rusqlite::Connection;
- use std::collections::HashMap;
- use std::sync::{Arc, Mutex};
-
- fn setup_test_db() -> DbConnection {
- let conn = Connection::open_in_memory().unwrap();
- let db = Arc::new(Mutex::new(conn));
- BatchTaskDao::init_tables(&db).unwrap();
- db
- }
-
- #[test]
- fn test_init_tables() {
- let db = setup_test_db();
- // 如果能成功创建,说明表初始化成功
- assert!(true);
- }
-
- #[test]
- fn test_save_and_get_template() {
- let db = setup_test_db();
-
- let template = TaskTemplate::new(
- "测试模板".to_string(),
- "gpt-4".to_string(),
- "请处理: {{content}}".to_string(),
- );
-
- // 保存模板
- TemplateDao::save(&db, &template).unwrap();
-
- // 查询模板
- let loaded = TemplateDao::get_by_id(&db, &template.id).unwrap();
- assert!(loaded.is_some());
-
- let loaded = loaded.unwrap();
- assert_eq!(loaded.name, template.name);
- assert_eq!(loaded.model, template.model);
- assert_eq!(loaded.user_message_template, template.user_message_template);
- }
-
- #[test]
- fn test_save_and_get_batch_task() {
- let db = setup_test_db();
-
- let template = TaskTemplate::new(
- "测试模板".to_string(),
- "gpt-4".to_string(),
- "请处理: {{content}}".to_string(),
- );
-
- let tasks = vec![super::super::batch::TaskDefinition {
- id: None,
- variables: {
- let mut map = HashMap::new();
- map.insert("content".to_string(), "测试内容".to_string());
- map
- },
- metadata: HashMap::new(),
- }];
-
- let batch_task = BatchTask::new(
- "测试批量任务".to_string(),
- template.id,
- tasks,
- super::super::batch::BatchOptions::default(),
- );
-
- // 保存批量任务
- BatchTaskDao::save(&db, &batch_task).unwrap();
-
- // 查询批量任务
- let loaded = BatchTaskDao::get_by_id(&db, &batch_task.id).unwrap();
- assert!(loaded.is_some());
-
- let loaded = loaded.unwrap();
- assert_eq!(loaded.name, batch_task.name);
- assert_eq!(loaded.template_id, batch_task.template_id);
- assert_eq!(loaded.tasks.len(), 1);
- }
-}
diff --git a/src-tauri/crates/scheduler/src/executor.rs b/src-tauri/crates/scheduler/src/executor.rs
index 9c018fac1..4ce90a946 100644
--- a/src-tauri/crates/scheduler/src/executor.rs
+++ b/src-tauri/crates/scheduler/src/executor.rs
@@ -1,6 +1,6 @@
//! Agent Task Executor
//!
-//! 负责执行调度的任务
+//! 负责执行调度任务。
use super::types::ScheduledTask;
use async_trait::async_trait;
@@ -97,10 +97,6 @@ impl TaskExecutor for AgentExecutor {
// 执行 Agent 对话任务
self.execute_agent_chat(task, db, &aster_config).await?
}
- "batch_process" => {
- // 执行批量处理任务
- self.execute_batch_process(task, db, &aster_config).await?
- }
"scheduled_report" => {
// 执行定时报告任务
self.execute_scheduled_report(task, db, &aster_config)
@@ -274,30 +270,6 @@ impl AgentExecutor {
}))
}
- /// 执行批量处理任务
- async fn execute_batch_process(
- &self,
- task: &ScheduledTask,
- _db: &DbConnection,
- _aster_config: &proxycast_agent::credential_bridge::AsterProviderConfig,
- ) -> Result {
- let items = task
- .params
- .get("items")
- .and_then(|v| v.as_array())
- .ok_or_else(|| "缺少 items 参数".to_string())?;
-
- tracing::info!("[AgentExecutor] 执行批量处理: {} 项", items.len());
-
- // TODO: 实际执行批量处理逻辑
- Ok(serde_json::json!({
- "type": "batch_process",
- "total": items.len(),
- "processed": items.len(),
- "status": "success"
- }))
- }
-
/// 执行定时报告任务
async fn execute_scheduled_report(
&self,
diff --git a/src-tauri/crates/scheduler/src/lib.rs b/src-tauri/crates/scheduler/src/lib.rs
index 525da08be..ac104973c 100644
--- a/src-tauri/crates/scheduler/src/lib.rs
+++ b/src-tauri/crates/scheduler/src/lib.rs
@@ -13,7 +13,6 @@
//! - 定时任务调度
//! - 任务状态跟踪
//! - 失败重试机制
-//! - 批量任务支持
//!
//! ## 使用示例
//!
@@ -44,23 +43,14 @@
//! # }
//! ```
-pub mod batch;
-pub mod batch_dao;
pub mod dao;
pub mod executor;
pub mod scheduler;
-pub mod template;
pub mod types;
-pub use batch::{
- BatchOptions, BatchTask, BatchTaskStatistics, BatchTaskStatus, TaskDefinition, TaskResult,
- TaskStatus as BatchTaskStatus2, TokenUsage,
-};
-pub use batch_dao::{BatchTaskDao, TemplateDao};
pub use dao::SchedulerDao;
pub use executor::{AgentExecutor, TaskExecutor};
pub use scheduler::{AgentScheduler, SchedulerGovernanceConfig, SchedulerTrait};
-pub use template::TaskTemplate;
pub use types::{
ScheduledTask, TaskFilter, TaskStatus, DEFAULT_TASK_COOLDOWN_SECS,
DEFAULT_TASK_FAILURE_THRESHOLD,
diff --git a/src-tauri/crates/scheduler/src/template.rs b/src-tauri/crates/scheduler/src/template.rs
deleted file mode 100644
index b9eb63f62..000000000
--- a/src-tauri/crates/scheduler/src/template.rs
+++ /dev/null
@@ -1,134 +0,0 @@
-//! 任务模板定义
-//!
-//! 定义可复用的任务模板
-
-use serde::{Deserialize, Serialize};
-use std::collections::HashMap;
-use uuid::Uuid;
-
-/// 任务模板
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct TaskTemplate {
- /// 模板 ID
- pub id: Uuid,
-
- /// 模板名称
- pub name: String,
-
- /// 模板描述
- pub description: Option,
-
- /// 模型名称
- pub model: String,
-
- /// 系统提示词
- pub system_prompt: Option,
-
- /// 用户消息模板 (支持变量替换,例如 "{{variable_name}}")
- pub user_message_template: String,
-
- /// 温度参数
- pub temperature: Option,
-
- /// 最大 tokens
- pub max_tokens: Option,
-
- /// 创建时间
- pub created_at: chrono::DateTime,
-
- /// 更新时间
- pub updated_at: chrono::DateTime,
-}
-
-impl TaskTemplate {
- /// 创建新的任务模板
- pub fn new(name: String, model: String, user_message_template: String) -> Self {
- let now = chrono::Utc::now();
- Self {
- id: Uuid::new_v4(),
- name,
- description: None,
- model,
- system_prompt: None,
- user_message_template,
- temperature: None,
- max_tokens: None,
- created_at: now,
- updated_at: now,
- }
- }
-
- /// 设置描述
- pub fn with_description(mut self, description: String) -> Self {
- self.description = Some(description);
- self
- }
-
- /// 设置系统提示词
- pub fn with_system_prompt(mut self, system_prompt: String) -> Self {
- self.system_prompt = Some(system_prompt);
- self
- }
-
- /// 设置温度
- pub fn with_temperature(mut self, temperature: f32) -> Self {
- self.temperature = Some(temperature);
- self
- }
-
- /// 设置最大 tokens
- pub fn with_max_tokens(mut self, max_tokens: u32) -> Self {
- self.max_tokens = Some(max_tokens);
- self
- }
-
- /// 渲染用户消息 (替换变量)
- pub fn render_user_message(&self, variables: &HashMap) -> String {
- let mut message = self.user_message_template.clone();
-
- for (key, value) in variables {
- let placeholder = format!("{{{{{}}}}}", key);
- message = message.replace(&placeholder, value);
- }
-
- message
- }
-}
-
-#[cfg(test)]
-mod tests {
- use super::*;
-
- #[test]
- fn test_template_creation() {
- let template = TaskTemplate::new(
- "测试模板".to_string(),
- "gpt-4".to_string(),
- "请处理: {{content}}".to_string(),
- )
- .with_description("这是一个测试模板".to_string())
- .with_temperature(0.7)
- .with_max_tokens(1000);
-
- assert_eq!(template.name, "测试模板");
- assert_eq!(template.model, "gpt-4");
- assert_eq!(template.temperature, Some(0.7));
- assert_eq!(template.max_tokens, Some(1000));
- }
-
- #[test]
- fn test_render_user_message() {
- let template = TaskTemplate::new(
- "测试模板".to_string(),
- "gpt-4".to_string(),
- "请处理内容: {{content}}, 来自: {{source}}".to_string(),
- );
-
- let mut variables = HashMap::new();
- variables.insert("content".to_string(), "测试内容".to_string());
- variables.insert("source".to_string(), "测试来源".to_string());
-
- let rendered = template.render_user_message(&variables);
- assert_eq!(rendered, "请处理内容: 测试内容, 来自: 测试来源");
- }
-}
diff --git a/src-tauri/crates/server/src/chrome_bridge.rs b/src-tauri/crates/server/src/chrome_bridge.rs
index 3470fbf69..4c76d50bd 100644
--- a/src-tauri/crates/server/src/chrome_bridge.rs
+++ b/src-tauri/crates/server/src/chrome_bridge.rs
@@ -32,6 +32,7 @@ const COMMAND_WHITELIST: &[&str] = &[
"go_back",
"go_forward",
"switch_tab",
+ "list_tabs",
];
#[derive(Debug, Clone, Serialize, Deserialize)]
@@ -108,6 +109,8 @@ pub struct ChromeBridgeCommandResult {
pub error: Option,
#[serde(skip_serializing_if = "Option::is_none")]
pub page_info: Option,
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub data: Option,
}
#[derive(Debug, Clone, Deserialize)]
@@ -120,6 +123,8 @@ pub struct ObserverCommandResultPayload {
pub message: Option,
#[serde(default)]
pub error: Option,
+ #[serde(default)]
+ pub data: Option,
}
#[derive(Debug, Clone, Deserialize)]
@@ -336,6 +341,7 @@ impl ChromeBridgeHub {
message: None,
error: Some("observer 通道发送失败，连接可能已断开。".to_string()),
page_info: None,
+ data: None,
},
None,
)
@@ -363,6 +369,7 @@ impl ChromeBridgeHub {
message: None,
error: Some("等待 Chrome 执行结果超时。".to_string()),
page_info: None,
+ data: None,
},
None,
)
@@ -449,6 +456,7 @@ impl ChromeBridgeHub {
message: None,
error: Some("observer 通道发送失败，连接可能已断开。".to_string()),
page_info: None,
+ data: None,
},
None,
)
@@ -555,6 +563,7 @@ impl ChromeBridgeHub {
message: payload.message.or(Some("命令执行成功".to_string())),
error: None,
page_info: None,
+ data: payload.data,
}
} else {
ChromeBridgeCommandResult {
@@ -564,6 +573,7 @@ impl ChromeBridgeHub {
message: None,
error: payload.error.or(Some("命令执行失败".to_string())),
page_info: None,
+ data: payload.data,
}
};
@@ -617,6 +627,7 @@ impl ChromeBridgeHub {
message: pending_cmd.execution_message.clone(),
error: None,
page_info: Some(page_info.clone()),
+ data: None,
};
self.dispatch_pending_result(pending_cmd, result, Some(true))
.await;
@@ -735,6 +746,7 @@ impl ChromeBridgeHub {
message: None,
error: Some("命令执行超时。".to_string()),
page_info: None,
+ data: None,
};
self.dispatch_pending_result(pending, result, None).await;
}
@@ -749,6 +761,7 @@ impl ChromeBridgeHub {
message: None,
error: Some("observer 已断开连接。".to_string()),
page_info: None,
+ data: None,
};
self.dispatch_pending_result(pending, result, None).await;
}
@@ -801,6 +814,7 @@ impl ChromeBridgeHub {
"requestId": result.request_id,
"status": "success",
"message": result.message,
+ "data": result.data,
}
}),
)
@@ -1018,6 +1032,7 @@ mod tests {
fn should_validate_command_whitelist() {
assert!(validate_command("open_url", &Some("https://example.com".to_string())).is_ok());
assert!(validate_command("click", &None).is_ok());
+ assert!(validate_command("list_tabs", &None).is_ok());
assert!(validate_command("eval_js", &None).is_err());
}
@@ -1136,4 +1151,76 @@ mod tests {
assert!(result.success);
assert!(result.page_info.is_some());
}
+
+ #[tokio::test]
+ async fn observer_command_result_should_preserve_data_payload() {
+ let hub = Arc::new(ChromeBridgeHub::new());
+ let (observer_tx, _observer_rx) = mpsc::unbounded_channel::();
+ hub.register_observer(
+ "observer-a".to_string(),
+ Some("default".to_string()),
+ None,
+ observer_tx,
+ )
+ .await;
+
+ let (result_tx, result_rx) = oneshot::channel();
+ {
+ let mut inner = hub.inner.lock().await;
+ inner.pending_commands.insert(
+ "req-tabs".to_string(),
+ PendingCommand {
+ request_id: "req-tabs".to_string(),
+ source: PendingSource::Api(result_tx),
+ command: "list_tabs".to_string(),
+ observer_client_id: "observer-a".to_string(),
+ wait_for_page_info: false,
+ command_completed: false,
+ execution_message: None,
+ created_at: Utc::now(),
+ expires_at: Instant::now() + Duration::from_secs(30),
+ },
+ );
+ }
+
+ hub.handle_observer_command_result(
+ "observer-a",
+ ObserverCommandResultPayload {
+ request_id: "req-tabs".to_string(),
+ status: "success".to_string(),
+ message: Some("ok".to_string()),
+ error: None,
+ data: Some(json!({
+ "tabs": [
+ {
+ "id": 101,
+ "index": 0,
+ "title": "首页",
+ "url": "https://weibo.com/home",
+ "active": true,
+ }
+ ],
+ })),
+ },
+ )
+ .await;
+
+ let result = result_rx.await.expect("must receive tabs result");
+ assert!(result.success);
+ assert_eq!(result.command, "list_tabs");
+ assert_eq!(
+ result.data,
+ Some(json!({
+ "tabs": [
+ {
+ "id": 101,
+ "index": 0,
+ "title": "首页",
+ "url": "https://weibo.com/home",
+ "active": true,
+ }
+ ],
+ })),
+ );
+ }
}
diff --git a/src-tauri/crates/server/src/handlers/batch_api.rs b/src-tauri/crates/server/src/handlers/batch_api.rs
deleted file mode 100644
index ffa303703..000000000
--- a/src-tauri/crates/server/src/handlers/batch_api.rs
+++ /dev/null
@@ -1,519 +0,0 @@
-//! 批量任务 API 端点
-//!
-//! 提供批量任务的创建、查询和管理接口
-
-use axum::{
- extract::{Path, State},
- http::StatusCode,
- response::{IntoResponse, Response},
- Json,
-};
-use proxycast_scheduler::{
- BatchOptions, BatchTask, BatchTaskDao, BatchTaskStatistics, TaskDefinition, TaskTemplate,
- TemplateDao,
-};
-use serde::{Deserialize, Serialize};
-use uuid::Uuid;
-
-use crate::AppState;
-
-/// 创建批量任务请求
-#[derive(Debug, Deserialize)]
-pub struct CreateBatchTaskRequest {
- /// 批量任务名称
- pub name: String,
-
- /// 任务模板 ID
- pub template_id: Uuid,
-
- /// 任务列表
- pub tasks: Vec,
-
- /// 批量任务选项
- #[serde(default)]
- pub options: BatchOptions,
-}
-
-/// 创建批量任务响应
-#[derive(Debug, Serialize)]
-pub struct CreateBatchTaskResponse {
- /// 批量任务 ID
- pub id: Uuid,
-
- /// 批量任务名称
- pub name: String,
-
- /// 任务数量
- pub task_count: usize,
-
- /// 创建时间
- pub created_at: chrono::DateTime,
-}
-
-/// 批量任务详情响应
-#[derive(Debug, Serialize)]
-pub struct BatchTaskDetailResponse {
- /// 批量任务信息
- #[serde(flatten)]
- pub batch_task: BatchTask,
-
- /// 统计信息
- pub statistics: BatchTaskStatistics,
-}
-
-/// POST /api/batch/tasks - 创建批量任务
-pub async fn create_batch_task(
- State(state): State,
- Json(request): Json,
-) -> Response {
- // 检查数据库是否可用
- let db = match &state.db {
- Some(db) => db,
- None => {
- return (
- StatusCode::INTERNAL_SERVER_ERROR,
- Json(serde_json::json!({
- "error": {
- "message": "数据库未初始化",
- "type": "database_error"
- }
- })),
- )
- .into_response();
- }
- };
-
- // 验证模板是否存在
- let _template = match TemplateDao::get_by_id(db, &request.template_id) {
- Ok(Some(t)) => t,
- Ok(None) => {
- return (
- StatusCode::NOT_FOUND,
- Json(serde_json::json!({
- "error": {
- "message": format!("模板不存在: {}", request.template_id),
- "type": "not_found"
- }
- })),
- )
- .into_response();
- }
- Err(e) => {
- return (
- StatusCode::INTERNAL_SERVER_ERROR,
- Json(serde_json::json!({
- "error": {
- "message": format!("查询模板失败: {}", e),
- "type": "database_error"
- }
- })),
- )
- .into_response();
- }
- };
-
- // 创建批量任务
- let batch_task = BatchTask::new(
- request.name.clone(),
- request.template_id,
- request.tasks,
- request.options,
- );
-
- let batch_id = batch_task.id;
- let task_count = batch_task.tasks.len();
- let created_at = batch_task.created_at;
-
- // 保存到数据库
- if let Err(e) = BatchTaskDao::save(db, &batch_task) {
- return (
- StatusCode::INTERNAL_SERVER_ERROR,
- Json(serde_json::json!({
- "error": {
- "message": format!("保存批量任务失败: {}", e),
- "type": "database_error"
- }
- })),
- )
- .into_response();
- }
-
- state.logs.write().await.add(
- "info",
- &format!(
- "[BATCH] 创建批量任务: id={}, name={}, task_count={}",
- batch_id, request.name, task_count
- ),
- );
-
- // 启动异步执行任务
- if let Some(executor) = state.batch_executor.read().await.as_ref() {
- executor.start_batch(batch_id).await;
- }
-
- // 返回响应
- (
- StatusCode::CREATED,
- Json(CreateBatchTaskResponse {
- id: batch_id,
- name: request.name,
- task_count,
- created_at,
- }),
- )
- .into_response()
-}
-
-/// GET /api/batch/tasks/:id - 获取批量任务详情
-pub async fn get_batch_task(State(state): State, Path(id): Path) -> Response {
- let db = match &state.db {
- Some(db) => db,
- None => {
- return (
- StatusCode::INTERNAL_SERVER_ERROR,
- Json(serde_json::json!({
- "error": {
- "message": "数据库未初始化",
- "type": "database_error"
- }
- })),
- )
- .into_response();
- }
- };
-
- match BatchTaskDao::get_by_id(db, &id) {
- Ok(Some(batch_task)) => {
- let statistics = batch_task.get_statistics();
- (
- StatusCode::OK,
- Json(BatchTaskDetailResponse {
- batch_task,
- statistics,
- }),
- )
- .into_response()
- }
- Ok(None) => (
- StatusCode::NOT_FOUND,
- Json(serde_json::json!({
- "error": {
- "message": format!("批量任务不存在: {}", id),
- "type": "not_found"
- }
- })),
- )
- .into_response(),
- Err(e) => (
- StatusCode::INTERNAL_SERVER_ERROR,
- Json(serde_json::json!({
- "error": {
- "message": format!("查询批量任务失败: {}", e),
- "type": "database_error"
- }
- })),
- )
- .into_response(),
- }
-}
-
-/// GET /api/batch/tasks - 获取批量任务列表
-pub async fn list_batch_tasks(State(state): State) -> Response {
- let db = match &state.db {
- Some(db) => db,
- None => {
- return (
- StatusCode::INTERNAL_SERVER_ERROR,
- Json(serde_json::json!({
- "error": {
- "message": "数据库未初始化",
- "type": "database_error"
- }
- })),
- )
- .into_response();
- }
- };
-
- match BatchTaskDao::list_all(db, 100) {
- Ok(tasks) => (
- StatusCode::OK,
- Json(serde_json::json!({
- "tasks": tasks
- })),
- )
- .into_response(),
- Err(e) => (
- StatusCode::INTERNAL_SERVER_ERROR,
- Json(serde_json::json!({
- "error": {
- "message": format!("查询批量任务列表失败: {}", e),
- "type": "database_error"
- }
- })),
- )
- .into_response(),
- }
-}
-
-/// DELETE /api/batch/tasks/:id - 取消批量任务
-pub async fn cancel_batch_task(State(state): State, Path(id): Path) -> Response {
- let db = match &state.db {
- Some(db) => db,
- None => {
- return (
- StatusCode::INTERNAL_SERVER_ERROR,
- Json(serde_json::json!({
- "error": {
- "message": "数据库未初始化",
- "type": "database_error"
- }
- })),
- )
- .into_response();
- }
- };
-
- // 检查任务是否存在
- let batch_task = match BatchTaskDao::get_by_id(db, &id) {
- Ok(Some(task)) => task,
- Ok(None) => {
- return (
- StatusCode::NOT_FOUND,
- Json(serde_json::json!({
- "error": {
- "message": format!("批量任务不存在: {}", id),
- "type": "not_found"
- }
- })),
- )
- .into_response();
- }
- Err(e) => {
- return (
- StatusCode::INTERNAL_SERVER_ERROR,
- Json(serde_json::json!({
- "error": {
- "message": format!("查询批量任务失败: {}", e),
- "type": "database_error"
- }
- })),
- )
- .into_response();
- }
- };
-
- // 只能取消运行中的任务
- if batch_task.status != proxycast_scheduler::BatchTaskStatus::Running
- && batch_task.status != proxycast_scheduler::BatchTaskStatus::Pending
- {
- return (
- StatusCode::BAD_REQUEST,
- Json(serde_json::json!({
- "error": {
- "message": format!("任务状态为 {:?}，无法取消", batch_task.status),
- "type": "invalid_state"
- }
- })),
- )
- .into_response();
- }
-
- // 通过执行器取消
- let cancelled = if let Some(executor) = state.batch_executor.read().await.as_ref() {
- executor.cancel_batch(&id).await
- } else {
- false
- };
-
- if !cancelled {
- // 如果执行器中没有找到（可能还没开始执行），直接更新 DB 状态
- let _ =
- BatchTaskDao::update_status(db, &id, proxycast_scheduler::BatchTaskStatus::Cancelled);
- }
-
- state
- .logs
- .write()
- .await
- .add("info", &format!("[BATCH] 取消批量任务: id={}", id));
-
- (StatusCode::OK, Json(serde_json::json!({"cancelled": true}))).into_response()
-}
-
-/// POST /api/batch/templates - 创建任务模板
-pub async fn create_template(
- State(state): State,
- Json(template): Json,
-) -> Response {
- let db = match &state.db {
- Some(db) => db,
- None => {
- return (
- StatusCode::INTERNAL_SERVER_ERROR,
- Json(serde_json::json!({
- "error": {
- "message": "数据库未初始化",
- "type": "database_error"
- }
- })),
- )
- .into_response();
- }
- };
-
- if let Err(e) = TemplateDao::save(db, &template) {
- return (
- StatusCode::INTERNAL_SERVER_ERROR,
- Json(serde_json::json!({
- "error": {
- "message": format!("保存模板失败: {}", e),
- "type": "database_error"
- }
- })),
- )
- .into_response();
- }
-
- state.logs.write().await.add(
- "info",
- &format!(
- "[BATCH] 创建任务模板: id={}, name={}",
- template.id, template.name
- ),
- );
-
- (StatusCode::CREATED, Json(template)).into_response()
-}
-
-/// GET /api/batch/templates - 获取模板列表
-pub async fn list_templates(State(state): State) -> Response {
- let db = match &state.db {
- Some(db) => db,
- None => {
- return (
- StatusCode::INTERNAL_SERVER_ERROR,
- Json(serde_json::json!({
- "error": {
- "message": "数据库未初始化",
- "type": "database_error"
- }
- })),
- )
- .into_response();
- }
- };
-
- match TemplateDao::list_all(db) {
- Ok(templates) => (
- StatusCode::OK,
- Json(serde_json::json!({
- "templates": templates
- })),
- )
- .into_response(),
- Err(e) => (
- StatusCode::INTERNAL_SERVER_ERROR,
- Json(serde_json::json!({
- "error": {
- "message": format!("查询模板列表失败: {}", e),
- "type": "database_error"
- }
- })),
- )
- .into_response(),
- }
-}
-
-/// GET /api/batch/templates/:id - 获取模板详情
-pub async fn get_template(State(state): State, Path(id): Path) -> Response {
- let db = match &state.db {
- Some(db) => db,
- None => {
- return (
- StatusCode::INTERNAL_SERVER_ERROR,
- Json(serde_json::json!({
- "error": {
- "message": "数据库未初始化",
- "type": "database_error"
- }
- })),
- )
- .into_response();
- }
- };
-
- match TemplateDao::get_by_id(db, &id) {
- Ok(Some(template)) => (StatusCode::OK, Json(template)).into_response(),
- Ok(None) => (
- StatusCode::NOT_FOUND,
- Json(serde_json::json!({
- "error": {
- "message": format!("模板不存在: {}", id),
- "type": "not_found"
- }
- })),
- )
- .into_response(),
- Err(e) => (
- StatusCode::INTERNAL_SERVER_ERROR,
- Json(serde_json::json!({
- "error": {
- "message": format!("查询模板失败: {}", e),
- "type": "database_error"
- }
- })),
- )
- .into_response(),
- }
-}
-
-/// DELETE /api/batch/templates/:id - 删除模板
-pub async fn delete_template(State(state): State, Path(id): Path) -> Response {
- let db = match &state.db {
- Some(db) => db,
- None => {
- return (
- StatusCode::INTERNAL_SERVER_ERROR,
- Json(serde_json::json!({
- "error": {
- "message": "数据库未初始化",
- "type": "database_error"
- }
- })),
- )
- .into_response();
- }
- };
-
- match TemplateDao::delete(db, &id) {
- Ok(true) => {
- state
- .logs
- .write()
- .await
- .add("info", &format!("[BATCH] 删除模板: id={}", id));
- (StatusCode::NO_CONTENT, ()).into_response()
- }
- Ok(false) => (
- StatusCode::NOT_FOUND,
- Json(serde_json::json!({
- "error": {
- "message": format!("模板不存在: {}", id),
- "type": "not_found"
- }
- })),
- )
- .into_response(),
- Err(e) => (
- StatusCode::INTERNAL_SERVER_ERROR,
- Json(serde_json::json!({
- "error": {
- "message": format!("删除模板失败: {}", e),
- "type": "database_error"
- }
- })),
- )
- .into_response(),
- }
-}
diff --git a/src-tauri/crates/server/src/handlers/batch_executor.rs b/src-tauri/crates/server/src/handlers/batch_executor.rs
deleted file mode 100644
index f8ad3102e..000000000
--- a/src-tauri/crates/server/src/handlers/batch_executor.rs
+++ /dev/null
@@ -1,420 +0,0 @@
-//! 批量任务执行器
-//!
-//! 负责异步执行批量任务，支持并发控制、重试、超时和取消
-
-use std::collections::HashMap;
-use std::sync::Arc;
-
-use axum::http::StatusCode;
-use proxycast_core::models::openai::{
- ChatCompletionRequest, ChatCompletionResponse, ChatMessage, MessageContent,
-};
-use proxycast_scheduler::{BatchTaskDao, BatchTaskStatus, TaskResult, TemplateDao, TokenUsage};
-use tokio::sync::RwLock;
-use tokio_util::sync::CancellationToken;
-use uuid::Uuid;
-
-use crate::AppState;
-
-/// 批量任务执行器
-#[derive(Clone)]
-pub struct BatchTaskExecutor {
- state: AppState,
- cancel_tokens: Arc>>,
-}
-
-impl BatchTaskExecutor {
- pub fn new(state: AppState) -> Self {
- Self {
- state,
- cancel_tokens: Arc::new(RwLock::new(HashMap::new())),
- }
- }
-
- /// 启动批量任务执行（spawn 后台任务）
- pub async fn start_batch(&self, batch_id: Uuid) {
- let cancel_token = CancellationToken::new();
- self.cancel_tokens
- .write()
- .await
- .insert(batch_id, cancel_token.clone());
-
- let state = self.state.clone();
- let cancel_tokens = self.cancel_tokens.clone();
-
- tokio::spawn(async move {
- Self::execute_batch(state, batch_id, cancel_token).await;
- // 执行完毕后清理 cancel token
- cancel_tokens.write().await.remove(&batch_id);
- });
- }
-
- /// 取消运行中的批量任务
- pub async fn cancel_batch(&self, batch_id: &Uuid) -> bool {
- if let Some(token) = self.cancel_tokens.read().await.get(batch_id) {
- token.cancel();
- true
- } else {
- false
- }
- }
-
- /// 核心执行逻辑
- async fn execute_batch(state: AppState, batch_id: Uuid, cancel_token: CancellationToken) {
- let db = match &state.db {
- Some(db) => db,
- None => {
- tracing::error!("[BATCH] 数据库未初始化, batch_id={}", batch_id);
- return;
- }
- };
-
- // 1. 从 DB 加载 BatchTask
- let mut batch_task = match BatchTaskDao::get_by_id(db, &batch_id) {
- Ok(Some(task)) => task,
- Ok(None) => {
- tracing::error!("[BATCH] 批量任务不存在: {}", batch_id);
- return;
- }
- Err(e) => {
- tracing::error!("[BATCH] 加载批量任务失败: {}", e);
- return;
- }
- };
-
- // 2. 加载模板
- let template = match TemplateDao::get_by_id(db, &batch_task.template_id) {
- Ok(Some(t)) => t,
- Ok(None) => {
- tracing::error!("[BATCH] 模板不存在: {}", batch_task.template_id);
- let _ = BatchTaskDao::update_status(db, &batch_id, BatchTaskStatus::Failed);
- return;
- }
- Err(e) => {
- tracing::error!("[BATCH] 加载模板失败: {}", e);
- let _ = BatchTaskDao::update_status(db, &batch_id, BatchTaskStatus::Failed);
- return;
- }
- };
-
- // 3. 更新状态为 Running
- let now = chrono::Utc::now();
- batch_task.status = BatchTaskStatus::Running;
- batch_task.started_at = Some(now);
- let _ = BatchTaskDao::update_results(
- db,
- &batch_id,
- BatchTaskStatus::Running,
- &batch_task.results,
- batch_task.started_at,
- None,
- );
-
- tracing::info!(
- "[BATCH] 开始执行批量任务: id={}, name={}, task_count={}",
- batch_id,
- batch_task.name,
- batch_task.tasks.len()
- );
-
- // 4. 用 Semaphore 控制并发
- let concurrency = batch_task.options.concurrency.max(1);
- let semaphore = Arc::new(tokio::sync::Semaphore::new(concurrency));
- let results = Arc::new(RwLock::new(Vec::::new()));
- let mut handles = Vec::new();
-
- for task_def in &batch_task.tasks {
- let task_id = task_def.id.unwrap_or_else(Uuid::new_v4);
- let variables = task_def.variables.clone();
- let sem = semaphore.clone();
- let state = state.clone();
- let cancel = cancel_token.clone();
- let results = results.clone();
- let model = template.model.clone();
- let system_prompt = template.system_prompt.clone();
- let user_message = template.render_user_message(&variables);
- let temperature = template.temperature;
- let max_tokens = template.max_tokens;
- let retry_count = batch_task.options.retry_count;
- let timeout_secs = batch_task.options.timeout_seconds;
- let db_clone = db.clone();
- let batch_id_clone = batch_id;
-
- let handle = tokio::spawn(async move {
- let _permit = sem.acquire().await.unwrap();
-
- // 检查取消
- if cancel.is_cancelled() {
- let result = TaskResult {
- task_id,
- status: proxycast_scheduler::BatchTaskStatus2::Cancelled,
- content: None,
- error: Some("任务已取消".to_string()),
- usage: TokenUsage::default(),
- started_at: chrono::Utc::now(),
- completed_at: Some(chrono::Utc::now()),
- };
- results.write().await.push(result);
- return;
- }
-
- let result = Self::execute_single_task(
- &state,
- task_id,
- &model,
- system_prompt.as_deref(),
- &user_message,
- temperature,
- max_tokens,
- retry_count,
- timeout_secs,
- &cancel,
- )
- .await;
-
- results.write().await.push(result);
-
- // 实时更新 DB 进度
- let current_results = results.read().await.clone();
- let _ = BatchTaskDao::update_results(
- &db_clone,
- &batch_id_clone,
- BatchTaskStatus::Running,
- ¤t_results,
- None,
- None,
- );
- });
-
- handles.push(handle);
- }
-
- // 等待所有任务完成
- for handle in handles {
- let _ = handle.await;
- }
-
- // 5. 计算最终状态
- let final_results = results.read().await.clone();
- let total = batch_task.tasks.len();
- let completed = final_results
- .iter()
- .filter(|r| r.status == proxycast_scheduler::BatchTaskStatus2::Completed)
- .count();
- let cancelled = final_results
- .iter()
- .filter(|r| r.status == proxycast_scheduler::BatchTaskStatus2::Cancelled)
- .count();
-
- let final_status = if cancel_token.is_cancelled() {
- BatchTaskStatus::Cancelled
- } else if completed == total {
- BatchTaskStatus::Completed
- } else if completed == 0 {
- BatchTaskStatus::Failed
- } else {
- BatchTaskStatus::PartiallyCompleted
- };
-
- let completed_at = chrono::Utc::now();
- let _ = BatchTaskDao::update_results(
- db,
- &batch_id,
- final_status,
- &final_results,
- batch_task.started_at,
- Some(completed_at),
- );
-
- tracing::info!(
- "[BATCH] 批量任务完成: id={}, status={:?}, completed={}/{}, cancelled={}",
- batch_id,
- final_status,
- completed,
- total,
- cancelled
- );
- }
-
- /// 执行单个子任务（含重试和超时）
- async fn execute_single_task(
- state: &AppState,
- task_id: Uuid,
- model: &str,
- system_prompt: Option<&str>,
- user_message: &str,
- temperature: Option,
- max_tokens: Option,
- retry_count: usize,
- timeout_secs: u64,
- cancel: &CancellationToken,
- ) -> TaskResult {
- let started_at = chrono::Utc::now();
- let max_attempts = retry_count + 1;
-
- for attempt in 0..max_attempts {
- if cancel.is_cancelled() {
- return TaskResult {
- task_id,
- status: proxycast_scheduler::BatchTaskStatus2::Cancelled,
- content: None,
- error: Some("任务已取消".to_string()),
- usage: TokenUsage::default(),
- started_at,
- completed_at: Some(chrono::Utc::now()),
- };
- }
-
- if attempt > 0 {
- tracing::info!(
- "[BATCH] 重试任务: task_id={}, attempt={}/{}",
- task_id,
- attempt + 1,
- max_attempts
- );
- }
-
- // 构建请求
- let mut messages = Vec::new();
- if let Some(sys) = system_prompt {
- messages.push(ChatMessage {
- role: "system".to_string(),
- content: Some(MessageContent::Text(sys.to_string())),
- tool_calls: None,
- tool_call_id: None,
- reasoning_content: None,
- });
- }
- messages.push(ChatMessage {
- role: "user".to_string(),
- content: Some(MessageContent::Text(user_message.to_string())),
- tool_calls: None,
- tool_call_id: None,
- reasoning_content: None,
- });
-
- let request = ChatCompletionRequest {
- model: model.to_string(),
- messages,
- temperature,
- max_tokens,
- top_p: None,
- stream: false,
- tools: None,
- tool_choice: None,
- reasoning_effort: None,
- };
-
- // 调用 LLM（带超时）
- let result = tokio::time::timeout(
- std::time::Duration::from_secs(timeout_secs),
- Self::call_llm(state, &request),
- )
- .await;
-
- match result {
- Ok(Ok((content, usage))) => {
- return TaskResult {
- task_id,
- status: proxycast_scheduler::BatchTaskStatus2::Completed,
- content: Some(content),
- error: None,
- usage,
- started_at,
- completed_at: Some(chrono::Utc::now()),
- };
- }
- Ok(Err(e)) => {
- if attempt == max_attempts - 1 {
- return TaskResult {
- task_id,
- status: proxycast_scheduler::BatchTaskStatus2::Failed,
- content: None,
- error: Some(e),
- usage: TokenUsage::default(),
- started_at,
- completed_at: Some(chrono::Utc::now()),
- };
- }
- // 重试前等待
- tokio::time::sleep(std::time::Duration::from_secs(1)).await;
- }
- Err(_) => {
- if attempt == max_attempts - 1 {
- return TaskResult {
- task_id,
- status: proxycast_scheduler::BatchTaskStatus2::Failed,
- content: None,
- error: Some(format!("任务超时 ({}s)", timeout_secs)),
- usage: TokenUsage::default(),
- started_at,
- completed_at: Some(chrono::Utc::now()),
- };
- }
- tokio::time::sleep(std::time::Duration::from_secs(1)).await;
- }
- }
- }
-
- // 不应到达这里
- TaskResult {
- task_id,
- status: proxycast_scheduler::BatchTaskStatus2::Failed,
- content: None,
- error: Some("未知错误".to_string()),
- usage: TokenUsage::default(),
- started_at,
- completed_at: Some(chrono::Utc::now()),
- }
- }
-
- /// 调用 LLM：选择凭证 + 调用 provider
- async fn call_llm(
- state: &AppState,
- request: &ChatCompletionRequest,
- ) -> Result<(String, TokenUsage), String> {
- let db = state.db.as_ref().ok_or("数据库未初始化")?;
-
- // 选择凭证
- let credential = state
- .pool_service
- .select_credential_with_fallback(
- db,
- &state.api_key_service,
- "",
- Some(&request.model),
- None,
- None,
- )
- .await?
- .ok_or_else(|| format!("没有可用的凭证来调用模型: {}", request.model))?;
-
- // 调用 provider
- let response =
- super::provider_calls::call_provider_openai(state, &credential, request, None).await;
-
- // 解析响应
- let status = response.status();
- let body = axum::body::to_bytes(response.into_body(), 10 * 1024 * 1024)
- .await
- .map_err(|e| format!("读取响应体失败: {}", e))?;
-
- if status != StatusCode::OK {
- let error_text = String::from_utf8_lossy(&body);
- return Err(format!("LLM 调用失败 ({}): {}", status, error_text));
- }
-
- let resp: ChatCompletionResponse =
- serde_json::from_slice(&body).map_err(|e| format!("解析响应失败: {}", e))?;
-
- let content = resp
- .choices
- .first()
- .and_then(|c| c.message.content.clone())
- .unwrap_or_default();
-
- let usage = TokenUsage::new(resp.usage.prompt_tokens, resp.usage.completion_tokens);
-
- Ok((content, usage))
- }
-}
diff --git a/src-tauri/crates/server/src/handlers/mod.rs b/src-tauri/crates/server/src/handlers/mod.rs
index cc742c66a..eb493f3a2 100644
--- a/src-tauri/crates/server/src/handlers/mod.rs
+++ b/src-tauri/crates/server/src/handlers/mod.rs
@@ -4,8 +4,6 @@
pub mod api;
pub mod api_key_provider_utils;
-pub mod batch_api;
-pub mod batch_executor;
pub mod chrome_bridge_ws;
pub mod credentials_api;
pub mod image_handler;
@@ -14,7 +12,6 @@ pub mod provider_calls;
pub mod websocket;
pub use api::*;
-pub use batch_api::*;
pub use chrome_bridge_ws::*;
pub use credentials_api::*;
pub use image_handler::*;
diff --git a/src-tauri/crates/server/src/lib.rs b/src-tauri/crates/server/src/lib.rs
index d5336e46f..cc9f9dde8 100644
--- a/src-tauri/crates/server/src/lib.rs
+++ b/src-tauri/crates/server/src/lib.rs
@@ -642,9 +642,6 @@ pub struct AppState {
pub kiro_event_service: Arc,
/// API Key Provider 服务（用于智能降级）
pub api_key_service: Arc,
- /// 批量任务执行器
- pub batch_executor:
- Arc>>,
/// 速率限制器
pub rate_limiter: Option>,
/// 幂等性存储
@@ -1082,7 +1079,6 @@ async fn run_server(
provider_models,
kiro_event_service,
api_key_service,
- batch_executor: Arc::new(tokio::sync::RwLock::new(None)),
rate_limiter: Some(Arc::new(
middleware::rate_limit::SlidingWindowRateLimiter::new(
middleware::rate_limit::RateLimitConfig::default(),
@@ -1095,12 +1091,6 @@ async fn run_server(
sanitizer: Arc::new(proxycast_core::sanitizer::CredentialSanitizer::with_defaults()),
};
- // 初始化批量任务执行器
- {
- let executor = handlers::batch_executor::BatchTaskExecutor::new(state.clone());
- *state.batch_executor.write().await = Some(executor);
- }
-
// ========== 开发模式：通过回调启动桥接服务器 ==========
if let Some(callback) = dev_bridge_callback {
callback(state.clone());
@@ -1151,23 +1141,6 @@ async fn run_server(
get(handlers::credentials_get_token),
);
- // 批量任务 API 路由
- let batch_api_routes = Router::new()
- .route("/api/batch/tasks", post(handlers::create_batch_task))
- .route("/api/batch/tasks", get(handlers::list_batch_tasks))
- .route("/api/batch/tasks/:id", get(handlers::get_batch_task))
- .route(
- "/api/batch/tasks/:id",
- axum::routing::delete(handlers::cancel_batch_task),
- )
- .route("/api/batch/templates", post(handlers::create_template))
- .route("/api/batch/templates", get(handlers::list_templates))
- .route("/api/batch/templates/:id", get(handlers::get_template))
- .route(
- "/api/batch/templates/:id",
- axum::routing::delete(handlers::delete_template),
- );
-
let allowed_origins = vec![
HeaderValue::from_static("http://localhost:1420"),
HeaderValue::from_static("http://127.0.0.1:1420"),
@@ -1245,8 +1218,6 @@ async fn run_server(
.merge(kiro_api_routes)
// 凭证 API 路由（用于 aster Agent 集成）
.merge(credentials_api_routes)
- // 批量任务 API 路由
- .merge(batch_api_routes)
.layer(cors_layer)
.layer(DefaultBodyLimit::max(body_limit))
.layer(TimeoutLayer::with_status_code(
diff --git a/src-tauri/crates/services/src/api_key_provider_service.rs b/src-tauri/crates/services/src/api_key_provider_service.rs
index c0c4eda99..18e1aed36 100644
--- a/src-tauri/crates/services/src/api_key_provider_service.rs
+++ b/src-tauri/crates/services/src/api_key_provider_service.rs
@@ -44,10 +44,19 @@ pub struct ConnectionTestResult {
mod tests {
use super::ApiKeyProviderService;
use proxycast_core::database::dao::api_key_provider::ApiProviderType;
- use proxycast_core::database::init_database;
+ use proxycast_core::database::{migration, schema, DbConnection};
+ use rusqlite::Connection;
use rusqlite::OptionalExtension;
+ use std::sync::{Arc, Mutex};
use tokio::io::{AsyncReadExt, AsyncWriteExt};
+ fn init_test_database() -> DbConnection {
+ let conn = Connection::open_in_memory().expect("创建内存数据库失败");
+ schema::create_tables(&conn).expect("初始化表结构失败");
+ migration::migrate_from_json(&conn).expect("执行数据库迁移失败");
+ Arc::new(Mutex::new(conn))
+ }
+
fn resolve_real_codex_provider_id(
db: &proxycast_core::database::DbConnection,
) -> Result {
@@ -146,6 +155,42 @@ data: [DONE]\n";
assert!(none.is_none());
}
+ #[test]
+ fn test_system_provider_type_can_be_updated() {
+ let db = init_test_database();
+ let service = ApiKeyProviderService::new();
+
+ service
+ .initialize_system_providers(&db)
+ .expect("初始化系统 Provider 失败");
+
+ let updated = service
+ .update_provider(
+ &db,
+ "openai",
+ None,
+ Some(ApiProviderType::Openai),
+ None,
+ None,
+ None,
+ None,
+ None,
+ None,
+ None,
+ None,
+ )
+ .expect("更新系统 Provider 类型失败");
+
+ assert_eq!(updated.provider_type, ApiProviderType::Openai);
+
+ let persisted = service
+ .get_provider(&db, "openai")
+ .expect("读取系统 Provider 失败")
+ .expect("系统 Provider 应存在");
+
+ assert_eq!(persisted.provider.provider_type, ApiProviderType::Openai);
+ }
+
#[test]
fn test_parse_openai_responses_content_prefers_output_text() {
let body = serde_json::json!({
@@ -1153,11 +1198,7 @@ impl ApiKeyProviderService {
if let Some(n) = name {
provider.name = n;
}
- // 只有自定义 Provider 才能修改类型
if let Some(t) = provider_type {
- if provider.is_system {
- return Err("系统 Provider 不允许修改类型".to_string());
- }
provider.provider_type = t;
}
if let Some(h) = api_host {
diff --git a/src-tauri/crates/websocket/src/handlers/rpc_handler.rs b/src-tauri/crates/websocket/src/handlers/rpc_handler.rs
index 0d76d1c97..731cc281f 100644
--- a/src-tauri/crates/websocket/src/handlers/rpc_handler.rs
+++ b/src-tauri/crates/websocket/src/handlers/rpc_handler.rs
@@ -503,7 +503,7 @@ impl RpcHandler {
self.create_run_record(
&db,
&execution_id,
- "heartbeat",
+ "automation",
Some(task.id.clone()),
None,
Some(json!({
@@ -667,7 +667,7 @@ impl RpcHandler {
.prepare(
"SELECT status, started_at
FROM agent_runs
- WHERE source = 'heartbeat'
+ WHERE source = 'automation'
AND status IN ('error', 'timeout')
AND datetime(started_at) >= datetime(?1)",
)
@@ -1417,7 +1417,7 @@ mod tests {
let now = Utc::now().to_rfc3339();
let run_error = AgentRun {
id: Uuid::new_v4().to_string(),
- source: "heartbeat".to_string(),
+ source: "automation".to_string(),
source_ref: Some("task-1".to_string()),
session_id: None,
status: AgentRunStatus::Error,
@@ -1433,7 +1433,7 @@ mod tests {
AgentRunDao::create_run(&conn, &run_error).expect("插入错误执行记录失败");
let run_timeout = AgentRun {
id: Uuid::new_v4().to_string(),
- source: "heartbeat".to_string(),
+ source: "automation".to_string(),
source_ref: Some("task-2".to_string()),
session_id: None,
status: AgentRunStatus::Timeout,
diff --git a/src-tauri/src/agent/heartbeat_service_adapter.rs b/src-tauri/src/agent/heartbeat_service_adapter.rs
deleted file mode 100644
index a5106add9..000000000
--- a/src-tauri/src/agent/heartbeat_service_adapter.rs
+++ /dev/null
@@ -1,204 +0,0 @@
-//! Heartbeat Service Adapter
-//!
-//! 将 Tauri 的 HeartbeatServiceState 适配为 Aster Agent 工具的 HeartbeatService trait
-
-use crate::services::heartbeat_service::{
- CycleResult, HeartbeatService as ProxycastHeartbeatService, HeartbeatServiceState,
- HeartbeatStatus as ProxycastHeartbeatStatus,
- HeartbeatTaskPreview as ProxycastHeartbeatTaskPreview,
-};
-use proxycast_agent::tools::heartbeat_tool::{
- HeartbeatCycleResult, HeartbeatExecutionRecord, HeartbeatService, HeartbeatStatus,
- HeartbeatTaskPreview, HeartbeatToolError,
-};
-use proxycast_core::app_paths;
-use proxycast_core::database::dao::heartbeat::HeartbeatExecution;
-use std::path::PathBuf;
-use std::sync::Arc;
-use tauri::AppHandle;
-
-/// Heartbeat Service 适配器
-///
-/// 将 Tauri 的 HeartbeatServiceState 转换为 Agent 工具可使用的 trait
-pub struct HeartbeatServiceAdapter {
- hb_service: Arc>,
- app_handle: AppHandle,
-}
-
-impl HeartbeatServiceAdapter {
- /// 创建新的适配器
- pub fn new(hb_state: HeartbeatServiceState, app_handle: AppHandle) -> Self {
- Self {
- hb_service: Arc::clone(&hb_state.0),
- app_handle,
- }
- }
-
- /// 获取应用数据目录
- fn app_data_dir(&self) -> Result {
- app_paths::preferred_data_dir()
- .map_err(|e| HeartbeatToolError::IoError(format!("获取应用数据目录失败: {}", e)))
- }
-
- /// 转换执行记录
- fn convert_execution(exec: &HeartbeatExecution) -> HeartbeatExecutionRecord {
- HeartbeatExecutionRecord {
- id: exec.id,
- task_description: exec.task_description.clone(),
- status: exec.status.clone(),
- started_at: exec.started_at.clone(),
- completed_at: exec.completed_at.clone(),
- duration_ms: exec.duration_ms,
- output: exec.output.clone(),
- retry_count: exec.retry_count,
- }
- }
-
- /// 转换任务预览
- fn convert_task_preview(task: &ProxycastHeartbeatTaskPreview) -> HeartbeatTaskPreview {
- HeartbeatTaskPreview {
- description: task.description.clone(),
- priority: task.priority,
- timeout_secs: task.timeout_secs,
- once: task.once,
- model: task.model.clone(),
- }
- }
-
- /// 转换状态
- fn convert_status(status: ProxycastHeartbeatStatus) -> HeartbeatStatus {
- HeartbeatStatus {
- running: status.running,
- last_run: status.last_run,
- next_run: status.next_run,
- last_task_count: status.last_task_count,
- total_executions: status.total_executions,
- schedule_description: status.schedule_description,
- }
- }
-}
-
-#[async_trait::async_trait]
-impl HeartbeatService for HeartbeatServiceAdapter {
- fn get_status(&self) -> Result {
- let service = self.hb_service.blocking_read();
- Ok(Self::convert_status(service.get_status()))
- }
-
- fn get_app_data_dir(&self) -> Result {
- self.app_data_dir()
- }
-
- fn preview_tasks(&self) -> Result, HeartbeatToolError> {
- let app_data_dir = self.app_data_dir()?;
- let service = self.hb_service.blocking_read();
- let tasks = service
- .preview_tasks(&app_data_dir)
- .map_err(|e| HeartbeatToolError::ExecutionFailed(format!("获取任务列表失败: {}", e)))?;
- Ok(tasks.iter().map(Self::convert_task_preview).collect())
- }
-
- fn add_task(
- &self,
- description: String,
- priority: Option,
- timeout_secs: Option,
- once: Option,
- model: Option,
- ) -> Result<(), HeartbeatToolError> {
- let app_data_dir = self.app_data_dir()?;
- let service = self.hb_service.blocking_read();
- service
- .add_task(
- &app_data_dir,
- description,
- priority,
- timeout_secs,
- once,
- model,
- )
- .map_err(|e| HeartbeatToolError::ExecutionFailed(format!("添加任务失败: {}", e)))
- }
-
- fn delete_task(&self, index: usize) -> Result<(), HeartbeatToolError> {
- let app_data_dir = self.app_data_dir()?;
- let service = self.hb_service.blocking_read();
- service
- .delete_task(&app_data_dir, index)
- .map_err(|e| HeartbeatToolError::ExecutionFailed(format!("删除任务失败: {}", e)))
- }
-
- fn update_task(
- &self,
- index: usize,
- description: String,
- priority: Option,
- timeout_secs: Option,
- once: Option,
- model: Option,
- ) -> Result<(), HeartbeatToolError> {
- let app_data_dir = self.app_data_dir()?;
- let service = self.hb_service.blocking_read();
- service
- .update_task(
- &app_data_dir,
- index,
- description,
- priority,
- timeout_secs,
- once,
- model,
- )
- .map_err(|e| HeartbeatToolError::ExecutionFailed(format!("更新任务失败: {}", e)))
- }
-
- fn get_history(
- &self,
- limit: usize,
- ) -> Result, HeartbeatToolError> {
- let service = self.hb_service.blocking_read();
- let records = service
- .get_execution_history(limit)
- .map_err(|e| HeartbeatToolError::ExecutionFailed(format!("获取历史失败: {}", e)))?;
- Ok(records.iter().map(Self::convert_execution).collect())
- }
-
- fn get_execution_detail(
- &self,
- id: i64,
- ) -> Result, HeartbeatToolError> {
- let service = self.hb_service.blocking_read();
- let record = service
- .get_execution_detail(id)
- .map_err(|e| HeartbeatToolError::ExecutionFailed(format!("获取详情失败: {}", e)))?;
- Ok(record.map(|r| Self::convert_execution(&r)))
- }
-
- async fn trigger_now(&self) -> Result {
- let app_data_dir = self.app_data_dir()?;
- let result = {
- let service = self.hb_service.read().await;
- service
- .trigger_now(app_data_dir, Some(self.app_handle.clone()))
- .await
- };
-
- // 更新状态
- {
- let mut service = self.hb_service.write().await;
- service.update_status_after_cycle(&CycleResult {
- task_count: result.task_count,
- success_count: result.success_count,
- failed_count: result.failed_count,
- timeout_count: result.timeout_count,
- });
- }
-
- Ok(HeartbeatCycleResult {
- task_count: result.task_count,
- success_count: result.success_count,
- failed_count: result.failed_count,
- timeout_count: result.timeout_count,
- })
- }
-}
diff --git a/src-tauri/src/agent/mod.rs b/src-tauri/src/agent/mod.rs
index 0a49e9426..ed88e5e53 100644
--- a/src-tauri/src/agent/mod.rs
+++ b/src-tauri/src/agent/mod.rs
@@ -6,7 +6,6 @@
pub mod aster_agent;
pub mod aster_state;
pub mod credential_bridge;
-pub mod heartbeat_service_adapter;
pub mod subagent_scheduler;
// 从 proxycast-agent crate re-export
@@ -23,7 +22,6 @@ pub use aster_state::AsterAgentState;
pub use credential_bridge::{
create_aster_provider, AsterProviderConfig, CredentialBridge, CredentialBridgeError,
};
-pub use heartbeat_service_adapter::HeartbeatServiceAdapter;
pub use proxycast_agent::{
convert_agent_event, convert_to_tauri_message, QueueInsertResult, QueuedTurnSnapshot,
QueuedTurnTask, SessionTurnQueueManager, TauriAgentEvent,
diff --git a/src-tauri/src/app/bootstrap.rs b/src-tauri/src/app/bootstrap.rs
index 53374b559..d21eb0958 100644
--- a/src-tauri/src/app/bootstrap.rs
+++ b/src-tauri/src/app/bootstrap.rs
@@ -28,7 +28,7 @@ use crate::database::{self, DbConnection};
use crate::logger;
use crate::mcp::McpManagerState;
use crate::plugin;
-use crate::services::heartbeat_service::{HeartbeatService, HeartbeatServiceState};
+use crate::services::automation_service::{AutomationService, AutomationServiceState};
use crate::skills::ensure_default_local_skills;
use crate::telemetry;
use crate::voice::recording_service::{create_recording_service_state, RecordingServiceState};
@@ -78,7 +78,7 @@ pub struct AppStates {
pub tool_hooks_service: ToolHooksServiceState,
pub recording_service: RecordingServiceState,
pub mcp_manager: McpManagerState,
- pub heartbeat_service: HeartbeatServiceState,
+ pub automation_service: AutomationServiceState,
pub workflow_service: Arc>,
pub progress_store: Arc>,
// 用于 setup hook 的共享实例
@@ -127,11 +127,6 @@ pub fn init_states(config: &Config) -> Result