mirrors/pikasTech-unidesk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: expand scheduling, notifications, and queue runtime

Browse Source 
- add scheduled task plumbing across backend core, CLI, and frontend surfaces

- add frontend notification UI and keep service pages using the repaired shared stylesheet

- refactor code queue runtime and update baidu netdisk/service integration docs
This commit is contained in:
Codex
2026-05-13 08:43:43 +00:00
parent 6a04144d3f
commit a242e3e3ec
45 changed files with 10421 additions and 6494 deletions
Download Patch File Download Diff File Expand all files Collapse all files
config.json
+1 -1
View File
@@ -324,7 +324,7 @@
"id": "baidu-netdisk",
"name": "Baidu Netdisk",
"providerId": "main-server",
"description": "容器化百度网盘存储用户服务，提供 OAuth 设备码登录、应用目录浏览和 staging 目录上传下载任务。",
"description": "容器化百度网盘存储用户服务，提供 OAuth 设备码登录、根目录浏览和 staging 目录上传下载任务。",
"repository": {
"url": "https://github.com/pikasTech/unidesk",
"commitId": "ae462ed9ef8057909fee9eabfadce5ed55e958a2",
docker-compose.yml
+8 -2
View File
@@ -14,6 +14,8 @@ services:
- "-c"
- "config_file=/etc/postgresql/postgresql.conf"
- "-c"
- "hba_file=/etc/postgresql/pg_hba.conf"
- "-c"
- "logging_collector=on"
- "-c"
- "log_directory=/var/log/unidesk/${UNIDESK_LOG_DAY}"
@@ -27,6 +29,7 @@ services:
- unidesk_pgdata_10gb:/var/lib/postgresql/data
- ./src/components/database/init:/docker-entrypoint-initdb.d:ro
- ./src/components/database/config/postgresql.conf:/etc/postgresql/postgresql.conf:ro
- ./src/components/database/config/pg_hba.conf:/etc/postgresql/pg_hba.conf:ro
- ${UNIDESK_LOG_DIR}:/var/log/unidesk
healthcheck:
test: ["CMD-SHELL", "pg_isready -U ${UNIDESK_DATABASE_USER} -d ${UNIDESK_DATABASE_NAME}"]
@@ -55,11 +58,14 @@ services:
TASK_PENDING_TIMEOUT_MS: "${UNIDESK_TASK_PENDING_TIMEOUT_MS:-600000}"
DATABASE_VOLUME_NAME: "${UNIDESK_DATABASE_VOLUME}"
DATABASE_VOLUME_SIZE: "${UNIDESK_DATABASE_VOLUME_SIZE}"
PGDATA_BACKUP_STAGING_DIR: "/data/baidu-netdisk-staging"
BAIDU_NETDISK_INTERNAL_URL: "http://baidu-netdisk:4244"
MICROSERVICES_JSON: "${UNIDESK_MICROSERVICES_JSON:-[]}"
LOG_FILE: "/var/log/unidesk/${UNIDESK_LOG_DAY}/${UNIDESK_LOG_PREFIX}_backend-core.jsonl"
UNIDESK_LOG_RETENTION_BYTES: "${UNIDESK_LOG_RETENTION_BYTES:-1GiB}"
volumes:
- ${UNIDESK_LOG_DIR}:/var/log/unidesk
- ./.state/baidu-netdisk/staging:/data/baidu-netdisk-staging
healthcheck:
test: ["CMD", "bun", "-e", "fetch('http://127.0.0.1:8080/health').then(r=>process.exit(r.ok?0:1)).catch(()=>process.exit(1))"]
interval: 5s
@@ -129,7 +135,7 @@ services:
CODE_QUEUE_SANDBOX: "danger-full-access"
CODE_QUEUE_APPROVAL_POLICY: "never"
CODE_QUEUE_MAX_ATTEMPTS: "99"
CODE_QUEUE_MAX_ACTIVE_QUEUES: "${UNIDESK_CODE_QUEUE_MAX_ACTIVE_QUEUES:-1}"
CODE_QUEUE_MAX_ACTIVE_QUEUES: "${UNIDESK_CODE_QUEUE_MAX_ACTIVE_QUEUES:-0}"
NODE_OPTIONS: "${UNIDESK_CODE_QUEUE_NODE_OPTIONS:---max-old-space-size=768}"
CODE_QUEUE_IN_MEMORY_OUTPUT_RECORDS: "${UNIDESK_CODE_QUEUE_IN_MEMORY_OUTPUT_RECORDS:-10}"
CODE_QUEUE_IN_MEMORY_EVENT_RECORDS: "${UNIDESK_CODE_QUEUE_IN_MEMORY_EVENT_RECORDS:-10}"
@@ -217,7 +223,7 @@ services:
BAIDU_NETDISK_CLIENT_ID: "${UNIDESK_BAIDU_NETDISK_CLIENT_ID:-}"
BAIDU_NETDISK_CLIENT_SECRET: "${UNIDESK_BAIDU_NETDISK_CLIENT_SECRET:-}"
BAIDU_NETDISK_TOKEN_KEY: "${UNIDESK_BAIDU_NETDISK_TOKEN_KEY:-}"
BAIDU_NETDISK_APP_ROOT: "${UNIDESK_BAIDU_NETDISK_APP_ROOT:-/apps/UniDeskBaiduNetdisk}"
BAIDU_NETDISK_APP_ROOT: "${UNIDESK_BAIDU_NETDISK_APP_ROOT:-/}"
BAIDU_NETDISK_STAGING_DIR: "/data/staging"
LOG_FILE: "/var/log/unidesk/${UNIDESK_LOG_DAY}/${UNIDESK_LOG_PREFIX}_baidu-netdisk.jsonl"
UNIDESK_LOG_RETENTION_BYTES: "${UNIDESK_LOG_RETENTION_BYTES:-1GiB}"
docs/issue/baidu-netdisk-env-setup.md
+5 -5
View File
@@ -40,8 +40,8 @@ from pathlib import Path
updates = {
"UNIDESK_BAIDU_NETDISK_CLIENT_ID": "paste-baidu-client-id-here",
"UNIDESK_BAIDU_NETDISK_CLIENT_SECRET": "paste-baidu-client-secret-here",
# Optional. Keep the existing value unless you intentionally want another app-folder name.
"UNIDESK_BAIDU_NETDISK_APP_ROOT": "/apps/UniDeskBaiduNetdisk",
# Optional. "/" makes UniDesk work at the Baidu Netdisk root; use /apps/<name> to sandbox again.
"UNIDESK_BAIDU_NETDISK_APP_ROOT": "/",
}
path = Path(".state/docker-compose.env")
@@ -68,7 +68,7 @@ PY
cd /root/unidesk
export UNIDESK_BAIDU_NETDISK_CLIENT_ID='paste-baidu-client-id-here'
export UNIDESK_BAIDU_NETDISK_CLIENT_SECRET='paste-baidu-client-secret-here'
export UNIDESK_BAIDU_NETDISK_APP_ROOT='/apps/UniDeskBaiduNetdisk'
export UNIDESK_BAIDU_NETDISK_APP_ROOT='/'
bun scripts/cli.ts server rebuild baidu-netdisk
```
@@ -101,11 +101,11 @@ bun scripts/cli.ts microservice proxy baidu-netdisk /api/auth/device/start --met
```bash
bun scripts/cli.ts microservice proxy baidu-netdisk '/api/account' --raw
bun scripts/cli.ts microservice proxy baidu-netdisk '/api/files?dir=/apps/UniDeskBaiduNetdisk&limit=20' --raw
bun scripts/cli.ts microservice proxy baidu-netdisk '/api/files?dir=/&limit=20' --raw
bun scripts/cli.ts microservice proxy baidu-netdisk /api/self-test --method POST --raw
```
`/api/files` 首次访问空应用目录时应返回 `ok=true` 和文件数组；如果远端应用目录还不存在，后端会先创建 `UNIDESK_BAIDU_NETDISK_APP_ROOT` 指向的 `/apps/...` 目录。`/api/self-test` 会生成小文本、上传、列表确认、下载并比较 MD5，适合授权完成后的端到端验收。
`/api/files` 访问根目录时应返回 `ok=true` 和文件数组；`/api/self-test` 会生成小文本、上传到当前 `UNIDESK_BAIDU_NETDISK_APP_ROOT` 指向的工作目录、列表确认、下载并比较 MD5，适合授权完成后的端到端验收。如果你把 `UNIDESK_BAIDU_NETDISK_APP_ROOT` 改回 `/apps/<name>`，后端会在首次访问时确保该应用目录存在。
## Token Key 轮换
docs/issue/baidu-netdisk-user-service.md
+6 -6
View File
@@ -52,9 +52,9 @@ Token handling requirements:
- Use a PostgreSQL row lock or advisory lock around refresh to avoid two workers spending the same refresh token concurrently.
- Never log tokens or dlinks; health/status endpoints should only expose redacted auth state.
### Scope and App Folder
### Scope and Remote Root
Use `scope=basic,netdisk`. Official docs describe third-party app data under `/apps/<productName>` and visible to users as `/我的应用数据/<productName>`. The service should default to a configured app root, for example `/apps/UniDeskBaiduNetdisk`, and reject paths outside that root unless the final approved app permission explicitly allows broader access.
Use `scope=basic,netdisk`. Official docs for download still describe third-party app data under `/apps/<productName>` and visible to users as `/我的应用数据/<productName>`, but the file-list docs also define `dir` as an absolute path defaulting to `/`. On 2026-05-13, the current UniDesk Baidu application and authorized account were tested directly against the official APIs: listing `/`, uploading a tiny temporary file to `/unidesk-root-probe-*.txt`, obtaining its `dlink`, downloading it back, verifying MD5, and deleting it all succeeded with `errno=0`. Therefore UniDesk now defaults `UNIDESK_BAIDU_NETDISK_APP_ROOT` to `/` and treats it as the remote working root. Operators can still set `UNIDESK_BAIDU_NETDISK_APP_ROOT=/apps/<name>` to re-enable an app-folder sandbox.
### Browse and Metadata
@@ -127,7 +127,7 @@ Expose a pure JSON control API first:
- `POST /api/auth/refresh`: force token refresh for diagnostics.
- `POST /api/auth/logout`: revoke local tokens and stop jobs.
- `GET /api/account`: user info and quota.
- `GET /api/files?dir=/apps/UniDeskBaiduNetdisk&start=0&limit=100`: directory listing.
- `GET /api/files?dir=/&start=0&limit=100`: directory listing under the configured remote working root.
- `GET /api/files/meta?fsids=...&dlink=0|1`: metadata, optionally dlink redacted by default.
- `POST /api/folders`: create folder through `method=create&isdir=1`.
- `POST /api/files/manage`: copy/move/rename/delete using `method=filemanager`.
@@ -205,8 +205,8 @@ If deployed on main server, use a Compose service name such as `http://baidu-net
Add a dedicated `src/components/frontend/src/baidu-netdisk.tsx` page and route tab:
- Login panel: QR image from `qrcode_url`, user code, expires timer, poll status, refresh QR and logout buttons.
- Account cards: username, UID, quota used/total, VIP state, app root path.
- File browser: breadcrumb rooted at `/apps/<appName>`, paginated table, folder creation, rename/delete/move controls.
- Account cards: username, UID, quota used/total, VIP state, remote working root path.
- File browser: breadcrumb rooted at the configured working root, now `/` by default, paginated table, folder creation, rename/delete/move controls.
- Transfer panel: upload-from-path form, download-to-path form, job rows, progress bars, speed, ETA, retry/cancel buttons.
- Safety text: private backend mapping, token storage redacted, no direct public Baidu token exposure.
- Raw JSON only behind explicit buttons, following existing user-service conventions.
@@ -219,7 +219,7 @@ Focused checks after implementation:
- `bun scripts/cli.ts microservice health baidu-netdisk` returns `ok=true`, `service=baidu-netdisk`, `storage=postgres` and redacted auth state.
- `bun scripts/cli.ts microservice proxy baidu-netdisk /api/auth/device/start --method POST` returns a login session with QR/user-code metadata but no token.
- After manual QR authorization, `/api/account` and `/api/files?dir=<root>` return user/quota/list data.
- Upload/download tests can use `bun scripts/cli.ts microservice proxy baidu-netdisk /api/self-test --method POST --raw`; the response must include a remote path in the app root, an `fsId`, succeeded upload/download jobs, and matching `expectedMd5`/`downloadedMd5`.
- Upload/download tests can use `bun scripts/cli.ts microservice proxy baidu-netdisk /api/self-test --method POST --raw`; the response must include a remote path in the working root, an `fsId`, succeeded upload/download jobs, and matching `expectedMd5`/`downloadedMd5`.
- Public port probes must fail for the service port; frontend access only through UniDesk.
- Playwright verifies `/app/baidu-netdisk/` renders shell, login card, account/quota, file browser, transfer panel and no naked JSON.
docs/reference/deployment.md
+1 -1
View File
@@ -49,7 +49,7 @@ frontend 的 Docker 上线顺序为：先运行必要的本地校验，例如 `b
## Main Server Memory Budget
主 server 内存预算按稀缺资源管理，不能把用户服务当作无限内存的 worker 节点使用。`code-queue-backend` 必须保持 `300m` memory/swap 硬上限，默认只允许 `CODE_QUEUE_MAX_ACTIVE_QUEUES=1`，并保持 `CODE_QUEUE_IN_MEMORY_OUTPUT_RECORDS=10`、`CODE_QUEUE_IN_MEMORY_EVENT_RECORDS=10` 这类小热窗口；任务历史、队列统计、Trace/output 读取和 `/health` 摘要必须优先从 PostgreSQL 直读或聚合，不能为了性能便利在 Bun 进程内缓存全量历史。任何提高 Code Queue 并发度、热窗口、日志缓冲、Playwright/Codex 子进程常驻规模或容器上限的变更，都必须在同一任务里说明内存预算来源，并通过 `docker inspect code-queue-backend`、`docker stats --no-stream code-queue-backend`、`microservice health code-queue` 和对应 E2E 证明未重新引入内存爆炸风险。
主 server 内存预算按稀缺资源管理，不能把用户服务当作无限内存的 worker 节点使用。`code-queue-backend` 必须保持明确的 memory/swap 硬上限，默认 `CODE_QUEUE_MAX_ACTIVE_QUEUES=0` 以恢复 queue 间并行，仍保持 `CODE_QUEUE_IN_MEMORY_OUTPUT_RECORDS=10`、`CODE_QUEUE_IN_MEMORY_EVENT_RECORDS=10` 这类小热窗口；任务历史、队列统计、Trace/output 读取和 `/health` 摘要必须优先从 PostgreSQL 直读或聚合，不能为了性能便利在 Bun 进程内缓存全量历史。任何提高 Code Queue 热窗口、日志缓冲、Playwright/Codex 子进程常驻规模或容器上限的变更，或把 `CODE_QUEUE_MAX_ACTIVE_QUEUES` 显式改成正数，都必须在同一任务里说明内存预算来源，并通过 `docker inspect code-queue-backend`、`docker stats --no-stream code-queue-backend`、`microservice health code-queue` 和对应 E2E 证明未重新引入内存爆炸风险。
## Database Volume
docs/reference/frontend.md
+2 -2
View File
@@ -77,11 +77,11 @@ frontend shell 必须把左侧主模块与顶部子标签编译为统一的 URL
- `Todo Note` 子标签必须把主 server `todo-note-backend` 后端渲染为 UniDesk React 控件，包括迁移清单、树形任务、筛选、提醒、拖放/移动、撤销/重做、字号控制和显式原始 JSON 按钮。
- `FindJob` 子标签必须把 D601 findjob 后端渲染为 UniDesk React 控件，包括岗位指标、岗位预览、草稿报告和显式原始 JSON 按钮。
- `ClaudeQQ` 子标签必须把 D601 ClaudeQQ 后端渲染为 UniDesk React 控件，包括 NapCat 容器登录二维码、NapCat HTTP/WS 状态、事件缓存、QQ 事件订阅表、订阅创建表单、消息推送表单、主用户私聊账号 `645275593` 标记、最近 QQ 事件、已发送记录和显式原始 JSON 按钮。
- `Baidu Netdisk` 子标签必须把主 server `baidu-netdisk-backend` 后端渲染为 UniDesk React 控件，包括 OAuth 设备码二维码/用户码登录、账号容量、应用目录文件浏览、staging 目录上传/下载任务、上传/下载自测按钮与 MD5 结果、脱敏安全说明、日志摘要和显式原始 JSON 按钮；不得把 access token、refresh token、dlink 或 staging 文件字节流裸露到浏览器。
- `Baidu Netdisk` 子标签必须把主 server `baidu-netdisk-backend` 后端渲染为 UniDesk React 控件，包括 OAuth 设备码二维码/用户码登录、账号容量、配置工作根文件浏览（当前默认百度网盘根目录 `/`）、staging 目录上传/下载任务、上传/下载自测按钮与 MD5 结果、脱敏安全说明、日志摘要和显式原始 JSON 按钮；不得把 access token、refresh token、dlink 或 staging 文件字节流裸露到浏览器。
- `Code Queue` 子标签必须把主 server `code-queue-backend` 后端渲染为 UniDesk React 控件，包括多 queue lane、queue 内串行、queue 间并行、任务 ID/复制任务 ID、引用按钮、任务耗时、任务提交/批量提交、引用任务 ID、创建成功提示、清空输入、模型下拉、显式入队份数、默认模型 `gpt-5.5`、MiniMax judge 状态、Codex CLI-like 输出流、attempt 终态、运行中追加 prompt、打断、手动重试和显式原始 JSON 按钮；Codex CLI-like 输出流必须始终保留任务的初始 `Submitted prompt` 和运行中 `Steer prompt`；整个 agent loop 消息流统一命名为专有名词 `Trace`，`Trace` 包含 assistant message、user prompt、system event 和 tool call；Code Queue 与 Pipeline/OpenCode messages 必须共用 `src/components/frontend/src/trace.tsx` 的 Trace 公共组件、统一 Trace item 接口和 codex/opencode port 适配层；连续 read/edit/run 工具调用只是在 Trace 内折叠为可展开工具调用组，汇总格式至少包含 `xx read, xx edit, xx run`，并展示读取文件、编辑文件、运行命令和耗时摘要；最近 3 个工具调用保持展开，工具调用内容不得自动换行且必须在工具调用块内部横向滚动，工具调用组展开后不得再增加额外左侧缩进；message 与 prompt 必须自动换行，普通 message 不显示左侧项目符号缩进且永不折叠；Trace 首屏可以是摘要预览，但终态任务被选中后必须自动在后台加载完整 Trace，手动“加载完整 Trace”也必须从 Code Queue output archive 分页补齐早期 trace，不得把 preview 的 `hasMore=false` 当成完整历史；即使热状态为控制体积裁剪了早期 raw output，也要从结构化 `basePrompt/displayPrompt/promptHistory` 和 archive 合成完整用户输入与 agent trace，并且初始 prompt 默认显示注入前 prompt 而不是引用注入全文；当初始 prompt 含引用注入时，引用内容必须默认折叠，并只在 Trace 的初始消息中提供可展开的“最终传入 Codex 的真实完整 prompt”，不得再渲染独立 Prompt 全量卡片；多轮引用注入必须按上游/最早上下文在前、直接引用在后的顺序排列，每一轮必须有明确 `Reference Round N/M` 分割线和时间范围，不能用固定 6 轮截断引用链；点击队列引用按钮必须自动把该任务 ID 写入提交表单的引用输入框，引用任务 ID 创建新任务时必须自动注入 `bun scripts/cli.ts codex task <taskId>` 的提示；连续执行同一 prompt 应通过入队份数一次性生成多条任务，避免快速连点造成操作员误判。
- `Code Queue` 前端改进必须在同一任务内重建并上线公网 frontend，不能只修改源码或本地 bundle；重建 frontend 是无状态 WebUI 替换，不会导致 Code Queue 长期任务失败。已结束未读任务只能在 task card 边角显示类似未读消息的 `codex-unread-badge` 圆点和“标为已读”操作，不得把整张卡片改成红色/琥珀色失败态边框、背景或胶囊标签；状态栏的“结束未读”提示也不得使用失败态红色。
- `Code Queue` 前端必须把 PostgreSQL-backed backend API 作为 task、queue、readAt/未读状态和 attempt 状态的唯一数据来源；不得用 `localStorage`、`sessionStorage` 或 IndexedDB 持久化这些业务状态，也不得在后端标记已读失败时伪造本地成功。前端允许保留 React 内存态、请求 in-flight guard 和本轮页面缓存，但刷新页面或切换设备后的状态必须完全由后端 PostgreSQL 数据恢复。
- `Code Queue` 的 queue/session 左侧边栏必须提供 task 关键词搜索，并采用顶部对齐和内容高度优先布局：搜索栏、列表、分组和 task card 都不得用居中、space-between、stretch 或隐式等高网格去拉满侧栏高度；item 少时允许下半部分留空，不能把单个 item 拉高来铺满；每个 task card 必须显示 `最近更新: ...前` 这类相对更新时间，便于判断运行中的 Trace 是否卡住。提交任务时必须立即锁定 prompt、引用 ID、queue、模型、工作目录、最大尝试和入队份数等输入控件，显示等待状态，并用前端 in-flight guard 阻止重复点击造成重复入队；当解析到多个待入队任务时必须显式要求用户勾选批量确认，防止 `---` 分隔或入队份数误操作导致错误传入多个任务。Trace 面板的主滚动条使用全站细窄现代滚动条；工具调用块内部的横向滚动必须可滚动但隐藏横向滚动条，避免移动端阅读被滚动条占用。公共 `TraceView` 的自动滚动必须采用 follow-tail 语义：只有当前滚动位置在底部附近时才跟随新增输出；用户手动向上滚动后立即暂停自动滚动，异步刷新不得把视图拉回底部，直到用户再次滚动到最底部才恢复自动跟随。
- `Code Queue` 的 queue/session 左侧边栏必须提供 task 关键词搜索，并采用顶部对齐和内容高度优先布局：搜索栏、列表、分组和 task card 都不得用居中、space-between、stretch 或隐式等高网格去拉满侧栏高度；item 少时允许下半部分留空，不能把单个 item 拉高来铺满；每个 task card 必须显示 `最近更新: ...前` 这类相对更新时间，便于判断运行中的 Trace 是否卡住；`queued` task card 的状态徽标必须显示排队原因，例如 `QUEUED(PREV TASK)`、`QUEUED(MEM LIMIT)`。提交任务时必须立即锁定 prompt、引用 ID、queue、模型、工作目录、最大尝试和入队份数等输入控件，显示等待状态，并用前端 in-flight guard 阻止重复点击造成重复入队；当解析到多个待入队任务时必须显式要求用户勾选批量确认，防止 `---` 分隔或入队份数误操作导致错误传入多个任务。Trace 面板的主滚动条使用全站细窄现代滚动条；工具调用块内部的横向滚动必须可滚动但隐藏横向滚动条，避免移动端阅读被滚动条占用。公共 `TraceView` 的自动滚动必须采用 follow-tail 语义：只有当前滚动位置在底部附近时才跟随新增输出；用户手动向上滚动后立即暂停自动滚动，异步刷新不得把视图拉回底部，直到用户再次滚动到最底部才恢复自动跟随。
- 用户服务页面不得 iframe 业务旧前端、Todo Note 原 Vite 前端或 Pipeline 自身 WebUI，不得把用户服务后端端口暴露为浏览器直连 URL，也不得把业务 API 的 JSON 裸铺在页面上。
- `Pipeline` 子标签是 D601 `/home/ubuntu/pipeline` 的 UniDesk host UI。
- Pipeline 仓库自带 WebUI 前端已经废弃；UniDesk frontend 是唯一用户可见的 Pipeline UI。
docs/reference/microservices.md
+8 -8
View File
@@ -72,15 +72,15 @@ Project Manager 在 UniDesk 语境中按纯后端服务管理：不得将 `4233`
- Provider：`main-server`，由 backend-core 直接访问同一 Compose 网络内的 `http://baidu-netdisk:4244`，公网不发布 `4244`。
- 代码引用：`https://github.com/pikasTech/unidesk` 与配置中的 `repository.commitId`；服务源码位于 `src/components/microservices/baidu-netdisk`，属于 UniDesk 自有主 server 用户服务。
- 部署引用：UniDesk 根仓库 `docker-compose.yml` 中的 `baidu-netdisk` service，Dockerfile 为 `src/components/microservices/baidu-netdisk/Dockerfile`，容器名为 `baidu-netdisk-backend`。
- 配置密钥：Compose 只透传 `UNIDESK_BAIDU_NETDISK_CLIENT_ID`、`UNIDESK_BAIDU_NETDISK_CLIENT_SECRET`、`UNIDESK_BAIDU_NETDISK_TOKEN_KEY` 与可选 `UNIDESK_BAIDU_NETDISK_APP_ROOT`；不得把百度 AppSecret、token key、access token 或 refresh token 写入仓库文件。
- 配置密钥：Compose 只透传 `UNIDESK_BAIDU_NETDISK_CLIENT_ID`、`UNIDESK_BAIDU_NETDISK_CLIENT_SECRET`、`UNIDESK_BAIDU_NETDISK_TOKEN_KEY` 与可选 `UNIDESK_BAIDU_NETDISK_APP_ROOT`；当前默认工作根目录为 `/`，如需收回到应用目录可显式设为 `/apps/<name>`；不得把百度 AppSecret、token key、access token 或 refresh token 写入仓库文件。
- 配置步骤：`UNIDESK_BAIDU_NETDISK_TOKEN_KEY` 可由本机生成；百度 `client_id` 和 `client_secret` 必须由账号拥有者在百度网盘开放平台创建应用后提供，操作清单见 `docs/issue/baidu-netdisk-env-setup.md`。
- 数据库：OAuth 设备码会话、账号摘要、加密 token、传输任务和事件写入主 PostgreSQL 表 `baidu_netdisk_*`；服务启动时自动创建/补齐 schema，不依赖仅首次生效的 database init SQL。
- 文件边界：v1 只支持容器 staging 目录 `/data/staging` 与百度网盘应用目录之间的后台上传/下载任务；staging 目录由主 server `.state/baidu-netdisk/staging` 挂载，`.state/` 只保存可重建文件缓存，不作为 token 或任务权威状态。授权成功、账号刷新、文件列表和上传任务都会确保 `UNIDESK_BAIDU_NETDISK_APP_ROOT` 指向的 `/apps/...` 应用目录存在；目录已存在时必须返回/记录 `errno=-8` 并继续，禁止使用会重命名的策略重复创建 `_YYYYMMDD_...` 目录。
- 文件边界：v1 只支持容器 staging 目录 `/data/staging` 与百度网盘配置工作根之间的后台上传/下载任务；staging 目录由主 server `.state/baidu-netdisk/staging` 挂载，`.state/` 只保存可重建文件缓存，不作为 token 或任务权威状态。当前授权账号已实测可对百度网盘根目录 `/` 执行列表、上传、获取 dlink、下载和删除临时探针，因此 `UNIDESK_BAIDU_NETDISK_APP_ROOT` 默认直接设为 `/`；仅当该值配置为 `/apps/...` 时，后端才会确保应用目录存在，目录已存在时必须返回/记录 `errno=-8` 并继续，禁止使用会重命名的策略重复创建 `_YYYYMMDD_...` 目录。
- API：`GET /health`；`GET /api/auth/status`；`POST /api/auth/device/start`；`GET /api/auth/device/status`；`POST /api/auth/refresh`；`POST /api/auth/logout`；`GET /api/account`；`GET /api/files`；`GET /api/files/meta`；`POST /api/folders`；`POST /api/files/manage`；`POST /api/transfers/upload-from-path`；`POST /api/transfers/download-to-path`；`POST /api/self-test`；`GET /api/transfers`；`GET|POST /api/transfers/{id}/cancel|retry`；`GET /logs`。
- 授权轮询：百度设备码轮询返回的 `authorization_pending` 和 `slow_down` 是正常中间态，后端必须把它们更新为 pending session（`slow_down` 增加轮询间隔）而不是向前端抛 HTTP 错误；只有拒绝、过期或未知 OAuth 错误才进入 rejected/expired/failed。
- 自测：`POST /api/self-test` 会在 staging 生成小文本、上传到应用目录、通过 `/api/files` 找到 `fs_id`、下载回 staging 并校验 MD5；该端点不得回显 token/dlink，适合 CLI、前端按钮和交付验收使用。
- 自测：`POST /api/self-test` 会在 staging 生成小文本、上传到配置工作根、通过 `/api/files` 找到 `fs_id`、下载回 staging 并校验 MD5；该端点不得回显 token/dlink，适合 CLI、前端按钮和交付验收使用。
- 代理路径：只允许 `/health`、`/logs` 和 `/api/` 前缀；允许方法为 `GET`、`HEAD`、`POST`、`DELETE`。
- UniDesk 前端：`用户服务 / Baidu Netdisk` React 页面负责展示设备码登录卡、账号容量、应用目录文件表、staging 上传/下载任务、上传/下载自测按钮与结果、脱敏日志和显式原始 JSON 按钮。
- UniDesk 前端：`用户服务 / Baidu Netdisk` React 页面负责展示设备码登录卡、账号容量、配置工作根文件表、staging 上传/下载任务、上传/下载自测按钮与结果、脱敏日志和显式原始 JSON 按钮。
Baidu Netdisk 在 UniDesk 语境中按纯后端服务管理：不得暴露百度 token、dlink 或 staging 文件字节流给浏览器；浏览器只能通过 UniDesk frontend 的 `/api/microservices/baidu-netdisk/health` 和 `/api/microservices/baidu-netdisk/proxy/...` 同源代理访问控制面 JSON。
@@ -111,17 +111,17 @@ Baidu Netdisk 在 UniDesk 语境中按纯后端服务管理：不得暴露百度
- 用户输入持久化：任务初始 prompt 以 `basePrompt/displayPrompt` 作为结构化来源，运行中追加的 `turn/steer` prompt 必须写入 `promptHistory`；transcript 构建时从这些结构化字段合成 `Submitted prompt` 和 `Steer prompt`，不能只依赖有 600 条上限的 raw output，否则长任务输出增长后会丢失关键人工指令。
- 队列语义：`POST /api/tasks` 或 `/api/tasks/batch` 入队，服务始终只运行一个 Codex turn；当前任务真正终止后才推进下一个任务。`GET /api/tasks` 与 `GET /api/tasks/{id}` 返回队列、attempt、judge 和输出；`GET /api/tasks/{id}/summary` 返回按任务 ID 查询的结构化摘要，包括初始 prompt、最后 assistant message、工具调用摘要、attempt、judge、错误和耗时；CLI 入口是 `bun scripts/cli.ts codex task <taskId>`。`POST /api/tasks/{id}/steer` 向运行中 turn 推入 prompt；`POST /api/tasks/{id}/interrupt` 或 `DELETE /api/tasks/{id}` 打断/取消；`POST /api/tasks/{id}/retry` 手动重试。队列 worker 必须隔离单个 task 的异常，不能因为某个 app-server、judge 异常或 judge 判定 `fail` 让后续 queued 任务停止；`fail` 只把当前任务标为 failed，随后必须继续扫描并推进下一个 queued/retry_wait 任务。当存在 queued/retry_wait 且 worker 空闲时，watchdog 必须自动重新调度。
- 稳定性与重启恢复：Code Queue 的第一目标是长期稳定可用；部署修复或运维排障时不得因为担心容器重启会打断任务而拒绝重启、重建或替换 `code-queue-backend`。容器重启、服务进程重启和镜像替换后，队列、`promptHistory`、running/judging/retry_wait 任务和 active session 元数据必须从 PostgreSQL 恢复，并在已有 `codexThreadId` 可用时用 `thread/resume` 和 continuation prompt 无缝继续当前任务；如果原 app-server turn 已丢失，也必须把当前任务恢复到可 retry/continue 的状态，不能错误推进下一个任务或永久卡住。主 server 侧重建必须走 `server rebuild code-queue`，该 job 受 `.state/locks/server-compose.lock` 串行化约束，并且必须在 build 后执行 no-deps force-recreate 与 post-up health validation；禁止在 job 中先手工 `docker rm` 再依赖后续命令补救，因为中断窗口会让容器消失并触发 frontend `direct microservice proxy failed`。重启后出现 active task 丢失、手动 steer/interrupt 记录丢失、running 任务卡死、误判完成、跳过当前任务、容器消失或阻塞队列，均属于 Code Queue 的 P0 核心缺陷，必须先修复并补充 restart-recovery 验收，不能把“避免重启”作为交付策略。
- 调度与 active run slot：Code Queue 必须把“queue processor 正在等待/退避/轮询”和“实际占用 Codex/OpenCode 子进程运行槽”分开建模；`CODE_QUEUE_MAX_ACTIVE_QUEUES` 只限制真实 active run slot，不能把 retry backoff、等待内存下降或等待前序任务的 `processingQueues` 计入 active slot，否则默认 `maxActiveQueues=1` 时一个空等队列会把其他 runnable queue 永久饿死。多个 queue 同时等待 active slot 时必须显式维护 FIFO waiter 队列，避免某个长 retry/backoff 队列刚释放 slot 就立刻重抢，导致更早进入等待的 `retry_wait` 任务长期饥饿；`/health` 必须同时暴露真实 `activeQueueIds`、`activeRunSlotCount`、等待中的 `processingQueueIds` 和 active slot waiters，排障时以 active run slot 与 waiter 顺序判断是否真的有任务在跑、谁应下一个启动。restart-recovery 后的 `retry_wait` 任务若缺失 `codexThreadId`/OpenCode session id，不得无限拒绝 retry；必须用紧凑 recovery prompt 和原始任务摘要重新开一个 agent thread/session，让任务继续推进并在 Trace 中留下 recovery 证据。任何修改 scheduler、retry backoff、queue move、manual retry、shutdown recovery 或内存等待逻辑时，都必须保留“空等 processor 不占 active run slot”、“等待者 FIFO 不饥饿”和“缺失 thread/session 可恢复”的自测或 live 验证。
- 内存优化过程与防回归：主 server 内存预算很小，Code Queue 的内存治理必须按“PostgreSQL 权威源优先、进程热状态最小化、容器硬上限兜底”的顺序设计。长期可复用的优化路径是：先确认任务、queue、readAt、promptHistory、active session 和通知 outbox 均可从 PostgreSQL 恢复；再把历史任务列表、详情、统计、Trace/output 和 `/health` 的只读查询改为 PostgreSQL 直读或聚合查询；随后只把 `queued`、`running`、`judging`、`retry_wait` 等调度必需任务载入 Bun 堆，并在 PostgreSQL 查询侧裁剪 hot `output`/`events`；最后用 dirty-only flush、append-only 输出归档、Codex SQLite 小批量导出、`bun --smol`、`mem_limit=600m`、`memswap_limit=1536m`、`NODE_OPTIONS=--max-old-space-size=768` 和 cgroup memory watchdog 作为运行时防线。PostgreSQL 到进程的单次读取足够快，不能为了减少 SQL 查询把全部历史 `task_json`、Trace、output 或统计摘要常驻内存；任何新增缓存都必须有默认较小的环境变量上限、明确淘汰策略、可从 PostgreSQL 或 append-only 归档重建，且不得影响重启恢复。新增或修改 `/api/tasks`、overview、stats、summary、transcript、output、trace、health、flush、scheduler 和通知路径时，禁止在常规请求中调用会物化全量历史任务 JSON 的代码，禁止启动后无条件重写全量历史 task JSON，禁止用未设上限的 `Map`/数组保存历史 output/event/Trace，禁止把 `CODE_QUEUE_MAX_ACTIVE_QUEUES` 在 600M 容器默认值下调高到大于 `1`；如确需更大热窗口或并发度，必须同时提高容器内存预算并补充内存压测验收。memory watchdog 必须以 cgroup working set 为主要判断，且在 swap 仍有余量时不得提前杀掉唯一 active run；否则 TypeScript/Playwright 这类短时高内存验证会被错误中断并让 retry 队列反复震荡。
- 调度与 active run slot：Code Queue 必须把“queue processor 正在等待/退避/轮询”和“实际占用 Codex/OpenCode 子进程运行槽”分开建模；`CODE_QUEUE_MAX_ACTIVE_QUEUES` 只限制真实 active run slot，不能把 retry backoff、等待内存下降或等待前序任务的 `processingQueues` 计入 active slot，否则设置全局 active slot 上限时，一个空等队列会把其他 runnable queue 永久饿死。多个 queue 同时等待 active slot 时必须显式维护 FIFO waiter 队列，避免某个长 retry/backoff 队列刚释放 slot 就立刻重抢，导致更早进入等待的 `retry_wait` 任务长期饥饿；`/health` 必须同时暴露真实 `activeQueueIds`、`activeRunSlotCount`、等待中的 `processingQueueIds` 和 active slot waiters，排障时以 active run slot 与 waiter 顺序判断是否真的有任务在跑、谁应下一个启动。restart-recovery 后的 `retry_wait` 任务若缺失 `codexThreadId`/OpenCode session id，不得无限拒绝 retry；必须用紧凑 recovery prompt 和原始任务摘要重新开一个 agent thread/session，让任务继续推进并在 Trace 中留下 recovery 证据。任何修改 scheduler、retry backoff、queue move、manual retry、shutdown recovery 或内存等待逻辑时，都必须保留“空等 processor 不占 active run slot”、“等待者 FIFO 不饥饿”和“缺失 thread/session 可恢复”的自测或 live 验证。
- 内存优化过程与防回归：主 server 内存预算很小，Code Queue 的内存治理必须按“PostgreSQL 权威源优先、进程热状态最小化、容器硬上限兜底”的顺序设计。长期可复用的优化路径是：先确认任务、queue、readAt、promptHistory、active session 和通知 outbox 均可从 PostgreSQL 恢复；再把历史任务列表、详情、统计、Trace/output 和 `/health` 的只读查询改为 PostgreSQL 直读或聚合查询；随后只把 `queued`、`running`、`judging`、`retry_wait` 等调度必需任务载入 Bun 堆，并在 PostgreSQL 查询侧裁剪 hot `output`/`events`；最后用 dirty-only flush、append-only 输出归档、Codex SQLite 小批量导出、`bun --smol`、`mem_limit=600m`、`memswap_limit=1536m`、`NODE_OPTIONS=--max-old-space-size=768` 和 cgroup memory watchdog 作为运行时防线。PostgreSQL 到进程的单次读取足够快，不能为了减少 SQL 查询把全部历史 `task_json`、Trace、output 或统计摘要常驻内存；任何新增缓存都必须有默认较小的环境变量上限、明确淘汰策略、可从 PostgreSQL 或 append-only 归档重建，且不得影响重启恢复。新增或修改 `/api/tasks`、overview、stats、summary、transcript、output、trace、health、flush、scheduler 和通知路径时，禁止在常规请求中调用会物化全量历史任务 JSON 的代码，禁止启动后无条件重写全量历史 task JSON，禁止用未设上限的 `Map`/数组保存历史 output/event/Trace，`CODE_QUEUE_MAX_ACTIVE_QUEUES=0` 表示不按 queue 数量设置全局排队上限；如显式设置为正数，必须同时说明内存预算并补充内存压测验收。memory watchdog 必须以 cgroup working set 为主要判断，且在 swap 仍有余量时不得提前杀掉唯一 active run；否则 TypeScript/Playwright 这类短时高内存验证会被错误中断并让 retry 队列反复震荡。
- 完成判定：app-server `turn/completed` 的 `turn.status=completed|interrupted|failed` 只代表 Codex turn 已结束；即使 `completed` 也必须把原始任务、assistant 最终回复、command/file-change 事件、stderr tail 和 current attempt events 组成 execution record 交给 judge 判断是否真的完成。配置了 `UNIDESK_CODE_QUEUE_MINIMAX_API_KEY` 且 MiniMax 可用时，MiniMax `MiniMax-M2.7` 对 `complete|retry|fail` 的判定是权威结果；当且仅当 MiniMax LLM 调用失效（未配置、额度/限流/网络/超时不可用、JSON 去噪与 repair 全部耗尽、或返回超预算反馈且修复耗尽）时，才允许启用非 LLM/fallback 判断。任何字符串匹配、正则、硬编码 safety override、`hardCompletionBlockers`/`retryRequiredReasons`、`recentOutput` 中旧 attempt 的 429/exceeded retry limit 证据、或面向特定任务的保护逻辑，都不得覆盖、降级、提升或重写一次成功的 MiniMax 判定；尤其不能因为 attempt 1 的限流中断仍在历史输出里，就禁止 MiniMax 把 attempt 2 的正常完成判为 `complete`。MiniMax 返回必须先做 JSON 去噪，支持去除 Markdown fence、`json` 标签和从夹杂文本中提取平衡 JSON object；如果去噪后仍无法解析，服务必须把解析错误和上一轮去噪前原始回答反馈给 MiniMax 做 JSON repair 重试，重试次数由 `UNIDESK_CODE_QUEUE_MINIMAX_JUDGE_REPAIR_ATTEMPTS` 控制，默认 `2`，耗尽后才进入 fallback，并在 fallback 原因中保留 MiniMax 失败信息。
- Judge 权威边界：MiniMax 成功返回可解析、预算内的 judge JSON 后，Code Queue 必须直接采用该 `decision/reason/continuePrompt`，不得再执行本地 post-validation、协议级完成门禁或 safety override；`hardCompletionBlockers`、`retryRequiredReasons` 这类本地门禁字段不得出现在发送给 MiniMax 的 `executionRecord` 中。只有 MiniMax 不可用或修复耗尽进入 fallback 时，才允许基于字符串/正则做保守 retry。
- Retry/推进语义：`retry` 不是新开一个独立任务或完全新 session；只要已有 `codexThreadId`，服务必须 `thread/resume` 原 thread 并 append 一个继续执行 prompt。continuation/judge feedback prompt 只应携带本轮缺口、恢复原因、验收要求和有界原始任务摘要，禁止重新注入完整引用上下文、历史 transcript 或长 JSON；服务重启恢复类 feedback 尤其必须保持短 prompt，依赖现有 thread 上文继续。超长 prompt 必须在 prompt 合成源头解决：每个 feedback/recovery/judge 生成器都要从结构化字段选择必要信息、去重合并缺口并提供按需查询入口，禁止先合成超长 prompt 再在末端用 substring/safePreview 一刀切硬截断；硬截断会静默丢失验收信息，风险高于长 prompt 本身。若 MiniMax `continuePrompt` 超出预算，必须要求 MiniMax 基于原始 judge 输入重新合成紧凑反馈，repair 耗尽后才可进入 fallback；不得把已生成的长 prompt 截尾后发送给 Codex。若 MiniMax 成功返回了预算内 `continuePrompt`，必须原样使用该反馈，不得再用 71-Freq、`period_sum/mpu_read_num`、`mpu_read_num`、历史限流中断等字符串识别把它覆盖成“简洁原始需求 continuation”。只有 judge 判定 `complete` 后，队列 worker 才把当前任务标为成功并推进下一个 queued/retry_wait 任务。非 LLM/fallback 判定产生的 `retry` 最多累计 `3` 次；达到上限后当前任务必须转为 `failed` 并记录原因，worker 继续推进后续 queued/retry_wait 任务，避免 fallback safety override 或硬编码判断造成无限循环。
- Judge 探针：`GET|POST /api/judge/probe` 使用同一套 judge 逻辑跑内置 synthetic execution records，覆盖正常完成、正常结束但只给计划、未上线/未部署的服务或 WebUI 改动、传输中断和用户打断等样本，返回 `hits`、`total`、`hitRate`、每例 `expected` 与 `decision`；该接口不得回显 MiniMax API key。
- 模型选择：默认 Codex 模型是 `gpt-5.5`，内置模型队列包含 `gpt-5.5`、`gpt-5.4-mini`、`gpt-5.4`；`gpt-5.5` 的默认 reasoning effort 必须是 `xhigh`，可通过 `CODE_QUEUE_MODEL_REASONING_EFFORTS` 追加或覆盖模型级默认值；每个入队任务可通过前端模型下拉菜单或 API 覆盖 `model`、`cwd`、`reasoningEffort` 和 `maxAttempts`，`maxAttempts` 上限为 `99`。Judge 判定 `retry` 或非用户取消类 `fail` 时必须继续已有 `codexThreadId`，不能新建 session；重试间隔使用指数退避，从 `1s` 开始，最大 `10min`。MiniMax 不可用而进入 fallback/non-LLM 判定时，当前 attempt 的 429、Too Many Requests、exceeded retry limit、overloaded、stream disconnected 等服务/限流错误应判定为 `retry`，不能当作完成；MiniMax 可用时，这些内容只能作为当前 attempt 的 factual evidence 提供给 MiniMax，不能通过硬编码覆盖 MiniMax 结果。
- 状态与日志：`main-server` 默认工作目录为容器内 `/root/unidesk`，该路径映射主 server 的 `~/unidesk`；同时保留 `/workspace` 映射以兼容历史任务。非主 server Provider 的任务默认工作目录为 `/home/ubuntu`，任务 JSON、列表、Trace 摘要和 CLI 查询都必须显示 `providerId` 与最终 `cwd`。Code Queue 的任务、queue、`readAt`/未读状态、attempt、judge、`promptHistory`、active session 元数据、控制状态和 ClaudeQQ 通知 outbox 一律以主 PostgreSQL 为权威，分别写入 `unidesk_code_queue_tasks`、`unidesk_code_queue_queues` 与 `unidesk_code_queue_notifications`；`DATABASE_URL` 是必需配置，服务不得在 PostgreSQL 缺失或不可用时进入文件存储模式。`.state/code-queue/state.json` 不再作为任务或 queue 状态存储，不得重新引入本地 JSON fallback；服务启动必须以 PostgreSQL 为唯一来源恢复队列，并把 running/judging 任务恢复为 retry_wait。主 server 内存很少，Code Queue 必须把“内存是稀缺资源”作为核心设计约束：历史任务列表、详情、统计和只读 Trace 查询优先从 PostgreSQL 直读，进程内只保留当前 running/judging、queued、retry_wait 等调度必需热任务，不得把全部历史 task JSON 长期缓存到 Bun 堆；需要短期热缓存时必须有严格上限、可裁剪、可从 PostgreSQL 和 append-only 输出归档重建。WebUI 不得用 browser `localStorage`、`sessionStorage` 或 IndexedDB 持久化 task/queue/readAt/unread 等业务状态；浏览器只能保留临时 UI 内存缓存，刷新后必须重新从后端读取 PostgreSQL 权威数据。Codex CLI-like output/Trace 的完整记录可以使用 append-only 文件作为日志型归档，但任务状态、未读状态和列表摘要不得依赖这些文件作为权威来源；`/api/tasks/<id>/transcript` 与 `/api/tasks/<id>/output` 必须能分页重建完整历史，不得因为热状态裁剪而丢失早期 trace。热 task JSON 只保留可配置窗口以保证 `/health`、`/api/tasks` 和 PostgreSQL flush 不被长任务拖死；主 server 为 Code Queue 放宽到 600M 容器预算后仍默认 `CODE_QUEUE_IN_MEMORY_OUTPUT_RECORDS=10`、`CODE_QUEUE_IN_MEMORY_EVENT_RECORDS=10`，启动时必须在 PostgreSQL 查询侧裁剪 hot output/events，并只 flush dirty task，禁止启动后无条件重写全量历史 task JSON；更高预算才允许调大热窗口。WebUI 必须支持多 queue 查看、显式创建 queue、提交时下拉选择 queue、提交时下拉选择执行 Provider，并支持把已创建且非 active 的任务移动到其他 queue；queue 内串行，queue 间可并行，但并行度必须受 `CODE_QUEUE_MAX_ACTIVE_QUEUES` 全局上限约束，600M 容器默认仍只运行 1 个 active queue，避免多个 Codex app-server 同时把容器推过内存上限。Code Queue 镜像必须内置 Playwright Chromium 浏览器与系统依赖，并使用 `bun --smol` 运行后端，保证队列任务能直接执行公网 frontend Playwright 回归且主进程内存可控，不得只在宿主机临时安装。日志写入 UniDesk `logs/{YYYYMMDD}/{startStamp}_{YYYYMMDD}_{HH}_code-queue.jsonl`，按小时切片并按日志族默认保留 `1GiB`；Codex app-server 上游产生的 `logs_*.sqlite` 只能作为短暂缓冲，必须由 Code Queue 周期性导出为 `logs/{YYYYMMDD}/{startStamp}_{YYYYMMDD}_{HH}_codex-app-server.jsonl`，导出后删除/压缩已导出的 SQLite 行，避免重新形成 `logs_2.sqlite` 大文件；`/logs` 端点返回最近结构化日志。`/health` 的 `queue.storage.primary` 必须恒为 `postgres`，并通过 `queue.storage.postgresReady`、`queue.devReady` 和 `/api/dev-ready` 暴露 PostgreSQL 可用性、develop-ready 自检、必需工具、Docker socket、`docker compose`、默认工作目录、Codex config 状态和 `/root/.ssh` 共享 SSH key 状态。Codex CLI-like 输出可能很大，服务必须节流状态持久化，禁止对每个 output delta 同步重写完整 state 导致 `/health` 和控制 API 卡死；容器 healthcheck 必须使用带超时的 HTTP 探针，不能留下堆积的无超时探针进程。
- 状态与日志：`main-server` 默认工作目录为容器内 `/root/unidesk`，该路径映射主 server 的 `~/unidesk`；同时保留 `/workspace` 映射以兼容历史任务。非主 server Provider 的任务默认工作目录为 `/home/ubuntu`，任务 JSON、列表、Trace 摘要和 CLI 查询都必须显示 `providerId` 与最终 `cwd`。Code Queue 的任务、queue、`readAt`/未读状态、attempt、judge、`promptHistory`、active session 元数据、控制状态和 ClaudeQQ 通知 outbox 一律以主 PostgreSQL 为权威，分别写入 `unidesk_code_queue_tasks`、`unidesk_code_queue_queues` 与 `unidesk_code_queue_notifications`；`DATABASE_URL` 是必需配置，服务不得在 PostgreSQL 缺失或不可用时进入文件存储模式。`.state/code-queue/state.json` 不再作为任务或 queue 状态存储，不得重新引入本地 JSON fallback；服务启动必须以 PostgreSQL 为唯一来源恢复队列，并把 running/judging 任务恢复为 retry_wait。主 server 内存很少，Code Queue 必须把“内存是稀缺资源”作为核心设计约束：历史任务列表、详情、统计和只读 Trace 查询优先从 PostgreSQL 直读，进程内只保留当前 running/judging、queued、retry_wait 等调度必需热任务，不得把全部历史 task JSON 长期缓存到 Bun 堆；需要短期热缓存时必须有严格上限、可裁剪、可从 PostgreSQL 和 append-only 输出归档重建。WebUI 不得用 browser `localStorage`、`sessionStorage` 或 IndexedDB 持久化 task/queue/readAt/unread 等业务状态；浏览器只能保留临时 UI 内存缓存，刷新后必须重新从后端读取 PostgreSQL 权威数据。Codex CLI-like output/Trace 的完整记录可以使用 append-only 文件作为日志型归档，但任务状态、未读状态和列表摘要不得依赖这些文件作为权威来源；`/api/tasks/<id>/transcript` 与 `/api/tasks/<id>/output` 必须能分页重建完整历史，不得因为热状态裁剪而丢失早期 trace。热 task JSON 只保留可配置窗口以保证 `/health`、`/api/tasks` 和 PostgreSQL flush 不被长任务拖死；主 server 为 Code Queue 放宽到 600M 容器预算后仍默认 `CODE_QUEUE_IN_MEMORY_OUTPUT_RECORDS=10`、`CODE_QUEUE_IN_MEMORY_EVENT_RECORDS=10`，启动时必须在 PostgreSQL 查询侧裁剪 hot output/events，并只 flush dirty task，禁止启动后无条件重写全量历史 task JSON；更高预算才允许调大热窗口。WebUI 必须支持多 queue 查看、显式创建 queue、提交时下拉选择 queue、提交时下拉选择执行 Provider，并支持把已创建且非 active 的任务移动到其他 queue；queue 内串行，queue 间默认并行且不互相排队；`CODE_QUEUE_MAX_ACTIVE_QUEUES` 仅作为显式配置的全局 active slot 上限，`0` 表示不按 queue 数量限流，内存不足时由 cgroup memory pressure 阻止新 run 并在任务响应中暴露 `QUEUED(MEM LIMIT)`。Code Queue 镜像必须内置 Playwright Chromium 浏览器与系统依赖，并使用 `bun --smol` 运行后端，保证队列任务能直接执行公网 frontend Playwright 回归且主进程内存可控，不得只在宿主机临时安装。日志写入 UniDesk `logs/{YYYYMMDD}/{startStamp}_{YYYYMMDD}_{HH}_code-queue.jsonl`，按小时切片并按日志族默认保留 `1GiB`；Codex app-server 上游产生的 `logs_*.sqlite` 只能作为短暂缓冲，必须由 Code Queue 周期性导出为 `logs/{YYYYMMDD}/{startStamp}_{YYYYMMDD}_{HH}_codex-app-server.jsonl`，导出后删除/压缩已导出的 SQLite 行，避免重新形成 `logs_2.sqlite` 大文件；`/logs` 端点返回最近结构化日志。`/health` 的 `queue.storage.primary` 必须恒为 `postgres`，并通过 `queue.storage.postgresReady`、`queue.devReady` 和 `/api/dev-ready` 暴露 PostgreSQL 可用性、develop-ready 自检、必需工具、Docker socket、`docker compose`、默认工作目录、Codex config 状态和 `/root/.ssh` 共享 SSH key 状态。Codex CLI-like 输出可能很大，服务必须节流状态持久化，禁止对每个 output delta 同步重写完整 state 导致 `/health` 和控制 API 卡死；容器 healthcheck 必须使用带超时的 HTTP 探针，不能留下堆积的无超时探针进程。
- ClaudeQQ 通知：Code Queue 可通过 backend-core 的 `claudeqq` 用户服务代理调用 `POST /api/push/text`，在每个任务进入 `succeeded`、`failed` 或 `canceled` 终态后向配置目标发送最终 response，并附带 task id、queue、状态、模型、attempt、当前 running/queued/retry_wait 数和任务总耗时；当所有 queue 进入 `0 running / 0 queued` 空闲态时，必须单独发送一次空闲提醒。通知由 `CODE_QUEUE_NOTIFY_CLAUDEQQ_ENABLED` 控制，目标由 `CODE_QUEUE_NOTIFY_CLAUDEQQ_TARGET_TYPE=private|group`、`CODE_QUEUE_NOTIFY_CLAUDEQQ_USER_ID`、`CODE_QUEUE_NOTIFY_CLAUDEQQ_GROUP_ID` 配置，默认私聊 `645275593`；代理基址、最终 response 最大字符数、单次超时和发送尝试次数分别由 `CODE_QUEUE_NOTIFY_CLAUDEQQ_BASE_URL`、`CODE_QUEUE_NOTIFY_CLAUDEQQ_MAX_RESPONSE_CHARS`、`CODE_QUEUE_NOTIFY_CLAUDEQQ_TIMEOUT_MS` 和 `CODE_QUEUE_NOTIFY_CLAUDEQQ_SEND_ATTEMPTS` 配置。任务终态和队列空闲通知必须先写入 PostgreSQL outbox 表 `unidesk_code_queue_notifications` 再异步发送；不得使用 `.state/code-queue/claudeqq-notifications.json`、`CODE_QUEUE_NOTIFY_CLAUDEQQ_OUTBOX_PATH` 或任何本地 JSON 作为通知权威存储。发送失败、NapCat 离线、代理 502 或容器重启时不能丢通知，必须按 `CODE_QUEUE_NOTIFY_CLAUDEQQ_RETRY_INTERVAL_MS` 指数退避重试并跨进程/容器重启保留。`/health` 的 `queue.notifications.claudeqq` 必须暴露非敏感配置、目标配置状态和 PostgreSQL outbox 统计；`GET /api/notifications/claudeqq` 返回 outbox 明细，`POST /api/notifications/claudeqq/drain` 手动触发发送，`POST /api/notifications/claudeqq/backfill` 可按 `since` 补入某次故障窗口内已终态任务，确保 QQ/NapCat 超时或离线不会让任务完成通知永久丢失。
- 代理路径：只允许 `/health`、`/logs` 和 `/api/` 前缀；允许方法为 `GET`、`HEAD`、`POST`、`DELETE`。Code Queue 只在 Compose 内网暴露 `4222/tcp`，不得映射或开放到公网。
- UniDesk 前端：`用户服务 / Code Queue` React 页面负责展示队列卡片、任务 ID、复制任务 ID、引用按钮、任务耗时、默认模型、模型下拉、执行 Provider 下拉、Provider 对应默认工作目录、显式入队份数、引用任务 ID、清空输入、创建成功提示、MiniMax judge 状态、Codex CLI-like 输出流、attempt 终态、追加 prompt、打断和手动重试控件；整个 agent loop 消息流统一命名为专有名词 `Trace`，`Trace` 包含 assistant message、user prompt、system event 和 tool call；Code Queue 与 Pipeline/OpenCode messages 必须共用 `src/components/frontend/src/trace.tsx` 的 Trace 公共组件、统一 Trace item 接口和 codex/opencode port 适配层；连续 read/edit/run 工具调用只是在 Trace 内折叠为可展开工具调用组，汇总格式至少包含 `xx read, xx edit, xx run`，并展示读取文件、编辑文件、运行命令和耗时摘要；最近 3 个工具调用保持展开，工具调用内容不得自动换行且必须在工具调用块内部横向滚动，工具调用组展开后不得再增加额外左侧缩进；message 与 prompt 必须自动换行，普通 message 不显示左侧项目符号缩进且永不折叠；点击队列卡片引用按钮必须自动把该任务 ID 写入提交表单的引用任务 ID 输入框；引用任务 ID 创建新任务时必须自动注入 `bun scripts/cli.ts codex task <taskId>` 的提示，让 Codex 读取初始 prompt、最后消息和工具摘要后继续；连续执行同一 prompt 应使用 `入队份数` 一次性生成多条队列任务，而不是依赖快速连点按钮；原始任务 JSON 只能通过显式 `查看原始JSON` 打开。
- UniDesk 前端：`用户服务 / Code Queue` React 页面负责展示队列卡片、任务 ID、复制任务 ID、引用按钮、任务耗时、默认模型、模型下拉、执行 Provider 下拉、Provider 对应默认工作目录、显式入队份数、引用任务 ID、清空输入、创建成功提示、MiniMax judge 状态、Codex CLI-like 输出流、attempt 终态、追加 prompt、打断和手动重试控件；整个 agent loop 消息流统一命名为专有名词 `Trace`，`Trace` 包含 assistant message、user prompt、system event 和 tool call；Code Queue 与 Pipeline/OpenCode messages 必须共用 `src/components/frontend/src/trace.tsx` 的 Trace 公共组件、统一 Trace item 接口和 codex/opencode port 适配层；连续 read/edit/run 工具调用只是在 Trace 内折叠为可展开工具调用组，汇总格式至少包含 `xx read, xx edit, xx run`，并展示读取文件、编辑文件、运行命令和耗时摘要；最近 3 个工具调用保持展开，工具调用内容不得自动换行且必须在工具调用块内部横向滚动，工具调用组展开后不得再增加额外左侧缩进；message 与 prompt 必须自动换行，普通 message 不显示左侧项目符号缩进且永不折叠；点击队列卡片引用按钮必须自动把该任务 ID 写入提交表单的引用任务 ID 输入框；引用任务 ID 创建新任务时必须自动注入 `bun scripts/cli.ts codex task <taskId>` 的提示，让 Codex 读取初始 prompt、最后消息和工具摘要后继续；连续执行同一 prompt 应使用 `入队份数` 一次性生成多条队列任务，而不是依赖快速连点按钮；左侧 queue/session 卡片的 `QUEUED` 状态必须显示原因，例如 `QUEUED(PREV TASK)`、`QUEUED(MEM LIMIT)`、`QUEUED(ACTIVE LIMIT)`；原始任务 JSON 只能通过显式 `查看原始JSON` 打开。
## D601 User Services
scripts/cli.ts
+8
View File
@@ -10,6 +10,7 @@ import { extractRemoteCliOptions, runRemoteCli } from "./src/remote";
import { runMicroserviceCommand } from "./src/microservices";
import { runCodeQueueCommand } from "./src/code-queue";
import { runProviderCommand } from "./src/provider-attach";
import { runScheduleCommand } from "./src/schedules";
const remoteOptions = extractRemoteCliOptions(process.argv.slice(2));
const args = remoteOptions.args;
@@ -41,6 +42,8 @@ function help(): unknown {
{ command: "microservice status <id>", description: "Show one user service config, repository reference, backend mapping, and runtime status." },
{ command: "microservice health <id>", description: "Probe one user service through backend-core -> provider-gateway HTTP proxy." },
{ command: "microservice proxy <id> <path> [--method GET|POST|PUT|PATCH|DELETE] [--raw] [--max-body-bytes N]", description: "Access a private user-service backend path through the same frontend-only proxy used by WebUI; large bodies are summarized unless --raw is set." },
{ command: "schedule list|get|runs|run|delete", description: "Manage backend-core scheduled tasks and run history; schedule run <id> supports --wait-ms N." },
{ command: "schedule upsert-pgdata-backup [--time HH:MM] [--remote-base /SERVER_DATA/UNIDESK_PG_DATA]", description: "Create or update the daily PGDATA physical backup task that uploads monthly rotated archives to Baidu Netdisk." },
{ command: "codex task <taskId> [--trace --tail|--from-start|--after-seq N|--before-seq N --limit N] [--full]", description: "Fetch a compact Code Queue task summary; trace rows are opt-in and paged with next/previous commands to avoid output explosion." },
{ command: "codex output <taskId> [--tail|--from-start|--after-seq N|--before-seq N --limit N] [--full-text]", description: "Fetch paged raw Code Queue output records by seq when a trace row has omitted command/output text." },
{ command: "codex (queues | queue create <queueId> | move <taskId> --queue <queueId>)", description: "List/create Code Queue lanes and move a queued task so each queue runs serially while queues run in parallel." },
@@ -178,6 +181,11 @@ async function main(): Promise<void> {
return;
}
if (top === "schedule") {
emitJson(commandName, await runScheduleCommand(config, args.slice(1)));
return;
}
if (top === "codex") {
emitJson(commandName, await runCodeQueueCommand(config, args.slice(1)));
return;
scripts/src/e2e.ts
+1
View File
@@ -301,6 +301,7 @@ const LAYOUT_OVERFLOW_PAGE_TEST_IDS: Record<string, string> = {
"/nodes/gateway/": "gateway-version-page",
"/tasks/pending/": "pending-task-page",
"/tasks/history/": "task-history-page",
"/tasks/scheduled/": "scheduled-task-page",
"/app/catalog/": "microservice-catalog-page",
"/app/todo-note/": "todo-note-page",
"/app/findjob/": "findjob-page",
scripts/src/schedules.ts
+110
View File
@@ -0,0 +1,110 @@
import { type UniDeskConfig } from "./config";
import { coreInternalFetch } from "./microservices";
function stringOption(args: string[], name: string): string | undefined {
const index = args.indexOf(name);
if (index === -1) return undefined;
const raw = args[index + 1];
if (raw === undefined || raw.length === 0) throw new Error(`${name} requires a non-empty value`);
return raw;
}
function numberOption(args: string[], name: string, defaultValue: number): number {
const raw = stringOption(args, name);
if (raw === undefined) return defaultValue;
const value = Number(raw);
if (!Number.isInteger(value) || value <= 0) throw new Error(`${name} must be a positive integer`);
return value;
}
function booleanOption(args: string[], name: string, defaultValue: boolean): boolean {
const raw = stringOption(args, name);
if (raw === undefined) return defaultValue;
if (["1", "true", "yes", "on"].includes(raw.toLowerCase())) return true;
if (["0", "false", "no", "off"].includes(raw.toLowerCase())) return false;
throw new Error(`${name} must be true or false`);
}
function responseBody(response: unknown): Record<string, unknown> {
if (typeof response !== "object" || response === null || Array.isArray(response)) return {};
const body = (response as { body?: unknown }).body;
return typeof body === "object" && body !== null && !Array.isArray(body) ? body as Record<string, unknown> : {};
}
function terminalRunStatus(status: unknown): boolean {
return ["succeeded", "failed", "skipped"].includes(String(status || ""));
}
async function waitForScheduleRun(scheduleId: string, runId: string, timeoutMs: number): Promise<unknown> {
const started = Date.now();
let latest: unknown = null;
while (Date.now() - started < timeoutMs) {
latest = coreInternalFetch(`/api/schedules/${encodeURIComponent(scheduleId)}/runs?limit=20`);
const runs = responseBody(latest).runs;
if (Array.isArray(runs)) {
const run = runs.find((item) => typeof item === "object" && item !== null && (item as { id?: unknown }).id === runId);
if (run !== undefined && terminalRunStatus((run as { status?: unknown }).status)) return { ok: true, run };
}
await Bun.sleep(2000);
}
return { ok: false, timeoutMs, latest };
}
function pgdataBackupScheduleBody(config: UniDeskConfig, args: string[]): Record<string, unknown> {
const id = stringOption(args, "--id") ?? "unidesk-pgdata-baidu-daily";
const timeOfDay = stringOption(args, "--time") ?? "03:30";
const remoteBaseDir = stringOption(args, "--remote-base") ?? "/SERVER_DATA/UNIDESK_PG_DATA";
const stagingSubdir = stringOption(args, "--staging-subdir") ?? "server-data/unidesk-pg-data";
const enabled = args.includes("--disabled") ? false : booleanOption(args, "--enabled", true);
const timeoutMs = numberOption(args, "--timeout-ms", 60 * 60_000);
return {
id,
name: "PGDATA daily Baidu Netdisk backup",
description: "Daily PostgreSQL physical base backup uploaded to Baidu Netdisk /SERVER_DATA with monthly rotation.",
enabled,
concurrencyPolicy: "skip",
schedule: { type: "daily", timeOfDay, timezone: config.project.timezone || "Etc/UTC" },
action: {
type: "pgdata_backup",
volumeName: config.database.volume,
remoteBaseDir,
stagingSubdir,
baiduBaseUrl: "http://baidu-netdisk:4244",
timeoutMs,
cleanupLocal: true,
},
};
}
export async function runScheduleCommand(config: UniDeskConfig, args: string[]): Promise<unknown> {
const [action = "list", idArg] = args;
if (action === "list") return coreInternalFetch("/api/schedules?limit=200");
if (action === "get") {
if (!idArg) throw new Error("schedule get requires schedule id");
return coreInternalFetch(`/api/schedules/${encodeURIComponent(idArg)}`);
}
if (action === "runs") {
const limit = numberOption(args, "--limit", 50);
return idArg
? coreInternalFetch(`/api/schedules/${encodeURIComponent(idArg)}/runs?limit=${limit}`)
: coreInternalFetch(`/api/schedules/runs?limit=${limit}`);
}
if (action === "delete") {
if (!idArg) throw new Error("schedule delete requires schedule id");
return coreInternalFetch(`/api/schedules/${encodeURIComponent(idArg)}`, { method: "DELETE" });
}
if (action === "run") {
if (!idArg) throw new Error("schedule run requires schedule id");
const response = coreInternalFetch(`/api/schedules/${encodeURIComponent(idArg)}/run`, { method: "POST", body: {} });
const run = responseBody(response).run as { id?: unknown } | undefined;
const waitMs = numberOption(args, "--wait-ms", 0);
const wait = waitMs > 0 && typeof run?.id === "string" ? await waitForScheduleRun(idArg, run.id, waitMs) : null;
return { trigger: response, wait };
}
if (action === "upsert-pgdata-backup" || action === "pgdata-backup") {
const body = pgdataBackupScheduleBody(config, args);
const id = String(body.id || "unidesk-pgdata-baidu-daily");
return coreInternalFetch(`/api/schedules/${encodeURIComponent(id)}`, { method: "PUT", body });
}
throw new Error("schedule command must be one of: list, get, runs, run, delete, upsert-pgdata-backup");
}
src/components/backend-core/Dockerfile
+1
View File
@@ -1,4 +1,5 @@
FROM oven/bun:1-alpine
RUN apk add --no-cache postgresql16-client tar gzip
WORKDIR /app/src/components/backend-core
COPY src/components/backend-core/package.json ./package.json
RUN bun install --production
src/components/backend-core/src/index.ts
+825
View File
@@ -1,4 +1,8 @@
import type { Server, ServerWebSocket } from "bun";
import { createHash } from "node:crypto";
import { createReadStream } from "node:fs";
import { mkdir, rm, stat } from "node:fs/promises";
import { basename, dirname, relative, resolve, posix as pathPosix } from "node:path";
import postgres from "postgres";
import { createHourlyJsonlWriter, logRetentionBytesForService } from "../../shared/src/rotating-jsonl";
import {
@@ -33,6 +37,8 @@ interface RuntimeConfig {
taskPendingTimeoutMs: number;
databaseVolumeName: string;
databaseVolumeSize: string;
pgdataBackupStagingDir: string;
baiduNetdiskInternalUrl: string;
microservices: MicroserviceConfig[];
logFile: string;
}
@@ -112,6 +118,63 @@ interface RawTaskRow {
updated_at: Date | string;
}
interface ScheduledTaskRow {
id: string;
name: string;
description: string;
enabled: boolean;
schedule_json: JsonValue;
action_json: JsonValue;
concurrency_policy: string;
next_run_at: Date | string | null;
last_run_at: Date | string | null;
last_run_id: string | null;
created_at: Date | string;
updated_at: Date | string;
}
interface ScheduledTaskRunRow {
id: string;
schedule_id: string;
trigger_type: string;
status: string;
task_id: string | null;
result: JsonValue | null;
error: string | null;
started_at: Date | string | null;
finished_at: Date | string | null;
duration_ms: number | string | null;
created_at: Date | string;
updated_at: Date | string;
}
interface ScheduleSpec {
type: "daily" | "interval";
timeOfDay?: string;
timezone?: string;
everySeconds?: number;
}
interface DispatchScheduleAction {
type: "dispatch";
providerId: string;
command: CoreDispatchMessage["command"];
payload: Record<string, JsonValue>;
timeoutMs?: number;
}
interface PgdataBackupScheduleAction {
type: "pgdata_backup";
volumeName: string;
remoteBaseDir: string;
stagingSubdir: string;
baiduBaseUrl: string;
timeoutMs: number;
cleanupLocal: boolean;
}
type ScheduleAction = DispatchScheduleAction | PgdataBackupScheduleAction;
type TaskTerminalWaiter = (task: RawTaskRow | null) => void;
interface MicroserviceProxyCacheEntry {
@@ -141,6 +204,7 @@ const maxPerformanceSamples = 3000;
const taskTerminalWaiters = new Map<string, Set<TaskTerminalWaiter>>();
const microserviceProxyCache = new Map<string, MicroserviceProxyCacheEntry>();
const microserviceProxyRefreshes = new Map<string, Promise<void>>();
const activeScheduledRuns = new Set<string>();
let lastTaskSweepAt = 0;
let taskSweepInFlight: Promise<void> | null = null;
const microserviceProxyMaxBodyTextLength = 8 * 1024 * 1024;
@@ -280,6 +344,8 @@ function readConfig(): RuntimeConfig {
taskPendingTimeoutMs: readOptionalNumberEnv("TASK_PENDING_TIMEOUT_MS", 10 * 60 * 1000),
databaseVolumeName: requiredEnv("DATABASE_VOLUME_NAME"),
databaseVolumeSize: requiredEnv("DATABASE_VOLUME_SIZE"),
pgdataBackupStagingDir: process.env.PGDATA_BACKUP_STAGING_DIR || "/data/baidu-netdisk-staging",
baiduNetdiskInternalUrl: process.env.BAIDU_NETDISK_INTERNAL_URL || "http://baidu-netdisk:4244",
microservices: readMicroservicesEnv(),
logFile: requiredEnv("LOG_FILE"),
};
@@ -342,6 +408,7 @@ function classifyRequestComponent(pathname: string): string {
if (pathname.startsWith("/api/nodes/")) return "node_metrics_api";
if (pathname === "/api/nodes") return "node_inventory_api";
if (pathname.startsWith("/api/tasks")) return "scheduler_api";
if (pathname.startsWith("/api/schedules")) return "scheduler_api";
if (pathname.startsWith("/api/events")) return "event_api";
if (pathname.startsWith("/api/performance")) return "performance_api";
if (pathname.startsWith("/api/")) return "core_api";
@@ -556,6 +623,38 @@ async function initDatabase(client: SqlClient): Promise<void> {
updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
)
`;
await client`
CREATE TABLE IF NOT EXISTS unidesk_scheduled_tasks (
id TEXT PRIMARY KEY,
name TEXT NOT NULL,
description TEXT NOT NULL DEFAULT '',
enabled BOOLEAN NOT NULL DEFAULT true,
schedule_json JSONB NOT NULL DEFAULT '{}'::jsonb,
action_json JSONB NOT NULL DEFAULT '{}'::jsonb,
concurrency_policy TEXT NOT NULL DEFAULT 'skip',
next_run_at TIMESTAMPTZ,
last_run_at TIMESTAMPTZ,
last_run_id TEXT,
created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
)
`;
await client`
CREATE TABLE IF NOT EXISTS unidesk_scheduled_task_runs (
id TEXT PRIMARY KEY,
schedule_id TEXT NOT NULL REFERENCES unidesk_scheduled_tasks(id) ON DELETE CASCADE,
trigger_type TEXT NOT NULL,
status TEXT NOT NULL,
task_id TEXT,
result JSONB,
error TEXT,
started_at TIMESTAMPTZ,
finished_at TIMESTAMPTZ,
duration_ms BIGINT,
created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
)
`;
await client`
CREATE TABLE IF NOT EXISTS unidesk_node_docker_status (
provider_id TEXT PRIMARY KEY,
@@ -586,6 +685,9 @@ async function initDatabase(client: SqlClient): Promise<void> {
`;
await client`CREATE INDEX IF NOT EXISTS idx_unidesk_tasks_updated_at ON unidesk_tasks(updated_at DESC)`;
await client`CREATE INDEX IF NOT EXISTS idx_unidesk_tasks_status_updated_at ON unidesk_tasks(status, updated_at DESC)`;
await client`CREATE INDEX IF NOT EXISTS idx_unidesk_scheduled_tasks_next_run ON unidesk_scheduled_tasks(enabled, next_run_at)`;
await client`CREATE INDEX IF NOT EXISTS idx_unidesk_scheduled_task_runs_schedule_updated ON unidesk_scheduled_task_runs(schedule_id, updated_at DESC)`;
await client`CREATE INDEX IF NOT EXISTS idx_unidesk_scheduled_task_runs_status_updated ON unidesk_scheduled_task_runs(status, updated_at DESC)`;
await client`CREATE INDEX IF NOT EXISTS idx_unidesk_node_system_status_updated_at ON unidesk_node_system_status(updated_at DESC)`;
await client`CREATE INDEX IF NOT EXISTS idx_unidesk_node_metric_samples_provider_time ON unidesk_node_metric_samples(provider_id, collected_at DESC)`;
dbReady = true;
@@ -1501,6 +1603,720 @@ async function waitForTaskTerminal(taskId: string, timeoutMs: number): Promise<R
});
}
function rowIso(value: Date | string | null | undefined): string | null {
if (value === null || value === undefined) return null;
return value instanceof Date ? value.toISOString() : String(value);
}
function isJsonRecord(value: unknown): value is Record<string, JsonValue> {
return typeof value === "object" && value !== null && !Array.isArray(value);
}
function scheduleRunView(row: ScheduledTaskRunRow): JsonValue {
return {
id: row.id,
scheduleId: row.schedule_id,
trigger: row.trigger_type,
status: row.status,
taskId: row.task_id,
result: compactJson(row.result ?? null),
error: row.error ?? "",
startedAt: rowIso(row.started_at),
finishedAt: rowIso(row.finished_at),
durationMs: row.duration_ms === null ? null : Number(row.duration_ms),
createdAt: rowIso(row.created_at),
updatedAt: rowIso(row.updated_at),
};
}
function scheduledTaskView(row: ScheduledTaskRow, runs: ScheduledTaskRunRow[] = []): JsonValue {
return {
id: row.id,
name: row.name,
description: row.description,
enabled: row.enabled,
schedule: row.schedule_json,
action: row.action_json,
concurrencyPolicy: row.concurrency_policy,
nextRunAt: rowIso(row.next_run_at),
lastRunAt: rowIso(row.last_run_at),
lastRunId: row.last_run_id,
createdAt: rowIso(row.created_at),
updatedAt: rowIso(row.updated_at),
recentRuns: runs.map(scheduleRunView),
};
}
function normalizeScheduleId(value: unknown): string {
const raw = typeof value === "string" && value.trim().length > 0
? value.trim()
: `schedule_${Date.now()}_${Math.random().toString(16).slice(2, 8)}`;
if (!/^[A-Za-z0-9_.:-]{1,120}$/u.test(raw)) {
throw new Error("schedule id must be 1-120 chars using letters, numbers, _, ., :, or -");
}
return raw;
}
function normalizeTimeOfDay(value: unknown): string {
const raw = typeof value === "string" && value.trim().length > 0 ? value.trim() : "03:00";
const match = raw.match(/^([01]\d|2[0-3]):([0-5]\d)$/u);
if (match === null) throw new Error("daily schedule timeOfDay must use HH:MM in UTC");
return `${match[1]}:${match[2]}`;
}
function numberInRange(value: unknown, fallback: number, min: number, max: number): number {
const parsed = typeof value === "number" ? value : typeof value === "string" ? Number(value) : fallback;
if (!Number.isFinite(parsed)) return fallback;
return Math.max(min, Math.min(max, Math.floor(parsed)));
}
function normalizeScheduleSpec(value: unknown): ScheduleSpec {
const record = isJsonRecord(value) ? value : {};
if (record.type === "interval") {
return {
type: "interval",
everySeconds: numberInRange(record.everySeconds, 3600, 60, 366 * 24 * 3600),
};
}
return {
type: "daily",
timeOfDay: normalizeTimeOfDay(record.timeOfDay),
timezone: typeof record.timezone === "string" && record.timezone.length > 0 ? record.timezone : "Etc/UTC",
};
}
function normalizeScheduleAction(value: unknown): ScheduleAction {
if (!isJsonRecord(value)) throw new Error("scheduled task action must be an object");
if (value.type === "dispatch") {
const providerId = typeof value.providerId === "string" ? value.providerId.trim() : "";
if (providerId.length === 0) throw new Error("dispatch action providerId is required");
if (!isProviderDispatchCommand(value.command)) throw new Error("dispatch action command is invalid");
const payload = isJsonRecord(value.payload) ? value.payload : {};
const timeoutMs = value.timeoutMs === undefined ? undefined : numberInRange(value.timeoutMs, config.taskPendingTimeoutMs, 1_000, 24 * 3600_000);
return { type: "dispatch", providerId, command: value.command, payload, ...(timeoutMs === undefined ? {} : { timeoutMs }) };
}
if (value.type === "pgdata_backup") {
return {
type: "pgdata_backup",
volumeName: typeof value.volumeName === "string" && value.volumeName.length > 0 ? value.volumeName : config.databaseVolumeName,
remoteBaseDir: normalizeRemoteDir(typeof value.remoteBaseDir === "string" ? value.remoteBaseDir : "/SERVER_DATA/UNIDESK_PG_DATA"),
stagingSubdir: normalizeRelativeStagingPath(typeof value.stagingSubdir === "string" ? value.stagingSubdir : "server-data/unidesk-pg-data").relativePath,
baiduBaseUrl: typeof value.baiduBaseUrl === "string" && value.baiduBaseUrl.length > 0 ? value.baiduBaseUrl : config.baiduNetdiskInternalUrl,
timeoutMs: numberInRange(value.timeoutMs, 60 * 60_000, 60_000, 24 * 3600_000),
cleanupLocal: value.cleanupLocal !== false,
};
}
throw new Error("scheduled task action.type must be dispatch or pgdata_backup");
}
function computeNextRunAt(schedule: ScheduleSpec, after = new Date()): Date {
if (schedule.type === "interval") {
return new Date(after.getTime() + Math.max(60, schedule.everySeconds ?? 3600) * 1000);
}
const [hourText = "03", minuteText = "00"] = (schedule.timeOfDay ?? "03:00").split(":");
const candidate = new Date(Date.UTC(after.getUTCFullYear(), after.getUTCMonth(), after.getUTCDate(), Number(hourText), Number(minuteText), 0, 0));
if (candidate.getTime() <= after.getTime()) candidate.setUTCDate(candidate.getUTCDate() + 1);
return candidate;
}
async function getScheduledTasks(limit: number): Promise<JsonValue[]> {
const rows = await sql<ScheduledTaskRow[]>`
SELECT *
FROM unidesk_scheduled_tasks
ORDER BY enabled DESC, next_run_at ASC NULLS LAST, updated_at DESC
LIMIT ${limit}
`;
const runRows = await sql<ScheduledTaskRunRow[]>`
SELECT *
FROM unidesk_scheduled_task_runs
ORDER BY updated_at DESC
LIMIT ${Math.max(20, limit * 5)}
`;
const runsBySchedule = new Map<string, ScheduledTaskRunRow[]>();
for (const run of runRows) {
const list = runsBySchedule.get(run.schedule_id) ?? [];
if (list.length < 5) list.push(run);
runsBySchedule.set(run.schedule_id, list);
}
return rows.map((row) => scheduledTaskView(row, runsBySchedule.get(row.id) ?? []));
}
async function getScheduledTaskRuns(scheduleId: string | null, limit: number): Promise<JsonValue[]> {
const rows = scheduleId === null
? await sql<ScheduledTaskRunRow[]>`
SELECT *
FROM unidesk_scheduled_task_runs
ORDER BY updated_at DESC
LIMIT ${limit}
`
: await sql<ScheduledTaskRunRow[]>`
SELECT *
FROM unidesk_scheduled_task_runs
WHERE schedule_id = ${scheduleId}
ORDER BY updated_at DESC
LIMIT ${limit}
`;
return rows.map(scheduleRunView);
}
async function getScheduledTaskRow(scheduleId: string): Promise<ScheduledTaskRow | null> {
const rows = await sql<ScheduledTaskRow[]>`
SELECT *
FROM unidesk_scheduled_tasks
WHERE id = ${scheduleId}
LIMIT 1
`;
return rows[0] ?? null;
}
async function upsertScheduledTask(req: Request, scheduleIdFromPath: string | null): Promise<Response> {
const body = await req.json().catch(() => ({})) as Record<string, unknown>;
const id = normalizeScheduleId(scheduleIdFromPath ?? body.id);
const schedule = normalizeScheduleSpec(body.schedule);
const action = normalizeScheduleAction(body.action);
const name = typeof body.name === "string" && body.name.trim().length > 0 ? body.name.trim() : id;
const description = typeof body.description === "string" ? body.description : "";
const enabled = typeof body.enabled === "boolean" ? body.enabled : true;
const concurrencyPolicy = body.concurrencyPolicy === "parallel" ? "parallel" : "skip";
const existing = await getScheduledTaskRow(id);
const nextRunAt = existing?.next_run_at && JSON.stringify(existing.schedule_json) === JSON.stringify(schedule)
? rowIso(existing.next_run_at)
: computeNextRunAt(schedule).toISOString();
const scheduleJson = schedule as unknown as JsonValue;
const actionJson = action as unknown as JsonValue;
const rows = await sql<ScheduledTaskRow[]>`
INSERT INTO unidesk_scheduled_tasks (id, name, description, enabled, schedule_json, action_json, concurrency_policy, next_run_at, updated_at)
VALUES (${id}, ${name}, ${description}, ${enabled}, ${sql.json(scheduleJson)}, ${sql.json(actionJson)}, ${concurrencyPolicy}, ${nextRunAt}, now())
ON CONFLICT (id) DO UPDATE SET
name = EXCLUDED.name,
description = EXCLUDED.description,
enabled = EXCLUDED.enabled,
schedule_json = EXCLUDED.schedule_json,
action_json = EXCLUDED.action_json,
concurrency_policy = EXCLUDED.concurrency_policy,
next_run_at = EXCLUDED.next_run_at,
updated_at = now()
RETURNING *
`;
await recordEvent(existing === null ? "scheduled_task_created" : "scheduled_task_updated", "scheduler", { scheduleId: id, name, enabled, schedule: scheduleJson, action: compactJson(action) });
return jsonResponse({ ok: true, schedule: scheduledTaskView(rows[0]) }, existing === null ? 201 : 200);
}
async function patchScheduledTask(scheduleId: string, req: Request): Promise<Response> {
const current = await getScheduledTaskRow(scheduleId);
if (current === null) return jsonResponse({ ok: false, error: `scheduled task not found: ${scheduleId}` }, 404);
const body = await req.json().catch(() => ({})) as Record<string, unknown>;
const schedule = body.schedule === undefined ? normalizeScheduleSpec(current.schedule_json) : normalizeScheduleSpec(body.schedule);
const action = body.action === undefined ? normalizeScheduleAction(current.action_json) : normalizeScheduleAction(body.action);
const name = typeof body.name === "string" && body.name.trim().length > 0 ? body.name.trim() : current.name;
const description = typeof body.description === "string" ? body.description : current.description;
const enabled = typeof body.enabled === "boolean" ? body.enabled : current.enabled;
const concurrencyPolicy = body.concurrencyPolicy === "parallel" || body.concurrencyPolicy === "skip" ? body.concurrencyPolicy : current.concurrency_policy;
const scheduleChanged = body.schedule !== undefined && JSON.stringify(schedule) !== JSON.stringify(current.schedule_json);
const nextRunAt = scheduleChanged || current.next_run_at === null ? computeNextRunAt(schedule).toISOString() : rowIso(current.next_run_at);
const scheduleJson = schedule as unknown as JsonValue;
const actionJson = action as unknown as JsonValue;
const rows = await sql<ScheduledTaskRow[]>`
UPDATE unidesk_scheduled_tasks
SET name = ${name},
description = ${description},
enabled = ${enabled},
schedule_json = ${sql.json(scheduleJson)},
action_json = ${sql.json(actionJson)},
concurrency_policy = ${concurrencyPolicy},
next_run_at = ${nextRunAt},
updated_at = now()
WHERE id = ${scheduleId}
RETURNING *
`;
await recordEvent("scheduled_task_updated", "scheduler", { scheduleId, name, enabled, schedule: scheduleJson, action: compactJson(action) });
return jsonResponse({ ok: true, schedule: scheduledTaskView(rows[0]) });
}
async function deleteScheduledTask(scheduleId: string): Promise<Response> {
const rows = await sql<Array<{ id: string }>>`
DELETE FROM unidesk_scheduled_tasks
WHERE id = ${scheduleId}
RETURNING id
`;
if (rows.length === 0) return jsonResponse({ ok: false, error: `scheduled task not found: ${scheduleId}` }, 404);
await recordEvent("scheduled_task_deleted", "scheduler", { scheduleId });
return jsonResponse({ ok: true, deleted: scheduleId });
}
function scheduledRawTaskJson(task: RawTaskRow | null): JsonValue {
if (task === null) return null;
return {
id: task.id,
providerId: task.provider_id,
command: task.command,
status: task.status,
payload: compactJson(task.payload),
result: compactJson(task.result ?? null),
updatedAt: rowIso(task.updated_at),
};
}
async function executeDispatchScheduleAction(action: DispatchScheduleAction): Promise<{ ok: boolean; taskId: string; result: JsonValue }> {
const { taskId, providerOnline } = await createAndSendTask(action.providerId, action.command, {
source: "scheduled-task",
...action.payload,
});
if (!providerOnline) {
return { ok: false, taskId, result: { providerOnline, taskId, error: `provider is offline: ${action.providerId}` } };
}
const timeoutMs = action.timeoutMs ?? numberInRange(action.payload.timeoutMs, config.taskPendingTimeoutMs + 5000, 1000, 24 * 3600_000);
const task = await waitForTaskTerminal(taskId, timeoutMs);
const ok = task?.status === "succeeded";
return {
ok,
taskId,
result: {
providerOnline,
taskId,
timeoutMs,
terminal: task === null ? false : isTerminalTaskStatus(task.status),
task: scheduledRawTaskJson(task),
},
};
}
function normalizeRemoteDir(input: string): string {
const raw = input.trim() || "/";
if (raw.includes("\0")) throw new Error("remote directory must not contain null bytes");
const normalized = pathPosix.normalize(raw.startsWith("/") ? raw : `/${raw}`);
return normalized === "/" ? "/" : normalized.replace(/\/+$/u, "");
}
function normalizeRelativeStagingPath(input: string): { relativePath: string; absolutePath: string } {
const cleaned = input.replace(/\\/g, "/").replace(/^\/+/u, "").trim();
const normalized = pathPosix.normalize(cleaned || ".");
if (normalized === "." || normalized.startsWith("../") || normalized === "..") throw new Error("staging path must be a relative child path");
const absolutePath = resolve(config.pgdataBackupStagingDir, normalized);
const rel = relative(config.pgdataBackupStagingDir, absolutePath);
if (rel.startsWith("..") || rel.includes("\0") || resolve(absolutePath) === resolve(config.pgdataBackupStagingDir)) {
throw new Error("staging path must stay inside PGDATA_BACKUP_STAGING_DIR");
}
return { relativePath: normalized, absolutePath };
}
function remoteFolderChain(remoteDir: string): string[] {
const parts = normalizeRemoteDir(remoteDir).split("/").filter(Boolean);
const folders: string[] = [];
let current = "";
for (const part of parts) {
current = `${current}/${part}`;
folders.push(current);
}
return folders;
}
function safeFilePart(value: string): string {
return value.replace(/[^A-Za-z0-9_.-]+/g, "_").replace(/^_+|_+$/g, "").slice(0, 80) || "data";
}
function utcBackupParts(date = new Date()): { date: string; time: string; month: string; stamp: string } {
const year = String(date.getUTCFullYear()).padStart(4, "0");
const monthNumber = String(date.getUTCMonth() + 1).padStart(2, "0");
const day = String(date.getUTCDate()).padStart(2, "0");
const hour = String(date.getUTCHours()).padStart(2, "0");
const minute = String(date.getUTCMinutes()).padStart(2, "0");
const second = String(date.getUTCSeconds()).padStart(2, "0");
return { date: `${year}${monthNumber}${day}`, time: `${hour}${minute}${second}`, month: `${year}${monthNumber}`, stamp: `${year}${monthNumber}${day}_${hour}${minute}${second}` };
}
function databaseConnectionParts(): { host: string; port: string; user: string; password: string } {
const url = new URL(config.databaseUrl);
return {
host: url.hostname || "database",
port: url.port || "5432",
user: decodeURIComponent(url.username || "postgres"),
password: decodeURIComponent(url.password || ""),
};
}
async function runLocalCommand(
command: string,
args: string[],
options: { cwd?: string; env?: Record<string, string>; timeoutMs: number },
): Promise<{ ok: boolean; stdout: string; stderr: string; exitCode: number | null; timedOut: boolean }> {
const proc = Bun.spawn([command, ...args], {
cwd: options.cwd,
env: { ...process.env, ...(options.env ?? {}) },
stdout: "pipe",
stderr: "pipe",
});
let timedOut = false;
const timer = setTimeout(() => {
timedOut = true;
proc.kill("SIGTERM");
}, Math.max(1, options.timeoutMs));
try {
const [stdout, stderr, exitCode] = await Promise.all([
new Response(proc.stdout).text(),
new Response(proc.stderr).text(),
proc.exited,
]);
return { ok: exitCode === 0 && !timedOut, stdout: truncateText(stdout, 4000), stderr: truncateText(stderr, 4000), exitCode, timedOut };
} finally {
clearTimeout(timer);
}
}
async function sha256File(filePath: string): Promise<string> {
const hash = createHash("sha256");
await new Promise<void>((resolveHash, rejectHash) => {
const stream = createReadStream(filePath);
stream.on("data", (chunk) => hash.update(chunk));
stream.on("error", rejectHash);
stream.on("end", resolveHash);
});
return hash.digest("hex");
}
async function fetchJsonWithTimeout(url: string, init: RequestInit, timeoutMs: number): Promise<Record<string, unknown>> {
const controller = new AbortController();
const timer = setTimeout(() => controller.abort(), Math.max(1, timeoutMs));
try {
const response = await fetch(url, { ...init, signal: controller.signal });
const text = await response.text();
let parsed: unknown = {};
try {
parsed = text.length > 0 ? JSON.parse(text) as unknown : {};
} catch {
parsed = { text };
}
if (!response.ok) throw new Error(`HTTP ${response.status}: ${truncateText(text, 1000)}`);
if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return { value: parsed };
return parsed as Record<string, unknown>;
} finally {
clearTimeout(timer);
}
}
async function baiduJson(baseUrl: string, path: string, init: RequestInit = {}, timeoutMs = 30_000): Promise<Record<string, unknown>> {
const url = new URL(path, baseUrl);
const headers = new Headers(init.headers);
if (init.body !== undefined && !headers.has("content-type")) headers.set("content-type", "application/json");
const body = await fetchJsonWithTimeout(url.toString(), { ...init, headers }, timeoutMs);
if (body.ok === false) throw new Error(`Baidu Netdisk API failed: ${JSON.stringify(compactJson(body))}`);
return body;
}
function jobRecord(value: unknown): Record<string, unknown> {
return typeof value === "object" && value !== null && !Array.isArray(value) ? value as Record<string, unknown> : {};
}
async function waitForBaiduTransfer(baseUrl: string, jobId: string, timeoutMs: number): Promise<Record<string, unknown>> {
const deadline = Date.now() + timeoutMs;
let latest: Record<string, unknown> = {};
while (Date.now() < deadline) {
const detail = await baiduJson(baseUrl, `/api/transfers/${encodeURIComponent(jobId)}`, {}, 30_000);
latest = detail;
const job = jobRecord(detail.job);
const status = String(job.status || "");
if (status === "succeeded") return detail;
if (status === "failed" || status === "canceled") throw new Error(`Baidu transfer ${status}: ${String(job.error || "no error detail")}`);
await Bun.sleep(2000);
}
throw new Error(`Baidu transfer timed out after ${timeoutMs}ms: ${JSON.stringify(compactJson(latest))}`);
}
async function executePgdataBackupAction(action: PgdataBackupScheduleAction, runId: string): Promise<{ ok: boolean; result: JsonValue }> {
const startedAt = new Date();
const parts = utcBackupParts(startedAt);
const filename = `${parts.stamp}_${safeFilePart(action.volumeName)}.pg_basebackup.tar.gz`;
const monthRelativeDir = pathPosix.join(action.stagingSubdir, parts.month);
const backupRelativePath = pathPosix.join(monthRelativeDir, filename);
const backupPath = normalizeRelativeStagingPath(backupRelativePath).absolutePath;
const tempRelativeDir = pathPosix.join(action.stagingSubdir, parts.month, `.tmp_${runId}`);
const tempDir = normalizeRelativeStagingPath(tempRelativeDir).absolutePath;
const remoteDir = normalizeRemoteDir(pathPosix.join(action.remoteBaseDir, parts.month));
const remotePath = normalizeRemoteDir(pathPosix.join(remoteDir, filename));
const db = databaseConnectionParts();
await mkdir(dirname(backupPath), { recursive: true });
await rm(tempDir, { recursive: true, force: true });
await mkdir(tempDir, { recursive: true });
let uploadDetail: Record<string, unknown> | null = null;
let backupBytes = 0;
let backupSha256 = "";
try {
const backupTimeoutMs = Math.max(60_000, Math.floor(action.timeoutMs * 0.55));
const packageTimeoutMs = Math.max(60_000, Math.floor(action.timeoutMs * 0.15));
const uploadTimeoutMs = Math.max(60_000, action.timeoutMs - backupTimeoutMs - packageTimeoutMs);
const basebackup = await runLocalCommand("pg_basebackup", [
"-h", db.host,
"-p", db.port,
"-U", db.user,
"-D", tempDir,
"-Ft",
"-X", "stream",
"-z",
"--checkpoint=fast",
"--no-sync",
], { env: { PGPASSWORD: db.password }, timeoutMs: backupTimeoutMs });
if (!basebackup.ok) throw new Error(`pg_basebackup failed exit=${basebackup.exitCode} timedOut=${basebackup.timedOut}: ${basebackup.stderr || basebackup.stdout}`);
const packaged = await runLocalCommand("tar", ["-czf", backupPath, "-C", tempDir, "."], { timeoutMs: packageTimeoutMs });
if (!packaged.ok) throw new Error(`tar packaging failed exit=${packaged.exitCode} timedOut=${packaged.timedOut}: ${packaged.stderr || packaged.stdout}`);
const info = await stat(backupPath);
backupBytes = info.size;
backupSha256 = await sha256File(backupPath);
for (const folder of remoteFolderChain(remoteDir)) {
await baiduJson(action.baiduBaseUrl, "/api/folders", {
method: "POST",
body: JSON.stringify({ path: folder }),
}, 60_000);
}
const created = await baiduJson(action.baiduBaseUrl, "/api/transfers/upload-from-path", {
method: "POST",
body: JSON.stringify({ localPath: backupRelativePath, remotePath }),
}, 60_000);
const jobId = String(jobRecord(created.job).id || "");
if (jobId.length === 0) throw new Error(`Baidu upload did not return a job id: ${JSON.stringify(compactJson(created))}`);
uploadDetail = await waitForBaiduTransfer(action.baiduBaseUrl, jobId, uploadTimeoutMs);
const uploadedJob = jobRecord(uploadDetail.job);
return {
ok: true,
result: {
backupType: "pg_basebackup",
volumeName: action.volumeName,
backupBytes,
backupSha256,
localRelativePath: backupRelativePath,
remotePath,
remoteDir,
month: parts.month,
timestampPrefix: parts.stamp,
baiduTransferJobId: jobId,
baiduTransferStatus: String(uploadedJob.status || ""),
baiduFsId: String(uploadedJob.fsId || ""),
baiduResult: compactJson(uploadedJob.result ?? null),
},
};
} finally {
await rm(tempDir, { recursive: true, force: true }).catch(() => undefined);
if (action.cleanupLocal) await rm(backupPath, { force: true }).catch(() => undefined);
}
}
async function executeScheduleAction(action: ScheduleAction, runId: string): Promise<{ ok: boolean; taskId: string | null; result: JsonValue }> {
if (action.type === "dispatch") {
const dispatched = await executeDispatchScheduleAction(action);
return { ok: dispatched.ok, taskId: dispatched.taskId, result: dispatched.result };
}
const backup = await executePgdataBackupAction(action, runId);
return { ok: backup.ok, taskId: null, result: backup.result };
}
async function executeScheduledRun(runId: string): Promise<void> {
if (activeScheduledRuns.has(runId)) return;
activeScheduledRuns.add(runId);
const started = Date.now();
try {
const queuedRuns = await sql<ScheduledTaskRunRow[]>`
SELECT *
FROM unidesk_scheduled_task_runs
WHERE id = ${runId}
LIMIT 1
`;
const queuedRun = queuedRuns[0];
if (queuedRun === undefined) return;
const scheduleRow = await getScheduledTaskRow(queuedRun.schedule_id);
if (scheduleRow === null) return;
const runRows = await sql<ScheduledTaskRunRow[]>`
UPDATE unidesk_scheduled_task_runs
SET status = 'running', started_at = now(), updated_at = now()
WHERE id = ${runId} AND status = 'queued'
RETURNING *
`;
if (runRows.length === 0) return;
try {
const action = normalizeScheduleAction(scheduleRow.action_json);
const outcome = await executeScheduleAction(action, runId);
const durationMs = Date.now() - started;
const status = outcome.ok ? "succeeded" : "failed";
const error = outcome.ok ? null : "scheduled action failed";
await sql.begin(async (tx) => {
await tx`
UPDATE unidesk_scheduled_task_runs
SET status = ${status},
task_id = ${outcome.taskId},
result = ${tx.json(outcome.result)},
error = ${error},
finished_at = now(),
duration_ms = ${durationMs},
updated_at = now()
WHERE id = ${runId}
`;
await tx`
UPDATE unidesk_scheduled_tasks
SET last_run_at = now(), last_run_id = ${runId}, updated_at = now()
WHERE id = ${scheduleRow.id}
`;
});
await recordEvent(`scheduled_task_${status}`, "scheduler", { scheduleId: scheduleRow.id, runId, durationMs, result: compactJson(outcome.result) });
} catch (error) {
const durationMs = Date.now() - started;
await sql.begin(async (tx) => {
await tx`
UPDATE unidesk_scheduled_task_runs
SET status = 'failed',
result = ${tx.json(errorToJson(error))},
error = ${error instanceof Error ? error.message : String(error)},
finished_at = now(),
duration_ms = ${durationMs},
updated_at = now()
WHERE id = ${runId}
`;
await tx`
UPDATE unidesk_scheduled_tasks
SET last_run_at = now(), last_run_id = ${runId}, updated_at = now()
WHERE id = ${scheduleRow.id}
`;
});
await recordEvent("scheduled_task_failed", "scheduler", { scheduleId: scheduleRow.id, runId, durationMs, error: errorToJson(error) });
}
} finally {
activeScheduledRuns.delete(runId);
}
}
async function triggerScheduledTask(scheduleId: string, triggerType: "manual" | "schedule"): Promise<JsonValue | null> {
const runId = `schedrun_${Date.now()}_${Math.random().toString(16).slice(2, 8)}`;
let createdRun: ScheduledTaskRunRow | null = null;
await sql.begin(async (tx) => {
const rows = await tx<ScheduledTaskRow[]>`
SELECT *
FROM unidesk_scheduled_tasks
WHERE id = ${scheduleId}
FOR UPDATE
`;
const scheduleRow = rows[0];
if (scheduleRow === undefined) throw new Error(`scheduled task not found: ${scheduleId}`);
if (triggerType === "schedule" && !scheduleRow.enabled) return;
const runningRows = await tx<Array<{ count: string | number }>>`
SELECT count(*)::int AS count
FROM unidesk_scheduled_task_runs
WHERE schedule_id = ${scheduleId}
AND status IN ('queued', 'running')
`;
const runningCount = Number(runningRows[0]?.count ?? 0);
const schedule = normalizeScheduleSpec(scheduleRow.schedule_json);
const shouldAdvanceNext = triggerType === "schedule";
if (shouldAdvanceNext) {
await tx`
UPDATE unidesk_scheduled_tasks
SET next_run_at = ${computeNextRunAt(schedule).toISOString()}, updated_at = now()
WHERE id = ${scheduleId}
`;
}
if (scheduleRow.concurrency_policy !== "parallel" && runningCount > 0) {
const skippedRows = await tx<ScheduledTaskRunRow[]>`
INSERT INTO unidesk_scheduled_task_runs (id, schedule_id, trigger_type, status, result, error, finished_at, duration_ms)
VALUES (${runId}, ${scheduleId}, ${triggerType}, 'skipped', ${tx.json({ reason: "previous run still active", runningCount })}, 'previous run still active', now(), 0)
RETURNING *
`;
createdRun = skippedRows[0] ?? null;
return;
}
const runRows = await tx<ScheduledTaskRunRow[]>`
INSERT INTO unidesk_scheduled_task_runs (id, schedule_id, trigger_type, status)
VALUES (${runId}, ${scheduleId}, ${triggerType}, 'queued')
RETURNING *
`;
createdRun = runRows[0] ?? null;
});
const run = createdRun as ScheduledTaskRunRow | null;
if (run === null) return null;
if (run.status === "queued") {
setTimeout(() => {
executeScheduledRun(runId).catch((error) => logger("error", "scheduled_run_uncaught", { runId, error: errorToJson(error) }));
}, 0);
}
await recordEvent("scheduled_task_triggered", "scheduler", { scheduleId, runId, triggerType, status: run.status });
return scheduleRunView(run);
}
async function scheduledTaskRoute(req: Request, url: URL): Promise<Response> {
const prefix = "/api/schedules";
const rest = url.pathname === prefix ? "" : url.pathname.slice(prefix.length + 1);
const segments = rest.split("/").filter(Boolean).map((part) => decodeURIComponent(part));
if (url.pathname === prefix && req.method === "GET") {
return jsonResponse({ ok: true, schedules: await getScheduledTasks(readLimit(url, 100)) });
}
if (url.pathname === prefix && req.method === "POST") return upsertScheduledTask(req, null);
if (segments.length === 1 && segments[0] === "runs" && req.method === "GET") {
return jsonResponse({ ok: true, runs: await getScheduledTaskRuns(null, readLimit(url, 100)) });
}
if (segments.length === 1 && req.method === "GET") {
const schedule = await getScheduledTaskRow(segments[0]);
if (schedule === null) return jsonResponse({ ok: false, error: `scheduled task not found: ${segments[0]}` }, 404);
const runs = await sql<ScheduledTaskRunRow[]>`
SELECT *
FROM unidesk_scheduled_task_runs
WHERE schedule_id = ${segments[0]}
ORDER BY updated_at DESC
LIMIT 20
`;
return jsonResponse({ ok: true, schedule: scheduledTaskView(schedule, runs) });
}
if (segments.length === 1 && req.method === "PUT") return upsertScheduledTask(req, segments[0]);
if (segments.length === 1 && req.method === "PATCH") return patchScheduledTask(segments[0], req);
if (segments.length === 1 && req.method === "DELETE") return deleteScheduledTask(segments[0]);
if (segments.length === 2 && segments[1] === "run" && req.method === "POST") {
const run = await triggerScheduledTask(segments[0], "manual");
if (run === null) return jsonResponse({ ok: false, error: `scheduled task was not triggered: ${segments[0]}` }, 409);
return jsonResponse({ ok: true, run });
}
if (segments.length === 2 && segments[1] === "runs" && req.method === "GET") {
return jsonResponse({ ok: true, runs: await getScheduledTaskRuns(segments[0], readLimit(url, 100)) });
}
return jsonResponse({ ok: false, error: "scheduled task route not found", path: url.pathname }, 404);
}
async function recoverScheduledRuns(): Promise<void> {
const rows = await sql<ScheduledTaskRunRow[]>`
UPDATE unidesk_scheduled_task_runs
SET status = 'failed',
error = 'backend-core restarted before scheduled run completed',
result = jsonb_build_object('error', 'backend-core restarted before scheduled run completed'),
finished_at = now(),
updated_at = now()
WHERE status IN ('queued', 'running')
RETURNING *
`;
if (rows.length > 0) await recordEvent("scheduled_runs_recovered", "scheduler", { failedRunCount: rows.length });
const schedules = await sql<ScheduledTaskRow[]>`
SELECT *
FROM unidesk_scheduled_tasks
WHERE next_run_at IS NULL
LIMIT 200
`;
for (const schedule of schedules) {
const nextRunAt = computeNextRunAt(normalizeScheduleSpec(schedule.schedule_json)).toISOString();
await sql`UPDATE unidesk_scheduled_tasks SET next_run_at = ${nextRunAt}, updated_at = now() WHERE id = ${schedule.id}`;
}
}
async function runDueScheduledTasks(): Promise<void> {
if (!dbReady) return;
const rows = await sql<ScheduledTaskRow[]>`
SELECT *
FROM unidesk_scheduled_tasks
WHERE enabled = true
AND (next_run_at IS NULL OR next_run_at <= now())
ORDER BY next_run_at ASC NULLS FIRST
LIMIT 5
`;
for (const row of rows) {
try {
await triggerScheduledTask(row.id, "schedule");
} catch (error) {
logger("error", "scheduled_task_due_trigger_failed", { scheduleId: row.id, error: errorToJson(error) });
}
}
}
function isMicroservicePathAllowed(service: MicroserviceConfig, path: string): boolean {
return service.backend.allowedPathPrefixes.some((prefix) => path === prefix || path.startsWith(prefix));
}
@@ -2228,6 +3044,9 @@ async function routeInner(req: Request, server: Server<WsData>): Promise<Respons
const summary = ["1", "true", "yes"].includes((url.searchParams.get("summary") ?? "").toLowerCase());
return jsonResponse({ ok: true, tasks: await withPerformanceOperation("core", "tasks", url.search, () => getTasks(readLimit(url, 100), url.searchParams.get("status") ?? "all", lite, summary)) });
}
if (url.pathname === "/api/schedules" || url.pathname.startsWith("/api/schedules/")) {
return withPerformanceOperation("scheduler", "schedules", url.pathname, () => scheduledTaskRoute(req, url));
}
if (url.pathname === "/api/microservices") return jsonResponse({ ok: true, microservices: await withPerformanceOperation("core", "microservices", url.pathname, () => getMicroservices()) });
if (url.pathname === "/api/performance") return jsonResponse(await getPerformance());
if (url.pathname === "/api/code-queue-load-test" && (req.method === "GET" || req.method === "POST")) return withPerformanceOperation("performance", "code_queue_load_test", url.pathname, () => codexQueueLoadTest(req));
@@ -2281,6 +3100,8 @@ function readLimit(url: URL, defaultLimit: number): number {
await initDatabaseWithRetry();
markStaleTasksFailed().catch((error) => logger("error", "task_timeout_sweep_failed", { error: errorToJson(error) }));
await recoverScheduledRuns();
runDueScheduledTasks().catch((error) => logger("error", "scheduled_task_sweep_failed", { error: errorToJson(error) }));
const apiServer = Bun.serve<WsData>({
port: config.port,
@@ -2365,6 +3186,10 @@ setInterval(() => {
markStaleTasksFailed().catch((error) => logger("error", "task_timeout_sweep_failed", { error: errorToJson(error) }));
}, Math.min(config.taskPendingTimeoutMs, 60_000));
setInterval(() => {
runDueScheduledTasks().catch((error) => logger("error", "scheduled_task_sweep_failed", { error: errorToJson(error) }));
}, 30_000);
logger("info", "server_listening", {
apiUrl: `http://0.0.0.0:${apiServer.port}`,
providerIngressUrl: `ws://0.0.0.0:${providerServer.port}/ws/provider`,
src/components/database/config/pg_hba.conf
+9
View File
@@ -0,0 +1,9 @@
# UniDesk PostgreSQL client and physical backup access.
local all all trust
host all all 127.0.0.1/32 trust
host all all ::1/128 trust
local replication all trust
host replication all 127.0.0.1/32 trust
host replication all ::1/128 trust
host replication all all scram-sha-256
host all all all scram-sha-256
src/components/frontend/public/app.js
+71 -71
View File
File diff suppressed because one or more lines are too long
src/components/frontend/public/style.css
+220 -7
View File
@@ -351,7 +351,7 @@ h2 { font-size: 14px; text-transform: uppercase; letter-spacing: 0.08em; }
align-items: start;
}
.overview-grid .panel:nth-child(n+3), .dispatch-grid .panel:first-child, .topology-grid .panel:nth-child(3) { grid-column: 1 / -1; }
.overview-grid .panel:nth-child(n+3), .dispatch-grid .panel:first-child, .scheduled-task-page .panel:first-child, .scheduled-task-page .panel:nth-child(3), .topology-grid .panel:nth-child(3) { grid-column: 1 / -1; }
.panel {
min-width: 0;
@@ -412,17 +412,17 @@ h2 { font-size: 14px; text-transform: uppercase; letter-spacing: 0.08em; }
}
.metric-hint { margin-top: 3px; color: var(--muted); font-size: 11px; }
.node-card-list, .compact-list, .log-list, .heartbeat-list, .endpoint-list, .policy-grid, .security-board, .result-grid {
.node-card-list, .compact-list, .log-list, .heartbeat-list, .endpoint-list, .policy-grid, .security-board, .result-grid, .schedule-card-grid {
display: grid;
gap: 8px;
}
.node-card, .compact-row, .log-row, .heartbeat-row, .endpoint-list article, .policy-grid article, .security-board article, .result-card, .label-card {
.node-card, .compact-row, .log-row, .heartbeat-row, .endpoint-list article, .policy-grid article, .security-board article, .result-card, .label-card, .schedule-card {
border: 1px solid var(--line-soft);
background: var(--panel-3);
}
.node-card, .result-card { padding: 9px; }
.node-card, .result-card, .schedule-card { padding: 9px; }
.node-card-head {
display: flex;
justify-content: space-between;
@@ -1362,6 +1362,34 @@ td { color: var(--text); }
letter-spacing: 0.12em;
}
.dispatch-actions { display: flex; gap: 6px; align-items: end; }
.schedule-card-grid { grid-template-columns: repeat(auto-fill, minmax(340px, 1fr)); }
.schedule-card dl {
display: grid;
grid-template-columns: 92px minmax(0, 1fr);
gap: 5px 8px;
margin: 8px 0;
}
.schedule-card dt { color: var(--muted); }
.schedule-card dd { margin: 0; overflow-wrap: anywhere; }
.schedule-form {
grid-template-columns: inherit;
}
.dispatch-form, .schedule-form {
display: grid;
grid-template-columns: 1.2fr 180px 150px 1fr 140px auto;
gap: 8px;
align-items: end;
}
.dispatch-form label, .schedule-form label {
display: grid;
gap: 4px;
color: var(--muted);
font-size: 11px;
text-transform: uppercase;
letter-spacing: 0.12em;
}
.raw-editor.compact { min-height: 72px; }
.schedule-run-table { min-width: 1180px; }
.dispatch-actions button[type="submit"], .login-form button[type="submit"] {
min-height: 32px;
padding: 0 12px;
@@ -5136,7 +5164,7 @@ input:focus, select:focus, textarea:focus { border-color: var(--accent-2); }
@media (max-width: 1120px) {
.metric-grid, .policy-grid, .security-board, .docker-metrics, .monitor-chart-grid, .monitor-summary-grid, .performance-metric-stack, .codex-load-test-grid, .baidu-doc-grid, .filebrowser-target-grid { grid-template-columns: repeat(2, minmax(0, 1fr)); }
.pipeline-oa-guarantees { grid-template-columns: repeat(2, minmax(0, 1fr)); }
.dispatch-form { grid-template-columns: 1fr 1fr; }
.dispatch-form, .schedule-form { grid-template-columns: 1fr 1fr; }
.dispatch-actions { align-items: center; }
.page-grid, .docker-layout, .monitor-layout, .performance-top-grid, .performance-grid, .findjob-grid, .findjob-hero, .pipeline-grid, .pipeline-hero, .met-grid, .met-form-grid, .code-queue-layout, .code-queue-hero, .codex-detail-grid, .project-manager-hero, .project-manager-layout, .baidu-netdisk-grid, .baidu-netdisk-hero, .baidu-transfer-forms, .filebrowser-hero { grid-template-columns: 1fr; }
.codex-session-shell { grid-template-columns: minmax(260px, 0.42fr) minmax(0, 1fr); position: relative; }
@@ -5151,7 +5179,7 @@ input:focus, select:focus, textarea:focus { border-color: var(--accent-2); }
.pipeline-node-control { max-height: none; min-height: 0; }
.findjob-grid .panel:nth-child(3), .claudeqq-page .findjob-grid .panel:nth-child(n+3), .pipeline-grid .panel:nth-child(3), .pipeline-grid .panel:nth-child(5), .met-grid .panel:nth-child(3), .met-grid .panel:nth-child(5), .met-detail-panel, .baidu-files-panel, .baidu-transfers-panel, .baidu-wide-panel, .baidu-docs-panel { grid-column: 1; }
.gateway-record-grid { grid-template-columns: 1fr; }
.overview-grid .panel:nth-child(n+3), .dispatch-grid .panel:first-child, .topology-grid .panel:nth-child(3) { grid-column: 1; }
.overview-grid .panel:nth-child(n+3), .dispatch-grid .panel:first-child, .scheduled-task-page .panel:first-child, .scheduled-task-page .panel:nth-child(3), .topology-grid .panel:nth-child(3) { grid-column: 1; }
}
@media (max-width: 760px) {
@@ -5323,7 +5351,7 @@ input:focus, select:focus, textarea:focus { border-color: var(--accent-2); }
padding: 4px 9px;
white-space: nowrap;
}
.metric-grid, .policy-grid, .security-board, .dispatch-form, .docker-metrics, .monitor-chart-grid, .monitor-summary-grid, .gateway-record-grid, .met-detail-kv, .code-queue-metrics, .codex-stats-summary-grid, .codex-form-grid, .baidu-doc-grid { grid-template-columns: 1fr; }
.metric-grid, .policy-grid, .security-board, .dispatch-form, .schedule-form, .schedule-card-grid, .docker-metrics, .monitor-chart-grid, .monitor-summary-grid, .gateway-record-grid, .met-detail-kv, .code-queue-metrics, .codex-stats-summary-grid, .codex-form-grid, .baidu-doc-grid { grid-template-columns: 1fr; }
.compact-row, .heartbeat-row, .log-row, .endpoint-list article, .volume-route, .findjob-hero, .pipeline-hero, .code-queue-hero, .claudeqq-login-card, .baidu-login-card, .baidu-pathbar { grid-template-columns: 1fr; align-items: start; }
.codex-output-line { grid-template-columns: 1fr; }
.codex-transcript { min-height: 360px; }
@@ -5870,3 +5898,188 @@ input:focus, select:focus, textarea:focus { border-color: var(--accent-2); }
min-height: 360px;
}
}
.notification-icon-btn {
position: relative;
display: inline-flex;
align-items: center;
justify-content: center;
width: 32px;
height: 32px;
border: none;
border-radius: 6px;
background: transparent;
color: var(--text);
cursor: pointer;
font-size: 18px;
transition: background 0.15s;
}
.notification-icon-btn:hover {
background: var(--panel-2);
}
.notification-icon-btn.has-unread {
color: var(--accent);
}
.notification-icon-btn .notification-badge {
position: absolute;
top: 2px;
right: 2px;
min-width: 16px;
height: 16px;
padding: 0 4px;
border-radius: 8px;
background: var(--danger);
color: #fff;
font-size: 10px;
font-weight: 600;
line-height: 16px;
text-align: center;
}
.notification-popup {
position: absolute;
top: calc(100% + 8px);
right: 0;
width: 360px;
max-height: 480px;
background: var(--panel);
border: 1px solid var(--line);
border-radius: 8px;
box-shadow: var(--shadow);
z-index: 9999;
overflow: hidden;
}
.notification-popup-header {
display: flex;
justify-content: space-between;
align-items: center;
padding: 12px 16px;
border-bottom: 1px solid var(--line);
font-weight: 600;
font-size: 14px;
}
.notification-popup-actions {
display: flex;
gap: 8px;
}
.notification-popup-clear,
.notification-popup-close {
padding: 4px 8px;
border: none;
border-radius: 4px;
background: transparent;
color: var(--muted);
cursor: pointer;
font-size: 12px;
}
.notification-popup-clear:hover,
.notification-popup-close:hover {
background: var(--panel-2);
color: var(--text);
}
.notification-popup-empty {
padding: 32px 16px;
text-align: center;
color: var(--muted);
font-size: 13px;
}
.notification-popup-list {
max-height: 400px;
overflow-y: auto;
}
.notification-item {
display: flex;
align-items: center;
gap: 10px;
padding: 10px 16px;
border-bottom: 1px solid var(--line-soft);
}
.notification-item:last-child {
border-bottom: none;
}
.notification-item.success .notification-item-icon {
color: var(--ok);
}
.notification-item.error .notification-item-icon {
color: var(--danger);
}
.notification-item-icon {
flex-shrink: 0;
font-size: 14px;
font-weight: 700;
}
.notification-item-message {
flex: 1;
font-size: 13px;
color: var(--text);
word-break: break-word;
}
.notification-item-dismiss {
flex-shrink: 0;
padding: 2px 6px;
border: none;
border-radius: 4px;
background: transparent;
color: var(--muted);
cursor: pointer;
font-size: 14px;
line-height: 1;
}
.notification-item-dismiss:hover {
background: var(--panel-2);
color: var(--text);
}
.notification-banner {
position: fixed;
top: 70px;
left: 50%;
transform: translateX(-50%);
display: flex;
align-items: center;
gap: 10px;
padding: 12px 20px;
border-radius: 8px;
box-shadow: var(--shadow);
z-index: 10000;
font-size: 14px;
animation: notification-slide-in 0.2s ease-out;
}
@keyframes notification-slide-in {
from {
opacity: 0;
transform: translateX(-50%) translateY(-10px);
}
to {
opacity: 1;
transform: translateX(-50%) translateY(0);
}
}
.notification-banner.success {
background: var(--ok);
color: #fff;
}
.notification-banner.error {
background: var(--danger);
color: #fff;
}
.notification-banner-icon {
font-size: 16px;
font-weight: 700;
}
.notification-banner-message {
flex: 1;
}
.notification-banner-dismiss {
padding: 2px 6px;
border: none;
border-radius: 4px;
background: rgba(255,255,255,0.2);
color: inherit;
cursor: pointer;
font-size: 14px;
line-height: 1;
}
.notification-banner-dismiss:hover {
background: rgba(255,255,255,0.3);
}
src/components/frontend/src/app.tsx
+270 -8
View File
@@ -15,6 +15,8 @@ import { TopStatusBar } from "./top-status";
import { LoadingTitle } from "./loading-indicator";
import { errorMessage, requestJson } from "./unidesk-error";
import { UniDeskErrorBanner } from "./unidesk-error-banner";
import { NotificationProvider, useNotification } from "./notification-context";
import { NotificationPopup, NotificationBanner } from "./notification-popup";
type AnyRecord = Record<string, any>;
@@ -61,7 +63,7 @@ function isDocumentVisible(): boolean {
function shellRefreshIntervalMs(moduleId: string, tabId: string): number {
if (moduleId === "ops" && tabId === "status") return 5_000;
if (moduleId === "nodes" && tabId === "monitor") return 5_000;
if (moduleId === "tasks" && (tabId === "dispatch" || tabId === "pending")) return 5_000;
if (moduleId === "tasks" && (tabId === "dispatch" || tabId === "scheduled" || tabId === "pending")) return 5_000;
if (moduleId === "nodes" || moduleId === "ops") return 10_000;
if (moduleId === "apps") return 15_000;
if (moduleId === "tasks") return 15_000;
@@ -502,7 +504,7 @@ function LoginScreen({ onLogin }: AnyRecord) {
);
}
function TopBar({ connection, lastRefresh, onRefresh, onLogout, session, clock, activeStatusItems = [] }: AnyRecord) {
function TopBar({ connection, lastRefresh, onRefresh, onLogout, session, clock, activeStatusItems = [], onNotificationToggle, unreadCount = 0 }: AnyRecord) {
const statusItems = [
{ key: "core", label: "核心", value: connection.text, tone: connection.ok ? "ok" : "fail", testId: "conn-text" },
...(Array.isArray(activeStatusItems) ? activeStatusItems : []),
@@ -517,8 +519,18 @@ function TopBar({ connection, lastRefresh, onRefresh, onLogout, session, clock,
title: "状态",
items: statusItems,
actions: [
h("button", { key: "refresh", type: "button", className: "ghost-btn", onClick: onRefresh }, "刷新"),
h("button", { key: "logout", type: "button", className: "ghost-btn danger", onClick: onLogout }, "退出"),
h("button", {
key: "notification",
type: "button",
className: `notification-icon-btn ${unreadCount > 0 ? "has-unread" : ""}`,
onClick: onNotificationToggle,
"aria-label": "通知",
},
"🔔",
unreadCount > 0 ? h("span", { key: "badge", className: "notification-badge" }, unreadCount > 99 ? "99+" : unreadCount) : null
),
h("button", { key: "refresh", type: "button", className: "ghost-btn", onClick: onRefresh }, "刷新"),
h("button", { key: "logout", type: "button", className: "ghost-btn danger", onClick: onLogout }, "退出"),
],
}),
);
@@ -1812,6 +1824,244 @@ function TaskResultsPage({ tasks, onRaw }: AnyRecord) {
);
}
function scheduleSpecLabel(schedule: any): string {
if (!schedule || typeof schedule !== "object") return "--";
if (schedule.type === "interval") return `每 ${fmtDuration(Number(schedule.everySeconds || 0))}`;
return `每天 ${schedule.timeOfDay || "03:00"} UTC`;
}
function scheduleActionLabel(action: any): string {
if (!action || typeof action !== "object") return "--";
if (action.type === "pgdata_backup") return `PGDATA -> ${action.remoteBaseDir || "/SERVER_DATA/UNIDESK_PG_DATA"}`;
if (action.type === "dispatch") return `${action.providerId || "--"} / ${action.command || "--"}`;
return String(action.type || "--");
}
function scheduleRunTone(status: any): string {
const value = String(status || "").toLowerCase();
if (value === "succeeded") return "online";
if (value === "failed") return "failed";
if (value === "running" || value === "queued") return "warn";
return value;
}
function scheduleRunDuration(run: any): string {
const ms = Number(run?.durationMs);
if (Number.isFinite(ms) && ms >= 0) return fmtDuration(ms / 1000);
const started = timeMs(run?.startedAt || run?.createdAt);
if (started === null) return "--";
const finished = timeMs(run?.finishedAt);
const ended = finished ?? Date.now();
return fmtDuration(Math.max(0, (ended - started) / 1000));
}
function defaultScheduleForm(nodes: any[]): AnyRecord {
return {
id: "unidesk-pgdata-baidu-daily",
name: "PGDATA daily Baidu Netdisk backup",
description: "Daily PostgreSQL physical base backup uploaded to Baidu Netdisk /SERVER_DATA with monthly rotation.",
enabled: true,
timeOfDay: "03:30",
actionType: "pgdata_backup",
providerId: nodes[0]?.providerId || "main-server",
command: "echo",
payloadJson: JSON.stringify({ source: "scheduled-task", message: "hello from scheduler" }, null, 2),
remoteBaseDir: "/SERVER_DATA/UNIDESK_PG_DATA",
stagingSubdir: "server-data/unidesk-pg-data",
timeoutMs: "3600000",
};
}
function TaskScheduledPage({ schedules, scheduleRuns, nodes, refresh, onRaw }: AnyRecord) {
const [form, setForm] = useState(defaultScheduleForm(nodes || []));
const [busy, setBusy] = useState(false);
const [error, setError] = useState("");
const [notice, setNotice] = useState("");
const sortedRuns = [...(scheduleRuns || [])].sort((left: any, right: any) => (timeMs(right.updatedAt) ?? 0) - (timeMs(left.updatedAt) ?? 0));
function update(key: string, value: any): void {
setForm((previous: AnyRecord) => ({ ...previous, [key]: value }));
}
function editSchedule(schedule: any): void {
const action = schedule?.action || {};
setForm({
id: schedule?.id || "",
name: schedule?.name || "",
description: schedule?.description || "",
enabled: schedule?.enabled !== false,
timeOfDay: schedule?.schedule?.timeOfDay || "03:30",
actionType: action.type || "dispatch",
providerId: action.providerId || nodes[0]?.providerId || "main-server",
command: action.command || "echo",
payloadJson: JSON.stringify(action.payload || { source: "scheduled-task" }, null, 2),
remoteBaseDir: action.remoteBaseDir || "/SERVER_DATA/UNIDESK_PG_DATA",
stagingSubdir: action.stagingSubdir || "server-data/unidesk-pg-data",
timeoutMs: String(action.timeoutMs || 3600000),
});
setNotice(`正在编辑 ${schedule?.id || ""}`);
}
function scheduleBody(): AnyRecord {
const base = {
id: form.id,
name: form.name,
description: form.description,
enabled: form.enabled,
concurrencyPolicy: "skip",
schedule: { type: "daily", timeOfDay: form.timeOfDay, timezone: "Etc/UTC" },
};
if (form.actionType === "pgdata_backup") {
return {
...base,
action: {
type: "pgdata_backup",
volumeName: "unidesk_pgdata_10gb",
remoteBaseDir: form.remoteBaseDir,
stagingSubdir: form.stagingSubdir,
timeoutMs: Number(form.timeoutMs) || 3600000,
cleanupLocal: true,
},
};
}
return {
...base,
action: {
type: "dispatch",
providerId: form.providerId,
command: form.command,
payload: JSON.parse(form.payloadJson || "{}"),
timeoutMs: Number(form.timeoutMs) || 600000,
},
};
}
async function save(event: any): Promise<void> {
event.preventDefault();
setBusy(true);
setError("");
setNotice("");
try {
const body = scheduleBody();
const id = encodeURIComponent(String(body.id));
await requestJson(`${cfg.apiBaseUrl}/schedules/${id}`, { method: "PUT", body: JSON.stringify(body) });
setNotice("定时任务已保存");
await refresh();
} catch (err) {
setError(errorMessage(err, "保存定时任务失败"));
} finally {
setBusy(false);
}
}
async function deleteSchedule(schedule: any): Promise<void> {
if (!schedule?.id) return;
setBusy(true);
setError("");
setNotice("");
try {
await requestJson(`${cfg.apiBaseUrl}/schedules/${encodeURIComponent(schedule.id)}`, { method: "DELETE" });
setNotice(`已删除 ${schedule.id}`);
await refresh();
} catch (err) {
setError(errorMessage(err, "删除定时任务失败"));
} finally {
setBusy(false);
}
}
async function runNow(schedule: any): Promise<void> {
if (!schedule?.id) return;
setBusy(true);
setError("");
setNotice("");
try {
const response = await requestJson(`${cfg.apiBaseUrl}/schedules/${encodeURIComponent(schedule.id)}/run`, { method: "POST", body: "{}" });
setNotice(`已触发 ${schedule.id} / ${response?.run?.id || "run"}`);
await refresh();
} catch (err) {
setError(errorMessage(err, "触发定时任务失败"));
} finally {
setBusy(false);
}
}
return h("div", { className: "page-grid scheduled-task-page", "data-testid": "scheduled-task-page" },
h(Panel, { title: "定时任务", eyebrow: `${(schedules || []).length} Schedules` },
(schedules || []).length === 0 ? h(EmptyState, { title: "暂无定时任务", text: "创建 daily / dispatch / PGDATA backup 任务后会在这里展示下一次执行时间和最近结果" }) :
h("div", { className: "schedule-card-grid" }, (schedules || []).map((schedule: any) => h("article", { key: schedule.id, className: "schedule-card", "data-testid": `schedule-row-${safeId(schedule.id)}` },
h("div", { className: "node-card-head" }, h("strong", null, schedule.name || schedule.id), h(StatusBadge, { status: schedule.enabled ? "online" : "warn" }, schedule.enabled ? "enabled" : "disabled")),
h("code", null, schedule.id),
h("dl", null,
h("dt", null, "计划"), h("dd", null, scheduleSpecLabel(schedule.schedule)),
h("dt", null, "动作"), h("dd", null, scheduleActionLabel(schedule.action)),
h("dt", null, "下次执行"), h("dd", null, fmtDate(schedule.nextRunAt)),
h("dt", null, "最近执行"), h("dd", null, schedule.lastRunAt ? `${fmtDate(schedule.lastRunAt)} / ${schedule.lastRunId || "--"}` : "--"),
),
h("div", { className: "dispatch-actions" },
h("button", { type: "button", className: "ghost-btn", disabled: busy, onClick: () => editSchedule(schedule) }, "编辑"),
h("button", { type: "button", className: "ghost-btn", disabled: busy, onClick: () => runNow(schedule), "data-testid": `schedule-run-${safeId(schedule.id)}` }, "手动触发"),
h("button", { type: "button", className: "ghost-btn danger", disabled: busy, onClick: () => deleteSchedule(schedule) }, "删除"),
h(RawButton, { title: `Schedule ${schedule.id}`, data: schedule, onOpen: onRaw }),
),
))),
),
h(Panel, { title: form.id ? "配置定时任务" : "新建定时任务", eyebrow: "CRUD" },
h("form", { className: "dispatch-form schedule-form", onSubmit: save },
h("label", null, "ID", h("input", { value: form.id, onChange: (event: any) => update("id", event.target.value) })),
h("label", null, "名称", h("input", { value: form.name, onChange: (event: any) => update("name", event.target.value) })),
h("label", null, "每日执行时间 UTC", h("input", { value: form.timeOfDay, placeholder: "03:30", onChange: (event: any) => update("timeOfDay", event.target.value) })),
h("label", null, "启用", h("select", { value: form.enabled ? "true" : "false", onChange: (event: any) => update("enabled", event.target.value === "true") },
h("option", { value: "true" }, "enabled"),
h("option", { value: "false" }, "disabled"),
)),
h("label", null, "动作类型", h("select", { value: form.actionType, onChange: (event: any) => update("actionType", event.target.value) },
h("option", { value: "pgdata_backup" }, "PGDATA 备份到百度网盘"),
h("option", { value: "dispatch" }, "Provider Dispatch"),
)),
form.actionType === "pgdata_backup" ? [
h("label", { key: "remote" }, "网盘根目录", h("input", { value: form.remoteBaseDir, onChange: (event: any) => update("remoteBaseDir", event.target.value) })),
h("label", { key: "staging" }, "本地 staging 子目录", h("input", { value: form.stagingSubdir, onChange: (event: any) => update("stagingSubdir", event.target.value) })),
] : [
h("label", { key: "provider" }, "Provider", h("select", { value: form.providerId, onChange: (event: any) => update("providerId", event.target.value) },
(nodes || []).map((node: any) => h("option", { key: node.providerId, value: node.providerId }, `${node.name} / ${node.providerId}`)),
)),
h("label", { key: "command" }, "Command", h("select", { value: form.command, onChange: (event: any) => update("command", event.target.value) },
h("option", { value: "echo" }, "echo"),
h("option", { value: "docker.ps" }, "docker.ps"),
h("option", { value: "host.ssh" }, "host.ssh"),
h("option", { value: "microservice.http" }, "microservice.http"),
)),
h("label", { key: "payload", className: "raw-editor-label" }, "Payload JSON", h("textarea", { className: "raw-editor", value: form.payloadJson, onChange: (event: any) => update("payloadJson", event.target.value) })),
],
h("label", null, "超时 ms", h("input", { value: form.timeoutMs, onChange: (event: any) => update("timeoutMs", event.target.value) })),
h("label", { className: "raw-editor-label" }, "描述", h("textarea", { className: "raw-editor compact", value: form.description, onChange: (event: any) => update("description", event.target.value) })),
h("div", { className: "dispatch-actions" },
h("button", { type: "button", className: "ghost-btn", disabled: busy, onClick: () => setForm(defaultScheduleForm(nodes || [])) }, "重置"),
h("button", { type: "submit", disabled: busy || !form.id }, busy ? "保存中" : "保存任务"),
),
notice ? h("p", { className: "muted paragraph" }, notice) : null,
h(UniDeskErrorBanner, { error, wide: true }),
),
),
h(Panel, { title: "历史执行记录", eyebrow: `${sortedRuns.length} Runs` },
sortedRuns.length === 0 ? h(EmptyState, { title: "暂无执行记录", text: "定时触发或手动触发后会生成 run history" }) :
h("div", { className: "table-wrap" }, h("table", { className: "task-history-table schedule-run-table" },
h("thead", null, h("tr", null, h("th", null, "状态"), h("th", null, "任务"), h("th", null, "触发"), h("th", null, "耗时"), h("th", null, "结果摘要"), h("th", null, "更新时间"), h("th", null, "操作"))),
h("tbody", null, sortedRuns.map((run: any) => h("tr", { key: run.id, "data-testid": `schedule-run-row-${safeId(run.id)}` },
h("td", null, h(StatusBadge, { status: scheduleRunTone(run.status) }, run.status)),
h("td", null, h("strong", null, run.scheduleId), h("code", null, run.id), run.taskId ? h("code", null, run.taskId) : null),
h("td", null, run.trigger || "--"),
h("td", null, scheduleRunDuration(run)),
h("td", null, h(DataSummary, { data: run.result || run.error, empty: "无结果" })),
h("td", null, fmtDate(run.updatedAt)),
h("td", null, h(RawButton, { title: `Schedule Run ${run.id}`, data: run, onOpen: onRaw })),
))),
)),
),
);
}
function TopologyPage({ data }: AnyRecord) {
const overview = data.overview || {};
return h("div", { className: "page-grid topology-grid" },
@@ -1870,6 +2120,7 @@ function WorkArea({ activeModule, activeTab, data, session, refresh, onRaw, onNa
if (activeModule === "nodes" && activeTab === "labels") return h(LabelsPage, { nodes: data.nodes });
if (activeModule === "nodes" && activeTab === "heartbeats") return h(HeartbeatPage, { nodes: data.nodes });
if (activeModule === "tasks" && activeTab === "dispatch") return h(DispatchPage, { nodes: data.nodes, onDispatched: refresh, onRaw });
if (activeModule === "tasks" && activeTab === "scheduled") return h(TaskScheduledPage, { schedules: data.schedules, scheduleRuns: data.scheduleRuns, nodes: data.nodes, refresh, onRaw });
if (activeModule === "tasks" && activeTab === "pending") return h(TaskPendingPage, { tasks: data.pendingTasks, onRaw });
if (activeModule === "tasks" && activeTab === "history") return h(TaskHistoryPage, { tasks: data.tasks, onRaw });
if (activeModule === "tasks" && activeTab === "results") return h(TaskResultsPage, { tasks: data.tasks, onRaw });
@@ -1893,7 +2144,7 @@ function Shell({ session, onLogout }: AnyRecord) {
const initialRouteTarget = resolveRouteTarget(ROUTE_REGISTRY, window.location.pathname);
const [activeModule, setActiveModule] = useState(initialRouteTarget.moduleId);
const [activeTabs, setActiveTabs] = useState({ ...DEFAULT_ACTIVE_TABS, [initialRouteTarget.moduleId]: initialRouteTarget.tabId });
const [data, setData] = useState({ overview: null, nodes: [], systemStatuses: [], dockerStatuses: [], microservices: [], events: [], tasks: [], pendingTasks: [], logs: [] });
const [data, setData] = useState({ overview: null, nodes: [], systemStatuses: [], dockerStatuses: [], microservices: [], events: [], tasks: [], pendingTasks: [], schedules: [], scheduleRuns: [], logs: [] });
const [connection, setConnection] = useState({ ok: false, text: "连接中" });
const [lastRefresh, setLastRefresh] = useState(null);
const [clock, setClock] = useState(new Date());
@@ -1933,7 +2184,7 @@ function Shell({ session, onLogout }: AnyRecord) {
};
const isOverview = activeModule === "ops" && activeTab === "status";
const needsOverviewSummary = isOverview || (activeModule === "config" && activeTab === "topology");
const needsNodes = isOverview || activeModule === "nodes" || (activeModule === "tasks" && activeTab === "dispatch");
const needsNodes = isOverview || activeModule === "nodes" || (activeModule === "tasks" && (activeTab === "dispatch" || activeTab === "scheduled"));
const needsMicroservices = activeModule === "apps" && activeTab !== "code-queue";
if (needsOverviewSummary) add("overview", `${cfg.apiBaseUrl}/overview`);
if (needsNodes) add("nodes", `${cfg.apiBaseUrl}/nodes`);
@@ -1944,6 +2195,9 @@ function Shell({ session, onLogout }: AnyRecord) {
add("dockerStatuses", `${cfg.apiBaseUrl}/nodes/docker-status`);
} else if (activeModule === "nodes" && activeTab === "gateway") {
add("tasks", `${cfg.apiBaseUrl}/tasks?limit=300&summary=1`);
} else if (activeModule === "tasks" && activeTab === "scheduled") {
add("schedules", `${cfg.apiBaseUrl}/schedules?limit=100`);
add("scheduleRuns", `${cfg.apiBaseUrl}/schedules/runs?limit=100`);
} else if (activeModule === "tasks" && activeTab === "pending") {
add("pendingTasks", `${cfg.apiBaseUrl}/tasks?status=pending&limit=100&summary=1`);
} else if (activeModule === "tasks" && (activeTab === "history" || activeTab === "results")) {
@@ -1967,6 +2221,8 @@ function Shell({ session, onLogout }: AnyRecord) {
if (key === "events") patch.events = value.events || [];
if (key === "tasks") patch.tasks = value.tasks || [];
if (key === "pendingTasks") patch.pendingTasks = value.tasks || [];
if (key === "schedules") patch.schedules = value.schedules || [];
if (key === "scheduleRuns") patch.scheduleRuns = value.runs || [];
if (key === "logs") patch.logs = value.logs || [];
setData((previous: AnyRecord) => ({ ...previous, ...patch }));
}));
@@ -2043,16 +2299,22 @@ function Shell({ session, onLogout }: AnyRecord) {
setRaw({ title, data: rawData });
}
const [notificationOpen, setNotificationOpen] = useState(false);
const { unreadCount, notifications } = useNotification();
const latestNotification = notifications.length > 0 ? notifications[notifications.length - 1] : null;
return h("div", { className: `shell ${railCollapsed ? "rail-collapsed" : ""}`, "data-testid": "app-shell" },
h(Sidebar, { activeModule, activeTabs, onNavigate: navigate, collapsed: railCollapsed, onToggle: () => setRailCollapsed((value: boolean) => !value) }),
h("main", { className: "workspace" },
h(TopBar, { connection, lastRefresh, onRefresh: refresh, onLogout: () => onLogout(true), session, clock, activeStatusItems }),
h(TopBar, { connection, lastRefresh, onRefresh: refresh, onLogout: () => onLogout(true), session, clock, activeStatusItems, onNotificationToggle: () => setNotificationOpen((v: boolean) => !v), unreadCount }),
h(TabBar, { module, activeTab, onNavigate: navigate }),
h(LoadingContext.Provider, { value: refreshing },
h(WorkArea, { activeModule, activeTab, data: effectiveData, session, refresh, onRaw: openRaw, onNavigate: navigate }),
),
),
h(RawDialog, { raw, onClose: () => setRaw(null) }),
latestNotification && h(NotificationBanner, { key: latestNotification.id, notification: latestNotification }),
notificationOpen && h(NotificationPopup, { onClose: () => setNotificationOpen(false) }),
);
}
@@ -2083,7 +2345,7 @@ function App() {
if (checking) return h("main", { className: "loading-screen" }, h("div", { className: "brand-mark" }, "UD"), h("span", null, "加载会话"));
if (!session) return h(LoginScreen, { onLogin: setSession });
return h(Shell, { session, onLogout: logout });
return h(NotificationProvider, null, h(Shell, { session, onLogout: logout }));
}
const rootElement = document.getElementById("root");
src/components/frontend/src/baidu-netdisk.tsx
+23 -9
View File
@@ -3,6 +3,7 @@ import { fmtClock, fmtDate } from "./time";
import { LoadingTitle } from "./loading-indicator";
import { errorMessage, requestJson as requestUniDeskJson } from "./unidesk-error";
import { UniDeskErrorBanner } from "./unidesk-error-banner";
import { useNotification } from "./notification-context";
type AnyRecord = Record<string, any>;
@@ -125,6 +126,10 @@ function pathJoin(base: string, name: string): string {
return `${base.replace(/\/+$/u, "")}/${safeName}`;
}
function rootDisplayName(root: string): string {
return root === "/" ? "/" : root.split("/").filter(Boolean).pop() || root;
}
function ProgressBar({ percent }: AnyRecord) {
const value = Math.max(0, Math.min(100, Number(percent) || 0));
return h("div", { className: "baidu-progress" }, h("span", { style: { width: `${value}%` } }), h("em", null, `${value.toFixed(1)}%`));
@@ -133,13 +138,23 @@ function ProgressBar({ percent }: AnyRecord) {
export function BaiduNetdiskPage({ microservices, onRaw, apiBaseUrl = "/api" }: AnyRecord) {
const service = microservices.find((item: any) => item.id === "baidu-netdisk") || null;
const [state, setState] = useState({ loading: false, actionLoading: false, error: "", message: "", health: null, account: null, files: null, transfers: null, logs: null, selfTest: null, refreshedAt: null });
const [currentDir, setCurrentDir] = useState("/apps/UniDeskBaiduNetdisk");
const [currentDir, setCurrentDir] = useState("/");
const [deviceSession, setDeviceSession] = useState(null);
const [folderName, setFolderName] = useState("");
const [uploadForm, setUploadForm] = useState({ localPath: "sample.txt", remotePath: "/apps/UniDeskBaiduNetdisk/sample.txt" });
const [uploadForm, setUploadForm] = useState({ localPath: "sample.txt", remotePath: "/sample.txt" });
const [downloadForm, setDownloadForm] = useState({ fsId: "", localPath: "downloads/" });
const { addNotification } = useNotification();
const appRoot = state.health?.baidu?.appRoot || state.account?.rootPath || "/apps/UniDeskBaiduNetdisk";
const appRoot = state.health?.baidu?.appRoot || state.account?.rootPath || "/";
useEffect(() => {
setUploadForm((prev: any) => {
const legacyDefaults = new Set(["/sample.txt", "/apps/UniDeskBaiduNetdisk/sample.txt"]);
if (prev.remotePath && !legacyDefaults.has(prev.remotePath)) return prev;
const remotePath = pathJoin(appRoot, "sample.txt");
return prev.remotePath === remotePath ? prev : { ...prev, remotePath };
});
}, [appRoot]);
async function loadFiles(dir = currentDir): Promise<void> {
const targetDir = dir || appRoot;
@@ -354,13 +369,12 @@ export function BaiduNetdiskPage({ microservices, onRaw, apiBaseUrl = "/api" }:
),
),
h(UniDeskErrorBanner, { error: state.error, wide: true }),
state.message ? h("div", { className: "form-success wide" }, state.message) : null,
),
h("div", { className: "metric-grid" },
h(MetricCard, { label: "Health", value: health.ok ? "OK" : "--", hint: health.storage?.postgres || "postgres", tone: health.ok ? "ok" : "warn" }),
h(MetricCard, { label: "OAuth", value: configured ? "已配置" : "待配置", hint: configured ? "client + secret + token key" : "需要设置 UNIDESK_BAIDU_NETDISK_*", tone: configured ? "ok" : "warn" }),
h(MetricCard, { label: "Login", value: loggedIn ? "已登录" : "未登录", hint: account?.username || "Device Code QR", tone: loggedIn ? "ok" : "warn" }),
h(MetricCard, { label: "App Root", value: appRoot.split("/").pop() || "apps", hint: appRoot }),
h(MetricCard, { label: "Work Root", value: rootDisplayName(appRoot), hint: appRoot }),
h(MetricCard, { label: "Quota", value: fmtBytes(quota.used), hint: quota.total ? `${quota.usedPercent || 0}% / ${fmtBytes(quota.total)}` : "授权后刷新" }),
h(MetricCard, { label: "Transfers", value: numberText(jobs.length), hint: `running ${state.transfers?.counts?.running || 0} / failed ${state.transfers?.counts?.failed || 0}` }),
),
@@ -387,7 +401,7 @@ export function BaiduNetdiskPage({ microservices, onRaw, apiBaseUrl = "/api" }:
}),
h(DocLinkCard, {
title: "服务方案与 API",
text: "说明 OAuth Device Code、应用目录、staging 上传下载任务和后端 API 设计。",
text: "说明 OAuth Device Code、根目录工作区、staging 上传下载任务和后端 API 设计。",
href: "/docs/issue/baidu-netdisk-user-service.md",
badge: "DESIGN",
}),
@@ -455,7 +469,7 @@ export function BaiduNetdiskPage({ microservices, onRaw, apiBaseUrl = "/api" }:
account ? h("div", { className: "baidu-account-card" },
h("div", { className: "node-version-line" }, h(StatusBadge, { status: "online" }, "connected"), h("span", null, account.baiduUid || "--"), h("span", null, `VIP ${account.vipType ?? "--"}`)),
h("h3", null, account.username || "Baidu Netdisk"),
h("p", { className: "muted paragraph" }, `应用目录固定在 ${account.rootPath || appRoot}；v1 上传/下载只读写容器 staging 目录，不把大文件字节流穿过 UniDesk proxy。`),
h("p", { className: "muted paragraph" }, `工作目录固定在 ${account.rootPath || appRoot}；v1 上传/下载只读写容器 staging 目录，不把大文件字节流穿过 UniDesk proxy。`),
h("div", { className: "quota-bar" }, h("span", { style: { width: `${Math.max(0, Math.min(100, Number(quota.usedPercent || 0)))}%` } })),
h("div", { className: "microservice-ref-card" }, h("span", null, "Quota"), h("strong", null, `${fmtBytes(quota.used)} / ${fmtBytes(quota.total)}`), h("code", null, `${quota.usedPercent || 0}% used`)),
) : h(EmptyState, { title: "尚未登录", text: "扫码授权后这里会显示账号、UID、会员状态和容量" }),
@@ -475,7 +489,7 @@ export function BaiduNetdiskPage({ microservices, onRaw, apiBaseUrl = "/api" }:
h("input", { value: folderName, onChange: (event: any) => setFolderName(event.target.value), placeholder: "新文件夹名称", disabled: !loggedIn }),
h("button", { type: "submit", className: "primary-btn", disabled: !loggedIn || !folderName.trim() }, "新建文件夹"),
),
!loggedIn ? h(EmptyState, { title: "等待授权", text: "登录后通过 /api/files 读取应用目录文件列表" }) : files.length === 0 ? h(EmptyState, { title: "目录为空", text: "可以从 staging 目录上传文件或新建文件夹" }) :
!loggedIn ? h(EmptyState, { title: "等待授权", text: "登录后通过 /api/files 读取工作目录文件列表" }) : files.length === 0 ? h(EmptyState, { title: "目录为空", text: "可以从 staging 目录上传文件或新建文件夹" }) :
h("div", { className: "table-wrap", "data-testid": "baidu-netdisk-file-table" }, h("table", null,
h("thead", null, h("tr", null, h("th", null, "名称"), h("th", null, "类型"), h("th", null, "大小"), h("th", null, "修改时间"), h("th", null, "fs_id"), h("th", null, "操作"))),
h("tbody", null, files.map((file: any) => h("tr", { key: file.fsId || file.path },
@@ -502,7 +516,7 @@ export function BaiduNetdiskPage({ microservices, onRaw, apiBaseUrl = "/api" }:
h("div", { className: "baidu-transfer-forms" },
h("form", { className: "stack-form", onSubmit: submitUpload, "data-testid": "baidu-upload-form" },
h("label", null, "容器 staging 文件", h("input", { value: uploadForm.localPath, onChange: (event: any) => setUploadForm((prev: any) => ({ ...prev, localPath: event.target.value })), placeholder: "sample.txt" })),
h("label", null, "百度网盘目标路径", h("input", { value: uploadForm.remotePath, onChange: (event: any) => setUploadForm((prev: any) => ({ ...prev, remotePath: event.target.value })), placeholder: `${appRoot}/sample.txt` })),
h("label", null, "百度网盘目标路径", h("input", { value: uploadForm.remotePath, onChange: (event: any) => setUploadForm((prev: any) => ({ ...prev, remotePath: event.target.value })), placeholder: pathJoin(appRoot, "sample.txt") })),
h("button", { type: "submit", className: "primary-btn", disabled: !loggedIn || state.actionLoading }, "上传 staging 文件"),
),
h("form", { className: "stack-form", onSubmit: submitDownload, "data-testid": "baidu-download-form" },
src/components/frontend/src/claudeqq.tsx
+11 -3
View File
@@ -3,6 +3,7 @@ import { fmtClock, fmtDate } from "./time";
import { LoadingTitle } from "./loading-indicator";
import { errorMessage, requestJson as requestUniDeskJson } from "./unidesk-error";
import { UniDeskErrorBanner } from "./unidesk-error-banner";
import { useNotification } from "./notification-context";
type AnyRecord = Record<string, any>;
@@ -111,6 +112,7 @@ export function ClaudeQqPage({ microservices, onRaw, apiBaseUrl = "/api" }: AnyR
const [pushForm, setPushForm] = useState({ targetType: "private", targetId: String(PRIMARY_PRIVATE_CHAT.userId), message: "" });
const [subscriptionForm, setSubscriptionForm] = useState({ name: "unidesk-callback", targetUrl: "", eventTypes: "message", secret: "" });
const [actionMessage, setActionMessage] = useState("");
const { addNotification } = useNotification();
async function load(): Promise<void> {
if (!service) return;
@@ -173,8 +175,10 @@ export function ClaudeQqPage({ microservices, onRaw, apiBaseUrl = "/api" }: AnyR
message: pushForm.message,
}),
});
const msg = "消息推送请求已提交";
setPushForm((prev: any) => ({ ...prev, targetType: "private", targetId: String(PRIMARY_PRIVATE_CHAT.userId), message: "" }));
setActionMessage("消息推送请求已提交");
setActionMessage(msg);
addNotification("success", msg);
await load();
} catch (err) {
setState((prev: any) => ({ ...prev, error: errorMessage(err, "发送失败") }));
@@ -199,7 +203,9 @@ export function ClaudeQqPage({ microservices, onRaw, apiBaseUrl = "/api" }: AnyR
enabled: true,
}),
});
setActionMessage("事件订阅已创建");
const msg = "事件订阅已创建";
setActionMessage(msg);
addNotification("success", msg);
await load();
} catch (err) {
setState((prev: any) => ({ ...prev, error: errorMessage(err, "订阅失败") }));
@@ -211,7 +217,9 @@ export function ClaudeQqPage({ microservices, onRaw, apiBaseUrl = "/api" }: AnyR
setActionMessage("");
try {
await requestJson(claudeqqApi(apiBaseUrl, `/api/events/subscriptions/${encodeURIComponent(id)}`), { method: "DELETE" });
setActionMessage("事件订阅已删除");
const msg = "事件订阅已删除";
setActionMessage(msg);
addNotification("success", msg);
await load();
} catch (err) {
setState((prev: any) => ({ ...prev, error: errorMessage(err, "删除订阅失败") }));
src/components/frontend/src/code-queue.tsx
+151 -39
View File
@@ -5,6 +5,7 @@ import { MarkdownBody } from "./markdown";
import { TraceView, codexTracePort } from "./trace";
import { errorMessage, requestJson as requestUniDeskJson } from "./unidesk-error";
import { UniDeskErrorBanner } from "./unidesk-error-banner";
import { useNotification } from "./notification-context";
type AnyRecord = Record<string, any>;
@@ -75,6 +76,13 @@ function latestTimestampValue(...values: any[]): string {
return best;
}
function timestampIsAfter(left: any, right: any): boolean {
const leftMs = timestampMs(left);
if (leftMs === null) return false;
const rightMs = timestampMs(right);
return rightMs === null || leftMs > rightMs + 1;
}
function fmtPreciseMs(ms: any): string {
const value = Number(ms);
if (!Number.isFinite(value) || value < 0) return "--";
@@ -98,9 +106,9 @@ async function requestJson(path: string, options: AnyRecord = {}): Promise<any>
});
}
function StatusBadge({ status, children }: AnyRecord) {
function StatusBadge({ status, children, title }: AnyRecord) {
const normalized = String(status || "unknown").toLowerCase();
return h("span", { className: `status-badge ${normalized}` }, children || status || "unknown");
return h("span", { className: `status-badge ${normalized}`, title }, children || status || "unknown");
}
function Panel({ title, eyebrow, summary, actions, children, className, loading }: AnyRecord) {
@@ -315,7 +323,7 @@ async function loadTaskOverview(apiBaseUrl: string, preferId: string, afterSeq =
async function loadTaskPage(apiBaseUrl: string, queueId: string, beforeId: string, limit = codexMoreTaskLimit, searchQuery = ""): Promise<any> {
return requestJson(codexApi(
apiBaseUrl,
`/api/tasks?limit=${encodeURIComponent(String(limit))}&lite=1&devReady=0&includeActive=0&beforeId=${encodeURIComponent(beforeId)}${taskListQuerySuffix(queueId, searchQuery)}`,
`/api/tasks/overview?limit=${encodeURIComponent(String(limit))}&transcriptLimit=1&compact=1&selected=0&includeActive=0&stats=0&beforeId=${encodeURIComponent(beforeId)}${taskListQuerySuffix(queueId, searchQuery)}`,
));
}
@@ -556,6 +564,35 @@ function taskExecutionSummary(task: any): AnyRecord {
return execution && typeof execution === "object" && !Array.isArray(execution) ? execution : {};
}
function rawTaskStepCount(task: any): number {
const value = Number(task?.stepCount ?? task?.llmStepCount ?? 0);
return Number.isFinite(value) && value >= 0 ? Math.floor(value) : 0;
}
function traceSummaryStepCount(summary: AnyRecord | null): number {
const execution = objectRecord(summary?.execution) || {};
const value = Number(summary?.stepCount ?? summary?.llmStepCount ?? execution.stepCount ?? execution.llmStepCount ?? execution.toolCallCount ?? 0);
return Number.isFinite(value) && value >= 0 ? Math.floor(value) : 0;
}
function traceSummaryIsCurrent(task: any): boolean {
if (!task || task?._traceSummaryLoaded !== true) return false;
const summary = taskTraceSummary(task);
const summaryAt = String(task?._traceSummaryUpdatedAt || summary?.updatedAt || "");
const updatedAt = String(task?.updatedAt || "");
if (updatedAt.length > 0) {
const summaryMs = timestampMs(summaryAt);
const updatedMs = timestampMs(updatedAt);
if (summaryMs !== null && updatedMs !== null) {
if (summaryMs + 1 < updatedMs) return false;
} else if (summaryAt !== updatedAt) {
return false;
}
}
const rawSteps = rawTaskStepCount(task);
return rawSteps <= 0 || traceSummaryStepCount(summary) >= rawSteps;
}
function taskBasePromptText(task: any): string {
const summaryPrompt = taskPromptSummary(task);
const basePrompt = String(summaryPrompt.basePrompt || "");
@@ -870,6 +907,36 @@ function taskQueueLabel(task: any): string {
return String(task?.queueId || "default");
}
function queuedReasonRecord(task: any): AnyRecord | null {
const reason = objectRecord(task?.queuedReason);
return reason;
}
function queuedReasonLabel(task: any): string {
const explicit = String(task?.queuedReasonLabel || "").trim();
if (explicit.length > 0) return explicit.toUpperCase();
const reason = queuedReasonRecord(task);
const label = String(reason?.label || "").trim();
return label.length > 0 ? label.toUpperCase() : "";
}
function taskStatusBadgeText(task: any): string {
const status = String(task?.status || "unknown");
if (status !== "queued") return status;
const reason = queuedReasonLabel(task);
return reason.length > 0 ? `QUEUED(${reason})` : "QUEUED";
}
function taskStatusBadgeTitle(task: any): string | undefined {
if (String(task?.status || "") !== "queued") return undefined;
const reason = queuedReasonRecord(task);
const message = String(reason?.message || "").trim();
const label = queuedReasonLabel(task);
if (message.length > 0 && label.length > 0) return `${label}: ${message}`;
if (message.length > 0) return message;
return label.length > 0 ? label : undefined;
}
function channelLabel(channel: string): string {
const labels: Record<string, string> = {
system: "SYS",
@@ -1190,7 +1257,7 @@ function TaskCard({ task, selected, onSelect, onCopy, onReference, onMarkRead, c
unread ? h("span", { className: "codex-unread-badge", title: "待读", "aria-label": "待读", "data-testid": `codex-unread-task-${taskId || "unknown"}` }) : null,
h("div", { className: "codex-task-card-head" },
h("div", { className: "codex-task-status-line" },
h(StatusBadge, { status: task?.status }, task?.status || "unknown"),
h(StatusBadge, { status: task?.status, title: taskStatusBadgeTitle(task) }, taskStatusBadgeText(task)),
),
h("span", { className: "mono-text" }, `${task?.currentAttempt || 0}/${task?.maxAttempts || 0}`),
),
@@ -1495,7 +1562,8 @@ function ProgressiveExecutionSummary({ task, attempt, attemptIndex, loading, onL
const stepsLoaded = taskTraceStepsLoaded(task, attemptIndex);
const errorCount = Number(attempt?.errorCount ?? summary?.errorCount ?? traceStepErrorCount(steps));
const toolCount = Number(execution.toolCallCount || 0);
const stepCount = Number(execution.stepCount ?? execution.llmStepCount ?? 0);
const summaryStepCountValue = Number(execution.stepCount ?? execution.llmStepCount ?? 0);
const summaryStepCount = Number.isFinite(summaryStepCountValue) && summaryStepCountValue >= 0 ? Math.floor(summaryStepCountValue) : 0;
const editedFiles = Array.isArray(execution.editedFiles) ? execution.editedFiles : [];
const commands = Array.isArray(execution.commands) ? execution.commands : [];
const synthetic = isSyntheticAttemptSegment(attempt, attemptIndex);
@@ -1503,6 +1571,11 @@ function ProgressiveExecutionSummary({ task, attempt, attemptIndex, loading, onL
const updatedAt = attemptExecutionUpdatedAt(task, attempt, attemptIndex, execution);
const recentUpdateLabel = `最近更新: ${fmtRelativeAge(updatedAt)}`;
const running = attemptExecutionIsRunning(task, attempt, attemptIndex);
const rawSteps = rawTaskStepCount(task);
const realAttemptCount = taskProgressiveAttempts(task).filter((item: any) => !isSyntheticAttemptSegment(item, item?.index)).length;
const canUseTaskStepFloor = !synthetic && steps.length === 0 && rawSteps > 0 && realAttemptCount <= 1;
const stepCount = canUseTaskStepFloor ? Math.max(summaryStepCount, rawSteps) : summaryStepCount;
const displayedToolCount = canUseTaskStepFloor ? Math.max(toolCount, stepCount) : toolCount;
return h("details", {
className: `codex-progressive-card codex-execution-summary ${running ? "running" : ""}`,
"data-testid": testId,
@@ -1518,7 +1591,7 @@ function ProgressiveExecutionSummary({ task, attempt, attemptIndex, loading, onL
h("strong", null, `执行过程摘要${labelSuffix}`),
running ? h("span", { className: "codex-summary-running-pill", "data-testid": `${testId}-running` }, "执行中") : null,
h("code", { title: updatedAt ? `最近更新: ${fmtDate(updatedAt)}` : recentUpdateLabel },
`${fmtDuration(execution.durationMs ?? execution.totalElapsedMs)} / ${toolCount} tools / ${recentUpdateLabel}`),
`${fmtDuration(execution.durationMs ?? execution.totalElapsedMs)} / ${displayedToolCount} tools / ${recentUpdateLabel}`),
),
h("div", { className: "codex-execution-digest" },
h("span", null, `read ${Number(execution.readCount || 0)}`),
@@ -1775,7 +1848,7 @@ export function CodeQueuePage({ microservices, onRaw, apiBaseUrl = "/api", initi
const loadMoreInFlightRef = useRef(false);
const searchLoadMoreInFlightRef = useRef(false);
const detailInFlightRef = useRef<{ taskId: string; token: number; promise: Promise<void> } | null>(null);
const traceSummaryInFlightRef = useRef<Map<string, Promise<void>>>(new Map());
const traceSummaryInFlightRef = useRef<Map<string, { promise: Promise<void>; refreshAfter: boolean }>>(new Map());
const promptDetailInFlightRef = useRef<Map<string, Promise<void>>>(new Map());
const traceStepsInFlightRef = useRef<Map<string, Promise<void>>>(new Map());
const traceStepInFlightRef = useRef<Map<string, Promise<void>>>(new Map());
@@ -1814,6 +1887,7 @@ export function CodeQueuePage({ microservices, onRaw, apiBaseUrl = "/api", initi
const [busy, setBusy] = useState(false);
const [error, setError] = useState("");
const [notice, setNotice] = useState("");
const { addNotification } = useNotification();
const [copiedTaskId, setCopiedTaskId] = useState("");
const [markingReadTaskId, setMarkingReadTaskId] = useState("");
const [markingAllRead, setMarkingAllRead] = useState(false);
@@ -2056,36 +2130,48 @@ export function CodeQueuePage({ microservices, onRaw, apiBaseUrl = "/api", initi
if (!service || !taskId) return;
const cached = sessionCacheRef.current.get(taskId);
const cachedTask = cached?.task;
const cachedSummaryAt = String(cachedTask?._traceSummaryUpdatedAt || "");
const cachedUpdatedAt = String(cachedTask?.updatedAt || "");
if (!force && cachedTask?._traceSummaryLoaded === true && cachedSummaryAt === cachedUpdatedAt) return;
if (!force && traceSummaryIsCurrent(cachedTask)) return;
const key = taskId;
const existing = traceSummaryInFlightRef.current.get(key);
if (existing) return existing;
if (existing) {
if (force || !traceSummaryIsCurrent(cachedTask)) existing.refreshAfter = true;
return existing.promise;
}
const token = detailLoadTokenRef.current;
const startedAt = performance.now();
if (selectedIdRef.current === taskId) setSelectedDetailLoading(true);
const inFlight = { promise: Promise.resolve(), refreshAfter: false };
const promise = (async () => {
try {
const result = await loadTaskTraceSummary(apiBaseUrl, taskId);
if (token !== detailLoadTokenRef.current || selectedIdRef.current !== taskId) return;
const summary = result?.summary || {};
const currentTask = sessionCacheRef.current.get(taskId)?.task || {};
const summaryUpdatedAt = String(summary.updatedAt || "");
const currentUpdatedAt = String(currentTask?.updatedAt || "");
const summaryBehind = timestampIsAfter(currentUpdatedAt, summaryUpdatedAt) || rawTaskStepCount(currentTask) > traceSummaryStepCount(summary);
if (summaryBehind) inFlight.refreshAfter = true;
const effectiveUpdatedAt = summaryBehind
? latestTimestampValue(currentUpdatedAt, summaryUpdatedAt)
: summaryUpdatedAt || currentUpdatedAt;
publishCachedTask(taskId, {
id: taskId,
status: summary.status,
updatedAt: summary.updatedAt,
startedAt: summary.startedAt,
finishedAt: summary.finishedAt,
currentAttempt: summary.currentAttempt,
maxAttempts: summary.maxAttempts,
finalResponse: summary.finalResponse,
lastJudge: summary.lastJudge,
lastError: summary.lastError,
attempts: Array.isArray(summary.attempts) ? summary.attempts : [],
status: summaryBehind ? (currentTask?.status || summary.status) : summary.status,
updatedAt: effectiveUpdatedAt,
startedAt: summary.startedAt || currentTask?.startedAt,
finishedAt: summaryBehind ? (currentTask?.finishedAt || summary.finishedAt) : summary.finishedAt,
currentAttempt: summary.currentAttempt ?? currentTask?.currentAttempt,
maxAttempts: summary.maxAttempts ?? currentTask?.maxAttempts,
finalResponse: summaryBehind ? preferLongerText(currentTask, summary, "finalResponse") : summary.finalResponse,
lastJudge: summaryBehind ? (currentTask?.lastJudge || summary.lastJudge) : summary.lastJudge,
lastError: summaryBehind ? (currentTask?.lastError || summary.lastError) : summary.lastError,
attempts: summaryBehind
? preferRicherArray(currentTask, { attempts: Array.isArray(summary.attempts) ? summary.attempts : [] }, "attempts")
: Array.isArray(summary.attempts) ? summary.attempts : [],
timing: summary.timing,
_traceSummary: summary,
_traceSummaryLoaded: true,
_traceSummaryUpdatedAt: String(summary.updatedAt || ""),
_traceSummaryUpdatedAt: summaryUpdatedAt,
_detailLoaded: true,
}, token);
setLoadStats({
@@ -2100,11 +2186,18 @@ export function CodeQueuePage({ microservices, onRaw, apiBaseUrl = "/api", initi
completedAt: new Date(),
});
} finally {
const shouldRefreshAfter = Boolean(inFlight.refreshAfter && selectedIdRef.current === taskId && !traceSummaryIsCurrent(sessionCacheRef.current.get(taskId)?.task));
traceSummaryInFlightRef.current.delete(key);
if (token === detailLoadTokenRef.current && selectedIdRef.current === taskId) setSelectedDetailLoading(false);
if (shouldRefreshAfter) {
window.setTimeout(() => {
void ensureTraceSummary(taskId, true).catch((err) => setError(errorText(err, "自动刷新 Trace Summary 失败")));
}, 0);
}
}
})();
traceSummaryInFlightRef.current.set(key, promise);
inFlight.promise = promise;
traceSummaryInFlightRef.current.set(key, inFlight);
await promise;
}
@@ -2543,7 +2636,9 @@ export function CodeQueuePage({ microservices, onRaw, apiBaseUrl = "/api", initi
}
if (!copied) throw new Error("browser clipboard rejected the copy request");
setCopiedTaskId(taskId);
setNotice(`已复制任务 ID：${taskId}`);
const msg = `已复制任务 ID：${taskId}`;
setNotice(msg);
addNotification("success", msg);
window.setTimeout(() => setCopiedTaskId((value: string) => value === taskId ? "" : value), 1600);
} catch (err) {
setError(`复制任务 ID 失败：${errorText(err)}`);
@@ -2553,7 +2648,9 @@ export function CodeQueuePage({ microservices, onRaw, apiBaseUrl = "/api", initi
function referenceTask(taskId: string): void {
if (!taskId) return;
setReferenceTaskId(taskId);
setNotice(`已引用任务 ID：${taskId}；提交时后端会读取并注入该任务上下文`);
const msg = `已引用任务 ID：${taskId}；提交时后端会读取并注入该任务上下文`;
setNotice(msg);
addNotification("success", msg);
}
async function markTaskRead(taskId: string): Promise<void> {
@@ -2569,7 +2666,9 @@ export function CodeQueuePage({ microservices, onRaw, apiBaseUrl = "/api", initi
const readAt = String(task?.readAt || new Date().toISOString());
patchLoadedReadState([taskId], readAt, result?.queue || null, task);
marked = true;
setNotice(`已将任务 ${taskId} 标为已读`);
const msg = `已将任务 ${taskId} 标为已读`;
setNotice(msg);
addNotification("success", msg);
}, "标记 Codex task 已读失败");
if (!marked) {
forgetLocalReadState([taskId]);
@@ -2608,7 +2707,9 @@ export function CodeQueuePage({ microservices, onRaw, apiBaseUrl = "/api", initi
patchLoadedReadState(readIds, readAt, result?.queue || null);
const markedCount = Number(result?.count || readIds.length);
marked = true;
setNotice(`已将 ${markedCount} 个已结束未读任务标为已读`);
const msg = `已将 ${markedCount} 个已结束未读任务标为已读`;
setNotice(msg);
addNotification("success", msg);
}, "全部标为已读失败");
if (!marked && optimisticReadIds.length > 0) {
forgetLocalReadState(optimisticReadIds);
@@ -2646,7 +2747,9 @@ export function CodeQueuePage({ microservices, onRaw, apiBaseUrl = "/api", initi
detailLoadTokenRef.current += 1;
setSelectedId("");
setSelectedTask(null);
setNotice(`已创建并切换到 queue：${createdId}`);
const msg = `已创建并切换到 queue：${createdId}`;
setNotice(msg);
addNotification("success", msg);
await load("", true, createdId);
}, "创建 Codex queue 失败");
}
@@ -2664,7 +2767,9 @@ export function CodeQueuePage({ microservices, onRaw, apiBaseUrl = "/api", initi
if (result?.summary) {
setTasksData((previous: any) => previous ? { ...previous, queue: result.summary } : previous);
}
setNotice(`已更新 queue 名称：${queueDisplayName(updatedQueue)}`);
const msg = `已更新 queue 名称：${queueDisplayName(updatedQueue)}`;
setNotice(msg);
addNotification("success", msg);
await load(selectedIdRef.current, true, selectedQueueId);
}, "修改 Codex queue 名称失败");
}
@@ -2672,7 +2777,8 @@ export function CodeQueuePage({ microservices, onRaw, apiBaseUrl = "/api", initi
async function enqueue(event: any): Promise<void> {
event.preventDefault();
if (enqueueInFlightRef.current) {
setNotice("任务正在提交中，请等待当前请求完成，已阻止重复提交。");
const msg = "任务正在提交中，请等待当前请求完成，已阻止重复提交。";
setNotice(msg);
return;
}
if (enqueueItems.length > 1 && !batchConfirmed) {
@@ -2702,13 +2808,14 @@ export function CodeQueuePage({ microservices, onRaw, apiBaseUrl = "/api", initi
const result = await requestJson(codexApi(apiBaseUrl, submittingItems.length === 1 ? "/api/tasks" : "/api/tasks/batch"), { method: "POST", body });
const firstId = result?.tasks?.[0]?.id || "";
const ids = Array.isArray(result?.tasks) ? result.tasks.map((task: any) => String(task?.id || "")).filter(Boolean) : [];
setNotice(`已创建 ${ids.length || submittingItems.length} 个任务${ids.length > 0 ? `：${ids.join(" / ")}` : ""}`);
const msg = `已创建 ${ids.length || submittingItems.length} 个任务${ids.length > 0 ? `：${ids.join(" / ")}` : ""}`;
setNotice(msg);
addNotification("success", msg);
setPrompt("");
setReferenceTaskId("");
setBatchConfirmed(false);
selectedIdRef.current = firstId;
if (selectedQueueId !== submitQueueId) setTasksData(null);
setSelectedQueueId(submitQueueId);
setQueueId(submitQueueId);
await load(firstId, true, submitQueueId);
}, "Codex 任务入队失败");
@@ -2759,7 +2866,9 @@ export function CodeQueuePage({ microservices, onRaw, apiBaseUrl = "/api", initi
const rows = taskRows(previous).map((task: any) => String(task?.id || "") === taskId ? { ...task, ...updatedTask } : task);
return { ...previous, queue: result?.queue || previous.queue, tasks: mergeTaskRowsPreferLatest([rows], activeTaskId) };
});
setNotice(result?.changed === false ? `任务 ${taskId} 的 prompt 未变化` : `已更新 queued 任务 ${taskId} 的用户 prompt`);
const msg = result?.changed === false ? `任务 ${taskId} 的 prompt 未变化` : `已更新 queued 任务 ${taskId} 的用户 prompt`;
setNotice(msg);
addNotification("success", msg);
await load(taskId, true, selectedQueueId);
}, "编辑 queued 任务 prompt 失败");
}
@@ -2801,7 +2910,9 @@ export function CodeQueuePage({ microservices, onRaw, apiBaseUrl = "/api", initi
setTasksData(null);
setSelectedQueueId(nextQueueId);
}
setNotice(`已将任务 ${taskId} 从 ${currentQueue} 移动到 ${nextQueueId}`);
const msg = `已将任务 ${taskId} 从 ${currentQueue} 移动到 ${nextQueueId}`;
setNotice(msg);
addNotification("success", msg);
await load(taskId, true, isAllQueues(selectedQueueId) ? allQueuesId : nextQueueId);
}, "移动任务 queue 失败");
}
@@ -2877,13 +2988,12 @@ export function CodeQueuePage({ microservices, onRaw, apiBaseUrl = "/api", initi
const taskId = String(selectedTask.id || "");
if (!taskId) return;
const updatedAt = String(selectedTask.updatedAt || "");
const summaryAt = String(selectedTask._traceSummaryUpdatedAt || "");
if (selectedTask._traceSummaryLoaded === true && summaryAt === updatedAt) return;
const key = `${taskId}:${updatedAt || "unknown"}`;
if (traceSummaryIsCurrent(selectedTask)) return;
const key = `${taskId}:${updatedAt || "unknown"}:${rawTaskStepCount(selectedTask)}:${traceSummaryStepCount(taskTraceSummary(selectedTask))}`;
if (autoTraceLoadKeysRef.current.has(key)) return;
autoTraceLoadKeysRef.current.add(key);
void ensureTraceSummary(taskId, true).catch((err) => setError(errorText(err, "自动加载 Trace Summary 失败")));
}, [service?.id, selectedTask?.id, selectedTask?.updatedAt, selectedTask?._traceSummaryUpdatedAt, selectedTask?._traceSummaryLoaded, selectedDetailLoading]);
}, [service?.id, selectedTask?.id, selectedTask?.updatedAt, selectedTask?.stepCount, selectedTask?.llmStepCount, selectedTask?._traceSummaryUpdatedAt, selectedTask?._traceSummaryLoaded, selectedDetailLoading]);
const taskListContent = sidebarTasks.length === 0 ? h(EmptyState, {
title: searchActive ? (searchLoading ? "搜索中" : "没有匹配任务") : "队列为空",
@@ -3115,7 +3225,9 @@ export function CodeQueuePage({ microservices, onRaw, apiBaseUrl = "/api", initi
setPrompt("");
setReferenceTaskId("");
setBatchConfirmed(false);
setNotice("已清空任务输入栏");
const msg = "已清空任务输入栏";
setNotice(msg);
addNotification("success", msg);
},
"data-testid": "codex-clear-input-button",
}, "清空输入"),
src/components/frontend/src/index.ts
+13 -3
View File
@@ -2,6 +2,7 @@ import { readFileSync } from "node:fs";
import { createHmac, randomBytes, timingSafeEqual } from "node:crypto";
import { join } from "node:path";
import { createHourlyJsonlWriter, logRetentionBytesForService } from "../../shared/src/rotating-jsonl";
import { notificationStyles } from "./notification-styles";
interface RuntimeConfig {
port: number;
@@ -80,6 +81,10 @@ function cachedCodeQueueOverview(pathWithQuery: string, maxAgeMs = codeQueueOver
return { payload: cached.payload, text: cached.text };
}
function invalidateCodeQueueOverviewCache(): void {
codeQueueOverviewCache.clear();
}
async function refreshCodeQueueOverview(pathWithQuery: string, timeoutMs = 800): Promise<JsonValue | null> {
const existing = codeQueueOverviewRefreshes.get(pathWithQuery);
if (existing !== undefined) return existing;
@@ -117,7 +122,11 @@ function renderIndexHtml(extraRootAttributes = ""): string {
const href = new URL(link.href, config.frontendPublicUrl).toString();
return `<a href="${escapeHtmlAttribute(href)}" data-page-section="${escapeHtmlAttribute(link.section)}">${escapeHtmlText(link.label)}</a>`;
}).join("")}</nav>`;
return indexHtmlTemplate.replace(
const notificationStyleTag = `<style>${notificationStyles}</style>`;
const htmlWithStyles = indexHtmlTemplate.includes("</head>")
? indexHtmlTemplate.replace("</head>", `${notificationStyleTag}</head>`)
: indexHtmlTemplate;
return htmlWithStyles.replace(
indexHtmlRootMarker,
`<div id="root" data-config="${escapeHtmlAttribute(clientConfig)}"${extraRootAttributes}>${docsFallback}</div>`,
);
@@ -698,6 +707,7 @@ async function proxyCodeQueueDirect(req: Request, url: URL): Promise<Response> {
}
const overviewCacheKey = `${suffix}${url.search}`;
const canUseOverviewCache = req.method === "GET" && suffix === "/api/tasks/overview";
if (req.method !== "GET" && req.method !== "HEAD") invalidateCodeQueueOverviewCache();
if (canUseOverviewCache) {
const cached = cachedCodeQueueOverview(overviewCacheKey);
if (cached !== null) {
@@ -726,7 +736,7 @@ async function proxyCodeQueueDirect(req: Request, url: URL): Promise<Response> {
const isJsonResponse = (upstreamContentType ?? "").toLowerCase().includes("json");
let parsedJson: unknown = null;
let jsonText = "";
if (isJsonResponse) {
if (canUseOverviewCache && upstream.ok && isJsonResponse) {
jsonText = new TextDecoder().decode(upstreamBody);
try {
parsedJson = jsonText ? JSON.parse(jsonText) as unknown : null;
@@ -753,7 +763,7 @@ async function proxyCodeQueueDirect(req: Request, url: URL): Promise<Response> {
}
}
if (canUseOverviewCache && upstream.ok && isJsonResponse) {
const text = new TextDecoder().decode(upstreamBody);
const text = jsonText;
if (typeof parsedJson === "object" && parsedJson !== null) {
codeQueueOverviewCache.set(codeQueueOverviewCacheKey(overviewCacheKey), { at: Date.now(), payload: parsedJson as JsonValue, text });
}
src/components/frontend/src/markdown.tsx
+15 -2
View File
@@ -22,6 +22,10 @@ interface ListItemInfo {
start?: number;
}
interface InlineRenderOptions {
linkify?: boolean;
}
export function MarkdownBody({ markdown, className, testId }: MarkdownBodyProps) {
const text = String(markdown ?? "").trimEnd();
const classes = ["markdown-body", className].filter(Boolean).join(" ");
@@ -261,9 +265,10 @@ function renderTable(headers: string[], separators: string[], rows: string[][],
);
}
function renderInline(text: string, keyPrefix: string): any[] {
function renderInline(text: string, keyPrefix: string, options: InlineRenderOptions = {}): any[] {
const children: any[] = [];
const pattern = /`([^`\n]+)`|\[([^\]\n]+)\]\(([^)\s]+)(?:\s+"[^"]*")?\)|(https?:\/\/[^\s<>)]+)|\*\*([^*\n]+)\*\*|__([^_\n]+)__|~~([^~\n]+)~~|\*([^*\n]+)\*|_([^_\n]+)_/gu;
const linkify = options.linkify !== false;
let cursor = 0;
let tokenIndex = 0;
for (const match of text.matchAll(pattern)) {
@@ -279,10 +284,18 @@ function renderInline(text: string, keyPrefix: string): any[] {
continue;
}
if (match[2] !== undefined && match[3] !== undefined) {
if (!linkify) {
appendText(children, token, `${key}-literal`);
continue;
}
children.push(renderLink(match[2], match[3], key));
continue;
}
if (match[4] !== undefined) {
if (!linkify) {
appendText(children, token, `${key}-literal`);
continue;
}
children.push(renderLink(match[4], match[4], key));
continue;
}
@@ -322,7 +335,7 @@ function renderLink(label: string, href: string, key: string): any {
href: safeHref,
target: external ? "_blank" : undefined,
rel: external ? "noreferrer" : undefined,
}, renderInline(label, `${key}-label`));
}, renderInline(label, `${key}-label`, { linkify: false }));
}
function safeMarkdownHref(raw: string): string | null {
src/components/frontend/src/navigation.ts
+1
View File
@@ -55,6 +55,7 @@ export const MODULES: UniDeskModuleDefinition[] = [
] },
{ id: "tasks", label: "任务调度", code: "TASK", tabs: [
{ id: "dispatch", label: "下发任务" },
{ id: "scheduled", label: "定时任务" },
{ id: "pending", label: "待处理任务" },
{ id: "history", label: "任务历史" },
{ id: "results", label: "执行结果" },
src/components/frontend/src/notification-context.tsx
+74
View File
@@ -0,0 +1,74 @@
import React from "react";
export type NotificationType = "success" | "error";
export interface NotificationItem {
id: string;
type: NotificationType;
message: string;
timestamp: number;
}
export interface NotificationContextValue {
notifications: NotificationItem[];
addNotification: (type: NotificationType, message: string) => void;
removeNotification: (id: string) => void;
clearNotifications: () => void;
unreadCount: number;
hasUnread: boolean;
}
const NotificationContext = React.createContext<NotificationContextValue | null>(null);
export function NotificationProvider({ children }: { children: React.ReactNode }) {
const [notifications, setNotifications] = React.useState<NotificationItem[]>([]);
const [lastReadTime, setLastReadTime] = React.useState<number>(Date.now());
const addNotification = React.useCallback((type: NotificationType, message: string) => {
const id = `notif_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
const newNotification: NotificationItem = { id, type, message, timestamp: Date.now() };
setNotifications(prev => {
const updated = [...prev, newNotification];
if (updated.length > 50) {
return updated.slice(-50);
}
return updated;
});
}, []);
const removeNotification = React.useCallback((id: string) => {
setNotifications(prev => prev.filter(n => n.id !== id));
}, []);
const clearNotifications = React.useCallback(() => {
setNotifications([]);
setLastReadTime(Date.now());
}, []);
const unreadCount = React.useMemo(() => {
return notifications.filter(n => n.timestamp > lastReadTime).length;
}, [notifications, lastReadTime]);
const hasUnread = unreadCount > 0;
const value: NotificationContextValue = {
notifications,
addNotification,
removeNotification,
clearNotifications,
unreadCount,
hasUnread,
};
return h(NotificationContext.Provider, { value }, children);
}
const h = React.createElement;
export function useNotification(): NotificationContextValue {
const context = React.useContext(NotificationContext);
if (!context) {
throw new Error("useNotification must be used within NotificationProvider");
}
return context;
}
src/components/frontend/src/notification-popup.tsx
+81
View File
@@ -0,0 +1,81 @@
import React from "react";
import { useNotification, NotificationItem } from "./notification-context";
const h = React.createElement;
interface NotificationPopupProps {
onClose: () => void;
}
export function NotificationPopup({ onClose }: NotificationPopupProps) {
const { notifications, removeNotification, clearNotifications } = useNotification();
const listRef = React.useRef<HTMLDivElement>(null);
React.useEffect(() => {
const handleClickOutside = (event: MouseEvent) => {
if (listRef.current && !listRef.current.contains(event.target as Node)) {
onClose();
}
};
document.addEventListener("mousedown", handleClickOutside);
return () => document.removeEventListener("mousedown", handleClickOutside);
}, [onClose]);
if (notifications.length === 0) {
return h("div", { className: "notification-popup", ref: listRef },
h("div", { className: "notification-popup-header" },
h("span", null, "通知"),
h("button", { className: "notification-popup-close", onClick: onClose }, "×"),
),
h("div", { className: "notification-popup-empty" }, "暂无通知"),
);
}
return h("div", { className: "notification-popup", ref: listRef },
h("div", { className: "notification-popup-header" },
h("span", null, `通知 (${notifications.length})`),
h("div", { className: "notification-popup-actions" },
h("button", { className: "notification-popup-clear", onClick: clearNotifications }, "清空"),
h("button", { className: "notification-popup-close", onClick: onClose }, "×"),
),
),
h("div", { className: "notification-popup-list" },
notifications.slice().reverse().map((item: NotificationItem) =>
h("div", {
key: item.id,
className: `notification-item ${item.type}`,
},
h("span", { className: "notification-item-icon" }, item.type === "success" ? "✓" : "×"),
h("span", { className: "notification-item-message" }, item.message),
h("button", {
className: "notification-item-dismiss",
onClick: () => removeNotification(item.id),
}, "×"),
)
),
),
);
}
export function NotificationBanner({ notification }: { notification: NotificationItem }) {
const { removeNotification } = useNotification();
React.useEffect(() => {
const timer = setTimeout(() => {
removeNotification(notification.id);
}, 3000);
return () => clearTimeout(timer);
}, [notification.id, removeNotification]);
return h("div", {
className: `notification-banner ${notification.type}`,
role: "alert",
},
h("span", { className: "notification-banner-icon" }, notification.type === "success" ? "✓" : "×"),
h("span", { className: "notification-banner-message" }, notification.message),
h("button", {
className: "notification-banner-dismiss",
onClick: () => removeNotification(notification.id),
}, "×"),
);
}
src/components/frontend/src/notification-styles.ts
+171
View File
@@ -0,0 +1,171 @@
export const notificationStyles = `
.notification-icon-btn {
position: relative;
background: none;
border: 1px solid #3a3a4a;
border-radius: 6px;
padding: 4px 8px;
cursor: pointer;
font-size: 16px;
transition: background-color 0.2s;
}
.notification-icon-btn:hover {
background-color: #2a2a3a;
}
.notification-icon-btn.has-unread {
border-color: #4a9eff;
}
.notification-badge {
position: absolute;
top: -6px;
right: -6px;
background: #e53e3e;
color: white;
border-radius: 10px;
font-size: 10px;
min-width: 16px;
height: 16px;
display: flex;
align-items: center;
justify-content: center;
padding: 0 4px;
}
.notification-popup {
position: fixed;
top: 48px;
right: 12px;
width: 340px;
max-height: 480px;
background: #1e1e2e;
border: 1px solid #3a3a4a;
border-radius: 8px;
box-shadow: 0 8px 32px rgba(0,0,0,0.5);
z-index: 99999;
display: flex;
flex-direction: column;
overflow: hidden;
}
.notification-popup-header {
display: flex;
align-items: center;
justify-content: space-between;
padding: 12px 16px;
border-bottom: 1px solid #3a3a4a;
font-weight: 600;
color: #e0e0e0;
}
.notification-popup-actions {
display: flex;
gap: 8px;
}
.notification-popup-clear,
.notification-popup-close {
background: none;
border: none;
cursor: pointer;
padding: 2px 6px;
border-radius: 4px;
color: #888;
font-size: 16px;
}
.notification-popup-clear:hover,
.notification-popup-close:hover {
color: #e0e0e0;
background-color: #2a2a3a;
}
.notification-popup-empty {
padding: 32px 16px;
text-align: center;
color: #666;
}
.notification-popup-list {
overflow-y: auto;
flex: 1;
}
.notification-item {
display: flex;
align-items: center;
gap: 8px;
padding: 10px 14px;
border-bottom: 1px solid #2a2a3a;
color: #e0e0e0;
font-size: 13px;
}
.notification-item.success {
border-left: 3px solid #38a169;
}
.notification-item.error {
border-left: 3px solid #e53e3e;
}
.notification-item-icon {
font-size: 14px;
width: 20px;
text-align: center;
}
.notification-item-message {
flex: 1;
overflow: hidden;
text-overflow: ellipsis;
white-space: nowrap;
}
.notification-item-dismiss {
background: none;
border: none;
cursor: pointer;
color: #666;
padding: 2px 4px;
font-size: 14px;
}
.notification-item-dismiss:hover {
color: #e0e0e0;
}
.notification-banner {
position: fixed;
top: 52px;
left: 50%;
transform: translateX(-50%);
padding: 10px 20px;
border-radius: 8px;
display: flex;
align-items: center;
gap: 10px;
z-index: 999999;
animation: slideDown 0.3s ease;
box-shadow: 0 4px 20px rgba(0,0,0,0.4);
font-size: 14px;
color: white;
}
.notification-banner.success {
background: linear-gradient(135deg, #38a169, #2f855a);
}
.notification-banner.error {
background: linear-gradient(135deg, #e53e3e, #c53030);
}
.notification-banner-icon {
font-size: 16px;
}
.notification-banner-message {
flex: 1;
}
.notification-banner-dismiss {
background: none;
border: none;
cursor: pointer;
color: rgba(255,255,255,0.7);
padding: 2px 6px;
font-size: 16px;
}
.notification-banner-dismiss:hover {
color: white;
}
@keyframes slideDown {
from {
opacity: 0;
transform: translateX(-50%) translateY(-20px);
}
to {
opacity: 1;
transform: translateX(-50%) translateY(0);
}
}
`;
src/components/frontend/src/pipeline.tsx
+4 -2
View File
@@ -5,6 +5,7 @@ import { Background, BaseEdge, Controls, Handle, MarkerType, Position, ReactFlow
import { TraceView, opencodeTracePort } from "./trace";
import { errorMessage, requestJson as requestUniDeskJson } from "./unidesk-error";
import { UniDeskErrorBanner } from "./unidesk-error-banner";
import { useNotification } from "./notification-context";
type AnyRecord = Record<string, any>;
@@ -995,7 +996,6 @@ function PipelineGanttDetailPanel({ selection, runDetails, nodeDetails, nodeDeta
{ label: "fetched", value: fetchedAt ? fmtClock(fetchedAt) : "--" },
context?.matchedStep ? { label: "matched step", value: `Step ${context.matchedStep.index ?? context.matchedStepIndex + 1}` } : null,
] }),
loading ? h("div", { className: "form-success" }, nodeLoading ? "正在抓取该 node 的 attempt / Trace..." : "正在抓取 epoch 执行过程..." ) : null,
h(UniDeskErrorBanner, { error }),
h("div", { className: "pipeline-gantt-detail-actions" },
h(RawButton, { title: `Procedure ${interval?.procedureRunId || marker?.procedureRunId || context?.nodeId || "node"}`, data: procedure, onOpen: onRaw, testId: "raw-pipeline-gantt-procedure" }),
@@ -3344,7 +3344,6 @@ function PipelineNodeControlPanel({ activeRun, pipelineRuns, selectedRunId, onRu
),
!selectedNodeId ? h(EmptyState, { title: "未选择 node", text: "点击 React Flow 控制图中的任意 node 后，可抓取执行过程、追加 prompt、下发引导、增量修改、审核通过或重做。" }) : null,
h(UniDeskErrorBanner, { error: control.error, wide: true }),
control.message ? h("div", { className: "form-success wide" }, control.message) : null,
h("div", { className: "pipeline-control-actions" },
h("label", null,
h("span", null, "实时追加 prompt（仅 running node）"),
@@ -3429,6 +3428,7 @@ export function PipelinePage({ microservices, onRaw, apiBaseUrl = "/api" }: AnyR
const [nodeControlOpen, setNodeControlOpen] = useState(false);
const [ganttDetailOpen, setGanttDetailOpen] = useState(false);
const loadRequestRef = useRef(0);
const { addNotification } = useNotification();
const loadInFlightRef = useRef(false);
const runDetailsRequestRef = useRef(0);
const runDetailsInFlightRef = useRef("");
@@ -3761,6 +3761,8 @@ export function PipelinePage({ microservices, onRaw, apiBaseUrl = "/api" }: AnyR
action === "approve" ? "已提交审核通过决策" :
"已排队重做命令",
}));
const msg = action === "append" ? "已追加到运行中 node" : action === "guide" ? "已下发 guide，等待 runner 处理" : action === "modify" ? "已排队增量修改命令" : action === "approve" ? "已提交审核通过决策" : "已排队重做命令";
addNotification("success", msg);
await fetchNodeDetails(activeRunId, selectedNodeId);
await fetchRunDetails(activeRunId, { silent: true });
if (action !== "append") await load();
src/components/frontend/src/project-manager.tsx
+11 -3
View File
@@ -3,6 +3,7 @@ import { beijingDateStamp, fmtClock, fmtDate } from "./time";
import { LoadingTitle } from "./loading-indicator";
import { errorMessage, requestBlob, requestJson } from "./unidesk-error";
import { UniDeskErrorBanner } from "./unidesk-error-banner";
import { useNotification } from "./notification-context";
type AnyRecord = Record<string, any>;
@@ -145,6 +146,7 @@ export function ProjectManagerPage({ microservices, onRaw, apiBaseUrl = "/api" }
const [form, setForm] = useState({ ...EMPTY_FORM });
const [query, setQuery] = useState("");
const [status, setStatus] = useState("all");
const { addNotification } = useNotification();
async function load(nextQuery = query, nextStatus = status): Promise<void> {
if (!service) return;
@@ -176,7 +178,9 @@ export function ProjectManagerPage({ microservices, onRaw, apiBaseUrl = "/api" }
} else {
await requestJson(projectApi(apiBaseUrl, "/api/projects"), { method: "POST", body: JSON.stringify(payload) });
}
setState((prev: any) => ({ ...prev, saving: false, notice: form.id ? "项目已更新" : "项目已创建" }));
const msg = form.id ? "项目已更新" : "项目已创建";
setState((prev: any) => ({ ...prev, saving: false, notice: msg }));
addNotification("success", msg);
await load();
} catch (err) {
setState((prev: any) => ({ ...prev, saving: false, error: errorMessage(err, "保存项目失败") }));
@@ -190,7 +194,9 @@ export function ProjectManagerPage({ microservices, onRaw, apiBaseUrl = "/api" }
try {
await requestJson(projectApi(apiBaseUrl, `/api/projects/${encodeURIComponent(form.id)}`), { method: "DELETE" });
setForm({ ...EMPTY_FORM });
setState((prev: any) => ({ ...prev, saving: false, notice: "项目已删除" }));
const msg = "项目已删除";
setState((prev: any) => ({ ...prev, saving: false, notice: msg }));
addNotification("success", msg);
await load();
} catch (err) {
setState((prev: any) => ({ ...prev, saving: false, error: errorMessage(err, "删除项目失败") }));
@@ -207,7 +213,9 @@ export function ProjectManagerPage({ microservices, onRaw, apiBaseUrl = "/api" }
method: "POST",
body: JSON.stringify({ fileName: file.name, contentBase64, replace: false }),
});
setState((prev: any) => ({ ...prev, importing: false, notice: `Excel 已导入 ${result.imported || 0} 条项目` }));
const msg = `Excel 已导入 ${result.imported || 0} 条项目`;
setState((prev: any) => ({ ...prev, importing: false, notice: msg }));
addNotification("success", msg);
event.target.value = "";
await load();
} catch (err) {
src/components/frontend/src/trace.tsx
+109 -54
View File
@@ -224,7 +224,7 @@ function isEditedFileChangeItem(item: TraceItem): boolean {
if ((status === "item/started" || status === "item/completed") && /file changes status=/u.test(body)) return true;
if (/^Success\. Updated the following files:/mu.test(body)) return true;
if (/^diff --git /mu.test(body)) return true;
return command.length === 0 && /^([AMDRCU?]{1,2})\s+\S+/mu.test(body);
return /^([AMDRCU?]{1,2})\s+\S+/mu.test(body) || (command.length > 0 && parseTraceDiffFiles(body).length > 0);
}
function cleanDiffPath(value: string): string {
@@ -527,35 +527,6 @@ function opencodePartRawSeq(part: any, fallback: any): any {
return part?.id || part?.messageId || fallback;
}
function partFieldValue(part: any, keys: string[]): string {
const normalized = new Set(keys.map((key) => key.toLowerCase()));
const records = [part?.state?.input, part?.input, part?.state?.metadata, part?.metadata, part]
.filter((item) => item && typeof item === "object" && !Array.isArray(item));
for (const record of records) {
for (const [key, value] of Object.entries(record)) {
if (!normalized.has(key.toLowerCase())) continue;
if (typeof value === "string") return value;
if (value !== undefined && value !== null) return shortText(JSON.stringify(value), 900);
}
}
for (const field of Array.isArray(part?.inputFields) ? part.inputFields : []) {
const key = String(field?.key || "").toLowerCase();
if (normalized.has(key)) return String(field?.value || "");
}
return "";
}
function opencodeToolKind(part: any): TraceItemKind {
const tool = String(part?.tool || part?.title || "").toLowerCase();
const command = partFieldValue(part, ["command", "cmd"]);
const normalized = `${tool} ${command}`.toLowerCase();
if (/\b(read|grep|glob|list|ls|find|search|view|cat|sed|rg)\b/u.test(normalized)) return "explored";
if (/\b(edit|write|patch|apply|update|create|delete|apply_patch|git apply|sed -i)\b/u.test(normalized)) return "edited";
if (/\b(rg|grep|find|ls|cat|sed|tail|head|git status|git diff|ps)\b/u.test(command)) return "explored";
if (/\b(apply_patch|git apply|cat >|tee .*<<|sed -i|python3? .*write_text)\b/u.test(command)) return "edited";
return "ran";
}
function opencodePreviewValue(value: any, max = 1200): string {
if (typeof value === "string") return value;
if (value === undefined || value === null) return "";
@@ -566,32 +537,93 @@ function opencodePreviewValue(value: any, max = 1200): string {
}
}
function opencodeToolOutput(state: any, part: any, event: any): string {
if (typeof state?.metadata?.diff === "string" && state.metadata.diff.length > 0) return state.metadata.diff;
if (typeof state?.metadata?.filediff?.patch === "string" && state.metadata.filediff.patch.length > 0) return state.metadata.filediff.patch;
if (typeof state?.output === "string" && state.output.length > 0) return state.output;
if (typeof state?.result === "string" && state.result.length > 0) return state.result;
if (typeof part?.output === "string" && part.output.length > 0) return part.output;
if (typeof event?.output === "string" && event.output.length > 0) return event.output;
if (typeof state?.metadata?.output === "string" && state.metadata.output.length > 0) return state.metadata.output;
return "";
}
function opencodeRecordString(record: any, keys: string[]): string {
if (!record || typeof record !== "object" || Array.isArray(record)) return "";
for (const key of keys) {
const value = record[key];
if (typeof value === "string" && value.length > 0) return value;
if (value !== undefined && value !== null && typeof value !== "object") return String(value);
}
return "";
}
function opencodeRecordNumber(record: any, keys: string[]): number | null {
if (!record || typeof record !== "object" || Array.isArray(record)) return null;
for (const key of keys) {
const value = Number(record[key]);
if (Number.isFinite(value)) return value;
}
return null;
}
function opencodeToolCommand(part: any, state: any): string {
const input = state?.input && typeof state.input === "object" && !Array.isArray(state.input)
? state.input
: part?.input && typeof part.input === "object" && !Array.isArray(part.input)
? part.input
: {};
const inputCommand = opencodeRecordString(input, ["command", "cmd", "script"]);
if (inputCommand.length > 0) return inputCommand;
if (typeof part?.command === "string" && part.command.length > 0) return part.command;
if (typeof state?.command === "string" && state.command.length > 0) return state.command;
const tool = String(part?.tool || part?.title || "tool");
const path = opencodeRecordString(input, ["filePath", "filepath", "path"]) || opencodeRecordString(part, ["filePath", "filepath", "path"]);
const pattern = opencodeRecordString(input, ["pattern", "query"]);
const offset = opencodeRecordNumber(input, ["offset"]);
const limit = opencodeRecordNumber(input, ["limit"]);
const args = [tool];
if (pattern.length > 0) args.push(pattern);
if (path.length > 0) args.push(path);
if (offset !== null) args.push(`offset=${offset}`);
if (limit !== null) args.push(`limit=${limit}`);
return args.length > 1 ? args.join(" ") : tool;
}
function opencodeRawEventToTrace(event: any, fallbackSeq: number): TraceItem | null {
const part = event?.part && typeof event.part === "object" && !Array.isArray(event.part) ? event.part : {};
const type = String(event?.type || event?.event || event?.name || part?.type || "").toLowerCase();
const partType = String(part?.type || "").toLowerCase();
const at = event?.at || event?.timestamp || part?.updatedAt || part?.createdAt;
const seq = Number.isFinite(Number(event?.seq)) ? Number(event.seq) : fallbackSeq;
if (type === "step_start" || type === "step-start" || partType === "step-start") {
return { seq, at, kind: "system", title: "OpenCode step started", status: "opencode/step-start", bodyPreview: `session=${event?.sessionID || part?.sessionID || "unknown"}`, rawSeqs: [part?.id || event?.sessionID || seq] };
}
if (type === "step_finish" || type === "step-finish" || partType === "step-finish") {
return { seq, at, kind: "system", title: "OpenCode step finished", status: "opencode/step-finish", bodyPreview: `reason=${part?.reason || event?.reason || "finished"}`, rawSeqs: [part?.id || event?.sessionID || seq] };
}
if (type === "step_start" || type === "step-start" || partType === "step-start") return null;
if (type === "step_finish" || type === "step-finish" || partType === "step-finish") return null;
if (partType === "tool" || /tool|bash|command/iu.test(`${type} ${partType}`)) {
const state = part?.state && typeof part.state === "object" && !Array.isArray(part.state) ? part.state : {};
const command = partFieldValue(part, ["command", "cmd"]) || partFieldValue(part, ["filePath", "filepath", "path"]) || String(part?.tool || part?.title || "tool");
const output = opencodePreviewValue(state?.output ?? state?.result ?? part?.output ?? event?.output ?? state?.metadata?.output, 3000);
const command = opencodeToolCommand(part, state);
const output = opencodeToolOutput(state, part, event);
const kind = opencodeToolKindFromCommand(command, String(part?.tool || part?.title || ""));
const observation = kind === "edited" ? {
status: String(state?.status || part?.status || event?.status || ""),
summary: shortText(output || command, 72),
files: parseTraceDiffFiles(output),
stages: [],
lines: traceDiffLines(output),
addedLines: 0,
removedLines: 0,
rawText: output,
} : undefined;
return {
seq,
at: opencodePartCompletedAt(part, at),
kind: opencodeToolKind(part),
kind,
title: String(state?.title || part?.title || state?.metadata?.description || part?.tool || "OpenCode tool"),
status: String(state?.status || part?.status || event?.status || ""),
commandPreview: command,
bodyPreview: output || opencodePreviewValue(event, 3000),
bodyPreview: output,
durationMs: opencodePartDurationMs(part),
rawSeqs: [part?.id || part?.callID || event?.sessionID || seq],
editObservation: observation,
};
}
const text = opencodePreviewValue(part?.text ?? part?.content ?? part?.delta ?? event?.text ?? event?.content ?? event?.delta, 3000).trim();
@@ -610,25 +642,38 @@ function opencodeRawEventToTrace(event: any, fallbackSeq: number): TraceItem | n
return null;
}
function opencodeToolKindFromCommand(command: string, tool: string): TraceItemKind {
const normalized = `${tool} ${command}`.toLowerCase();
if (/\b(read|grep|glob|list|ls|find|search|view|cat|sed|rg|head|tail|wc|file)\b/iu.test(normalized)) return "explored";
if (/\b(edit|write|patch|apply|update|create|delete|apply_patch|git apply|cat >|tee .*<<|sed -i|python3? .*write_text|mkdir|rm |touch )\b/iu.test(normalized)) return "edited";
return "ran";
}
export function opencodeStepsToTrace(steps: any[]): TraceItem[] {
const rows: TraceItem[] = [];
let seq = 1;
for (const step of Array.isArray(steps) ? steps : []) {
if (step?.kind && step?.title) {
const status = String(step?.status || "");
if (status === "opencode/step-start" || status === "opencode/step-finish") continue;
rows.push({ ...step, seq: Number.isFinite(Number(step?.seq)) ? Number(step.seq) : seq++ });
continue;
}
if (step?.part || step?.sessionID || String(step?.type || "").startsWith("step_") || String(step?.type || "").includes("tool")) {
const item = opencodeRawEventToTrace(step, seq);
if (item !== null) {
rows.push(item);
seq = Math.max(seq + 1, Number(item.seq) + 1);
}
continue;
}
const at = step?.createdAt || step?.updatedAt || step?.completedAt;
const role = String(step?.role || "assistant").toLowerCase();
const parts = Array.isArray(step?.parts) ? step.parts : [];
if (parts.length === 0) {
if (step?.part && (step?.sessionID || String(step?.type || "").startsWith("step_") || String(step?.type || "").includes("tool"))) {
const item = opencodeRawEventToTrace(step, seq);
if (item !== null) {
rows.push(item);
seq = Math.max(seq + 1, Number(item.seq) + 1);
}
} else if (step?.textPreview) {
rows.push({ seq: seq++, at, kind: "message", title: `${role || "assistant"} message`, status: role, bodyPreview: String(step.textPreview), rawSeqs: [step?.messageId || seq] });
}
continue;
}
for (const part of parts) {
const type = String(part?.type || "").toLowerCase();
if (type === "step-start" || type === "step-finish") continue;
@@ -648,27 +693,37 @@ export function opencodeStepsToTrace(steps: any[]): TraceItem[] {
continue;
}
if (type === "tool") {
const command = partFieldValue(part, ["command", "cmd"]) || partFieldValue(part, ["filePath", "filepath", "path"]) || String(part?.title || part?.tool || "tool");
const output = String(part?.outputPreview && part.outputPreview !== "--" ? part.outputPreview : part?.textPreview || "");
const state = part?.state && typeof part.state === "object" && !Array.isArray(part.state) ? part.state : {};
const command = opencodeToolCommand(part, state);
const output = opencodeToolOutput(state, part, {});
const kind = opencodeToolKindFromCommand(command, String(part?.tool || part?.title || ""));
const observation = kind === "edited" ? {
status: String(state?.status || part?.status || ""),
summary: shortText(output || command, 72),
files: parseTraceDiffFiles(output),
stages: [],
lines: traceDiffLines(output),
addedLines: 0,
removedLines: 0,
rawText: output,
} : undefined;
rows.push({
seq: seq++,
at: opencodePartCompletedAt(part, at),
kind: opencodeToolKind(part),
kind,
title: String(part?.title || part?.tool || "tool"),
status: String(part?.status || ""),
commandPreview: command,
bodyPreview: output,
durationMs: opencodePartDurationMs(part),
rawSeqs: [opencodePartRawSeq(part, seq)],
editObservation: observation,
});
continue;
}
const text = String(part?.textPreview || part?.title || type || "").trim();
if (text) rows.push({ seq: seq++, at: opencodePartCompletedAt(part, at), kind: "system", title: type || "part", bodyPreview: text, status: String(part?.status || ""), durationMs: opencodePartDurationMs(part), rawSeqs: [opencodePartRawSeq(part, seq)] });
}
if (parts.length === 0 && step?.textPreview) {
rows.push({ seq: seq++, at, kind: "message", title: `${role || "assistant"} message`, status: role, bodyPreview: String(step.textPreview), rawSeqs: [step?.messageId || seq] });
}
}
return rows;
}
src/components/microservices/baidu-netdisk/src/index.ts
+13 -7
View File
@@ -99,9 +99,9 @@ const serviceStartedAt = new Date().toISOString();
const recentLogs: JsonRecord[] = [];
function normalizedAppRoot(value: string): string {
const root = pathPosix.normalize(`/${String(value || "").replace(/^\/+/, "")}`);
if (!root.startsWith("/apps/")) return "/apps/UniDeskBaiduNetdisk";
return root.replace(/\/+$/u, "") || "/apps/UniDeskBaiduNetdisk";
const raw = String(value || "/").trim() || "/";
const normalized = pathPosix.normalize(raw.startsWith("/") ? raw : `/${raw}`);
return normalized === "/" ? "/" : normalized.replace(/\/+$/u, "") || "/";
}
function configFromEnv(): RuntimeConfig {
@@ -116,7 +116,7 @@ function configFromEnv(): RuntimeConfig {
clientId: process.env.BAIDU_NETDISK_CLIENT_ID || process.env.BAIDU_NETDISK_APP_KEY || "",
clientSecret: process.env.BAIDU_NETDISK_CLIENT_SECRET || process.env.BAIDU_NETDISK_SECRET_KEY || "",
tokenKey: process.env.BAIDU_NETDISK_TOKEN_KEY || "",
appRoot: normalizedAppRoot(process.env.BAIDU_NETDISK_APP_ROOT || "/apps/UniDeskBaiduNetdisk"),
appRoot: normalizedAppRoot(process.env.BAIDU_NETDISK_APP_ROOT || "/"),
stagingDir: resolve(process.env.BAIDU_NETDISK_STAGING_DIR || "/data/staging"),
partSizeBytes: Number.isFinite(partSizeBytes) && partSizeBytes > 0 ? partSizeBytes : 4 * 1024 * 1024,
userAgent: process.env.BAIDU_NETDISK_USER_AGENT || "pan.baidu.com",
@@ -448,6 +448,11 @@ async function createRemoteFolder(accessToken: string, path: string): Promise<Js
}
async function ensureAppRoot(accessToken: string, force = false): Promise<void> {
if (config.appRoot === "/") {
appRootEnsuredAt = Date.now();
if (force) log("remote_root_ready", { path: config.appRoot });
return;
}
if (!force && appRootEnsuredAt > 0 && Date.now() - appRootEnsuredAt < 10 * 60 * 1000) return;
if (appRootEnsurePromise) return appRootEnsurePromise;
appRootEnsurePromise = (async () => {
@@ -465,10 +470,11 @@ async function ensureAppRoot(accessToken: string, force = false): Promise<void>
function remotePathInsideRoot(input: string | undefined, fallback = config.appRoot): string {
const raw = String(input || fallback).trim() || fallback;
if (raw.includes("\0")) throw new HttpError(400, "remote path must not contain null bytes");
const normalized = pathPosix.normalize(raw.startsWith("/") ? raw : pathPosix.join(config.appRoot, raw));
const clean = normalized.replace(/\/+$/u, "") || config.appRoot;
if (clean !== config.appRoot && !clean.startsWith(`${config.appRoot}/`)) {
throw new HttpError(400, "remote path must stay inside app root", { appRoot: config.appRoot, path: clean });
const clean = normalized === "/" ? "/" : normalized.replace(/\/+$/u, "") || config.appRoot;
if (config.appRoot !== "/" && clean !== config.appRoot && !clean.startsWith(`${config.appRoot}/`)) {
throw new HttpError(400, "remote path must stay inside configured root", { rootPath: config.appRoot, path: clean });
}
return clean;
}
src/components/microservices/code-queue/src/code-agent/codex.ts
+392
View File
@@ -0,0 +1,392 @@
// 重构前 index.ts 只读参考：commit 6a04144d3f5103014f75b637d7e6bc2f45bf007f，blob 56e590c1a6b5ca7ad128bf2c992f60e46c355a58；可用 `git show 6a04144d3f5103014f75b637d7e6bc2f45bf007f:src/components/microservices/code-queue/src/index.ts` 查看。
import { spawn, type ChildProcessWithoutNullStreams } from "node:child_process";
import * as readline from "node:readline";
import type { AppServerExit, CodexEventSummary, CodexRunResult, JsonValue, QueueTask, RuntimeConfig, SessionCommandOutput, TerminalStatus } from "../types";
import type { ActiveRun, CodeAgentClient } from "./common";
import { extractRecord, extractString, terminalStatus, textInput } from "./common";
export interface CodexPortContext {
config: Pick<RuntimeConfig, "approvalPolicy" | "codexHome" | "defaultWorkdir" | "sandbox" | "turnNoActivityTimeoutMs">;
activeRuns: Map<string, ActiveRun>;
appendOutput: (task: QueueTask, channel: "system" | "assistant" | "reasoning" | "command" | "diff" | "tool" | "error", text: string, method?: string, itemId?: string, append?: boolean) => unknown;
addEvent: (task: QueueTask, event: CodexEventSummary) => void;
ensureTaskExecutionContainer: (task: QueueTask) => Promise<void>;
formatCommandOutput: (output: SessionCommandOutput | null | undefined) => string;
logger: (level: "debug" | "info" | "warn" | "error", message: string, data?: JsonValue) => void;
persistTaskState: (task: QueueTask) => void;
providerIsMain: (providerId: string) => boolean;
queueIdOf: (task: QueueTask) => string;
recordNumberField: (record: Record<string, unknown> | null, keys: string[]) => number | null;
recordStringField: (record: Record<string, unknown> | null, keys: string[]) => string;
remoteAppServerCommand: (task: QueueTask) => string;
resolveReasoningEffort: (model: string, explicit?: string | null) => string | null;
safePreview: (value: string, max?: number) => string;
nowIso: () => string;
}
let context: CodexPortContext | null = null;
export function configureCodexPort(runtimeContext: CodexPortContext): void {
context = runtimeContext;
}
function ctx(): CodexPortContext {
if (context === null) throw new Error("codex port is not configured");
return context;
}
class AppServerClient {
private child: ChildProcessWithoutNullStreams;
private nextId = 1;
private pending = new Map<number, { resolve: (value: unknown) => void; reject: (error: Error) => void }>();
private stderrChunks: Buffer[] = [];
private closed = false;
private exitInfo: AppServerExit | null = null;
private closeResolve!: (value: AppServerExit) => void;
readonly closedPromise: Promise<AppServerExit>;
constructor(private readonly task: QueueTask, private readonly onNotification: (message: Record<string, unknown>) => void) {
this.closedPromise = new Promise((resolveClosed) => { this.closeResolve = resolveClosed; });
this.child = ctx().providerIsMain(task.providerId)
? spawn("codex", ["app-server", "--listen", "stdio://"], {
cwd: task.cwd,
env: { ...process.env, CODEX_HOME: ctx().config.codexHome, CODEX_INTERNAL_ORIGINATOR_OVERRIDE: "unidesk_code_queue" },
stdio: "pipe",
})
: spawn("bun", ["scripts/cli.ts", "ssh", task.providerId, ctx().remoteAppServerCommand(task)], {
cwd: ctx().config.defaultWorkdir,
env: process.env,
stdio: "pipe",
});
this.child.stderr.on("data", (chunk: Buffer) => {
this.stderrChunks.push(chunk);
while (Buffer.concat(this.stderrChunks).length > 96_000) this.stderrChunks.shift();
});
const rl = readline.createInterface({ input: this.child.stdout, crlfDelay: Infinity });
void this.readLines(rl);
this.child.on("close", (code, signal) => this.handleClose(code, signal));
this.child.on("error", (error) => this.handleClose(127, error.message));
}
async initialize(): Promise<void> {
await this.request("initialize", {
clientInfo: { name: "unidesk_code_queue", title: "UniDesk Code Queue", version: "0.1.0" },
capabilities: { experimentalApi: true },
});
this.notify("initialized", {});
}
async startOrResumeThread(): Promise<string> {
if (this.task.codexThreadId !== null) {
ctx().appendOutput(this.task, "system", `thread resume requested ${this.task.codexThreadId}\n`, "thread/resume");
const response = await this.request("thread/resume", {
threadId: this.task.codexThreadId,
model: this.task.model,
cwd: this.task.cwd,
approvalPolicy: ctx().config.approvalPolicy,
sandbox: ctx().config.sandbox,
});
const threadId = extractString(extractRecord(response)?.thread, "id");
if (threadId === null) throw new Error("thread/resume response did not include thread.id");
ctx().appendOutput(this.task, "system", `thread resumed ${threadId}\n`, "thread/resume");
return threadId;
}
const response = await this.request("thread/start", {
model: this.task.model,
cwd: this.task.cwd,
approvalPolicy: ctx().config.approvalPolicy,
sandbox: ctx().config.sandbox,
serviceName: "unidesk-code-queue",
});
const threadId = extractString(extractRecord(response)?.thread, "id");
if (threadId === null) throw new Error("thread/start response did not include thread.id");
return threadId;
}
async startTurn(threadId: string, prompt: string): Promise<string> {
const params: Record<string, JsonValue> = {
threadId,
input: textInput(prompt),
cwd: this.task.cwd,
approvalPolicy: ctx().config.approvalPolicy,
model: this.task.model,
};
const effort = ctx().resolveReasoningEffort(this.task.model, this.task.reasoningEffort);
if (effort !== null) params.effort = effort;
const response = await this.request("turn/start", params);
const turnId = extractString(extractRecord(response)?.turn, "id");
if (turnId === null) throw new Error("turn/start response did not include turn.id");
return turnId;
}
async steer(threadId: string, turnId: string, prompt: string): Promise<void> {
await this.request("turn/steer", { threadId, expectedTurnId: turnId, input: textInput(prompt) });
}
async interrupt(threadId: string, turnId: string): Promise<void> {
await this.request("turn/interrupt", { threadId, turnId });
}
stop(): void {
if (this.closed) return;
this.child.kill("SIGTERM");
setTimeout(() => {
if (!this.closed) this.child.kill("SIGKILL");
}, 1500).unref?.();
}
private request(method: string, params: unknown): Promise<unknown> {
if (this.closed) return Promise.reject(new Error("app-server is already closed"));
const id = this.nextId++;
const message = { method, id, params };
return new Promise((resolve, reject) => {
this.pending.set(id, { resolve, reject });
this.write(message);
});
}
private notify(method: string, params: unknown): void {
this.write({ method, params });
}
private write(message: unknown): void {
this.child.stdin.write(`${JSON.stringify(message)}\n`);
}
private async readLines(rl: readline.Interface): Promise<void> {
try {
for await (const line of rl) {
const trimmed = String(line).trim();
if (trimmed.length === 0) continue;
const message = JSON.parse(trimmed) as Record<string, unknown>;
this.handleMessage(message);
}
} catch (error) {
ctx().appendOutput(this.task, "error", `app-server stream error: ${error instanceof Error ? error.message : String(error)}\n`, "app-server");
}
}
private handleMessage(message: Record<string, unknown>): void {
const id = typeof message.id === "number" ? message.id : null;
const method = typeof message.method === "string" ? message.method : null;
if (id !== null && method === null) {
const pending = this.pending.get(id);
if (pending === undefined) return;
this.pending.delete(id);
if ("error" in message) {
pending.reject(new Error(JSON.stringify(message.error)));
} else {
pending.resolve(message.result);
}
return;
}
if (id !== null && method !== null) {
this.handleServerRequest(id, method);
return;
}
if (method !== null) this.onNotification(message);
}
private handleServerRequest(id: number, method: string): void {
if (method === "item/commandExecution/requestApproval") {
this.write({ id, result: { decision: "decline" } });
return;
}
if (method === "item/fileChange/requestApproval") {
this.write({ id, result: { decision: "decline" } });
return;
}
this.write({ id, error: { code: -32601, message: `Unsupported client-side request: ${method}` } });
}
private handleClose(code: number | null, signal: string | null): void {
if (this.closed) return;
this.closed = true;
this.exitInfo = { code, signal, stderrTail: Buffer.concat(this.stderrChunks).toString("utf8").slice(-8000) };
for (const pending of this.pending.values()) pending.reject(new Error(`app-server closed with code=${code} signal=${signal}`));
this.pending.clear();
this.closeResolve(this.exitInfo);
}
}
function eventSummary(message: Record<string, unknown>): CodexEventSummary {
const params = extractRecord(message.params);
const item = extractRecord(params?.item);
const turn = extractRecord(params?.turn);
const error = extractRecord(turn?.error) ?? extractRecord(params?.error);
return {
at: ctx().nowIso(),
method: typeof message.method === "string" ? message.method : "unknown",
itemType: typeof item?.type === "string" ? item.type : undefined,
status: typeof item?.status === "string" ? item.status : typeof turn?.status === "string" ? turn.status : undefined,
message: typeof error?.message === "string" ? ctx().safePreview(error.message, 600) : undefined,
textPreview: typeof item?.text === "string" ? ctx().safePreview(item.text, 800) : undefined,
};
}
function commandCompletionStreams(item: Record<string, unknown> | null): { stdout: string; stderr: string; output: string; exitCode: number | null } {
if (item === null) return { stdout: "", stderr: "", output: "", exitCode: null };
const result = extractRecord(item.result);
const stdout = ctx().recordStringField(item, ["stdout", "stdoutText"]) || ctx().recordStringField(result, ["stdout", "stdoutText"]);
const stderr = ctx().recordStringField(item, ["stderr", "stderrText"]) || ctx().recordStringField(result, ["stderr", "stderrText"]);
const output = ctx().recordStringField(item, ["output", "outputText", "text"]) || ctx().recordStringField(result, ["output", "outputText", "text"]);
const exitCode = ctx().recordNumberField(item, ["exitCode", "code"]) ?? ctx().recordNumberField(result, ["exitCode", "code"]);
return { stdout: stdout || (stderr.length > 0 ? "" : output), stderr, output: output || [stdout, stderr].filter(Boolean).join("\n"), exitCode };
}
function hasRecentCommandOutputDelta(task: QueueTask, itemId: string | undefined): boolean {
if (itemId === undefined) return false;
for (let index = task.output.length - 1; index >= 0 && index >= task.output.length - 80; index -= 1) {
const output = task.output[index];
if (output?.itemId !== itemId) continue;
if (output.method === "item/commandExecution/outputDelta") return true;
if (output.method === "item/started") return false;
}
return false;
}
function handleNotification(task: QueueTask, message: Record<string, unknown>, terminal: (status: TerminalStatus, error: string | null) => void): void {
const method = typeof message.method === "string" ? message.method : "unknown";
const params = extractRecord(message.params);
ctx().addEvent(task, eventSummary(message));
if (method === "thread/started") {
const threadId = extractString(extractRecord(params?.thread), "id");
if (threadId !== null) task.codexThreadId = threadId;
ctx().appendOutput(task, "system", `thread started ${threadId ?? "unknown"}\n`, method);
return;
}
if (method === "turn/started") {
const turnId = extractString(extractRecord(params?.turn), "id");
task.activeTurnId = turnId;
ctx().appendOutput(task, "system", `turn started ${turnId ?? "unknown"}\n`, method);
return;
}
if (method === "item/agentMessage/delta") {
ctx().appendOutput(task, "assistant", String(params?.delta ?? ""), method, extractString(params, "itemId") ?? undefined, true);
return;
}
if (method === "item/reasoning/summaryTextDelta" || method === "item/reasoning/textDelta") {
ctx().appendOutput(task, "reasoning", String(params?.delta ?? ""), method, extractString(params, "itemId") ?? undefined, true);
return;
}
if (method === "item/commandExecution/outputDelta") {
ctx().appendOutput(task, "command", String(params?.delta ?? ""), method, extractString(params, "itemId") ?? undefined, true);
return;
}
if (method === "item/fileChange/outputDelta") {
ctx().appendOutput(task, "diff", String(params?.delta ?? ""), method, extractString(params, "itemId") ?? undefined, true);
return;
}
if (method === "item/started" || method === "item/completed") {
const item = extractRecord(params?.item);
const type = String(item?.type ?? "item");
if (type === "agentMessage" && typeof item?.text === "string") task.finalResponse = item.text;
if (type === "commandExecution") {
const itemId = extractString(item, "id") ?? undefined;
if (method === "item/completed") {
const streams = commandCompletionStreams(item);
const hasDelta = hasRecentCommandOutputDelta(task, itemId);
const completedOutput = hasDelta && streams.stderr.trim().length > 0
? `\n[stderr]\n${streams.stderr.trimEnd()}`
: hasDelta
? ""
: ctx().formatCommandOutput({ callId: itemId ?? "", at: ctx().nowIso(), stdout: streams.stdout, stderr: streams.stderr, output: streams.output, exitCode: streams.exitCode });
if (completedOutput.trim().length > 0) ctx().appendOutput(task, "command", `${completedOutput.trimEnd()}\n`, "item/commandExecution/outputDelta", itemId, true);
}
ctx().appendOutput(task, "command", `${method}: ${String(item?.command ?? "command")} status=${String(item?.status ?? "unknown")}\n`, method, itemId);
}
if (type === "fileChange") ctx().appendOutput(task, "diff", `${method}: file changes status=${String(item?.status ?? "unknown")}\n`, method, extractString(item, "id") ?? undefined);
if (type === "mcpToolCall" || type === "webSearch" || type === "dynamicToolCall") ctx().appendOutput(task, "tool", `${method}: ${type}\n`, method, extractString(item, "id") ?? undefined);
return;
}
if (method === "error") {
const error = extractRecord(params?.error);
ctx().appendOutput(task, "error", `${String(error?.message ?? "Codex error")}\n`, method);
return;
}
if (method === "turn/completed") {
const turn = extractRecord(params?.turn);
const status = terminalStatus(String(turn?.status ?? "failed"));
const error = extractRecord(turn?.error);
task.activeTurnId = null;
ctx().appendOutput(task, status === "completed" ? "system" : "error", `turn completed status=${status ?? "unknown"}\n`, method);
terminal(status, typeof error?.message === "string" ? error.message : null);
}
}
export async function runCodexTurn(task: QueueTask, prompt: string): Promise<CodexRunResult> {
const queueId = ctx().queueIdOf(task);
const events: CodexEventSummary[] = [];
let terminalSeen = false;
let lastAppActivityAt = Date.now();
let terminalResult: { status: TerminalStatus; error: string | null } = { status: null, error: null };
let terminalResolve!: () => void;
const terminalPromise = new Promise<void>((resolveTerminal) => { terminalResolve = resolveTerminal; });
await ctx().ensureTaskExecutionContainer(task);
const app = new AppServerClient(task, (message) => {
const method = typeof message.method === "string" ? message.method : "unknown";
if (method !== "thread/started" && method !== "turn/started") lastAppActivityAt = Date.now();
const before = task.events.length;
handleNotification(task, message, (status, error) => {
terminalSeen = true;
terminalResult = { status, error };
terminalResolve();
});
events.push(...task.events.slice(before));
});
try {
await app.initialize();
const threadId = await app.startOrResumeThread();
task.codexThreadId = threadId;
ctx().activeRuns.set(queueId, { taskId: task.id, queueId, app, port: "codex", threadId, turnId: null });
const turnId = await app.startTurn(threadId, prompt);
task.activeTurnId = turnId;
const run = ctx().activeRuns.get(queueId);
if (run?.app === app) run.turnId = turnId;
ctx().persistTaskState(task);
const activityWatchdog = setInterval(() => {
if (terminalSeen) return;
const idleMs = Date.now() - lastAppActivityAt;
if (idleMs < ctx().config.turnNoActivityTimeoutMs) return;
const message = `No Codex app activity for ${Math.round(idleMs / 1000)}s; stopping app-server so the existing thread can retry.`;
ctx().appendOutput(task, "error", `${message}\n`, "turn/no-activity-watchdog");
ctx().logger("warn", "turn_no_activity_watchdog", { taskId: task.id, turnId, idleMs, timeoutMs: ctx().config.turnNoActivityTimeoutMs });
app.stop();
}, 15_000);
const race = await Promise.race([terminalPromise.then(() => "terminal" as const), app.closedPromise.then(() => "closed" as const)]);
clearInterval(activityWatchdog);
const closedBeforeTerminal = race === "closed" && !terminalSeen;
if (terminalSeen) app.stop();
const exit = await app.closedPromise;
return {
threadId,
turnId,
finalResponse: task.finalResponse,
terminalStatus: terminalResult.status,
terminalError: terminalResult.error,
transportClosedBeforeTerminal: closedBeforeTerminal,
appServerExit: exit,
events,
};
} catch (error) {
const message = error instanceof Error ? error.message : String(error);
ctx().appendOutput(task, "error", `${message}\n`, "app-server");
app.stop();
const exit = await app.closedPromise;
return {
threadId: task.codexThreadId,
turnId: task.activeTurnId,
finalResponse: task.finalResponse,
terminalStatus: "failed",
terminalError: message,
transportClosedBeforeTerminal: !terminalSeen,
appServerExit: exit,
events,
};
} finally {
if (ctx().activeRuns.get(queueId)?.app === app) ctx().activeRuns.delete(queueId);
app.stop();
}
}
src/components/microservices/code-queue/src/code-agent/common.ts
+84
View File
@@ -0,0 +1,84 @@
// 重构前 index.ts 只读参考：commit 6a04144d3f5103014f75b637d7e6bc2f45bf007f，blob 56e590c1a6b5ca7ad128bf2c992f60e46c355a58；可用 `git show 6a04144d3f5103014f75b637d7e6bc2f45bf007f:src/components/microservices/code-queue/src/index.ts` 查看。
import type { JsonValue } from "../types";
export type CodeAgentPortKind = "codex" | "opencode";
export interface CodeAgentClient {
stop(): void;
steer?(threadId: string, turnId: string, prompt: string): Promise<void>;
interrupt?(threadId: string, turnId: string): Promise<void>;
}
export interface ActiveRun {
taskId: string;
queueId: string;
app: CodeAgentClient;
port: CodeAgentPortKind;
threadId: string | null;
turnId: string | null;
}
export interface ActiveRunSlotWaiter {
id: number;
taskId: string;
queueId: string;
enqueuedAt: string;
}
export const minimaxM27Model = "minimax-m2.7";
export const defaultCodeModels = ["gpt-5.5", "gpt-5.4-mini", "gpt-5.4", minimaxM27Model];
export const opencodeNpmPackage = "opencode-ai@1.14.48";
export function normalizeCodeModel(value: string): string {
const raw = String(value || "").trim();
if (raw.length === 0) return raw;
const lower = raw.toLowerCase();
const leaf = lower.includes("/") ? lower.split("/").at(-1) ?? lower : lower;
if (leaf === "minimax-m2.7" || leaf === "m2.7") return minimaxM27Model;
return raw;
}
export function codeAgentPortForModel(model: string): CodeAgentPortKind {
return normalizeCodeModel(model) === minimaxM27Model ? "opencode" : "codex";
}
export function opencodeModels(models: string[]): string[] {
return models.filter((model) => codeAgentPortForModel(model) === "opencode");
}
export function codeModelPorts(models: string[]): Record<string, CodeAgentPortKind> {
return Object.fromEntries(models.map((model) => [model, codeAgentPortForModel(model)]));
}
export function codeAgentPortInfo(kind: CodeAgentPortKind): Record<string, JsonValue> {
return {
kind,
protocol: kind === "codex" ? "codex-app-server-jsonrpc-stdio" : "opencode-run-json-events",
sessionResume: kind === "codex" ? "thread/resume" : "opencode --session with persisted XDG storage and stale-session recovery",
tracePort: kind === "codex" ? "codex-transcript" : "opencode-json-event",
};
}
export function textInput(text: string): JsonValue[] {
return [{ type: "text", text, text_elements: [] }];
}
export function extractRecord(value: unknown): Record<string, unknown> | null {
return typeof value === "object" && value !== null && !Array.isArray(value) ? value as Record<string, unknown> : null;
}
export function extractString(value: unknown, key: string): string | null {
const record = extractRecord(value);
const field = record?.[key];
return typeof field === "string" ? field : null;
}
export function terminalStatus(value: string): import("../types").TerminalStatus {
if (value === "completed" || value === "interrupted" || value === "failed") return value;
return null;
}
export function stripAnsi(text: string): string {
return text.replace(/\u001b\[[0-9;]*m/gu, "");
}
src/components/microservices/code-queue/src/code-agent/opencode.ts
+400
View File
@@ -0,0 +1,400 @@
// 重构前 index.ts 只读参考：commit 6a04144d3f5103014f75b637d7e6bc2f45bf007f，blob 56e590c1a6b5ca7ad128bf2c992f60e46c355a58；可用 `git show 6a04144d3f5103014f75b637d7e6bc2f45bf007f:src/components/microservices/code-queue/src/index.ts` 查看。
import { spawn, type ChildProcessWithoutNullStreams } from "node:child_process";
import * as readline from "node:readline";
import type { AppServerExit, CodexEventSummary, CodexRunResult, JsonValue, QueueTask, RuntimeConfig, TerminalStatus } from "../types";
import type { ActiveRun, CodeAgentClient } from "./common";
import { extractRecord, minimaxM27Model, normalizeCodeModel, stripAnsi } from "./common";
export interface OpenCodePortContext {
config: Pick<RuntimeConfig, "defaultWorkdir" | "minimaxApiBase" | "minimaxApiKey" | "minimaxModel" | "turnNoActivityTimeoutMs">;
activeRuns: Map<string, ActiveRun>;
addEvent: (task: QueueTask, event: CodexEventSummary) => void;
appendOutput: (task: QueueTask, channel: "system" | "assistant" | "reasoning" | "command" | "diff" | "tool" | "error", text: string, method?: string, itemId?: string, append?: boolean) => unknown;
buildDevContainerPlan: (providerId: string, body: Record<string, unknown>) => { containerName: string; remoteOpencodeXdgDir: string };
compactRetryTaskContext: (task: QueueTask) => string;
ensureTaskExecutionContainer: (task: QueueTask) => Promise<void>;
judgeReasonForPrompt: (reason: string) => string;
logger: (level: "debug" | "info" | "warn" | "error", message: string, data?: JsonValue) => void;
nowIso: () => string;
openCodeFreshRecoveryPrompt: (task: QueueTask, prompt: string, reason: string) => string;
openCodeXdgEnv: (root?: string) => Record<string, string>;
persistTaskState: (task: QueueTask) => void;
providerIsMain: (providerId: string) => boolean;
queueIdOf: (task: QueueTask) => string;
recordStringField: (record: Record<string, unknown> | null, keys: string[], max?: number) => string;
remoteHostWorkdirForTask: (task: QueueTask) => string;
safePreview: (value: string, max?: number) => string;
shellQuote: (value: string) => string;
shutdownRequested: () => boolean;
}
let context: OpenCodePortContext | null = null;
export function configureOpenCodePort(runtimeContext: OpenCodePortContext): void {
context = runtimeContext;
}
function ctx(): OpenCodePortContext {
if (context === null) throw new Error("opencode port is not configured");
return context;
}
interface OpenCodeTextParts {
reasoning: string;
assistant: string;
}
function stripThinkBlocks(text: string): string {
return String(text || "").replace(/<(?:think|thinking)\b[^>]*>[\s\S]*?<\/(?:think|thinking)>/giu, "").trim();
}
function splitOpenCodeAssistantText(text: string): OpenCodeTextParts {
const reasoning: string[] = [];
const withoutClosedThink = String(text || "").replace(/<(?:think|thinking)\b[^>]*>([\s\S]*?)<\/(?:think|thinking)>/giu, (_match, body) => {
const item = String(body || "").trim();
if (item.length > 0) reasoning.push(item);
return "";
});
const closeThinkMatches = Array.from(withoutClosedThink.matchAll(/<\/(?:think|thinking)>/giu));
const lastClose = closeThinkMatches.at(-1);
const assistant = lastClose?.index === undefined
? withoutClosedThink.trim()
: withoutClosedThink.slice(lastClose.index + lastClose[0].length).trim();
return { reasoning: reasoning.join("\n\n").trim(), assistant };
}
function openCodeModelId(model: string): string {
if (normalizeCodeModel(model) !== minimaxM27Model) throw new Error(`OpenCode port does not support model ${model}`);
const providerModel = ctx().config.minimaxModel.trim() || "MiniMax-M2.7";
return `minimax/${providerModel}`;
}
function openCodeConfigContent(): string {
const providerModel = ctx().config.minimaxModel.trim() || "MiniMax-M2.7";
return JSON.stringify({
$schema: "https://opencode.ai/config.json",
provider: {
minimax: {
npm: "@ai-sdk/openai-compatible",
name: "MiniMax",
options: {
baseURL: ctx().config.minimaxApiBase,
apiKey: "{env:MINIMAX_API_KEY}",
},
models: {
[providerModel]: {
name: minimaxM27Model,
limit: { context: 200000, output: 16384 },
},
},
},
},
});
}
function openCodeEnv(): NodeJS.ProcessEnv {
const xdgEnv = ctx().openCodeXdgEnv();
return {
...process.env,
...xdgEnv,
MINIMAX_API_KEY: ctx().config.minimaxApiKey,
MINIMAX_API_BASE: ctx().config.minimaxApiBase,
MINIMAX_MODEL: ctx().config.minimaxModel,
OPENCODE_CONFIG_CONTENT: openCodeConfigContent(),
};
}
function shellJoin(args: string[]): string {
return args.map(ctx().shellQuote).join(" ");
}
function openCodeRunArgs(task: QueueTask, prompt: string): string[] {
const args = ["run", "--format", "json", "--model", openCodeModelId(task.model), "--dir", task.cwd, "--dangerously-skip-permissions"];
if (task.codexThreadId !== null && task.codexThreadId.trim().length > 0) args.push("--session", task.codexThreadId);
args.push(prompt);
return args;
}
function remoteOpenCodeRunCommand(task: QueueTask, prompt: string): string {
const plan = ctx().buildDevContainerPlan(task.providerId, { workdir: ctx().remoteHostWorkdirForTask(task) });
const envExports = [
...Object.entries(ctx().openCodeXdgEnv(plan.remoteOpencodeXdgDir)).map(([key, value]) => `export ${key}=${ctx().shellQuote(value)}`),
`export MINIMAX_API_BASE=${ctx().shellQuote(ctx().config.minimaxApiBase)}`,
`export MINIMAX_MODEL=${ctx().shellQuote(ctx().config.minimaxModel)}`,
`export OPENCODE_CONFIG_CONTENT=${ctx().shellQuote(openCodeConfigContent())}`,
].join("; ");
const inner = [
"set -euo pipefail",
`mkdir -p ${ctx().shellQuote(task.cwd)}`,
`cd ${ctx().shellQuote(task.cwd)}`,
envExports,
`exec ${shellJoin(openCodeRunArgs(task, prompt))}`,
].join("; ");
return `docker exec -i ${ctx().shellQuote(plan.containerName)} bash -lc ${ctx().shellQuote(inner)}`;
}
function openCodeSessionIdFromRecord(record: Record<string, unknown>, part: Record<string, unknown> | null): string | null {
const top = ctx().recordStringField(record, ["sessionID", "sessionId", "session_id"]);
if (top.length > 0) return top;
const nested = ctx().recordStringField(part, ["sessionID", "sessionId", "session_id"]);
return nested.length > 0 ? nested : null;
}
function openCodeEventSummary(record: Record<string, unknown>): CodexEventSummary {
const part = extractRecord(record.part);
const type = ctx().recordStringField(record, ["type", "event", "name"]) || ctx().recordStringField(part, ["type"]) || "unknown";
const text = ctx().recordStringField(part, ["text", "content", "delta", "message"]) || ctx().recordStringField(record, ["text", "content", "delta", "message"]);
const error = ctx().recordStringField(part, ["error", "message"]) || ctx().recordStringField(record, ["error", "message"]);
return {
at: ctx().nowIso(),
method: `opencode/${type}`,
itemType: ctx().recordStringField(part, ["type"]) || type,
status: ctx().recordStringField(part, ["status", "reason"]) || ctx().recordStringField(record, ["status", "reason"]) || undefined,
message: error.length > 0 ? ctx().safePreview(error, 600) : undefined,
textPreview: text.length > 0 ? ctx().safePreview(text, 800) : undefined,
};
}
class OpenCodeRunClient implements CodeAgentClient {
private child: ChildProcessWithoutNullStreams;
private stderrChunks: Buffer[] = [];
private closed = false;
private closeResolve!: (value: AppServerExit) => void;
private assistantChunks: string[] = [];
private sessionAnnounced = false;
readonly closedPromise: Promise<AppServerExit>;
readonly runId = `opencode_${Date.now()}_${Math.random().toString(16).slice(2, 8)}`;
readonly events: CodexEventSummary[] = [];
sessionId: string | null = null;
finalResponse = "";
stepFinished = false;
lastActivityAt = Date.now();
constructor(private readonly task: QueueTask, prompt: string) {
this.closedPromise = new Promise((resolveClosed) => { this.closeResolve = resolveClosed; });
this.child = ctx().providerIsMain(task.providerId)
? spawn("opencode", openCodeRunArgs(task, prompt), {
cwd: task.cwd,
env: openCodeEnv(),
stdio: "pipe",
})
: spawn("bun", ["scripts/cli.ts", "ssh", task.providerId, remoteOpenCodeRunCommand(task, prompt)], {
cwd: ctx().config.defaultWorkdir,
env: process.env,
stdio: "pipe",
});
// opencode waits for stdin EOF even when the prompt is supplied as argv.
// Close stdin immediately so non-interactive queue runs can start.
this.child.stdin.end();
this.child.stderr.on("data", (chunk: Buffer) => {
this.stderrChunks.push(chunk);
while (Buffer.concat(this.stderrChunks).length > 96_000) this.stderrChunks.shift();
});
const rl = readline.createInterface({ input: this.child.stdout, crlfDelay: Infinity });
void this.readLines(rl);
this.child.on("close", (code, signal) => this.handleClose(code, signal));
this.child.on("error", (error) => this.handleClose(127, error.message));
}
stop(): void {
if (this.closed) return;
this.child.kill("SIGTERM");
setTimeout(() => {
if (!this.closed) this.child.kill("SIGKILL");
}, 1500).unref?.();
}
private async readLines(rl: readline.Interface): Promise<void> {
try {
for await (const line of rl) {
const trimmed = String(line).trim();
if (trimmed.length === 0) continue;
this.lastActivityAt = Date.now();
this.handleLine(trimmed);
}
} catch (error) {
ctx().appendOutput(this.task, "error", `opencode stream error: ${error instanceof Error ? error.message : String(error)}\n`, "opencode/stream");
}
}
private handleLine(line: string): void {
let parsed: Record<string, unknown> | null = null;
try {
const value = JSON.parse(line) as unknown;
parsed = extractRecord(value);
} catch {
this.appendAssistantText(line, "opencode/stdout", undefined);
return;
}
if (parsed === null) {
this.appendAssistantText(line, "opencode/stdout", undefined);
return;
}
const part = extractRecord(parsed.part);
const event = openCodeEventSummary(parsed);
this.events.push(event);
ctx().addEvent(this.task, event);
const sessionId = openCodeSessionIdFromRecord(parsed, part);
if (sessionId !== null) this.setSessionId(sessionId);
const type = ctx().recordStringField(parsed, ["type", "event", "name"]) || ctx().recordStringField(part, ["type"]) || "unknown";
const partType = ctx().recordStringField(part, ["type"]);
const itemId = ctx().recordStringField(part, ["id"]) || undefined;
if (type === "step_finish" || type === "step-finish" || partType === "step-finish") {
this.stepFinished = true;
return;
}
if (type === "step_start" || type === "step-start" || partType === "step-start") {
return;
}
const text = ctx().recordStringField(part, ["text", "content", "delta"]) || ctx().recordStringField(parsed, ["text", "content", "delta"]);
if (text.length > 0 && (type === "text" || partType === "text" || partType === "reasoning")) {
if (partType === "reasoning") ctx().appendOutput(this.task, "reasoning", `${text.trimEnd()}\n`, "opencode/reasoning", itemId, true);
else this.appendAssistantText(text, "opencode/text", itemId);
return;
}
if (/tool|bash|command/iu.test(`${type} ${partType}`)) {
ctx().appendOutput(this.task, type.includes("command") || partType.includes("command") ? "command" : "tool", `${JSON.stringify(parsed)}\n`, "opencode/tool", itemId);
return;
}
if (/error|failed/iu.test(`${type} ${partType}`)) {
ctx().appendOutput(this.task, "error", `${ctx().safePreview(JSON.stringify(parsed), 3000)}\n`, "opencode/error", itemId);
}
}
private setSessionId(sessionId: string): void {
this.sessionId = sessionId;
if (this.task.codexThreadId === null) this.task.codexThreadId = sessionId;
const run = ctx().activeRuns.get(ctx().queueIdOf(this.task));
if (run?.app === this) run.threadId = sessionId;
if (this.sessionAnnounced) return;
const resumed = this.task.currentMode === "retry" || this.task.attempts.length > 0;
ctx().appendOutput(this.task, "system", `opencode session ${resumed ? "resumed" : "started"} ${sessionId}\n`, resumed ? "opencode/session-resume" : "opencode/session-start");
this.sessionAnnounced = true;
}
private appendAssistantText(rawText: string, method: string, itemId: string | undefined): void {
const parts = splitOpenCodeAssistantText(rawText);
if (parts.reasoning.length > 0) ctx().appendOutput(this.task, "reasoning", `${parts.reasoning.trimEnd()}\n`, "opencode/reasoning", itemId, true);
const visible = parts.assistant.length > 0 ? parts.assistant : parts.reasoning.length > 0 ? "" : rawText.trim();
if (visible.length === 0) return;
this.assistantChunks.push(visible);
this.finalResponse = stripThinkBlocks(this.assistantChunks.join("\n\n").trim());
this.task.finalResponse = this.finalResponse;
ctx().appendOutput(this.task, "assistant", `${visible.trimEnd()}\n`, method, itemId, true);
}
private handleClose(code: number | null, signal: string | null): void {
if (this.closed) return;
this.closed = true;
this.closeResolve({ code, signal, stderrTail: Buffer.concat(this.stderrChunks).toString("utf8").slice(-8000) });
}
}
function openCodeExitError(exit: AppServerExit): string {
const base = `OpenCode exited with code=${exit.code} signal=${exit.signal}`;
const stderr = stripAnsi(exit.stderrTail).trim();
return stderr.length > 0 ? `${base}: ${ctx().safePreview(stderr, 800)}` : base;
}
function openCodeSessionMissing(result: CodexRunResult): boolean {
return /Session not found/iu.test(stripAnsi(`${result.terminalError ?? ""}\n${result.appServerExit.stderrTail}`));
}
export async function runOpenCodeTurn(task: QueueTask, prompt: string): Promise<CodexRunResult> {
const attemptedSessionId = task.codexThreadId;
const first = await runOpenCodeTurnOnce(task, prompt);
if (attemptedSessionId === null || task.cancelRequested || ctx().shutdownRequested() || !openCodeSessionMissing(first)) return first;
const reason = first.terminalError ?? first.appServerExit.stderrTail;
ctx().appendOutput(task, "system", `opencode session ${attemptedSessionId} was not found; clearing stale session and starting a fresh OpenCode session via the opencode port\n`, "opencode/session-recovery");
ctx().logger("warn", "opencode_session_missing_recover_fresh", { taskId: task.id, sessionId: attemptedSessionId, reason: ctx().safePreview(stripAnsi(reason), 500) });
task.codexThreadId = null;
task.activeTurnId = null;
ctx().persistTaskState(task);
return runOpenCodeTurnOnce(task, ctx().openCodeFreshRecoveryPrompt(task, prompt, reason));
}
async function runOpenCodeTurnOnce(task: QueueTask, prompt: string): Promise<CodexRunResult> {
const queueId = ctx().queueIdOf(task);
if (ctx().config.minimaxApiKey.length === 0) {
const message = "MINIMAX_API_KEY is required for opencode model minimax-m2.7.";
ctx().appendOutput(task, "error", `${message}\n`, "opencode/config");
return {
threadId: task.codexThreadId,
turnId: null,
finalResponse: task.finalResponse,
terminalStatus: "failed",
terminalError: message,
transportClosedBeforeTerminal: true,
appServerExit: { code: 1, signal: null, stderrTail: message },
events: [],
};
}
await ctx().ensureTaskExecutionContainer(task);
const app = new OpenCodeRunClient(task, prompt);
ctx().activeRuns.set(queueId, { taskId: task.id, queueId, app, port: "opencode", threadId: task.codexThreadId, turnId: app.runId });
task.activeTurnId = null;
ctx().persistTaskState(task);
const activityWatchdog = setInterval(() => {
const idleMs = Date.now() - app.lastActivityAt;
if (idleMs < ctx().config.turnNoActivityTimeoutMs) return;
const message = `No OpenCode activity for ${Math.round(idleMs / 1000)}s; stopping opencode run so the existing session can retry.`;
ctx().appendOutput(task, "error", `${message}\n`, "turn/no-activity-watchdog");
ctx().logger("warn", "opencode_no_activity_watchdog", { taskId: task.id, runId: app.runId, idleMs, timeoutMs: ctx().config.turnNoActivityTimeoutMs });
app.stop();
}, 15_000);
try {
const exit = await app.closedPromise;
clearInterval(activityWatchdog);
const finalResponse = app.finalResponse || task.finalResponse;
const exitOk = exit.code === 0;
const hasFinal = finalResponse.trim().length > 0;
const status: TerminalStatus = exitOk && hasFinal ? "completed" : "failed";
const terminalError = status === "completed"
? null
: exitOk
? "OpenCode returned no final assistant response."
: openCodeExitError(exit);
const stderr = stripAnsi(exit.stderrTail).trim();
ctx().appendOutput(
task,
status === "completed" ? "system" : "error",
`opencode completed status=${status} exit=${exit.code ?? "null"} signal=${exit.signal ?? "null"}${stderr.length > 0 ? ` stderr=${ctx().safePreview(stderr, 1200)}` : ""}\n`,
"opencode/complete",
);
return {
threadId: app.sessionId ?? task.codexThreadId,
turnId: app.runId,
finalResponse,
terminalStatus: status,
terminalError,
transportClosedBeforeTerminal: !exitOk || !app.stepFinished,
appServerExit: exit,
events: app.events,
};
} catch (error) {
clearInterval(activityWatchdog);
const message = error instanceof Error ? error.message : String(error);
ctx().appendOutput(task, "error", `${message}\n`, "opencode");
app.stop();
const exit = await app.closedPromise;
return {
threadId: app.sessionId ?? task.codexThreadId,
turnId: app.runId,
finalResponse: app.finalResponse || task.finalResponse,
terminalStatus: "failed",
terminalError: message,
transportClosedBeforeTerminal: true,
appServerExit: exit,
events: app.events,
};
} finally {
clearInterval(activityWatchdog);
if (ctx().activeRuns.get(queueId)?.app === app) ctx().activeRuns.delete(queueId);
app.stop();
}
}
src/components/microservices/code-queue/src/dev-containers.ts
+193
View File
@@ -0,0 +1,193 @@
// 重构前 index.ts 只读参考：commit 6a04144d3f5103014f75b637d7e6bc2f45bf007f，blob 56e590c1a6b5ca7ad128bf2c992f60e46c355a58；可用 `git show 6a04144d3f5103014f75b637d7e6bc2f45bf007f:src/components/microservices/code-queue/src/index.ts` 查看。
import type { DevContainerCommandLog, DevContainerPlan, JsonValue, QueueTask, RuntimeConfig } from "./types";
export interface DevContainerContext {
config: Pick<RuntimeConfig, "devContainerDefaultProviderId">;
appendOutput: (task: QueueTask, channel: "system" | "assistant" | "reasoning" | "command" | "diff" | "tool" | "error", text: string, method?: string, itemId?: string, append?: boolean) => unknown;
buildDevContainerPlan: (providerId: string, body: Record<string, unknown>) => DevContainerPlan;
containerTunnelStartScript: (plan: DevContainerPlan) => string;
devContainerEnsurePromises: Map<string, Promise<void>>;
devContainerPingScript: (plan: DevContainerPlan) => string;
errorToJson: (error: unknown) => JsonValue;
extractRecord: (value: unknown) => Record<string, unknown> | null;
jsonResponse: (body: unknown, status?: number) => Response;
logger: (level: "debug" | "info" | "warn" | "error", message: string, data?: JsonValue) => void;
masterKeyReadScript: (plan: DevContainerPlan) => string;
masterKeySetupScript: (plan: DevContainerPlan) => string;
masterProxyEvidenceScript: (plan: DevContainerPlan) => string;
masterProxyFinishScript: (plan: DevContainerPlan) => string;
masterProxyPrepareScript: (plan: DevContainerPlan) => string;
normalizeProviderId: (value: unknown) => string | null;
providerIsMain: (providerId: string) => boolean;
readJson: (req: Request) => Promise<unknown>;
remoteCodexConfigInstallScript: (plan: DevContainerPlan) => string;
remoteCodexRuntimePrepareScript: (plan: DevContainerPlan) => string;
remoteContainerStartScript: (plan: DevContainerPlan, forceRecreate: boolean) => string;
remoteHostWorkdirForTask: (task: QueueTask) => string;
remoteKeyInstallScript: (plan: DevContainerPlan, privateKeyBase64: string) => string;
runCodeQueueSsh: (providerId: string, script: string, timeoutMs: number, name: string) => DevContainerCommandLog;
safePreview: (value: string, max?: number) => string;
shellQuote: (value: string) => string;
throwIfCommandFailed: (command: DevContainerCommandLog) => void;
}
let context: DevContainerContext | null = null;
export function configureDevContainers(runtimeContext: DevContainerContext): void {
context = runtimeContext;
}
function ctx(): DevContainerContext {
if (context === null) throw new Error("dev-containers module is not configured");
return context;
}
async function startDevContainerPlan(plan: DevContainerPlan, options: { forceRecreate: boolean; verifyPing: boolean; prepareRuntime: boolean }): Promise<{
ok: boolean;
providerId: string;
plan: DevContainerPlan;
commands: DevContainerCommandLog[];
verification?: Record<string, JsonValue>;
}> {
const commands: DevContainerCommandLog[] = [];
const run = (targetProviderId: string, script: string, timeoutMs: number, name: string): DevContainerCommandLog => {
const command = ctx().runCodeQueueSsh(targetProviderId, script, timeoutMs, name);
commands.push(command);
ctx().throwIfCommandFailed(command);
return command;
};
run("main-server", ctx().masterKeySetupScript(plan), 45_000, "master-key-setup");
const keyRead = run("main-server", ctx().masterKeyReadScript(plan), 15_000, "master-key-read");
const keyBase64 = keyRead.stdout.trim();
if (!/^[A-Za-z0-9+/=\r\n]+$/u.test(keyBase64) || keyBase64.length < 40) throw new Error("master key read returned invalid base64");
keyRead.stdout = "[redacted private tunnel key]\n";
run(plan.providerId, ctx().remoteKeyInstallScript(plan, keyBase64), 30_000, "remote-key-install");
run(plan.providerId, ctx().remoteCodexConfigInstallScript(plan), 30_000, "remote-codex-config-install");
run(plan.providerId, ctx().remoteContainerStartScript(plan, options.forceRecreate), 60_000, "remote-container-start");
run("main-server", ctx().masterProxyPrepareScript(plan), 30_000, "master-proxy-prepare");
run(plan.providerId, ctx().containerTunnelStartScript(plan), 45_000, "remote-tunnel-start");
run("main-server", ctx().masterProxyFinishScript(plan), 30_000, "master-proxy-finish");
if (options.prepareRuntime) run(plan.providerId, ctx().remoteCodexRuntimePrepareScript(plan), 180_000, "remote-codex-runtime-prepare");
const verification: Record<string, JsonValue> = {};
if (options.verifyPing) {
const before = run("main-server", ctx().masterProxyEvidenceScript(plan), 15_000, "master-proxy-evidence-before-ping");
const ping = run(plan.providerId, ctx().devContainerPingScript(plan), 20_000, "remote-container-ping-google");
const after = run("main-server", ctx().masterProxyEvidenceScript(plan), 15_000, "master-proxy-evidence-after-ping");
verification.pingGoogleOk = ping.exitCode === 0 && /0% packet loss|1 packets received|1 received/iu.test(ping.stdout);
verification.directPingEvidence = commands.find((command) => command.name === "remote-tunnel-start")?.stdout.includes("direct_ping=failed_expected") === true
? `direct ${plan.providerId} container ping failed before tunnel`
: "direct ping did not fail before tunnel";
verification.masterProxyEvidenceBefore = ctx().safePreview(before.stdout, 2000);
verification.pingGoogleLog = ping.stdout;
verification.masterProxyEvidenceAfter = ctx().safePreview(after.stdout, 2000);
}
return { ok: true, providerId: plan.providerId, plan, commands, verification };
}
export async function ensureTaskExecutionContainer(task: QueueTask): Promise<void> {
if (ctx().providerIsMain(task.providerId)) return;
const plan = ctx().buildDevContainerPlan(task.providerId, { workdir: ctx().remoteHostWorkdirForTask(task) });
const existing = ctx().devContainerEnsurePromises.get(plan.providerId);
if (existing !== undefined) return existing;
const promise = (async () => {
ctx().appendOutput(task, "system", `ensuring provider=${plan.providerId} container=${plan.containerName} workdir=${task.cwd}\n`, "provider/container");
const result = await startDevContainerPlan(plan, { forceRecreate: false, verifyPing: false, prepareRuntime: true });
ctx().appendOutput(task, "system", `provider container ready provider=${plan.providerId} container=${plan.containerName} commands=${result.commands.length}\n`, "provider/container");
ctx().logger("info", "task_provider_container_ready", {
taskId: task.id,
providerId: plan.providerId,
containerName: plan.containerName,
workdir: task.cwd,
hostWorkdir: plan.workdir,
});
})();
ctx().devContainerEnsurePromises.set(plan.providerId, promise);
try {
await promise;
} finally {
if (ctx().devContainerEnsurePromises.get(plan.providerId) === promise) ctx().devContainerEnsurePromises.delete(plan.providerId);
}
}
export async function startDevContainer(req: Request, providerFromPath: string | null): Promise<Response> {
const body = ctx().extractRecord(await ctx().readJson(req)) ?? {};
const providerFromBody = ctx().normalizeProviderId(body.providerId);
const providerId = ctx().normalizeProviderId(providerFromPath ?? "") ?? providerFromBody ?? ctx().normalizeProviderId(ctx().config.devContainerDefaultProviderId) ?? "D601";
const plan = ctx().buildDevContainerPlan(providerId, body);
try {
const result = await startDevContainerPlan(plan, { forceRecreate: true, verifyPing: true, prepareRuntime: false });
ctx().logger("info", "dev_container_started", {
providerId,
containerName: plan.containerName,
masterHost: plan.masterHost,
tunName: plan.tunName,
natChain: plan.natChain,
pingPreview: ctx().safePreview(String(result.verification?.pingGoogleLog ?? ""), 600),
natAfterPreview: ctx().safePreview(String(result.verification?.masterProxyEvidenceAfter ?? ""), 600),
});
return ctx().jsonResponse({
ok: true,
providerId,
container: {
name: plan.containerName,
image: plan.image,
workdir: plan.workdir,
containerWorkdir: plan.containerWorkdir,
},
masterProxy: {
mode: "ssh-tun-nat",
masterHost: plan.masterHost,
tunId: plan.tunId,
tunName: plan.tunName,
serverIp: plan.serverIp,
clientIp: plan.clientIp,
natChain: plan.natChain,
},
verification: result.verification,
commands: result.commands,
});
} catch (error) {
ctx().logger("error", "dev_container_start_failed", { providerId, containerName: plan.containerName, error: ctx().errorToJson(error) });
return ctx().jsonResponse({
ok: false,
error: error instanceof Error ? error.message : String(error),
providerId,
containerName: plan.containerName,
masterProxy: {
mode: "ssh-tun-nat",
masterHost: plan.masterHost,
tunName: plan.tunName,
clientIp: plan.clientIp,
natChain: plan.natChain,
},
}, 500);
}
}
export async function devContainerStatus(providerFromPath: string | null): Promise<Response> {
const providerId = ctx().normalizeProviderId(providerFromPath ?? "") ?? ctx().normalizeProviderId(ctx().config.devContainerDefaultProviderId) ?? "D601";
const plan = ctx().buildDevContainerPlan(providerId, {});
const commands: DevContainerCommandLog[] = [];
const statusScript = `set -euo pipefail
CONTAINER=${ctx().shellQuote(plan.containerName)}
docker inspect "$CONTAINER" --format 'container={{.Name}} state={{.State.Status}} image={{.Config.Image}} workdir={{ index .Config.Labels "unidesk.workdir" }} started={{.State.StartedAt}}' 2>/dev/null || true
if docker inspect "$CONTAINER" >/dev/null 2>&1; then
docker exec "$CONTAINER" bash -lc 'export PATH=/tmp/unidesk-tools:$PATH; echo default=$(ip route show default | head -1); echo resolv=$(tr "\\n" " " </etc/resolv.conf); echo pwd=$(pwd); command -v codex || true; ip addr show ${plan.tunName} 2>/dev/null || true' || true
fi`;
commands.push(ctx().runCodeQueueSsh(providerId, statusScript, 15_000, "remote-container-status"));
commands.push(ctx().runCodeQueueSsh("main-server", ctx().masterProxyEvidenceScript(plan), 15_000, "master-proxy-status"));
return ctx().jsonResponse({
ok: commands.every((command) => command.exitCode === 0),
providerId,
containerName: plan.containerName,
masterProxy: {
mode: "ssh-tun-nat",
masterHost: plan.masterHost,
tunName: plan.tunName,
clientIp: plan.clientIp,
natChain: plan.natChain,
},
commands,
});
}
src/components/microservices/code-queue/src/index.ts
+571 -6261
View File
File diff suppressed because it is too large Load Diff
src/components/microservices/code-queue/src/judge-probes.ts
+366
View File
@@ -0,0 +1,366 @@
// 重构前 index.ts 只读参考：commit 6a04144d3f5103014f75b637d7e6bc2f45bf007f，blob 56e590c1a6b5ca7ad128bf2c992f60e46c355a58；可用 `git show 6a04144d3f5103014f75b637d7e6bc2f45bf007f:src/components/microservices/code-queue/src/index.ts` 查看。
import type { JudgeProbeCase } from "./types";
function nowIso(): string {
return new Date().toISOString();
}
export const defaultJudgeProbeCases: JudgeProbeCase[] = [
{
id: "completed_exact_response",
prompt: "Reply exactly: code-queue-judge-complete.",
finalResponse: "code-queue-judge-complete.",
expected: "complete",
terminalStatus: "completed",
outputs: [
{ channel: "user", text: "Reply exactly: code-queue-judge-complete.\n", method: "enqueue" },
{ channel: "assistant", text: "code-queue-judge-complete.", method: "item/agentMessage/delta" },
{ channel: "system", text: "turn completed status=completed\n", method: "turn/completed" },
],
events: [{ at: nowIso(), method: "turn/completed", status: "completed" }],
},
{
id: "completed_but_plan_only",
prompt: "Create /root/unidesk/tmp/judge_probe.txt containing exactly judge-probe-ok, then summarize the file path.",
finalResponse: "I can do that. Plan: create the file under /root/unidesk/tmp and then summarize the path.",
expected: "retry",
terminalStatus: "completed",
outputs: [
{ channel: "user", text: "Create /root/unidesk/tmp/judge_probe.txt containing exactly judge-probe-ok, then summarize the file path.\n", method: "enqueue" },
{ channel: "assistant", text: "I can do that. Plan: create the file under /root/unidesk/tmp and then summarize the path.", method: "item/agentMessage/delta" },
{ channel: "system", text: "turn completed status=completed\n", method: "turn/completed" },
],
events: [{ at: nowIso(), method: "turn/completed", status: "completed" }],
},
{
id: "pikapython_skill_ablation_not_run",
prompt: "从这个结果看，是通过专门定向优化prompt解决了pikabench-4的可解性，并且使得其他组件都没有明显贡献，这个思路是错误的，输入任务prompt应当是通用的，需求导向而非精确控制内部过程的。改进方案是将专门定向的prompt改为泛化的经验型skill来注入，预期的结果是，不注入这个泛化的经验型skill，就不能跑出4/4，注入了就能跑出。将禁止针对任务定向优化prompt的原则也固化到 pipeline 长期文档。",
finalResponse: "已把这轮“定向 prompt 解题”的路径改成“通用需求 prompt + 可消融的经验型 skill”。D601 Pipeline prompt 已去定向化，泛化经验已移入 PikaPython skill，no-skill 边界已恢复，长期规则已固化，测试已补防回归。验证已通过：npm run typecheck、npm run components:validate、npm run test，50 tests passed。我没有启动新的 PikaBench-4 baseline/no-skill 实跑，避免继续消耗 MiniMax 限额；现在代码与测试层面已经把“skill 可消融”边界重新建立起来。下一步如果要验证预期，应只跑最小对照：pikabench-4-ablation-baseline vs pikabench-4-no-skill。",
expected: "retry",
terminalStatus: "completed",
outputs: [
{
channel: "user",
text: "从这个结果看，是通过专门定向优化prompt解决了pikabench-4的可解性，并且使得其他组件都没有明显贡献，这个思路是错误的，输入任务prompt应当是通用的，需求导向而非精确控制内部过程的。改进方案是将专门定向的prompt改为泛化的经验型skill来注入，预期的结果是，不注入这个泛化的经验型skill，就不能跑出4/4，注入了就能跑出。将禁止针对任务定向优化prompt的原则也固化到 pipeline 长期文档。\n",
method: "enqueue",
},
{
channel: "command",
text: "item/completed: bun scripts/cli.ts ssh D601 'cd /home/ubuntu/pipeline && npm run typecheck && npm run components:validate && npm run test' status=completed; 50 tests passed",
method: "item/completed",
},
{
channel: "assistant",
text: "已把这轮“定向 prompt 解题”的路径改成“通用需求 prompt + 可消融的经验型 skill”。验证已通过：npm run typecheck、npm run components:validate、npm run test，50 tests passed。我没有启动新的 PikaBench-4 baseline/no-skill 实跑，避免继续消耗 MiniMax 限额；下一步如果要验证预期，应只跑最小对照：pikabench-4-ablation-baseline vs pikabench-4-no-skill。",
method: "item/agentMessage/delta",
},
{ channel: "system", text: "turn completed status=completed\n", method: "turn/completed" },
],
events: [{ at: nowIso(), method: "turn/completed", status: "completed" }],
},
{
id: "constar_docs_steer_unfinished_should_retry",
prompt: "constar的工作目录在D601 /mnt/f/work/constar，你先摸清楚这个工程怎么用D601的skills做编译，下载等，摸熟悉之后更新长期参考文档，包括unidesk中简要引导，constar 里面补充在wsl中开发的注意事项等",
finalResponse: "已按你的更正处理：长期文档可以留在 `constar/docs/`，不再放在 `constar/projects/` 里维护。已迁移非 docx 项目文档，已更新长期规则与索引，并验证项目文档目录只剩 docx。注意：根仓库新增/修改 `docs/reference/...`，FREQ 子仓库中 `README.md` 修改、`项目文档/quick_start_debug.md` 删除。",
expected: "retry",
terminalStatus: "completed",
outputs: [
{
channel: "user",
text: "constar的工作目录在D601 /mnt/f/work/constar，你先摸清楚这个工程怎么用D601的skills做编译，下载等，摸熟悉之后更新长期参考文档，包括unidesk中简要引导，constar 里面补充在wsl中开发的注意事项等\n",
method: "enqueue",
},
{
channel: "command",
text: "item/completed: bun scripts/cli.ts ssh D601 skills --limit 120 status=completed; keil/serial-monitor/board-comm wrappers discovered",
method: "item/completed",
},
{
channel: "command",
text: "item/completed: bun scripts/cli.ts ssh D601 -- 'cd /mnt/f/Work/ConStart && keil build --wait -p projects/71-00075-11/FirmWare/MDK-ARM/FREQ_Controller_FW.uvprojx -t FREQ_Controller_FW' status=completed; return_code=0 success=true",
method: "item/completed",
},
{
channel: "user",
text: "[steer] freq项目里面的项目文档要迁移到constar/docs/ 里面(docx不迁移)，并在长期文档中说明只创建和维护constar/docs里面的长期文档\n",
method: "turn/steer",
},
{
channel: "assistant",
text: "已按你的更正处理：长期文档可以留在 `constar/docs/`，不再放在 `constar/projects/` 里维护。已迁移非 docx 项目文档，并验证相关 Markdown。",
method: "item/agentMessage/delta",
},
{ channel: "system", text: "turn completed status=completed\n", method: "turn/completed" },
],
events: [{ at: nowIso(), method: "turn/completed", status: "completed" }],
},
{
id: "rate_limit_after_partial_work_should_retry",
prompt: "不要总是刷新登录二维码，这样容易过期，只在没有获取二维码的时候获取，之后不要自动刷新，只保留手动刷新",
finalResponse: "",
expected: "retry",
terminalStatus: "failed",
terminalError: "exceeded retry limit, last status: 429 Too Many Requests, request id: 21zqfw7apcg",
outputs: [
{
channel: "user",
text: "不要总是刷新登录二维码，这样容易过期，只在没有获取二维码的时候获取，之后不要自动刷新，只保留手动刷新\n",
method: "enqueue",
},
{ channel: "command", text: "item/completed: git diff -- src/components/frontend/src/claudeqq.tsx status=completed", method: "item/completed" },
{ channel: "command", text: "item/completed: bun run check status=completed", method: "item/completed" },
{ channel: "command", text: "item/completed: bun scripts/cli.ts server rebuild frontend status=completed; job succeeded", method: "item/completed" },
{ channel: "command", text: "item/completed: bun scripts/cli.ts e2e run --only frontend:claudeqq status=failed; Playwright browser/dependency issue", method: "item/completed" },
{ channel: "command", text: "item/started: bunx playwright install-deps chromium status=inProgress", method: "item/started" },
{ channel: "error", text: "exceeded retry limit, last status: 429 Too Many Requests, request id: 21zqfw7apcg\n", method: "error" },
{ channel: "error", text: "turn completed status=failed\n", method: "turn/completed" },
],
events: [
{ at: nowIso(), method: "item/completed", itemType: "commandExecution", status: "failed", message: "Playwright dependency validation not complete" },
{ at: nowIso(), method: "turn/completed", status: "failed", message: "exceeded retry limit, last status: 429 Too Many Requests" },
],
},
{
id: "codex_1778545138372_limit_error_no_final_response_should_retry",
prompt: "基于 `https://github.com/filebrowser/filebrowser` 开发和部署一个文件管理器的用户服务，支持浏览 main server host、provider host 和 windows 文件 (wsl的/mnt/c/ 等目录，如果 provider 是 WSL，例如 D518 和 D601)",
finalResponse: "",
expected: "retry",
terminalStatus: "failed",
terminalError: "exceeded retry limit, last status: 429 Too Many Requests, request id: 9h5h8iolxwr",
outputs: [
{
channel: "user",
text: "基于 `https://github.com/filebrowser/filebrowser` 开发和部署一个文件管理器的用户服务，支持浏览 main server host、provider host 和 windows 文件 (wsl的/mnt/c/ 等目录，如果 provider 是 WSL，例如 D518 和 D601)\n",
method: "enqueue",
},
{
channel: "command",
text: "item/completed: microservice list shows filebrowser main-server, D601 and D518 containers all Up/healthy",
method: "item/completed",
},
{
channel: "command",
text: "item/completed: API checks returned 200 for /mnt/c/Users and /mnt/c/Windows on D601 and D518 with directory item counts",
method: "item/completed",
},
{
channel: "diff",
text: "item/completed: file changes status=completed; M docker-compose.yml M docs/reference/microservices.md",
method: "item/completed",
},
{
channel: "command",
text: "item/completed: docker compose up -d --no-deps --force-recreate filebrowser status=completed; filebrowser-main became healthy",
method: "item/completed",
},
{ channel: "error", text: "exceeded retry limit, last status: 429 Too Many Requests, request id: 9h5h8iolxwr\n", method: "error" },
{ channel: "error", text: "turn completed status=failed\n", method: "turn/completed" },
],
events: [
{ at: nowIso(), method: "item/completed", itemType: "commandExecution", status: "completed", message: "filebrowser runtime checks showed partial success before interruption" },
{ at: nowIso(), method: "turn/completed", status: "failed", message: "exceeded retry limit, last status: 429 Too Many Requests" },
],
},
{
id: "codex_1778551922480_fb2cc7_rate_limit_feedback_should_not_add_no_arg_api_requirement",
prompt: "71-Freq 工程里面的 main.c:282 打印了 period_sum/mpu_read_num，我需要在282的后面新增两个打印，分别是打印滑动滤波前和滑动滤波后的值，你先分析要使得能够正常打印，需要哪些工作（例如初始化、配置等），并且在 period_sum/mpu_read_num 相同的条件下打印（这个打印应该是在 little_shell 触发的某个命令下进入打印状态），这个命令如果已经做好了频率测量的初始化和配置，那就不需要再配置",
finalResponse: "",
expected: "retry",
expectedContinuePromptIncludes: [
"未完成",
"原始需求",
"继续按照原始需求",
],
expectedContinuePromptExcludes: [
"无参",
"无参数",
"mpu_sensor_get_frequency_millihz()",
"mpu_sensor_get_filtered_frequency_millihz()",
"把 `mpu_sensor_get_frequency_millihz`",
"return value",
"返回 `uint32_t`",
"FirmWare/Core/Src/main.c",
"第 276-292 行",
],
expectedContinuePromptMaxChars: 420,
expectedContinuePromptMaxLines: 6,
terminalStatus: "failed",
terminalError: "exceeded retry limit, last status: 429 Too Many Requests, request id: 8qegpzommds",
outputs: [
{
channel: "user",
text: "71-Freq 工程里面的 main.c:282 打印了 period_sum/mpu_read_num，我需要在282的后面新增两个打印，分别是打印滑动滤波前和滑动滤波后的值，你先分析要使得能够正常打印，需要哪些工作（例如初始化、配置等），并且在 period_sum/mpu_read_num 相同的条件下打印（这个打印应该是在 little_shell 触发的某个命令下进入打印状态），这个命令如果已经做好了频率测量的初始化和配置，那就不需要再配置\n",
method: "enqueue",
},
{
channel: "system",
text: "attempt 2/99 queue=constar provider=main-server cwd=/root/unidesk mode=retry model=gpt-5.5\n",
method: "queue",
},
{
channel: "system",
text: "上一次 judge feedback 曾指定了具体 printf 形态；其中无参读取不是原始用户要求，只是 judge 推测。\n",
method: "queue",
},
{
channel: "command",
text: "item/started: bun scripts/cli.ts debug dispatch D601 host.ssh --ssh-command 'cd /mnt/f/Work/ConStart/projects/71-00075-11 && sed -n \"276,292p\" FirmWare/Core/Src/main.c' status=inProgress",
method: "item/started",
},
{
channel: "error",
text: "exceeded retry limit, last status: 429 Too Many Requests, request id: 8qegpzommds\n",
method: "error",
},
{ channel: "error", text: "turn completed status=failed\n", method: "turn/completed" },
],
events: [
{ at: nowIso(), method: "item/started", itemType: "commandExecution", status: "inProgress", message: "reading D601 main.c context" },
{ at: nowIso(), method: "turn/completed", status: "failed", message: "exceeded retry limit, last status: 429 Too Many Requests" },
],
},
{
id: "frontend_visible_change_without_rebuild_should_retry",
prompt: "unidesk 把侧边栏的 `微服务` 改成 `用户服务`，单纯进行改名，长期文档中也要同步修改命名，明确概念，用户服务指的是在 unidesk 核心服务上挂载的用户使用的服务，unidesk 核心缺少这些服务也依然可以运行",
finalResponse: "已完成，属于纯命名调整，没有改路由/API/CLI 的兼容命名。\n\n- 前端侧边栏主模块从 `微服务` 改为 `用户服务`：`src/components/frontend/src/navigation.ts`\n- 同步了前端可见文案，包括用户服务目录、顶部状态、各服务页 eyebrow/raw title/空状态。\n- 更新 E2E 选择器和断言，Playwright 现在点击/校验 `用户服务`。\n- 长期文档已同步概念。\n\n验证已跑：\n- `bun scripts/cli.ts check` 通过\n- `bun scripts/cli.ts help` 过滤确认 `microservice` 命令描述已改为 user services\n\n未跑完整公网 E2E；本次只做命名和文档同步。",
expected: "retry",
terminalStatus: "completed",
outputs: [
{
channel: "user",
text: "unidesk 把侧边栏的 `微服务` 改成 `用户服务`，单纯进行改名，长期文档中也要同步修改命名，明确概念，用户服务指的是在 unidesk 核心服务上挂载的用户使用的服务，unidesk 核心缺少这些服务也依然可以运行\n",
method: "enqueue",
},
{ channel: "diff", text: "item/completed: file changes status=completed; M src/components/frontend/src/navigation.ts M src/components/frontend/src/app.tsx M docs/reference/microservices.md", method: "item/completed" },
{ channel: "command", text: "item/completed: bun scripts/cli.ts check status=completed; ok=true", method: "item/completed" },
{ channel: "command", text: "item/completed: bun scripts/cli.ts help | python3 ... status=completed; microservice descriptions mention user services", method: "item/completed" },
{
channel: "assistant",
text: "已完成，属于纯命名调整。验证已跑：bun scripts/cli.ts check 通过；bun scripts/cli.ts help 过滤确认 microservice 命令描述已改为 user services。未跑完整公网 E2E；本次只做命名和文档同步。",
method: "item/agentMessage/delta",
},
{ channel: "system", text: "turn completed status=completed\n", method: "turn/completed" },
],
events: [{ at: nowIso(), method: "turn/completed", status: "completed" }],
},
{
id: "codex_1778483956252_c65680_mid_task_confirmation_should_retry",
prompt: "code-queue的这个卡片已经没有意义了，因为已经能够在 TraceView 展开，所以应当取消这个卡片，只保留TraceView即可\n\n```\ncodex_1778483881863_a48b0a\n\nPrompt 全量\nqueued\nmodel=gpt-5.5\ncwd=/root/unidesk\ncreated=2026/5/11 15:18:01\n29 lines / 385 chars\n渐进式 Trace\n首屏使用后端 Summary；展开 prompt / 步骤时只按需拉取对应片段，不一次性拉取完整 transcript。\n...\n```",
finalResponse: "我这边已完成 Code Queue 前端改动并跑过检查，但刚刚发现一个我没有修改的文件也变成了 modified：\n\n- `src/components/microservices/code-queue/src/index.ts`\n\n开始时工作树是干净的，我没有编辑这个文件。按安全规则我需要先停下确认，避免覆盖你的/其他进程的变更。\n\n请确认要我怎么处理：\n\n1. 忽略这个文件，只继续交付我已改的前端相关变更\n2. 先查看这个文件的 diff，判断来源和影响\n3. 你会自行处理，我这边只汇报已完成内容",
expected: "retry",
terminalStatus: "completed",
outputs: [
{
channel: "user",
text: "code-queue的这个卡片已经没有意义了，因为已经能够在 TraceView 展开，所以应当取消这个卡片，只保留TraceView即可\n\n```\ncodex_1778483881863_a48b0a\n\nPrompt 全量\nqueued\nmodel=gpt-5.5\ncwd=/root/unidesk\ncreated=2026/5/11 15:18:01\n29 lines / 385 chars\n渐进式 Trace\n首屏使用后端 Summary；展开 prompt / 步骤时只按需拉取对应片段，不一次性拉取完整 transcript。\n...\n```\n",
method: "enqueue",
},
{ channel: "diff", text: "item/completed: file changes status=completed; M docs/reference/frontend.md M scripts/src/e2e.ts M src/components/frontend/public/app.js M src/components/frontend/public/style.css M src/components/frontend/src/code-queue.tsx", method: "item/completed" },
{ channel: "command", text: "item/completed: bun run --cwd src/components/frontend check status=completed; ok=true", method: "item/completed" },
{ channel: "command", text: "item/completed: bun run --cwd src/components/frontend build status=completed; ok=true", method: "item/completed" },
{ channel: "command", text: "item/completed: bun scripts/cli.ts check status=completed; ok=true", method: "item/completed" },
{ channel: "command", text: "item/completed: git status --short status=completed; M src/components/microservices/code-queue/src/index.ts also present", method: "item/completed" },
{
channel: "assistant",
text: "我这边已完成 Code Queue 前端改动并跑过检查，但刚刚发现一个我没有修改的文件也变成了 modified：\n\n- `src/components/microservices/code-queue/src/index.ts`\n\n开始时工作树是干净的，我没有编辑这个文件。按安全规则我需要先停下确认，避免覆盖你的/其他进程的变更。\n\n请确认要我怎么处理：\n\n1. 忽略这个文件，只继续交付我已改的前端相关变更\n2. 先查看这个文件的 diff，判断来源和影响\n3. 你会自行处理，我这边只汇报已完成内容",
method: "item/agentMessage/delta",
},
{ channel: "system", text: "turn completed status=completed\n", method: "turn/completed" },
],
events: [{ at: nowIso(), method: "turn/completed", status: "completed" }],
},
{
id: "codex_1778476426776_a2bf19_not_deployed_should_retry",
prompt: "originprompt -> 执行过程 Summary 1 -> finalresponse1 -> judge1 -> 执行过程 Summary 2 -> finalresponse2 judge2 还不够，还要有 judge feedback prompt，例如 originprompt -> 执行过程 Summary 1 -> finalresponse1 -> judge1 -> judge feedback prompt -> 执行过程 Summary 2 -> finalresponse2 judge2",
finalResponse: "已把 Trace 顶级链路补成：origin prompt -> Summary 1 -> final response 1 -> judge 1 -> judge feedback prompt -> Summary 2 -> final response 2 -> judge 2。后端扩展 attempt 数据，trace-summary 现在返回 feedback prompt preview/chars/lines/source，/api/tasks/:id/prompt?part=feedback&attempt=N 支持按需拉取完整内容，前端显示 feedback prompt cards。验证已通过：bun run --cwd src/components/microservices/code-queue check、bun run --cwd src/components/frontend check、bun scripts/cli.ts check、git diff --check。当前 git diff clean。我没有重建运行中的容器。若要上线验证：1. bun scripts/cli.ts server rebuild code-queue 2. bun scripts/cli.ts server rebuild frontend。",
expected: "retry",
terminalStatus: "completed",
outputs: [
{
channel: "user",
text: "originprompt -> 执行过程 Summary 1 -> finalresponse1 -> judge1 -> 执行过程 Summary 2 -> finalresponse2 judge2 还不够，还要有 judge feedback prompt，例如 originprompt -> 执行过程 Summary 1 -> finalresponse1 -> judge1 -> judge feedback prompt -> 执行过程 Summary 2 -> finalresponse2 judge2\n",
method: "enqueue",
},
{ channel: "diff", text: "item/completed: file changes status=completed; M src/components/microservices/code-queue/src/index.ts M src/components/frontend/src/code-queue.tsx", method: "item/completed" },
{ channel: "command", text: "item/completed: bun run --cwd src/components/microservices/code-queue check status=completed; ok=true", method: "item/completed" },
{ channel: "command", text: "item/completed: bun run --cwd src/components/frontend check status=completed; ok=true", method: "item/completed" },
{
channel: "assistant",
text: "已把 Trace 顶级链路补成 judge feedback prompt。验证已通过 type/check；我没有重建运行中的容器。若要上线验证可重建 code-queue 和 frontend。",
method: "item/agentMessage/delta",
},
{ channel: "system", text: "turn completed status=completed\n", method: "turn/completed" },
],
events: [{ at: nowIso(), method: "turn/completed", status: "completed" }],
},
{
id: "beijing_time_deployed_after_prior_retry_feedback_should_complete",
prompt: "unidesk 的所有 frontend 时间显示必须采用北京时间，要修改 unidesk 的前端，并在长期参考文档中要求这一点",
finalResponse: "已完成北京时间任务并已上线验证。源码新增统一北京时间工具并替换 frontend 时间显示入口；长期参考文档已加入 Frontend Time Zone Policy，要求所有 UniDesk frontend timestamps、clocks、Trace times、Gantt labels 和 datetime-local 都固定使用 Asia/Shanghai / UTC+8。已执行 `bun scripts/cli.ts server rebuild frontend`，job succeeded，`unidesk-frontend` healthy。已用 Playwright 打开公网 UniDesk UI，并在 America/Los_Angeles 浏览器时区下验证顶部北京时间时钟、任务历史、Code Queue card、Codex Trace 和 Pipeline run 时间都显示北京时间。本轮不是只改源码未上线，运行中 served UI 已验证通过。",
expected: "complete",
terminalStatus: "completed",
outputs: [
{
channel: "user",
text: "unidesk 的所有 frontend 时间显示必须采用北京时间，要修改 unidesk 的前端，并在长期参考文档中要求这一点\n",
method: "enqueue",
},
{
channel: "system",
text: "judge=retry confidence=0.95 source=minimax: Frontend bundle was not rebuilt/deployed; finalResponse explicitly states the frontend rebuild was skipped to avoid service restart.\n",
method: "judge",
},
{
channel: "system",
text: "上一次 judge 判定为 retry：当前实现仍是未上线/未完成状态，不能只复述源码修改。\n",
method: "queue",
},
{
channel: "command",
text: "item/completed: bun scripts/cli.ts server rebuild frontend status=completed; job succeeded; unidesk-frontend healthy",
method: "item/completed",
},
{
channel: "command",
text: "item/completed: Playwright live UI verification under America/Los_Angeles timezone status=completed; topbar/task/Codex/Pipeline times use Asia/Shanghai",
method: "item/completed",
},
{
channel: "assistant",
text: "已完成北京时间任务并已上线验证。长期参考文档已加入 Frontend Time Zone Policy。已执行 server rebuild frontend，job succeeded，unidesk-frontend healthy。Playwright live UI verification 通过。本轮不是只改源码未上线，运行中 served UI 已验证通过。",
method: "item/agentMessage/delta",
},
{ channel: "system", text: "turn completed status=completed\n", method: "turn/completed" },
],
events: [{ at: nowIso(), method: "turn/completed", status: "completed" }],
},
{
id: "transport_closed_before_terminal",
prompt: "Refactor the queue worker and run the focused tests.",
finalResponse: "",
expected: "retry",
terminalStatus: null,
transportClosedBeforeTerminal: true,
stderrTail: "stream disconnected before completion: upstream overloaded; app-server closed before turn/completed",
outputs: [
{ channel: "user", text: "Refactor the queue worker and run the focused tests.\n", method: "enqueue" },
{ channel: "system", text: "attempt 1/3 mode=initial model=gpt-5.4-mini\n", method: "queue" },
],
events: [{ at: nowIso(), method: "thread/status/changed", status: "inProgress" }],
},
{
id: "user_interrupted",
prompt: "Run a long shell command, then produce a report.",
finalResponse: "",
expected: "fail",
terminalStatus: "interrupted",
cancelRequested: true,
outputs: [
{ channel: "user", text: "Run a long shell command, then produce a report.\n", method: "enqueue" },
{ channel: "system", text: "interrupt requested\n", method: "turn/interrupt" },
{ channel: "error", text: "turn completed status=interrupted\n", method: "turn/completed" },
],
events: [{ at: nowIso(), method: "turn/completed", status: "interrupted" }],
},
];
src/components/microservices/code-queue/src/judge.ts
+715
View File
@@ -0,0 +1,715 @@
// 重构前 index.ts 只读参考：commit 6a04144d3f5103014f75b637d7e6bc2f45bf007f，blob 56e590c1a6b5ca7ad128bf2c992f60e46c355a58；可用 `git show 6a04144d3f5103014f75b637d7e6bc2f45bf007f:src/components/microservices/code-queue/src/index.ts` 查看。
import type {
CodexRunResult,
FeedbackPromptRecord,
JudgeDecision,
JudgeProbeCase,
JudgeResult,
JsonValue,
LiveOutput,
MiniMaxJudgeResponse,
ParsedJudgeJson,
QueueTask,
} from "./types";
export interface JudgeRuntimeContext {
config: {
minimaxApiKey: string;
minimaxApiBase: string;
minimaxModel: string;
judgeTimeoutMs: number;
judgeRepairAttempts: number;
judgeMaxTokens: number;
};
logger: (level: "debug" | "info" | "warn" | "error", message: string, data?: JsonValue) => void;
safePreview: (value: string, max?: number) => string;
userPromptForDisplay: (prompt: string) => string;
taskFullOutput: (task: QueueTask) => LiveOutput[];
taskReferenceIds: (task: QueueTask) => string[];
extractRecord: (value: unknown) => Record<string, unknown> | null;
extractString: (value: unknown, key: string) => string | null;
promptLineCount: (text: string) => number;
judgeFailRetryLimit: number;
}
let context: JudgeRuntimeContext | null = null;
export function configureJudge(runtimeContext: JudgeRuntimeContext): void {
context = runtimeContext;
}
function ctx(): JudgeRuntimeContext {
if (context === null) throw new Error("judge module is not configured");
return context;
}
function config(): JudgeRuntimeContext["config"] {
return ctx().config;
}
function logger(level: "debug" | "info" | "warn" | "error", message: string, data?: JsonValue): void {
ctx().logger(level, message, data);
}
function safePreview(value: string, max?: number): string {
return ctx().safePreview(value, max);
}
function userPromptForDisplay(prompt: string): string {
return ctx().userPromptForDisplay(prompt);
}
function taskFullOutput(task: QueueTask): LiveOutput[] {
return ctx().taskFullOutput(task);
}
function taskReferenceIds(task: QueueTask): string[] {
return ctx().taskReferenceIds(task);
}
function extractRecord(value: unknown): Record<string, unknown> | null {
return ctx().extractRecord(value);
}
function extractString(value: unknown, key: string): string | null {
return ctx().extractString(value, key);
}
function promptLineCount(text: string): number {
return ctx().promptLineCount(text);
}
function fallbackJudge(result: CodexRunResult, minimaxError?: string): JudgeResult {
if (result.transportClosedBeforeTerminal || result.terminalStatus === null) {
return { decision: "retry", confidence: 0.75, reason: "Codex app-server 在 turn/completed 之前关闭。", continuePrompt: retryInstruction, source: "fallback" };
}
if (result.terminalStatus === "failed") {
return { decision: "retry", confidence: 0.7, reason: result.terminalError ? `Codex turn 失败：${result.terminalError}` : "Codex turn 失败。", continuePrompt: retryInstruction, source: "fallback" };
}
if (result.terminalStatus === "interrupted") {
return { decision: "fail", confidence: 0.8, reason: "Codex turn 被用户请求打断。", source: "fallback" };
}
if (result.finalResponse.trim().length === 0) {
return { decision: "retry", confidence: 0.78, reason: "Codex turn 没有返回最终 assistant response，不能视为任务已完成。", continuePrompt: retryInstruction, source: "fallback" };
}
if (minimaxError !== undefined) {
return {
decision: "retry",
confidence: 0.65,
reason: `MiniMax judge 失败（${safePreview(minimaxError, 240)}）；安全 fallback 将继续现有 session，而不是把 turn/completed 当作任务已完成。`,
source: "fallback",
};
}
return { decision: "complete", confidence: 0.65, reason: "Codex 输出了 completed 状态的 turn/completed，且未配置 MiniMax judge。", source: "fallback" };
}
export const retryInstruction = "这是同一个 Codex thread 的 continuation，不是新任务。请基于上文继续完成原始任务；只做最小必要状态核查，避免从头重新摸索、避免重复已经完成的修改。";
const codeQueueRestartSafetyGuidance = "Code Queue 服务具备 restart-recovery，允许在任何时候重启、重建或替换 `code-queue-backend`；当当前任务修改 Code Queue 自身时，禁止等待当前 Code Queue task 退出或等待队列归零后再重启，因为这会等待自己退出形成自锁。正确做法是直接触发 `server rebuild code-queue` 或等价 no-deps force-recreate，并在恢复后用 live health/task 查询验证。";
export function explicitUserInterrupt(task: QueueTask, result: CodexRunResult): boolean {
return result.terminalStatus === "interrupted"
&& (task.cancelRequested || task.output.some((item) => item.method === "turn/interrupt" || item.text.includes("interrupt requested")));
}
function currentAttemptOutputForJudge(task: QueueTask): LiveOutput[] {
const latestAttempt = task.attempts.at(-1);
const startSeq = Number(latestAttempt?.outputStartSeq ?? NaN);
const endSeq = Number(latestAttempt?.outputEndSeq ?? NaN);
const output = taskFullOutput(task);
if (Number.isFinite(startSeq)) {
return output.filter((item) => item.seq >= startSeq && (!Number.isFinite(endSeq) || item.seq <= endSeq));
}
return task.output.slice(-80);
}
function judgeEvidenceText(task: QueueTask, result: CodexRunResult): string {
const currentOutput = currentAttemptOutputForJudge(task);
return [
result.terminalError ?? "",
result.appServerExit.stderrTail,
...currentOutput.slice(-120)
.filter((item) => item.channel === "error" || item.method === "turn/completed" || item.method === "app-server" || item.method?.includes("watchdog") === true)
.map((item) => item.text),
...result.events.slice(-80).map((event) => [event.method, event.status, event.message, event.textPreview].filter(Boolean).join(" ")),
].join("\n");
}
function hasServiceLimitOrTransportError(text: string): boolean {
return /(429|Too Many Requests|rate limit|quota exceeded|overloaded|exceeded retry limit|stream disconnected|no activity timeout|app-server closed|ECONNRESET|ETIMEDOUT)/iu.test(text);
}
function judgePrompt(task: QueueTask, result: CodexRunResult): string {
const latestAttempt = task.attempts[task.attempts.length - 1] ?? null;
const originalUserTask = task.basePrompt || userPromptForDisplay(task.prompt);
const resolvedPromptForCodex = task.prompt === originalUserTask ? null : safePreview(task.prompt, 12000);
const currentAttemptOutput = currentAttemptOutputForJudge(task);
// Keep this record factual. Do not add local completion gates here; MiniMax
// is authoritative whenever it returns a valid judge JSON.
return JSON.stringify({
instruction: "请判定一个 Codex 编码任务是否真正完成、是否应通过向现有 Codex thread 追加 continuation prompt 继续重试，或是否应作为不可重试失败处理。只能返回 JSON，不要输出 Markdown fence、解释性正文或注释。所有自然语言字段必须使用中文，尤其是 reason 和 continuePrompt。重要：普通的 Codex turn/completed 状态只表示传输/session 终止事件，不等于用户任务已完成。决策前必须检查当前尝试的 transcript、最终回复、命令/文件变更事件、stderr 和原始任务。请严格判定：如果用户任务中的任一显式验收项缺少已完成证据，就选择 retry。最常见错误是把未完成或跑偏的工作标成 fail；未完成工作必须选择 retry，让同一个 session 继续。不要把更早 attempt 的限流/中断证据自动当作当前 attempt 的完成门禁；如果当前最新 attempt 已经提供完整完成证据，可以判定 complete。",
schema: { decision: "complete|retry|fail", confidence: "0..1", reason: "中文短句", continuePrompt: "decision=retry 时必填，除非确实没有可用的继续提示；内容必须是中文，保持简洁，不要粘贴原始任务、引用上下文、transcript 或 JSON" },
originalTask: originalUserTask,
resolvedPromptForCodex,
attempt: task.currentAttempt,
maxAttempts: task.maxAttempts,
executionRecord: {
terminalStatus: result.terminalStatus,
terminalError: result.terminalError,
transportClosedBeforeTerminal: result.transportClosedBeforeTerminal,
appServerExitCode: result.appServerExit.code,
appServerSignal: result.appServerExit.signal,
stderrTail: safePreview(result.appServerExit.stderrTail, 2000),
finalResponse: safePreview(result.finalResponse, 6000),
finalResponseChars: result.finalResponse.length,
finalResponseMissing: result.finalResponse.trim().length === 0,
latestAttempt,
judgeFailCount: task.judgeFailCount,
judgeFailRetryLimit: ctx().judgeFailRetryLimit,
cancelRequested: task.cancelRequested,
currentAttemptOutput: currentAttemptOutput.slice(-80).map((item) => ({ channel: item.channel, text: safePreview(item.text, 500), method: item.method })),
currentAttemptEvents: result.events.slice(-60),
},
policy: {
complete: "仅当 transcript/最终回复证明当前任务确实完成，并且每个显式验收项都有证据时使用；队列 worker 随后会推进到下一个 queued 任务。",
retry: "当当前任务未完成、Codex 只做了计划、跳过了请求的编辑/命令、只完成了部分工作、在 steer prompt 后跑偏到旁支任务、需要再跑一轮，或遇到临时网络/server/disconnected/transport/internal 错误时使用。只要存在 thread id，retry 必须恢复现有 thread 并追加 continuePrompt。",
fail: "仅用于明确的用户打断/取消、缺少 agent 无法补充的凭据/权限/用户输入，或已证实的确定性不可重试外部阻塞。不要仅因为 agent 漏掉核心目标、产出错误/部分工作、或未运行必要验证就使用 fail；这些都应选择 retry。",
codeQueueSelfRestart: codeQueueRestartSafetyGuidance,
},
retryContinuePromptRules: [
"当 decision=retry 时，continuePrompt 是给同一个 Codex thread 的反馈；只能基于 originalTask 中已存在的要求和 executionRecord 中已证实的缺口，不得新增 originalTask 没有要求的 API 形态、参数签名、实现细节、文件路径或命令细节。",
"continuePrompt 只写“未完成哪些原始需求，继续按照原始需求补齐剩余任务”和必要验收证据，通常不超过 1200 字；不要复制 originalTask、resolvedPromptForCodex、recentOutput、引用任务全文或完整 transcript。",
"如果 retry 原因是 429/Too Many Requests/exceeded retry limit、transport/app-server 中断、finalResponse 为空，或 executionRecord 还没有足够证据确认具体未完成细节，continuePrompt 必须保持高层反馈：`未完成xxx原始需求，继续按照原始需求完成剩余任务`；不要推测下一步代码写法。",
"如果缺口很多，必须在生成 continuePrompt 的源头去重、合并和分组；不要依赖接收方对已生成长文本做末端截断，因为截断会丢失验收信息。",
"列出缺失的验收证据，并要求下一轮在最终回复中给出真实命令/API/UI 结果。",
"如果 agent 在交付中途停下来询问用户如何处理一个它本不需要触碰的并发修改文件，continuePrompt 必须要求它忽略该并发文件并继续交付自己的变更范围，而不是让用户选择。",
"对于未部署/未上线的服务或 WebUI 工作，continuePrompt 必须明确要求重建/重启所有受影响的 service/container/bundle，并在部署后验证运行中的真实行为。",
"如果受影响服务包含 Code Queue 和 frontend，部署反馈应点名 `bun scripts/cli.ts server rebuild code-queue`、`bun scripts/cli.ts server rebuild frontend`，并按场景要求 live API/WebUI 验证，例如 `/api/judge/probe`、`/trace-summary` 或已服务的 Code Queue 页面。",
"如果受影响服务包含 Code Queue 自身，continuePrompt 禁止要求等待当前 task 结束、等待 queue idle 或等待 `0 running` 后再重启；这会形成自锁。应明确 Code Queue 可以立即重启/重建，并依赖 restart-recovery 恢复本任务后继续验证。",
],
hallucinationNoiseGuardrails: [
"judge 只能判断完成/未完成和指出原始需求缺口，不能充当实现规划器；不要在 feedback 中发明“下一步必须这样改”的新要求。",
"如果 originalTask 只要求分析初始化/配置并在既有打印条件下新增滤波前/后打印，continuePrompt 不得额外要求把现有 API 改成无参数调用，也不得指定函数签名从 out-parameter 改成 return value。",
"若缺口是“原始任务尚未完成”，feedback 采用高层模板：未完成<原始需求摘要>，继续按照原始需求完成剩余任务，并在最终回复给出证据。",
],
completionEvidenceGuidance: [
"如果 finalResponse 表示“我没有重建运行中的容器”“后续如需上线”“若要上线验证”“未上线”“not deployed”“not rebuilt”或等价含义，并且任务触碰了 runtime/UI/service 代码，则禁止 decision=complete。",
"如果 transcript 只证明源码编辑、检查或构建，但没有针对 runtime/UI/service 变更的部署后 live API/browser 验证，即使最终回复说实现已完成，也要选择 retry。",
"把 rebuild/deploy 描述为可选、建议、未来工作或下一步，本身就是用户可见/runtime 任务尚未完成的证据。",
"判断 429、Too Many Requests、exceeded retry limit、stream disconnected 等限流/传输证据时，只把当前最新 attempt 的证据作为当前判定依据；更早 attempt 的失败不能自动否定后续正常完成的 attempt。",
"如果当前 attempt 的 terminalStatus 是 failed/null/interrupted，transportClosedBeforeTerminal 为 true，或当前 attempt 以 Codex/API 基础设施错误结束，则禁止 complete；除非这是应判为 fail 的明确用户打断。service/rate-limit/transport/internal 失败应选择 retry。",
"如果当前 attempt 的 stderr、terminalError、currentAttemptOutput 或 currentAttemptEvents 包含 429、Too Many Requests、rate limit、quota、overloaded、exceeded retry limit、stream disconnected、no activity timeout 或 app-server closed，即使错误前发生过代码编辑或重建，也要选择 retry。",
"如果 terminalStatus=failed 且 finalResponse 为空，必须选择 retry；即使中途已有容器 healthy、API 200、目录列表、文件改动或文档更新证据，也不能把没有最终回复的失败 turn 判为 complete。",
"如果原始任务要求运行、通过、复现、比较、打分、benchmark、validate 或证明经验结果，complete 必须有 transcript 证据显示请求的命令/pipeline/scorer 已运行，并给出结果数字或状态。",
"如果任务要求 A/B、ablation、with/without、before/after、skill/no-skill、baseline/optimized 或正/负样本比较，complete 必须为每个请求侧都提供证据；只实现一侧代码或测试属于未完成。",
"如果最终回复说必需的 benchmark/pipeline 未运行、为节省 quota/time 跳过、应作为下一步运行，或仅根据代码检查预期会通过，即使单元测试通过，也要选择 retry。",
"不要接受用 unit/type/component 测试替代明确请求的 benchmark 分数或 pipeline 运行的自我辩解。",
"对于 frontend 或 WebUI 可见变更，源码编辑和 type check 不够。complete 需要证明已重建/重启或刷新已服务的 frontend bundle；当用户可见行为是验收目标时，还要有针对运行中 UniDesk frontend 的 browser/E2E/UI 验证。",
"如果 frontend/UI 任务的最终回复说 public/full E2E 未运行，或 transcript 缺少 frontend rebuild/server rebuild 加 served-UI 验证，而请求变更可能在已部署 UI bundle 中不可见，则选择 retry。",
"对于 Code Queue、backend-core、provider-gateway、frontend 或任何其他 UniDesk service/runtime 行为变更，源码编辑、TypeScript 检查和本地构建不够。complete 需要证明每个受影响的运行中 service/container/bundle 已重建或重启，并且部署后的 live API/UI 行为已验证。",
"对于 Code Queue 自身的 runtime 行为变更，不得把“等待当前 Code Queue task 结束/等待自己退出后再重启”当作完成计划或阻塞理由；这是自锁。应选择 retry，反馈要求直接重启/重建 Code Queue 并在 restart-recovery 后验证 live health/task 证据。",
"如果用户要求功能在 WebUI 可见或“上线/生效/提供展示”，不要把 rebuild/restart/deploy 当成建议。若没有运行中服务或已服务浏览器 UI 的证据，选择 retry，并要求部署加验证。",
"如果最终回复说它停下来要求用户确认如何处理一个 unexpected/concurrently modified 文件，而该文件不在 agent 必要交付范围内，则选择 retry：任务尚未自主交付完成。",
"对于提到 4/4、8/8、40/40 或 skill/no-skill 行为等分数的 PikaPython/PikaBench 任务，在 complete 前必须有实际 scorer 或 pipeline 运行证据，证明请求分数和比较结果。",
"对于 hardware、firmware、provider、WSL、SSH passthrough、skill、compile、flash/download、serial 或 board-comm 任务，complete 需要请求的操作步骤证据；如果请求了 download/board/serial 验证但没有证据，只有部分文档或一次成功 build 应选择 retry。",
"如果最终回复主要处理后来的 steer prompt，而原始任务仍有部分未完成，应选择 retry，并给出同时协调 steer 与原始任务的 continuation prompt。",
],
classicFailureExamples: [
{
pattern: "原始任务要求：没有通用 PikaPython benchmark skill 时不能达到 4/4；有该 skill 时必须达到 4/4。",
incompleteEvidence: "执行代理只是把定向 prompt 内容移入 skill，运行了 type/component/unit 测试，并表示为节省 quota 没有启动 PikaBench-4 baseline/no-skill 实跑。",
requiredDecision: "retry",
reason: "请求的 with-skill/no-skill 经验 pipeline 对照没有运行，因此声明的验收条件没有被证明。",
},
{
pattern: "原始任务要求学习 D601 ConStart/constar 固件工作区、使用 skill 完成 compile/download 等，并更新长期文档；后续 steer 要求把项目文档移动到 constar/docs。",
incompleteEvidence: "执行代理做了一些 skill discovery 和文档迁移，但最终回复主要围绕 steer 驱动的文档迁移，未证明所有请求的 compile/download/serial/board-comm 操作验收点已完成。",
requiredDecision: "retry",
reason: "这是原始任务未完成，不是不可重试失败；应继续同一个 session，补齐缺失的操作验证和文档。",
},
{
pattern: "原始任务要求停止 ClaudeQQ 登录二维码自动刷新。代码已编辑且 frontend rebuild 成功，但 Codex turn 后来在 E2E 或依赖验证仍在运行时因 429 Too Many Requests / exceeded retry limit 失败结束。",
incompleteEvidence: "终止 turn 状态是 failed，最终回复为空或缺少完整总结，且验证因服务限流没有完成。",
requiredDecision: "retry",
reason: "rate-limit 或 retry-limit 终止属于基础设施中断，不能算完成，必须继续现有 session。",
},
{
pattern: "原始任务要求基于 filebrowser 开发/部署文件管理器，支持 main server host、provider host 和 WSL Windows /mnt/c 文件浏览，例如 task codex_1778545138372_ec5e05。",
incompleteEvidence: "中途命令显示 main-server/D601/D518 filebrowser 容器健康、WebUI/API/Windows 路径一度可读，但最后出现 `exceeded retry limit, last status: 429 Too Many Requests`、turn completed status=failed，且 finalResponse 为空。",
requiredDecision: "retry",
reason: "当前 attempt 的限流失败和空 finalResponse 是未完成证据；不能用中途运行证据替代失败 turn 的最终交付。必须继续同一 thread 生成最终总结并补齐/复核验证。",
},
{
pattern: "原始任务要求把 UniDesk sidebar/WebUI 标签从“微服务”改为“用户服务”，并更新长期文档。",
incompleteEvidence: "执行代理编辑了 frontend 源码、文档和 E2E selector，并运行 `bun scripts/cli.ts check`，但没有重建/重启 frontend bundle，也没有验证运行中的 served UI；最终回复还说 full public E2E 未运行。用户后来观察到 UI 变更实际上未生效。",
requiredDecision: "retry",
reason: "WebUI 可见变更只有在 deployed/served frontend 已重建或刷新并验证后才算完成；源码编辑加 type check 可能让 live UI 保持不变。",
},
{
pattern: "原始任务要求移除 Code Queue 前端的 `Prompt 全量` card，因为 TraceView 已可展开它，例如 task codex_1778483956252_c65680。",
incompleteEvidence: "执行代理编辑 frontend 并运行检查，但最终回复停下来要求用户选择如何处理 `src/components/microservices/code-queue/src/index.ts`；它自己说没有修改该文件，并给出忽略该文件、只交付 frontend 变更的选项。",
requiredDecision: "retry",
requiredContinuePrompt: "这是其他任务正在并发开发，忽略这个文件，只继续交付我已改的前端相关变更。",
reason: "agent 尚未自主完成交付；即使安全下一步是忽略无关并发文件并完成自己的 frontend 范围，它仍暂停要求用户确认。",
},
{
pattern: "原始任务要求 Code Queue 在 trace 链路和 WebUI 中暴露 judge feedback prompt，例如 task codex_1778476426776_a2bf19。",
incompleteEvidence: "执行代理编辑 backend/frontend 源码并通过 type check，但没有 `server rebuild code-queue`，没有 `server rebuild frontend` 或等价 served bundle 部署，也没有 live API/UI 验证证明 `/trace-summary` 或 WebUI 包含 judge feedback prompt。最终回复说“我没有重建运行中的容器”，或把 rebuild/deploy 当作建议/未来工作。",
requiredDecision: "retry",
requiredContinuePrompt: "请让同一个 Codex thread 部署已修改的 Code Queue/frontend 服务，然后在声明完成前验证 live API/UI 证据。",
reason: "这是 service/UI 功能。只有运行中的 Code Queue backend 和 served frontend 已更新并验证后才算完成；否则用户仍看不到该功能。",
},
{
pattern: "原始任务要求修改或验证 Code Queue 自身，并且完成条件需要重启/重建 `code-queue-backend`。",
incompleteEvidence: "执行代理表示要等当前 Code Queue task 结束、等队列空闲、等 0 running、或等自己退出后再重启 Code Queue，因此没有执行重启/重建和恢复后 live 验证。",
requiredDecision: "retry",
requiredContinuePrompt: "不要等待当前 Code Queue task 退出；Code Queue 可随时重启/重建。请直接执行 `server rebuild code-queue` 或等价 no-deps force-recreate，依赖 restart-recovery 恢复本任务，然后验证 live health/task 证据。",
reason: "等待当前任务结束后再重启 Code Queue 会让任务等待自己退出，属于自锁；正确交付路径是先重启/重建再由 restart-recovery 继续。",
},
],
});
}
function parseRecordJson(text: string, source: string): ParsedJudgeJson {
const parsed = JSON.parse(text) as unknown;
if (typeof parsed === "string") return parseJudgeJson(parsed);
if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new Error(`${source} parsed to non-object JSON`);
return { value: parsed as Record<string, unknown>, source };
}
function balancedJsonCandidates(text: string): string[] {
const candidates: string[] = [];
for (let start = 0; start < text.length; start += 1) {
if (text[start] !== "{") continue;
let depth = 0;
let inString = false;
let escaped = false;
for (let index = start; index < text.length; index += 1) {
const char = text[index] ?? "";
if (inString) {
if (escaped) {
escaped = false;
} else if (char === "\\") {
escaped = true;
} else if (char === "\"") {
inString = false;
}
continue;
}
if (char === "\"") {
inString = true;
} else if (char === "{") {
depth += 1;
} else if (char === "}") {
depth -= 1;
if (depth === 0) {
candidates.push(text.slice(start, index + 1));
break;
}
}
}
}
return candidates;
}
function judgeJsonCandidates(text: string): Array<{ source: string; text: string }> {
const normalized = text.replace(/^\uFEFF/u, "").trim();
const candidates: Array<{ source: string; text: string }> = [];
const pushText = (source: string, value: string): void => {
const trimmed = value.trim();
if (trimmed.length > 0) candidates.push({ source, text: trimmed });
};
const pushDerivedCandidates = (sourcePrefix: string, value: string): void => {
const trimmed = value.trim();
if (trimmed.length === 0) return;
pushText(sourcePrefix, trimmed);
const fenced = /```[ \t]*(?:json|JSON|javascript|js)?[^\n\r]*[\r\n]+([\s\S]*?)```/gu;
for (const match of trimmed.matchAll(fenced)) {
const body = typeof match[1] === "string" ? match[1].trim() : "";
if (body.length > 0) pushText(`${sourcePrefix}_fenced`, body);
}
const strippedFence = trimmed
.replace(/^```[^\n\r]*[\r\n]?/u, "")
.replace(/```$/u, "")
.trim();
if (strippedFence !== trimmed) pushText(`${sourcePrefix}_stripped_fence`, strippedFence);
const strippedLabel = trimmed.replace(/^(?:json|JSON)\s*[:\n\r]\s*/u, "").trim();
if (strippedLabel !== trimmed) pushText(`${sourcePrefix}_stripped_label`, strippedLabel);
const jsonTag = trimmed.match(/<json\b[^>]*>([\s\S]*?)<\/json>/iu);
if (typeof jsonTag?.[1] === "string") pushText(`${sourcePrefix}_json_tag`, jsonTag[1]);
for (const candidate of balancedJsonCandidates(trimmed)) pushText(`${sourcePrefix}_balanced_object`, candidate);
};
pushDerivedCandidates("direct", normalized);
const withoutClosedThink = normalized.replace(/<(?:think|thinking)\b[^>]*>[\s\S]*?<\/(?:think|thinking)>/giu, "").trim();
if (withoutClosedThink !== normalized) pushDerivedCandidates("stripped_think", withoutClosedThink);
const closeThinkMatches = Array.from(normalized.matchAll(/<\/(?:think|thinking)>/giu));
const lastThinkClose = closeThinkMatches.at(-1);
if (lastThinkClose?.index !== undefined) {
const afterThink = normalized.slice(lastThinkClose.index + lastThinkClose[0].length).trim();
if (afterThink.length > 0) pushDerivedCandidates("after_think", afterThink);
}
const seen = new Set<string>();
return candidates.filter((candidate) => {
const key = candidate.text;
if (key.length === 0 || seen.has(key)) return false;
seen.add(key);
return true;
});
}
export function parseJudgeJson(text: string): ParsedJudgeJson {
let lastError = "no candidate JSON was found";
for (const candidate of judgeJsonCandidates(text)) {
try {
const parsed = parseRecordJson(candidate.text, candidate.source);
if (validJudgeDecisionValue(parsed.value.decision)) return parsed;
lastError = `${candidate.source} parsed JSON does not contain a valid decision`;
} catch (error) {
lastError = error instanceof Error ? error.message : String(error);
}
}
throw new Error(`MiniMax judge did not return parseable JSON after denoise: ${lastError}; preview=${safePreview(text, 500)}`);
}
function normalizedDecision(value: unknown): JudgeDecision {
if (value === "complete" || value === "retry" || value === "fail") return value;
if (value === "continue") return "retry";
return "retry";
}
function validJudgeDecisionValue(value: unknown): boolean {
return value === "complete" || value === "retry" || value === "fail" || value === "continue";
}
const retryTaskSummaryMaxChars = 1200;
const judgeReasonPromptMaxChars = 1200;
export const compactContinuationPromptTargetChars = 1200;
export const continuePromptSourceBudgetChars = 4000;
export function judgeReasonForPrompt(reason: string): string {
return safePreview(reason, judgeReasonPromptMaxChars) || "(empty)";
}
function continuationPromptForRetry(prompt: string): string {
return prompt.trim();
}
export function compactRetryTaskContext(task: QueueTask): string {
const basePrompt = task.basePrompt || userPromptForDisplay(task.prompt);
const referenceTaskIds = taskReferenceIds(task);
return [
"原始任务摘要（同一 thread 已有完整上文，不重新注入引用全文）：",
safePreview(basePrompt, retryTaskSummaryMaxChars) || "(empty)",
referenceTaskIds.length > 0 ? `引用任务 ID：${referenceTaskIds.join(", ")}` : "",
`按需查询有界摘要：bun scripts/cli.ts codex task ${task.id}`,
].filter((line) => line.length > 0).join("\n");
}
export function queueRecoveryRetryPrompt(task: QueueTask, reason: string): string {
return [
retryInstruction,
"Code Queue 服务在任务运行中重启/停止；这是自动恢复提示，不是新任务，也不需要重新粘贴原始任务或引用全文。",
"如果本轮任务正是修改 Code Queue 自身，不要等待当前 task 退出；服务重启已经发生，继续完成恢复后的验证和剩余交付。",
`恢复原因：${judgeReasonForPrompt(reason)}`,
"请基于当前 thread 上文继续，只做最小必要状态核查，恢复未完成的等待、验证、部署或命令；最终 response 必须给出真实结果证据。",
"原始任务摘要/按需查询：",
compactRetryTaskContext(task),
].join("\n\n");
}
export function retryPrompt(task: QueueTask, judge: JudgeResult): string {
if (judge.continuePrompt !== undefined && judge.continuePrompt.trim().length > 0) return continuationPromptForRetry(judge.continuePrompt);
return [
retryInstruction,
"上一次 judge 判定为 retry，下面是必须传递给本轮 continuation 的 judge feedback。请优先补齐这些缺口，不要只做泛泛的状态核查。",
`judge 来源：${judge.source}`,
`judge 置信度：${judge.confidence.toFixed(2)}`,
`judge 未完成原因：${judgeReasonForPrompt(judge.reason)}`,
"请在本轮最终 response 中明确说明已如何解决上述 judge feedback；如果 judge 要求 benchmark/上线/运行中验证，就必须提供对应真实命令和结果证据。",
"原始任务摘要/按需查询：",
compactRetryTaskContext(task),
].join("\n\n");
}
export function judgeFailContinuationPrompt(task: QueueTask, judge: JudgeResult, failCount: number): string {
const limit = ctx().judgeFailRetryLimit;
const parts = [
`上一次 judge 判定为 fail (${failCount}/${limit})，但 Code Queue 策略要求：非用户取消、非确定不可恢复的情况必须当作“未完成”继续当前 session，直到 fail 累计 ${limit} 次才真正放弃。`,
"这是同一个 Codex thread 的 continuation，不是新任务；不要重新开局或从头摸索，只补齐缺失验收项。",
`judge 理由：${judgeReasonForPrompt(judge.reason)}`,
"请不要放弃或新开任务。继续完成原始任务中尚未完成/未验证的验收项，优先补齐 judge 指出的缺口，并给出真实命令、文件或运行结果证据。",
];
if (judge.continuePrompt !== undefined && judge.continuePrompt.trim().length > 0) {
parts.push("judge 建议的继续提示：", continuationPromptForRetry(judge.continuePrompt));
}
parts.push("原始任务摘要/按需查询：", compactRetryTaskContext(task));
return parts.join("\n\n");
}
export function parsedContinuePromptForJudge(parsed: Record<string, unknown>, decision: JudgeDecision): string | undefined {
const prompt = typeof parsed.continuePrompt === "string" ? parsed.continuePrompt.trim() : "";
if (prompt.length === 0 || decision === "complete") return undefined;
if (prompt.length > continuePromptSourceBudgetChars) {
throw new Error(`MiniMax judge continuePrompt exceeds source budget (${prompt.length}/${continuePromptSourceBudgetChars} chars); resynthesize compact feedback at the source instead of tail-truncating`);
}
return prompt;
}
const judgeSystemPrompt = [
"你是严格的任务状态分类器。",
"你没有工具访问，不能执行命令、读取文件或续写编码 agent 行为；只能根据 user 消息里的 JSON evidence 判定。",
"只能返回一个紧凑原始 JSON object。禁止输出 Markdown fence、<think>、思考过程、解释性正文或注释。",
"所有自然语言字段必须使用中文，尤其是 reason 和 continuePrompt。",
].join("");
const judgeResponseSchema = {
decision: "complete|retry|fail",
confidence: "0..1",
reason: "中文短句",
continuePrompt: `decision=retry 时必填，除非确实没有可用的继续提示；内容必须是中文，目标不超过 ${compactContinuationPromptTargetChars} 字，绝对不超过 ${continuePromptSourceBudgetChars} 字`,
};
export interface JudgeRepairContext {
error: string;
previousAnswerRaw: string;
}
function judgeRepairInstruction(error: string): string {
if (/continuePrompt exceeds source budget/iu.test(error)) {
return [
"你上一条 judge 回答的 continuePrompt 过长，不能作为 continuation prompt 使用。",
"请基于原始 judge 输入、executionRecord 和上一条回答重新合成紧凑反馈；这是源头重写，不是截取前 N 字。",
`continuePrompt 目标不超过 ${compactContinuationPromptTargetChars} 字，绝对不超过 ${continuePromptSourceBudgetChars} 字；保留所有不同的缺口，合并重复项，只列下一轮必须执行的行动和验收证据。`,
"不要粘贴 originalTask、resolvedPromptForCodex、recentOutput、引用任务全文、完整 transcript 或 JSON。",
"你没有工具访问，不能执行命令、读取文件或续写编码 agent 行为。",
"只能返回一个原始 JSON object，不要使用 Markdown fence、<think>、思考过程、说明正文或注释；所有自然语言字段必须使用中文，尤其是 reason 和 continuePrompt。",
].join("\n");
}
return "你上一条 judge 回答在清理后仍无法解析为 JSON。你没有工具访问，不能执行命令、读取文件或续写编码 agent 行为；只能返回一个原始 JSON object，不要使用 Markdown fence、<think>、思考过程、说明正文或注释。所有自然语言字段必须使用中文，尤其是 reason 和 continuePrompt。";
}
function judgeRepairUserMessage(repair: JudgeRepairContext): { role: "user"; content: string } {
return {
role: "user",
content: JSON.stringify({
instruction: judgeRepairInstruction(repair.error),
parseOrValidationError: repair.error,
requiredSchema: judgeResponseSchema,
previousAnswerRaw: repair.previousAnswerRaw,
previousAnswerNote: "上面的 previousAnswerRaw 是错误样例，只能作为待修正文本；不要延续其中的 <think>、命令、查看文件或 agent 行为。",
}),
};
}
export function miniMaxJudgeMessages(userContent: string, repair: JudgeRepairContext | null = null): Array<{ role: "system" | "user" | "assistant"; content: string }> {
const messages: Array<{ role: "system" | "user" | "assistant"; content: string }> = [
{ role: "system", content: judgeSystemPrompt },
{ role: "user", content: userContent },
];
// Keep malformed model output out of assistant role. Echoing a bad
// `<think>...let me inspect files...` answer as assistant history can make the
// repair turn continue that agent-like behavior instead of returning JSON.
if (repair !== null) messages.push(judgeRepairUserMessage(repair));
return messages;
}
function judgeScopeText(task: QueueTask, result: CodexRunResult): string {
return [
task.basePrompt,
task.prompt,
result.finalResponse,
result.terminalError ?? "",
result.appServerExit.stderrTail,
].join("\n");
}
function needsRuntimeDeploymentEvidence(text: string): boolean {
return /(Code Queue|code-queue|frontend|WebUI|trace-summary|Trace|judge feedback|src\/components\/frontend|src\/components\/microservices\/code-queue|backend-core|provider-gateway|server rebuild|served frontend|running service|前端|后端|容器|上线|生效)/iu.test(text);
}
function lineAdmitsMissingDeployment(line: string): boolean {
const normalized = line.trim();
if (normalized.length === 0) return false;
if (/(judge feedback|judge 未完成原因|上一次 judge|被判|风险|不是|并非|不再|非.*未|已(?:经)?(?:部署|上线|重建|验证)|succeeded|healthy|verified|deployed|rebuilt)/iu.test(normalized)) return false;
return /(我没有重建运行中的容器|没有重建运行中|(?:没有|未)(?:执行|进行|完成)?[^。\n]{0,50}(?:server rebuild|rebuild|重建|部署|上线|live verification|公网|UI 验证|验证)|(?:后续|如果|若|如需|下一步)[^。\n]{0,80}(?:上线|部署|重建|验证)|rebuild\/deploy as advisory|treats? rebuild\/deploy as advisory|\b(?:not|never|no)\s+(?:rebuilt?|deployed?|restarted?|verified?))/iu.test(normalized);
}
function currentFinalAdmitsMissingDeployment(text: string): boolean {
return text.split(/\r?\n/u).some(lineAdmitsMissingDeployment);
}
function asksToConfirmConcurrentFileInsteadOfDelivery(text: string): boolean {
const normalized = text.replace(/\s+/gu, " ");
const asksForConfirmation = /(请确认要我怎么处理|按安全规则[^。.!?]*先停下确认|需要先停下确认|please confirm (?:how|what|whether)|I need to stop[^.?!]*confirm)/iu.test(normalized);
const concurrentFileContext = /(我没有修改的文件[^。.!?]*(?:modified|变成了 modified)|没有编辑这个文件|unexpected[^.?!]*(?:modified|change)|concurrent[^.?!]*(?:file|task|work)|其他任务[^。.!?]*并发|并发开发|忽略这个文件，只继续交付|只继续交付我已改的[^。.!?]*变更)/iu.test(normalized);
return asksForConfirmation && concurrentFileContext;
}
function concurrentFileConfirmationFeedbackPrompt(task: QueueTask, reason: string): string {
return [
retryInstruction,
"上一次 judge 判定为 retry：上一轮没有自主完成交付，而是在中途把并发修改文件的问题抛给用户确认。",
`judge 未完成原因：${judgeReasonForPrompt(reason)}`,
"这是其他任务正在并发开发，忽略这个文件，只继续交付我已改的前端相关变更。",
"不要再要求用户选择 1/2/3，也不要检查、覆盖或回滚那个并发修改文件；只围绕自己已改的前端相关文件完成必要验证、总结交付，并在最终 response 中列出实际验证结果。",
"如果自己的前端改动需要构建、上线或运行中验证，按项目规则执行对应 rebuild/live verification 后再声明完成；如确有阻塞，请给出具体命令和错误。",
"原始任务摘要/按需查询：",
compactRetryTaskContext(task),
].join("\n\n");
}
function deploymentFeedbackPrompt(task: QueueTask, reason: string): string {
return [
retryInstruction,
"上一次 judge 判定为 retry：当前实现仍是未上线/未完成状态，不能只复述源码修改。",
`judge 未完成原因：${judgeReasonForPrompt(reason)}`,
"请先确认受影响范围；凡是 Code Queue、frontend、backend-core、provider-gateway 或其他运行服务/前端 bundle 的行为变化，都必须更新运行中的服务后再验收。",
"若受影响的是 Code Queue 自身，不要等待当前 Code Queue task 退出或等待队列空闲；可以立即重启/重建 `code-queue-backend`，由 restart-recovery 恢复本任务后继续验证。",
"如果本轮改动影响 Code Queue 和 frontend，请执行并记录真实结果：`bun scripts/cli.ts server rebuild code-queue`、`bun scripts/cli.ts server rebuild frontend`。",
"部署后必须做 live verification：至少用运行中的 API 或公网 WebUI 证明目标行为已经生效，例如 Code Queue `/api/judge/probe` 命中该样例、`/trace-summary` 返回 judge feedback prompt，或 served Code Queue 页面展示对应 feedback prompt。",
"最终 response 必须列出实际执行的部署命令和 live verification 结果；如果不能上线或验证，请说明阻塞并保持 retry 语义。",
"原始任务摘要/按需查询：",
compactRetryTaskContext(task),
].join("\n\n");
}
function rateLimitFeedbackNeedsOriginalRequirementOnly(task: QueueTask, result: CodexRunResult): boolean {
if (!hasServiceLimitOrTransportError(judgeEvidenceText(task, result))) return false;
const finalResponseMissing = result.finalResponse.trim().length === 0;
const terminalNotCompleted = result.terminalStatus === "failed" || result.terminalStatus === null || result.transportClosedBeforeTerminal;
if (!finalResponseMissing && !terminalNotCompleted) return false;
const scopeText = [task.basePrompt, task.prompt, result.finalResponse, ...task.output.slice(-40).map((item) => item.text)].join("\n");
return /period_sum\s*\/\s*mpu_read_num|滑动滤波前|滑动滤波后|71-Freq|71-FREQ|main\.c:282/iu.test(scopeText);
}
function originalRequirementOnlyFeedbackPrompt(task: QueueTask, reason: string): string {
const originalTask = safePreview(task.basePrompt || userPromptForDisplay(task.prompt), 260).replace(/\s+/gu, " ").trim();
void reason;
return `未完成原始需求：${originalTask || "原始任务尚未完成"}。继续按照原始需求完成剩余任务。`;
}
function applyFallbackSafetyOverrides(task: QueueTask, result: CodexRunResult, judge: JudgeResult): JudgeResult {
// Non-LLM string/regex overrides are a last-resort fallback only. Never call
// this on a successful MiniMax judge result; MiniMax is the authoritative judge.
if (judge.source !== "fallback") return judge;
const currentFinalText = result.finalResponse || "";
if (judge.decision === "retry" && rateLimitFeedbackNeedsOriginalRequirementOnly(task, result)) {
const reason = judge.reason || "任务因限流/传输中断，原始需求尚未完成。";
return {
...judge,
reason,
continuePrompt: originalRequirementOnlyFeedbackPrompt(task, reason),
raw: { previous: judge.raw ?? null, _safetyOverride: "original_requirement_only_feedback" },
};
}
if (asksToConfirmConcurrentFileInsteadOfDelivery(currentFinalText)) {
const reason = "最终回复停下来询问用户如何处理并发修改/无关文件，而不是自主完成自己的变更交付范围。";
return {
...judge,
decision: "retry",
confidence: Math.max(judge.confidence, 0.94),
reason,
continuePrompt: concurrentFileConfirmationFeedbackPrompt(task, reason),
raw: { previous: judge.raw ?? null, _safetyOverride: "mid_task_user_confirmation_concurrent_file" },
};
}
if (judge.decision !== "complete") return judge;
const scopeText = judgeScopeText(task, result);
if (!needsRuntimeDeploymentEvidence(scopeText) || !currentFinalAdmitsMissingDeployment(currentFinalText)) return judge;
const reason = "最终回复承认 runtime/UI/service 变更尚未部署到运行中服务或已服务 UI；只有源码编辑和检查还不完整。";
return {
...judge,
decision: "retry",
confidence: Math.max(judge.confidence, 0.92),
reason,
continuePrompt: deploymentFeedbackPrompt(task, reason),
raw: { previous: judge.raw ?? null, _safetyOverride: "missing_runtime_deployment" },
};
}
export async function judgeTask(task: QueueTask, result: CodexRunResult): Promise<JudgeResult> {
if (config().minimaxApiKey.length === 0) return applyFallbackSafetyOverrides(task, result, fallbackJudge(result));
const judgePromptContent = judgePrompt(task, result);
try {
let lastParseError: string | null = null;
let repairContext: JudgeRepairContext | null = null;
for (let repairAttempt = 0; repairAttempt <= config().judgeRepairAttempts; repairAttempt += 1) {
const messages = miniMaxJudgeMessages(judgePromptContent, repairContext);
const response = await requestMiniMaxJudge(messages);
const preDenoiseContent = response.content;
try {
const parsedResult = parseJudgeJson(preDenoiseContent);
const parsed = parsedResult.value;
if (parsedResult.source !== "direct") {
logger("info", "judge_json_denoised", { taskId: task.id, parseSource: parsedResult.source, repairAttempt });
}
const decision = normalizedDecision(parsed.decision);
const continuePrompt = parsedContinuePromptForJudge(parsed, decision);
const confidenceRaw = Number(parsed.confidence ?? 0.5);
const judge: JudgeResult = {
decision,
confidence: Number.isFinite(confidenceRaw) ? Math.max(0, Math.min(1, confidenceRaw)) : 0.5,
reason: typeof parsed.reason === "string" ? parsed.reason : "MiniMax judge returned a decision.",
continuePrompt,
source: "minimax",
raw: { ...(parsed as Record<string, JsonValue>), _parseSource: parsedResult.source, _repairAttempt: repairAttempt },
};
// No local hard-gate validation or safety override is applied to a
// successful MiniMax result. Fallback rules are only for MiniMax failure.
return judge;
} catch (error) {
lastParseError = error instanceof Error ? error.message : String(error);
if (repairAttempt >= config().judgeRepairAttempts) throw new Error(lastParseError);
logger("warn", "judge_json_parse_retry", {
taskId: task.id,
repairAttempt: repairAttempt + 1,
maxRepairAttempts: config().judgeRepairAttempts,
error: safePreview(lastParseError, 800),
preDenoiseResponsePreview: safePreview(preDenoiseContent, 1200),
});
repairContext = { error: lastParseError, previousAnswerRaw: preDenoiseContent };
}
}
throw new Error(lastParseError ?? "MiniMax judge exhausted JSON repair attempts");
} catch (error) {
const message = error instanceof Error ? error.message : String(error);
logger("warn", "judge_failed_fallback", { taskId: task.id, error: message });
return applyFallbackSafetyOverrides(task, result, fallbackJudge(result, message));
}
}
async function requestMiniMaxJudge(messages: Array<{ role: "system" | "user" | "assistant"; content: string }>): Promise<MiniMaxJudgeResponse> {
const controller = new AbortController();
const timer = setTimeout(() => controller.abort(), config().judgeTimeoutMs);
try {
const response = await fetch(`${config().minimaxApiBase}/chat/completions`, {
method: "POST",
headers: { authorization: `Bearer ${config().minimaxApiKey}`, "content-type": "application/json" },
body: JSON.stringify({
model: config().minimaxModel,
temperature: 0,
max_tokens: config().judgeMaxTokens,
messages,
}),
signal: controller.signal,
});
const rawText = await response.text();
if (!response.ok) throw new Error(`MiniMax HTTP ${response.status}: ${safePreview(rawText, 1000)}`);
let content = rawText;
try {
const payload = JSON.parse(rawText) as Record<string, unknown>;
const first = Array.isArray(payload.choices) ? extractRecord(payload.choices[0]) : null;
const message = extractRecord(first?.message);
content = extractString(message, "content")
?? extractString(payload, "content")
?? extractString(payload, "reply")
?? extractString(payload, "text")
?? (Object.prototype.hasOwnProperty.call(payload, "decision") ? JSON.stringify(payload) : rawText);
} catch {
content = rawText;
}
return { rawText, content };
} finally {
clearTimeout(timer);
}
}
src/components/microservices/code-queue/src/notifications.ts
+567
View File
@@ -0,0 +1,567 @@
// 重构前 index.ts 只读参考：commit 6a04144d3f5103014f75b637d7e6bc2f45bf007f，blob 56e590c1a6b5ca7ad128bf2c992f60e46c355a58；可用 `git show 6a04144d3f5103014f75b637d7e6bc2f45bf007f:src/components/microservices/code-queue/src/index.ts` 查看。
import postgres from "postgres";
import type { ClaudeQqNotificationItem, ClaudeQqNotificationOutboxState, ClaudeQqNotificationRow, JsonValue, QueueTask, RuntimeConfig } from "./types";
type SqlExecutor = postgres.Sql | postgres.TransactionSql;
export interface NotificationsContext {
config: Pick<RuntimeConfig,
"notifyClaudeQqBaseUrl" | "notifyClaudeQqEnabled" | "notifyClaudeQqGroupId" | "notifyClaudeQqMaxOutboxItems" | "notifyClaudeQqMaxResponseChars" | "notifyClaudeQqRetryIntervalMs" | "notifyClaudeQqSendAttempts" | "notifyClaudeQqTargetType" | "notifyClaudeQqTimeoutMs" | "notifyClaudeQqUserId"
>;
activeRunCount: () => number;
activeRunSlotCount: () => number;
activeRunTaskIds: () => string[];
errorToJson: (error: unknown) => JsonValue;
hasRunnableTask: () => boolean;
lastAssistantMessage: (task: QueueTask) => JsonValue;
loadAllTasksForRead: () => Promise<QueueTask[]>;
logger: (level: "debug" | "info" | "warn" | "error", message: string, data?: JsonValue) => void;
nonNegativeElapsed: (startMs: number | null, endMs: number | null) => number | null;
nowIso: () => string;
processingQueueCount: () => number;
queueCount: () => number;
queueIdOf: (task: QueueTask) => string;
safePreview: (value: string, max?: number) => string;
shutdownRequested: () => boolean;
sql: postgres.Sql;
taskTimestamp: (value: string | null) => string | null;
tasks: () => QueueTask[];
timestampMs: (value: string | null | undefined) => number | null;
databaseReady: () => boolean;
}
let context: NotificationsContext | null = null;
let claudeQqNotificationOutbox: ClaudeQqNotificationOutboxState = { version: 1, updatedAt: new Date().toISOString(), items: [] };
const sentTaskNotificationKeys = new Set<string>();
const inFlightTaskNotificationKeys = new Set<string>();
let idleNotificationSent = true;
let idleNotificationInFlight = false;
let claudeQqNotificationDrainTimer: ReturnType<typeof setTimeout> | null = null;
let claudeQqNotificationDrainInFlight = false;
export function configureNotifications(runtimeContext: NotificationsContext): void {
context = runtimeContext;
}
function ctx(): NotificationsContext {
if (context === null) throw new Error("notifications module is not configured");
return context;
}
function terminalTask(task: QueueTask): boolean {
return task.status === "succeeded" || task.status === "failed" || task.status === "canceled";
}
function durationMsBetween(startAt: string | null | undefined, endAt: string | null | undefined): number | null {
return ctx().nonNegativeElapsed(ctx().timestampMs(startAt), ctx().timestampMs(endAt));
}
function formatDurationMs(value: number | null): string {
if (value === null) return "-";
const totalSeconds = Math.max(0, Math.floor(value / 1000));
const days = Math.floor(totalSeconds / 86_400);
const hours = Math.floor((totalSeconds % 86_400) / 3600);
const minutes = Math.floor((totalSeconds % 3600) / 60);
const seconds = totalSeconds % 60;
const parts: string[] = [];
if (days > 0) parts.push(`${days}d`);
if (hours > 0 || parts.length > 0) parts.push(`${hours}h`);
if (minutes > 0 || parts.length > 0) parts.push(`${minutes}m`);
parts.push(`${seconds}s`);
return parts.join(" ");
}
function emptyClaudeQqNotificationOutbox(): ClaudeQqNotificationOutboxState {
return { version: 1, updatedAt: ctx().nowIso(), items: [] };
}
function notificationItemFromRow(row: ClaudeQqNotificationRow): ClaudeQqNotificationItem {
const createdAt = ctx().taskTimestamp(String(row.created_at)) ?? ctx().nowIso();
const updatedAt = ctx().taskTimestamp(String(row.updated_at)) ?? createdAt;
return {
id: row.id,
kind: row.kind || "unknown",
dedupKey: row.dedup_key || row.id,
target: row.target || "-",
message: row.message || "",
createdAt,
updatedAt,
attempts: Number.isInteger(row.attempts) && row.attempts >= 0 ? row.attempts : 0,
nextAttemptAt: ctx().taskTimestamp(String(row.next_attempt_at)) ?? updatedAt,
lastError: typeof row.last_error === "string" && row.last_error.length > 0 ? row.last_error : null,
sentAt: row.sent_at === null ? null : ctx().taskTimestamp(String(row.sent_at)),
};
}
async function loadClaudeQqNotificationOutboxFromDatabase(client: SqlExecutor = ctx().sql): Promise<void> {
const rows = await client<ClaudeQqNotificationRow[]>`
SELECT id, kind, dedup_key, target, message, created_at, updated_at, attempts, next_attempt_at, last_error, sent_at
FROM unidesk_code_queue_notifications
ORDER BY created_at ASC, id ASC
`;
claudeQqNotificationOutbox = {
version: 1,
updatedAt: ctx().nowIso(),
items: rows.map(notificationItemFromRow).filter((item) => item.id.length > 0 && item.message.length > 0),
};
pruneClaudeQqNotificationOutbox();
}
async function upsertClaudeQqNotificationToDatabase(client: SqlExecutor, item: ClaudeQqNotificationItem): Promise<void> {
await client`
INSERT INTO unidesk_code_queue_notifications (
id,
kind,
dedup_key,
target,
message,
created_at,
updated_at,
attempts,
next_attempt_at,
last_error,
sent_at
) VALUES (
${item.id},
${item.kind},
${item.dedupKey},
${item.target},
${item.message},
${ctx().taskTimestamp(item.createdAt) ?? ctx().nowIso()},
${ctx().taskTimestamp(item.updatedAt) ?? ctx().nowIso()},
${item.attempts},
${ctx().taskTimestamp(item.nextAttemptAt) ?? ctx().nowIso()},
${item.lastError},
${ctx().taskTimestamp(item.sentAt)}
)
ON CONFLICT (id) DO UPDATE SET
kind = EXCLUDED.kind,
dedup_key = EXCLUDED.dedup_key,
target = EXCLUDED.target,
message = EXCLUDED.message,
updated_at = EXCLUDED.updated_at,
attempts = EXCLUDED.attempts,
next_attempt_at = EXCLUDED.next_attempt_at,
last_error = EXCLUDED.last_error,
sent_at = EXCLUDED.sent_at
`;
}
async function persistClaudeQqNotificationItem(item: ClaudeQqNotificationItem): Promise<void> {
if (!ctx().databaseReady()) throw new Error("PostgreSQL is not ready for ClaudeQQ notification outbox");
claudeQqNotificationOutbox.updatedAt = ctx().nowIso();
const deletedIds = pruneClaudeQqNotificationOutbox();
const stillPresent = claudeQqNotificationOutbox.items.some((candidate) => candidate.id === item.id);
await ctx().sql.begin(async (client) => {
if (stillPresent) await upsertClaudeQqNotificationToDatabase(client, item);
for (const id of deletedIds) await client`DELETE FROM unidesk_code_queue_notifications WHERE id = ${id}`;
});
if (stillPresent && !claudeQqNotificationOutbox.items.some((candidate) => candidate.id === item.id)) {
claudeQqNotificationOutbox.items.push(item);
pruneClaudeQqNotificationOutbox();
}
}
async function persistClaudeQqNotificationOutbox(): Promise<void> {
if (!ctx().databaseReady()) throw new Error("PostgreSQL is not ready for ClaudeQQ notification outbox");
claudeQqNotificationOutbox.updatedAt = ctx().nowIso();
const deletedIds = pruneClaudeQqNotificationOutbox();
await ctx().sql.begin(async (client) => {
for (const item of claudeQqNotificationOutbox.items) await upsertClaudeQqNotificationToDatabase(client, item);
for (const id of deletedIds) await client`DELETE FROM unidesk_code_queue_notifications WHERE id = ${id}`;
});
}
function queueNotificationStats(): Record<string, JsonValue> {
const counts = ctx().tasks().reduce<Record<string, number>>((memo, task) => {
memo[task.status] = (memo[task.status] ?? 0) + 1;
return memo;
}, {});
const activeTaskIds = Array.from(new Set([
...ctx().activeRunTaskIds(),
...ctx().tasks().filter((task) => task.status === "running" || task.status === "judging").map((task) => task.id),
])).sort();
const activeTask = activeTaskIds.length > 0 ? ctx().tasks().find((task) => task.id === activeTaskIds[0]) ?? null : null;
const queued = (counts.queued ?? 0) + (counts.retry_wait ?? 0);
const running = (counts.running ?? 0) + (counts.judging ?? 0);
return {
running,
queued,
retryWait: counts.retry_wait ?? 0,
judging: counts.judging ?? 0,
total: ctx().tasks().length,
queueCount: ctx().queueCount(),
processingQueueCount: ctx().processingQueueCount(),
activeRunCount: ctx().activeRunCount(),
activeRunSlotCount: ctx().activeRunSlotCount(),
activeTaskIds,
activeTaskElapsed: activeTask === null ? "-" : formatDurationMs(durationMsBetween(activeTask.startedAt ?? activeTask.createdAt, ctx().nowIso())),
};
}
function notificationTargetConfigured(): boolean {
if (!ctx().config.notifyClaudeQqEnabled) return false;
return ctx().config.notifyClaudeQqTargetType === "group"
? ctx().config.notifyClaudeQqGroupId.length > 0
: ctx().config.notifyClaudeQqUserId.length > 0;
}
function claudeQqTargetPayload(message: string): Record<string, string> {
if (ctx().config.notifyClaudeQqTargetType === "group") {
return { targetType: "group", groupId: ctx().config.notifyClaudeQqGroupId, message };
}
return { targetType: "private", userId: ctx().config.notifyClaudeQqUserId, message };
}
function notificationTargetLabel(): string {
return ctx().config.notifyClaudeQqTargetType === "group"
? `group:${ctx().config.notifyClaudeQqGroupId || "-"}`
: `private:${ctx().config.notifyClaudeQqUserId || "-"}`;
}
function truncateNotificationText(value: string, maxChars: number): string {
if (value.length <= maxChars) return value;
return `${value.slice(0, maxChars)}\n\n...[Code Queue notification truncated: ${value.length - maxChars} chars omitted; use CLI/WebUI for the full trace]`;
}
function taskFinalResponseForNotification(task: QueueTask): string {
const last = ctx().lastAssistantMessage(task) as Record<string, unknown>;
const text = typeof last.text === "string" ? last.text.trimEnd() : "";
if (text.trim().length > 0) return text;
if (typeof task.lastError === "string" && task.lastError.trim().length > 0) return `（没有最终 assistant response；lastError: ${task.lastError.trim()}）`;
return "（没有最终 assistant response）";
}
function taskNotificationKey(task: QueueTask): string {
return `${task.id}:${task.status}:${task.finishedAt ?? task.updatedAt}:${task.attempts.length}`;
}
function rememberTaskNotificationKey(key: string): void {
sentTaskNotificationKeys.add(key);
while (sentTaskNotificationKeys.size > 1000) {
const oldest = sentTaskNotificationKeys.values().next().value as string | undefined;
if (oldest === undefined) break;
sentTaskNotificationKeys.delete(oldest);
}
}
function claudeQqNotificationId(kind: string, dedupKey: string): string {
return `${kind}:${dedupKey}`;
}
function claudeQqNotificationOutboxStats(): Record<string, JsonValue> {
const pending = claudeQqNotificationOutbox.items.filter((item) => item.sentAt === null);
const failed = pending.filter((item) => item.lastError !== null);
const oldestPending = pending.reduce<string | null>((oldest, item) => {
if (oldest === null) return item.createdAt;
return (ctx().timestampMs(item.createdAt) ?? 0) < (ctx().timestampMs(oldest) ?? 0) ? item.createdAt : oldest;
}, null);
return {
storage: "postgres",
total: claudeQqNotificationOutbox.items.length,
pending: pending.length,
failed: failed.length,
sent: claudeQqNotificationOutbox.items.length - pending.length,
inFlight: claudeQqNotificationDrainInFlight,
nextDueAt: pending
.map((item) => item.nextAttemptAt)
.sort((left, right) => (ctx().timestampMs(left) ?? 0) - (ctx().timestampMs(right) ?? 0))[0] ?? null,
oldestPendingAt: oldestPending,
};
}
function pruneClaudeQqNotificationOutbox(): string[] {
const beforeIds = new Set(claudeQqNotificationOutbox.items.map((item) => item.id));
const pending = claudeQqNotificationOutbox.items.filter((item) => item.sentAt === null);
const sent = claudeQqNotificationOutbox.items
.filter((item) => item.sentAt !== null)
.sort((left, right) => (ctx().timestampMs(right.sentAt) ?? 0) - (ctx().timestampMs(left.sentAt) ?? 0));
const sentBudget = Math.max(0, ctx().config.notifyClaudeQqMaxOutboxItems - pending.length);
claudeQqNotificationOutbox.items = [...pending, ...sent.slice(0, sentBudget)]
.sort((left, right) => (ctx().timestampMs(left.createdAt) ?? 0) - (ctx().timestampMs(right.createdAt) ?? 0));
const afterIds = new Set(claudeQqNotificationOutbox.items.map((item) => item.id));
return Array.from(beforeIds).filter((id) => !afterIds.has(id));
}
function claudeQqNotificationRetryDelayMs(attempts: number): number {
const exponent = Math.max(0, Math.min(8, attempts - 1));
return Math.min(30 * 60_000, ctx().config.notifyClaudeQqRetryIntervalMs * (2 ** exponent));
}
function scheduleClaudeQqNotificationDrain(delayMs = ctx().config.notifyClaudeQqRetryIntervalMs): void {
if (!notificationTargetConfigured() || ctx().shutdownRequested()) return;
if (claudeQqNotificationOutbox.items.every((item) => item.sentAt !== null)) return;
if (claudeQqNotificationDrainTimer !== null) return;
claudeQqNotificationDrainTimer = setTimeout(() => {
claudeQqNotificationDrainTimer = null;
void drainClaudeQqNotificationOutbox("timer").catch((error) => ctx().logger("warn", "claudeqq_notify_outbox_drain_failed", { trigger: "timer", error: ctx().errorToJson(error) }));
}, Math.max(1000, delayMs));
}
async function enqueueClaudeQqNotification(kind: string, dedupKey: string, message: string): Promise<boolean> {
if (!notificationTargetConfigured()) return false;
const id = claudeQqNotificationId(kind, dedupKey);
const existing = claudeQqNotificationOutbox.items.find((item) => item.id === id);
if (existing !== undefined && existing.sentAt !== null) return false;
const at = ctx().nowIso();
let item: ClaudeQqNotificationItem;
if (existing !== undefined) {
existing.message = message;
existing.target = notificationTargetLabel();
existing.updatedAt = at;
existing.nextAttemptAt = at;
existing.lastError = null;
item = existing;
} else {
item = {
id,
kind,
dedupKey,
target: notificationTargetLabel(),
message,
createdAt: at,
updatedAt: at,
attempts: 0,
nextAttemptAt: at,
lastError: null,
sentAt: null,
};
claudeQqNotificationOutbox.items.push(item);
}
await persistClaudeQqNotificationItem(item);
void drainClaudeQqNotificationOutbox(`enqueue:${kind}`).catch((error) => ctx().logger("warn", "claudeqq_notify_outbox_drain_failed", { trigger: `enqueue:${kind}`, error: ctx().errorToJson(error) }));
return true;
}
function dueClaudeQqNotificationItems(limit = 3): ClaudeQqNotificationItem[] {
const nowMs = Date.now();
return claudeQqNotificationOutbox.items
.filter((item) => item.sentAt === null && (ctx().timestampMs(item.nextAttemptAt) ?? 0) <= nowMs)
.sort((left, right) => (ctx().timestampMs(left.nextAttemptAt) ?? 0) - (ctx().timestampMs(right.nextAttemptAt) ?? 0))
.slice(0, limit);
}
async function drainClaudeQqNotificationOutbox(trigger = "manual"): Promise<Record<string, JsonValue>> {
if (!notificationTargetConfigured()) return { ok: true, trigger, skipped: "not_configured" };
if (claudeQqNotificationDrainInFlight) return { ok: true, trigger, skipped: "in_flight" };
claudeQqNotificationDrainInFlight = true;
let sent = 0;
let failed = 0;
try {
await loadClaudeQqNotificationOutboxFromDatabase();
const due = dueClaudeQqNotificationItems();
for (const item of due) {
item.attempts += 1;
item.updatedAt = ctx().nowIso();
await persistClaudeQqNotificationItem(item);
try {
await postClaudeQqText(item.kind, item.message);
item.sentAt = ctx().nowIso();
item.updatedAt = item.sentAt;
item.lastError = null;
sent += 1;
if (item.kind === "task_terminal") rememberTaskNotificationKey(item.dedupKey);
ctx().logger("info", "claudeqq_notify_outbox_sent", { id: item.id, kind: item.kind, target: item.target, attempts: item.attempts, trigger });
} catch (error) {
failed += 1;
const message = error instanceof Error ? error.message : String(error);
item.lastError = ctx().safePreview(message, 1000);
item.updatedAt = ctx().nowIso();
item.nextAttemptAt = new Date(Date.now() + claudeQqNotificationRetryDelayMs(item.attempts)).toISOString();
ctx().logger("warn", "claudeqq_notify_outbox_retry_scheduled", {
id: item.id,
kind: item.kind,
target: item.target,
attempts: item.attempts,
nextAttemptAt: item.nextAttemptAt,
trigger,
error: ctx().errorToJson(error),
});
} finally {
await persistClaudeQqNotificationItem(item);
}
}
} finally {
claudeQqNotificationDrainInFlight = false;
await persistClaudeQqNotificationOutbox();
if (claudeQqNotificationOutbox.items.some((item) => item.sentAt === null)) scheduleClaudeQqNotificationDrain();
}
return { ok: true, trigger, sent, failed, outbox: claudeQqNotificationOutboxStats() };
}
async function postClaudeQqText(kind: string, message: string): Promise<void> {
if (!notificationTargetConfigured()) return;
const url = `${ctx().config.notifyClaudeQqBaseUrl}/api/push/text`;
let lastError: unknown = null;
for (let attempt = 1; attempt <= ctx().config.notifyClaudeQqSendAttempts; attempt += 1) {
const controller = new AbortController();
const timer = setTimeout(() => controller.abort(), ctx().config.notifyClaudeQqTimeoutMs);
let responseText = "";
try {
const response = await fetch(url, {
method: "POST",
headers: { "content-type": "application/json" },
body: JSON.stringify(claudeQqTargetPayload(message)),
signal: controller.signal,
});
responseText = await response.text();
if (!response.ok) throw new Error(`ClaudeQQ proxy returned HTTP ${response.status}: ${ctx().safePreview(responseText, 500)}`);
try {
const parsed = JSON.parse(responseText) as Record<string, unknown>;
if (parsed.ok === false || parsed.success === false || parsed.status === "napcat_offline") {
throw new Error(`ClaudeQQ push failed: ${ctx().safePreview(responseText, 500)}`);
}
} catch (error) {
if (error instanceof SyntaxError) {
// Some deployments return plain text; HTTP 2xx is still accepted.
} else {
throw error;
}
}
ctx().logger("info", "claudeqq_notify_sent", { kind, target: notificationTargetLabel(), attempt, chars: message.length, responsePreview: ctx().safePreview(responseText, 500) });
return;
} catch (error) {
lastError = error;
if (attempt >= ctx().config.notifyClaudeQqSendAttempts) break;
const delayMs = Math.min(30_000, 1000 * (2 ** (attempt - 1)));
ctx().logger("warn", "claudeqq_notify_retry", { kind, target: notificationTargetLabel(), attempt, nextDelayMs: delayMs, error: ctx().errorToJson(error) });
await Bun.sleep(delayMs);
} finally {
clearTimeout(timer);
}
}
if (lastError !== null) {
throw lastError instanceof Error ? lastError : new Error(String(lastError));
}
}
function taskTerminalNotificationMessage(task: QueueTask): string {
const stats = queueNotificationStats();
const totalElapsed = formatDurationMs(durationMsBetween(task.createdAt, task.finishedAt ?? task.updatedAt));
const runElapsed = formatDurationMs(durationMsBetween(task.startedAt ?? task.createdAt, task.finishedAt ?? task.updatedAt));
const response = truncateNotificationText(taskFinalResponseForNotification(task), ctx().config.notifyClaudeQqMaxResponseChars);
return [
"Code Queue 任务结束",
`task: ${task.id}`,
`queue: ${ctx().queueIdOf(task)}`,
`status: ${task.status}`,
`provider: ${task.providerId}`,
`cwd: ${task.cwd}`,
`model: ${task.model}${task.reasoningEffort ? ` (${task.reasoningEffort})` : ""}`,
`attempts: ${task.attempts.length}/${task.maxAttempts}`,
`elapsed: total=${totalElapsed}, run=${runElapsed}`,
`current queue: running=${stats.running}, queued=${stats.queued}, retry_wait=${stats.retryWait}`,
"",
"Final response:",
response,
].join("\n");
}
async function notifyTaskTerminal(task: QueueTask): Promise<void> {
if (!terminalTask(task) || !notificationTargetConfigured()) return;
const key = taskNotificationKey(task);
if (sentTaskNotificationKeys.has(key) || inFlightTaskNotificationKeys.has(key)) return;
inFlightTaskNotificationKeys.add(key);
try {
await enqueueClaudeQqNotification("task_terminal", key, taskTerminalNotificationMessage(task));
} catch (error) {
ctx().logger("warn", "claudeqq_task_notify_failed", { taskId: task.id, status: task.status, target: notificationTargetLabel(), error: ctx().errorToJson(error) });
} finally {
inFlightTaskNotificationKeys.delete(key);
}
}
async function backfillClaudeQqTaskNotifications(since: string | null, limit: number, dryRun: boolean): Promise<Record<string, JsonValue>> {
if (!notificationTargetConfigured()) return { ok: true, skipped: "not_configured" };
await loadClaudeQqNotificationOutboxFromDatabase();
const sinceMs = ctx().timestampMs(since);
const candidates = ctx().tasks()
.filter((task) => terminalTask(task))
.filter((task) => sinceMs === null || (ctx().timestampMs(task.finishedAt ?? task.updatedAt) ?? 0) > sinceMs)
.sort((left, right) => (ctx().timestampMs(left.finishedAt ?? left.updatedAt) ?? 0) - (ctx().timestampMs(right.finishedAt ?? right.updatedAt) ?? 0))
.slice(0, limit);
const items = candidates.map((task) => ({
taskId: task.id,
status: task.status,
queueId: ctx().queueIdOf(task),
finishedAt: task.finishedAt ?? task.updatedAt,
dedupKey: taskNotificationKey(task),
alreadyInOutbox: claudeQqNotificationOutbox.items.some((item) => item.id === claudeQqNotificationId("task_terminal", taskNotificationKey(task))),
}));
if (dryRun) return { ok: true, dryRun, since: since ?? null, scanned: candidates.length, enqueued: 0, items };
let enqueued = 0;
for (const task of candidates) {
if (await enqueueClaudeQqNotification("task_terminal", taskNotificationKey(task), taskTerminalNotificationMessage(task))) enqueued += 1;
}
return { ok: true, dryRun, since: since ?? null, scanned: candidates.length, enqueued, outbox: claudeQqNotificationOutboxStats(), items };
}
function armIdleNotification(): void {
if (notificationTargetConfigured()) idleNotificationSent = false;
}
async function maybeNotifyQueueIdle(triggerTaskId: string | null = null): Promise<void> {
if (!notificationTargetConfigured() || idleNotificationSent || idleNotificationInFlight) return;
const stats = queueNotificationStats();
if (Number(stats.running) !== 0 || Number(stats.queued) !== 0 || ctx().processingQueueCount() !== 0 || ctx().activeRunCount() !== 0) return;
idleNotificationInFlight = true;
try {
const message = [
"Code Queue 已空闲",
"running=0, queued=0",
`total tasks=${stats.total}, queues=${stats.queueCount}`,
triggerTaskId === null ? "" : `last task=${triggerTaskId}`,
].filter((line) => line.length > 0).join("\n");
await enqueueClaudeQqNotification("queue_idle", `queue_idle:${triggerTaskId ?? "unknown"}:${stats.total}`, message);
idleNotificationSent = true;
} catch (error) {
ctx().logger("warn", "claudeqq_idle_notify_failed", { triggerTaskId: triggerTaskId ?? "", target: notificationTargetLabel(), error: ctx().errorToJson(error) });
} finally {
idleNotificationInFlight = false;
}
}
function claudeQqNotificationOutboxItemCount(): number {
return claudeQqNotificationOutbox.items.length;
}
function claudeQqNotificationItems(limit: number): JsonValue[] {
return claudeQqNotificationOutbox.items.slice(-limit).map((item) => ({
id: item.id,
kind: item.kind,
dedupKey: item.dedupKey,
target: item.target,
createdAt: item.createdAt,
updatedAt: item.updatedAt,
attempts: item.attempts,
nextAttemptAt: item.nextAttemptAt,
lastError: item.lastError,
sentAt: item.sentAt,
messagePreview: ctx().safePreview(item.message, 500),
messageChars: item.message.length,
})) as unknown as JsonValue[];
}
export {
armIdleNotification,
backfillClaudeQqTaskNotifications,
claudeQqNotificationItems,
claudeQqNotificationOutboxItemCount,
claudeQqNotificationOutboxStats,
drainClaudeQqNotificationOutbox,
loadClaudeQqNotificationOutboxFromDatabase,
maybeNotifyQueueIdle,
notificationTargetConfigured,
notificationTargetLabel,
notifyTaskTerminal,
persistClaudeQqNotificationOutbox,
scheduleClaudeQqNotificationDrain,
};
src/components/microservices/code-queue/src/prompts.ts
+53
View File
@@ -0,0 +1,53 @@
// 重构前 index.ts 只读参考：commit 6a04144d3f5103014f75b637d7e6bc2f45bf007f，blob 56e590c1a6b5ca7ad128bf2c992f60e46c355a58；可用 `git show 6a04144d3f5103014f75b637d7e6bc2f45bf007f:src/components/microservices/code-queue/src/index.ts` 查看。
import type { QueueTaskRequest } from "./types";
export const resolvedReferenceContextTitle = "# Code Queue 已解析引用上下文";
export const currentTaskPromptMarker = "\n# 本次任务\n";
export const codeQueueEnvironmentHintTitle = "# Code Queue 运行环境提示";
export const codeQueueEnvironmentHint = [
codeQueueEnvironmentHintTitle,
"如果当前 Code Queue Docker 容器缺少完成任务所需的环境、系统包或语言依赖，可以先在容器内临时安装以推进当前任务；同时必须把该依赖补到 `src/components/microservices/code-queue/Dockerfile`，让后续任务重建镜像后可直接使用。",
].join("\n");
export function stripAutoReferenceHint(prompt: string): string {
const trimmed = prompt.trimStart();
if (!/^引用\s+Code Queue\s+任务\s+codex_\d+_[A-Za-z0-9_-]+/u.test(trimmed)) return prompt;
const marker = "\n\n本次任务：";
const index = trimmed.indexOf(marker);
if (index === -1) return prompt;
return trimmed.slice(index + marker.length).trimStart();
}
export function stripResolvedReferenceContext(prompt: string): string {
const trimmed = prompt.trimStart();
if (!trimmed.startsWith(resolvedReferenceContextTitle)) return prompt;
const offset = prompt.length - trimmed.length;
const index = prompt.lastIndexOf(currentTaskPromptMarker);
if (index < offset) return prompt;
return prompt.slice(index + currentTaskPromptMarker.length).trimStart();
}
export function stripCodeQueueEnvironmentHint(prompt: string): string {
const trimmed = prompt.trimStart();
if (!trimmed.startsWith(codeQueueEnvironmentHintTitle)) return prompt;
const offset = prompt.length - trimmed.length;
const index = prompt.indexOf(currentTaskPromptMarker, offset);
if (index < offset) return prompt;
return prompt.slice(index + currentTaskPromptMarker.length).trimStart();
}
export function userPromptForDisplay(prompt: string): string {
return stripAutoReferenceHint(stripResolvedReferenceContext(stripCodeQueueEnvironmentHint(prompt)));
}
export function promptWithCodeQueueEnvironmentHint(prompt: string): string {
if (prompt.trimStart().startsWith(codeQueueEnvironmentHintTitle)) return prompt;
return [codeQueueEnvironmentHint, "", "# 本次任务", prompt.trim()].join("\n");
}
export function injectCodeQueueEnvironmentHint(request: QueueTaskRequest): QueueTaskRequest {
if (request.prompt.trimStart().startsWith(codeQueueEnvironmentHintTitle)) return request;
const basePrompt = request.basePrompt ?? userPromptForDisplay(request.prompt);
return { ...request, prompt: promptWithCodeQueueEnvironmentHint(request.prompt), basePrompt };
}
src/components/microservices/code-queue/src/provider-runtime.ts
+455
View File
@@ -0,0 +1,455 @@
// 重构前 index.ts 只读参考：commit 6a04144d3f5103014f75b637d7e6bc2f45bf007f，blob 56e590c1a6b5ca7ad128bf2c992f60e46c355a58；可用 `git show 6a04144d3f5103014f75b637d7e6bc2f45bf007f:src/components/microservices/code-queue/src/index.ts` 查看。
import { spawnSync } from "node:child_process";
import { existsSync, readFileSync } from "node:fs";
import { resolve } from "node:path";
import { opencodeNpmPackage } from "./code-agent/common";
import type { DevContainerCommandLog, DevContainerPlan, JsonValue, QueueTask, RuntimeConfig } from "./types";
export interface ProviderRuntimeContext {
config: Pick<RuntimeConfig,
"codexHome" | "defaultWorkdir" | "devContainerDefaultProviderId" | "devContainerImage" | "devContainerMasterHost" | "devContainerWorkdir" | "executionProviderIds" | "mainProviderId" | "remoteCodexEnvKeys" | "remoteDefaultWorkdir" | "sourceCodexConfig"
>;
safePreview: (value: string, max?: number) => string;
}
let context: ProviderRuntimeContext | null = null;
export function configureProviderRuntime(runtimeContext: ProviderRuntimeContext): void {
context = runtimeContext;
}
function ctx(): ProviderRuntimeContext {
if (context === null) throw new Error("provider-runtime module is not configured");
return context;
}
function shellQuote(value: string): string {
return `'${value.replace(/'/gu, "'\\''")}'`;
}
function safeDockerName(value: string): string {
return value.replace(/[^a-zA-Z0-9_.-]/gu, "-").replace(/^-+/u, "").slice(0, 80) || "node";
}
function normalizeProviderId(value: unknown): string | null {
if (typeof value !== "string") return null;
const trimmed = value.trim();
return /^[A-Za-z0-9_.-]{1,64}$/u.test(trimmed) ? trimmed : null;
}
function normalizeTaskProviderId(value: unknown): string {
return normalizeProviderId(value) ?? ctx().config.mainProviderId;
}
function providerIsMain(providerId: string): boolean {
return normalizeTaskProviderId(providerId) === ctx().config.mainProviderId;
}
function defaultWorkdirForProvider(providerId: string): string {
return providerIsMain(providerId) ? ctx().config.defaultWorkdir : ctx().config.remoteDefaultWorkdir;
}
function resolveTaskCwd(providerId: string, value: unknown): string {
const raw = typeof value === "string" ? value.trim() : "";
const base = defaultWorkdirForProvider(providerId);
if (raw.length === 0) return base;
return raw.startsWith("/") ? raw : resolve(base, raw);
}
function remoteHostWorkdirForTask(task: QueueTask): string {
const base = defaultWorkdirForProvider(task.providerId);
return task.cwd === base || task.cwd.startsWith(`${base}/`) ? base : task.cwd;
}
function executionProviderOptions(): JsonValue[] {
const ids = Array.from(new Set([
ctx().config.mainProviderId,
...ctx().config.executionProviderIds,
ctx().config.devContainerDefaultProviderId,
].map(normalizeProviderId).filter((value): value is string => value !== null)));
return ids.map((providerId) => ({
id: providerId,
label: providerIsMain(providerId) ? `${providerId} (master)` : providerId,
kind: providerIsMain(providerId) ? "local" : "remote-dev-container",
defaultWorkdir: defaultWorkdirForProvider(providerId),
containerName: providerIsMain(providerId) ? null : buildDevContainerPlan(providerId, {}).containerName,
}));
}
function numericIdFromProvider(providerId: string): number {
const digits = providerId.match(/\d+/u)?.[0] ?? "";
if (digits.length > 0) {
const parsed = Number(digits);
if (Number.isInteger(parsed) && parsed >= 0 && parsed <= 4095) return parsed;
}
let hash = 0;
for (const char of providerId) hash = (Math.imul(hash, 31) + char.charCodeAt(0)) >>> 0;
return 100 + (hash % 3900);
}
function buildDevContainerPlan(providerId: string, body: Record<string, unknown>): DevContainerPlan {
const safeProvider = safeDockerName(providerId);
const tunId = numericIdFromProvider(providerId);
const imageFromBody = typeof body.image === "string" && body.image.trim().length > 0 ? body.image.trim() : "";
const workdirFromBody = typeof body.workdir === "string" && body.workdir.trim().length > 0 ? body.workdir.trim() : "";
const masterFromBody = typeof body.masterHost === "string" && body.masterHost.trim().length > 0 ? body.masterHost.trim() : "";
const containerFromBody = typeof body.containerName === "string" && body.containerName.trim().length > 0 ? body.containerName.trim() : "";
const image = imageFromBody.length > 0
? imageFromBody
: ctx().config.devContainerImage.length > 0
? ctx().config.devContainerImage
: "unidesk-code-queue:latest";
const workdir = workdirFromBody.length > 0 ? workdirFromBody : ctx().config.devContainerWorkdir;
const thirdOctet = providerId === "D601" ? 6 : Math.max(1, Math.min(250, Math.floor(tunId / 64)));
const baseOctet = providerId === "D601" ? 0 : (tunId % 64) * 4;
const serverLastOctet = providerId === "D601" ? 1 : baseOctet + 1;
const clientLastOctet = providerId === "D601" ? 2 : baseOctet + 2;
return {
providerId,
containerName: safeDockerName(containerFromBody.length > 0 ? containerFromBody : `unidesk-codex-dev-${safeProvider}`),
image,
workdir,
containerWorkdir: workdir,
remoteCodexHome: "/var/lib/unidesk/code-queue/codex-home",
remoteOpencodeXdgDir: "/var/lib/unidesk/code-queue/opencode-xdg",
masterHost: masterFromBody.length > 0 ? masterFromBody : ctx().config.devContainerMasterHost,
tunId,
tunName: `tun${tunId}`,
serverIp: `10.214.${thirdOctet}.${serverLastOctet}`,
clientIp: `10.214.${thirdOctet}.${clientLastOctet}`,
natChain: safeDockerName(`UNIDESK-CODEX-DEV-${safeProvider}`).toUpperCase().slice(0, 28),
keyDir: `/home/ubuntu/.unidesk/codex-dev-proxy/${safeProvider}`,
masterKeyPath: resolve(ctx().config.defaultWorkdir, ".state/code-queue/dev-proxy", safeProvider, "id_ed25519"),
};
}
function runCodeQueueSsh(providerId: string, script: string, timeoutMs: number, name: string): DevContainerCommandLog {
const started = Date.now();
const result = spawnSync("bun", ["scripts/cli.ts", "ssh", providerId, "bash -s"], {
cwd: ctx().config.defaultWorkdir,
input: script,
encoding: "utf8",
timeout: timeoutMs,
maxBuffer: 8 * 1024 * 1024,
});
const stdout = typeof result.stdout === "string" ? result.stdout : String(result.stdout ?? "");
const stderr = typeof result.stderr === "string" ? result.stderr : String(result.stderr ?? "");
const errorText = result.error === undefined ? "" : `${result.error.name}: ${result.error.message}`;
return {
name,
providerId,
exitCode: result.status,
signal: result.signal,
durationMs: Date.now() - started,
stdout,
stderr: errorText.length > 0 ? `${stderr}\n${errorText}`.trim() : stderr,
};
}
function throwIfCommandFailed(command: DevContainerCommandLog): void {
if (command.exitCode === 0) return;
throw new Error(`${command.name} failed on ${command.providerId ?? "local"} exit=${command.exitCode} stderr=${ctx().safePreview(command.stderr, 1000)}`);
}
function masterKeySetupScript(plan: DevContainerPlan): string {
const marker = `unidesk-codex-dev-proxy-${plan.providerId}`;
return `set -euo pipefail
PROVIDER_ID=${shellQuote(plan.providerId)}
TUN_ID=${shellQuote(String(plan.tunId))}
KEY=${shellQuote(plan.masterKeyPath)}
BASE=$(dirname "$KEY")
MARK=${shellQuote(marker)}
mkdir -p "$BASE" /root/.ssh /etc/ssh/sshd_config.d
chmod 700 /root/.ssh
if [ ! -s "$KEY" ]; then
ssh-keygen -t ed25519 -N '' -C "$MARK" -f "$KEY" >/dev/null
fi
chmod 600 "$KEY"
printf 'PermitTunnel yes\\n' > /etc/ssh/sshd_config.d/90-unidesk-codex-dev-tunnel.conf
sshd -t
if command -v systemctl >/dev/null 2>&1; then systemctl reload ssh || systemctl reload sshd || true; fi
if command -v service >/dev/null 2>&1; then service ssh reload || service sshd reload || true; fi
touch /root/.ssh/authorized_keys
chmod 600 /root/.ssh/authorized_keys
tmp=$(mktemp)
grep -v "$MARK" /root/.ssh/authorized_keys > "$tmp" || true
cat "$tmp" > /root/.ssh/authorized_keys
rm -f "$tmp"
PUB=$(cat "$KEY.pub")
printf 'tunnel="%s",no-agent-forwarding,no-X11-forwarding,no-pty %s\\n' "$TUN_ID" "$PUB" >> /root/.ssh/authorized_keys
echo "master_key_ready provider=$PROVIDER_ID key=$KEY permitTunnel=$(sshd -T | awk '$1==\"permittunnel\"{print $2; exit}')"`;
}
function masterKeyReadScript(plan: DevContainerPlan): string {
return `set -euo pipefail
base64 -w0 ${shellQuote(plan.masterKeyPath)}`;
}
function remoteKeyInstallScript(plan: DevContainerPlan, privateKeyBase64: string): string {
return `set -euo pipefail
KEY_DIR=${shellQuote(plan.keyDir)}
MASTER=${shellQuote(plan.masterHost)}
umask 077
mkdir -p "$KEY_DIR"
printf %s ${shellQuote(privateKeyBase64)} | base64 -d > "$KEY_DIR/id_ed25519"
chmod 600 "$KEY_DIR/id_ed25519"
ssh-keyscan -H "$MASTER" > "$KEY_DIR/known_hosts" 2>/dev/null
chmod 600 "$KEY_DIR/known_hosts"
echo "remote_key_ready keyDir=$KEY_DIR master=$MASTER"`;
}
function base64Text(value: string): string {
return Buffer.from(value, "utf8").toString("base64");
}
function remoteCodexEnvFile(): string {
return ctx().config.remoteCodexEnvKeys
.map((key) => key.trim())
.filter((key) => /^[A-Za-z_][A-Za-z0-9_]*$/u.test(key) && process.env[key] !== undefined)
.map((key) => `${key}=${String(process.env[key] ?? "").replace(/\r?\n/gu, "")}`)
.join("\n");
}
function remoteCodexConfigText(): string {
const homeConfig = resolve(ctx().config.codexHome, "config.toml");
const path = existsSync(homeConfig) ? homeConfig : ctx().config.sourceCodexConfig;
if (!existsSync(path)) return "";
return readFileSync(path, "utf8");
}
function remoteCodexConfigInstallScript(plan: DevContainerPlan): string {
const configBase64 = base64Text(remoteCodexConfigText());
const envBase64 = base64Text(remoteCodexEnvFile());
return `set -euo pipefail
KEY_DIR=${shellQuote(plan.keyDir)}
CODEX_HOME_DIR="$KEY_DIR/codex-home"
OPENCODE_XDG_DIR="$KEY_DIR/opencode-xdg"
mkdir -p "$CODEX_HOME_DIR" "$OPENCODE_XDG_DIR"
chmod 700 "$KEY_DIR" "$CODEX_HOME_DIR" "$OPENCODE_XDG_DIR"
printf %s ${shellQuote(configBase64)} | base64 -d > "$CODEX_HOME_DIR/config.toml"
printf %s ${shellQuote(envBase64)} | base64 -d > "$KEY_DIR/codex-env"
chmod 600 "$CODEX_HOME_DIR/config.toml" "$KEY_DIR/codex-env"
echo "remote_codex_config_ready keyDir=$KEY_DIR codexHome=$CODEX_HOME_DIR opencodeXdg=$OPENCODE_XDG_DIR envKeys=${ctx().config.remoteCodexEnvKeys.filter((key) => process.env[key] !== undefined).length}"`;
}
function remoteContainerStartScript(plan: DevContainerPlan, forceRecreate: boolean): string {
return `set -euo pipefail
CONTAINER=${shellQuote(plan.containerName)}
REQUESTED_IMAGE=${shellQuote(plan.image)}
CODEX_IMAGE=unidesk-code-queue:latest
FALLBACK_IMAGE=${shellQuote(`unidesk_provider-gateway:${plan.providerId.toLowerCase()}`)}
KEY_DIR=${shellQuote(plan.keyDir)}
WORKDIR=${shellQuote(plan.workdir)}
CONTAINER_WORKDIR=${shellQuote(plan.containerWorkdir)}
IMAGE="$REQUESTED_IMAGE"
SSH_DIR="\${UNIDESK_HOST_ROOT_SSH_DIR:-$HOME/.ssh}"
SSH_MOUNT_ARGS=()
if [ -d "$SSH_DIR" ]; then SSH_MOUNT_ARGS=(-v "$SSH_DIR":/root/.ssh:ro); fi
if ! docker image inspect "$IMAGE" >/dev/null 2>&1 && docker image inspect "$CODEX_IMAGE" >/dev/null 2>&1; then
IMAGE="$CODEX_IMAGE"
fi
if ! docker image inspect "$IMAGE" >/dev/null 2>&1; then
if docker image inspect "$FALLBACK_IMAGE" >/dev/null 2>&1; then
IMAGE="$FALLBACK_IMAGE"
else
echo "missing requested image $REQUESTED_IMAGE, codex image $CODEX_IMAGE and fallback $FALLBACK_IMAGE" >&2
exit 1
fi
fi
test -r "$KEY_DIR/id_ed25519"
test -r "$KEY_DIR/known_hosts"
test -r "$KEY_DIR/codex-env"
test -r /usr/bin/busybox
mkdir -p "$WORKDIR" "$KEY_DIR/opencode-xdg"
if [ ${forceRecreate ? "1" : "0"} -eq 0 ] && docker inspect "$CONTAINER" >/dev/null 2>&1; then
STATE=$(docker inspect "$CONTAINER" --format '{{.State.Status}}' 2>/dev/null || true)
LABEL_WORKDIR=$(docker inspect "$CONTAINER" --format '{{ index .Config.Labels "unidesk.workdir" }}' 2>/dev/null || true)
if [ "$STATE" = "running" ] && [ "$LABEL_WORKDIR" = "$WORKDIR" ]; then
docker exec "$CONTAINER" bash -lc 'echo reuse_ready; command -v bash; test -d /run/unidesk-dev-proxy; test -d /var/lib/unidesk/code-queue/codex-home; test -d /var/lib/unidesk/code-queue/opencode-xdg' >/dev/null
echo "remote_container_reused container=$CONTAINER image=$(docker inspect "$CONTAINER" --format '{{.Config.Image}}') workdir=$WORKDIR"
exit 0
fi
fi
docker rm -f "$CONTAINER" >/dev/null 2>&1 || true
cid=$(docker run -d \\
--name "$CONTAINER" \\
--hostname ${shellQuote(`codex-dev-${plan.providerId}`)} \\
--user root \\
--cap-add NET_ADMIN \\
--device /dev/net/tun \\
--add-host host.docker.internal:host-gateway \\
--label unidesk.role=codex-dev \\
--label unidesk.provider=${shellQuote(plan.providerId)} \\
--label "unidesk.workdir=$WORKDIR" \\
--env-file "$KEY_DIR/codex-env" \\
-e CODEX_HOME=${shellQuote(plan.remoteCodexHome)} \\
-e CODEX_INTERNAL_ORIGINATOR_OVERRIDE=unidesk_code_queue \\
-e XDG_DATA_HOME=${shellQuote(resolve(plan.remoteOpencodeXdgDir, "data"))} \\
-e XDG_CONFIG_HOME=${shellQuote(resolve(plan.remoteOpencodeXdgDir, "config"))} \\
-e XDG_CACHE_HOME=${shellQuote(resolve(plan.remoteOpencodeXdgDir, "cache"))} \\
-e XDG_STATE_HOME=${shellQuote(resolve(plan.remoteOpencodeXdgDir, "state"))} \\
-v /var/run/docker.sock:/var/run/docker.sock \\
-v /usr/bin/busybox:/usr/local/bin/busybox:ro \\
-v "$KEY_DIR":/run/unidesk-dev-proxy:ro \\
-v "$KEY_DIR/codex-home":${shellQuote(plan.remoteCodexHome)} \\
-v "$KEY_DIR/opencode-xdg":${shellQuote(plan.remoteOpencodeXdgDir)} \\
"\${SSH_MOUNT_ARGS[@]}" \\
-v "$WORKDIR":"$CONTAINER_WORKDIR" \\
-v "$WORKDIR":/root/unidesk \\
-w "$CONTAINER_WORKDIR" \\
"$IMAGE" \\
bash -lc 'mkdir -p /tmp/unidesk-tools; ln -sf /usr/local/bin/busybox /tmp/unidesk-tools/ip; ln -sf /usr/local/bin/busybox /tmp/unidesk-tools/ping; export PATH=/tmp/unidesk-tools:$PATH; echo ready; sleep infinity')
docker exec "$CONTAINER" bash -lc 'mkdir -p /tmp/unidesk-tools; ln -sf /usr/local/bin/busybox /tmp/unidesk-tools/ip; ln -sf /usr/local/bin/busybox /tmp/unidesk-tools/ping; export PATH=/tmp/unidesk-tools:$PATH; echo container=$(hostname); pwd; ip route show default; ls -ld /dev/net/tun /run/unidesk-dev-proxy/id_ed25519 /var/lib/unidesk/code-queue/codex-home /var/lib/unidesk/code-queue/opencode-xdg; command -v ssh; command -v ip; command -v ping'
echo "remote_container_ready container=$CONTAINER cid=$cid image=$IMAGE workdir=$WORKDIR"`;
}
function masterProxyPrepareScript(plan: DevContainerPlan): string {
return `set -euo pipefail
TUN=${shellQuote(plan.tunName)}
CLIENT_IP=${shellQuote(plan.clientIp)}
CHAIN=${shellQuote(plan.natChain)}
EGRESS=$(ip route get 8.8.8.8 | awk '{for(i=1;i<=NF;i++){if($i=="dev"){print $(i+1); exit}}}')
if [ -z "$EGRESS" ]; then echo "cannot detect master egress interface" >&2; exit 1; fi
ip link show "$TUN" >/dev/null 2>&1 && ip link delete "$TUN" || true
sysctl -w net.ipv4.ip_forward=1 >/dev/null
iptables -t nat -N "$CHAIN" 2>/dev/null || true
iptables -t nat -F "$CHAIN"
iptables -t nat -A "$CHAIN" -s "$CLIENT_IP/32" -o "$EGRESS" -j MASQUERADE
iptables -t nat -C POSTROUTING -j "$CHAIN" 2>/dev/null || iptables -t nat -A POSTROUTING -j "$CHAIN"
iptables -C FORWARD -i "$TUN" -o "$EGRESS" -j ACCEPT 2>/dev/null || iptables -I FORWARD 1 -i "$TUN" -o "$EGRESS" -j ACCEPT
iptables -C FORWARD -i "$EGRESS" -o "$TUN" -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT 2>/dev/null || iptables -I FORWARD 1 -i "$EGRESS" -o "$TUN" -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
echo "master_proxy_prepared tun=$TUN egress=$EGRESS client=$CLIENT_IP chain=$CHAIN"
iptables -t nat -L "$CHAIN" -v -n -x`;
}
function containerTunnelStartScript(plan: DevContainerPlan): string {
return `set -euo pipefail
CONTAINER=${shellQuote(plan.containerName)}
docker exec -i "$CONTAINER" bash -s <<'INNER'
set -euo pipefail
mkdir -p /tmp/unidesk-tools
ln -sf /usr/local/bin/busybox /tmp/unidesk-tools/ip
ln -sf /usr/local/bin/busybox /tmp/unidesk-tools/ping
export PATH=/tmp/unidesk-tools:$PATH
MASTER=${plan.masterHost}
TUN_ID=${plan.tunId}
TUN=${plan.tunName}
CLIENT_IP=${plan.clientIp}
SERVER_IP=${plan.serverIp}
KNOWN_HOSTS=/tmp/unidesk-dev-proxy-known_hosts
cp /run/unidesk-dev-proxy/known_hosts "$KNOWN_HOSTS"
chmod 600 "$KNOWN_HOSTS"
DEFAULT_LINE=$(ip route show default | head -1)
ORIG_GW=$(printf '%s\\n' "$DEFAULT_LINE" | sed -n 's/^default via \\([^ ]*\\) dev \\([^ ]*\\).*/\\1/p')
ORIG_DEV=$(printf '%s\\n' "$DEFAULT_LINE" | sed -n 's/^default via \\([^ ]*\\) dev \\([^ ]*\\).*/\\2/p')
if [ -z "$ORIG_GW" ] || [ -z "$ORIG_DEV" ]; then echo "cannot parse default route: $DEFAULT_LINE" >&2; exit 1; fi
( ping -c 1 -W 3 google.com >/tmp/direct-ping.log 2>&1 && echo direct_ping=unexpected_ok ) || echo direct_ping=failed_expected
ip route replace $MASTER/32 via "$ORIG_GW" dev "$ORIG_DEV"
if command -v pkill >/dev/null 2>&1; then pkill -f "ssh .* -w $TUN_ID:$TUN_ID .*$MASTER" >/dev/null 2>&1 || true; fi
ssh -f -N -w $TUN_ID:$TUN_ID -o Tunnel=point-to-point -o ExitOnForwardFailure=yes -o ServerAliveInterval=15 -o ServerAliveCountMax=2 -o StrictHostKeyChecking=yes -o UserKnownHostsFile="$KNOWN_HOSTS" -i /run/unidesk-dev-proxy/id_ed25519 root@$MASTER
for i in 1 2 3 4 5; do ip link show "$TUN" >/dev/null 2>&1 && break; sleep 1; done
ip addr replace $CLIENT_IP peer $SERVER_IP dev "$TUN"
ip link set "$TUN" up
ip route replace default via $SERVER_IP dev "$TUN"
printf 'nameserver 8.8.8.8\\nnameserver 1.1.1.1\\noptions timeout:2 attempts:2\\n' > /etc/resolv.conf
echo "container_tunnel_ready orig=$ORIG_GW/$ORIG_DEV route_to_master=$(ip route get $MASTER | head -1) default=$(ip route show default | head -1) dns=$(tr '\\n' ' ' </etc/resolv.conf)"
INNER`;
}
function masterProxyFinishScript(plan: DevContainerPlan): string {
return `set -euo pipefail
TUN=${shellQuote(plan.tunName)}
SERVER_IP=${shellQuote(plan.serverIp)}
CLIENT_IP=${shellQuote(plan.clientIp)}
CHAIN=${shellQuote(plan.natChain)}
for i in 1 2 3 4 5; do ip link show "$TUN" >/dev/null 2>&1 && break; sleep 1; done
ip addr replace $SERVER_IP peer $CLIENT_IP dev "$TUN"
ip link set "$TUN" up
echo "master_tunnel_ready $(ip addr show "$TUN" | tr '\\n' ' ')"
iptables -t nat -L "$CHAIN" -v -n -x`;
}
function masterProxyEvidenceScript(plan: DevContainerPlan): string {
return `set -euo pipefail
CHAIN=${shellQuote(plan.natChain)}
TUN=${shellQuote(plan.tunName)}
iptables -t nat -L "$CHAIN" -v -n -x
ip -s link show "$TUN"`;
}
function devContainerPingScript(plan: DevContainerPlan): string {
return `set -euo pipefail
CONTAINER=${shellQuote(plan.containerName)}
docker exec "$CONTAINER" bash -lc 'export PATH=/tmp/unidesk-tools:$PATH; echo route=$(ip route show default | head -1); echo resolv=$(tr "\\n" " " </etc/resolv.conf); ping -c 1 -W 5 google.com'`;
}
function remoteCodexRuntimePrepareScript(plan: DevContainerPlan): string {
return `set -euo pipefail
CONTAINER=${shellQuote(plan.containerName)}
docker exec -i "$CONTAINER" bash -s <<'INNER'
set -euo pipefail
WORKDIR=${shellQuote(plan.containerWorkdir)}
CODEX_HOME_DIR=${shellQuote(plan.remoteCodexHome)}
OPENCODE_XDG_DIR=${shellQuote(plan.remoteOpencodeXdgDir)}
export PATH=/tmp/unidesk-tools:$PATH
if command -v apt-get >/dev/null 2>&1; then
missing=""
for c in git rg curl python3 pip3 jq rsync patch make gcc g++ tar gzip unzip; do command -v "$c" >/dev/null 2>&1 || missing="$missing $c"; done
if [ -n "$missing" ]; then
export DEBIAN_FRONTEND=noninteractive
apt-get update
apt-get install -y --no-install-recommends git ripgrep curl python3 python3-pip jq rsync patch make gcc g++ tar gzip unzip ca-certificates
rm -rf /var/lib/apt/lists/*
fi
fi
if ! command -v codex >/dev/null 2>&1; then
npm install -g @openai/codex@0.128.0
fi
if ! command -v opencode >/dev/null 2>&1; then
npm install -g ${opencodeNpmPackage}
fi
mkdir -p "$WORKDIR" "$CODEX_HOME_DIR" "$OPENCODE_XDG_DIR/data" "$OPENCODE_XDG_DIR/config" "$OPENCODE_XDG_DIR/cache" "$OPENCODE_XDG_DIR/state"
echo "code_agent_runtime_ready codex=$(command -v codex) opencode=$(command -v opencode) cwd=$WORKDIR home=$CODEX_HOME_DIR opencodeXdg=$OPENCODE_XDG_DIR"
INNER`;
}
function remoteAppServerCommand(task: QueueTask): string {
const plan = buildDevContainerPlan(task.providerId, { workdir: remoteHostWorkdirForTask(task) });
const inner = [
"set -euo pipefail",
`mkdir -p ${shellQuote(task.cwd)}`,
`cd ${shellQuote(task.cwd)}`,
`export CODEX_HOME=${shellQuote(plan.remoteCodexHome)}`,
"export CODEX_INTERNAL_ORIGINATOR_OVERRIDE=unidesk_code_queue",
"exec codex app-server --listen stdio://",
].join("; ");
return `docker exec -i ${shellQuote(plan.containerName)} bash -lc ${shellQuote(inner)}`;
}
export {
buildDevContainerPlan,
containerTunnelStartScript,
defaultWorkdirForProvider,
devContainerPingScript,
executionProviderOptions,
masterKeyReadScript,
masterKeySetupScript,
masterProxyEvidenceScript,
masterProxyFinishScript,
masterProxyPrepareScript,
normalizeProviderId,
normalizeTaskProviderId,
providerIsMain,
remoteAppServerCommand,
remoteCodexConfigInstallScript,
remoteCodexRuntimePrepareScript,
remoteContainerStartScript,
remoteHostWorkdirForTask,
remoteKeyInstallScript,
resolveTaskCwd,
runCodeQueueSsh,
shellQuote,
throwIfCommandFailed,
};
src/components/microservices/code-queue/src/queue-api.ts
+1133
View File
File diff suppressed because it is too large Load Diff
src/components/microservices/code-queue/src/references.ts
+187
View File
@@ -0,0 +1,187 @@
// 重构前 index.ts 只读参考：commit 6a04144d3f5103014f75b637d7e6bc2f45bf007f，blob 56e590c1a6b5ca7ad128bf2c992f60e46c355a58；可用 `git show 6a04144d3f5103014f75b637d7e6bc2f45bf007f:src/components/microservices/code-queue/src/index.ts` 查看。
import { lastAssistantMessage } from "./task-view";
import { resolvedReferenceContextTitle, userPromptForDisplay } from "./prompts";
import type { QueueTask, QueueTaskRequest, ReferenceInjectionRecord, ReferenceInjectionSummaryItem } from "./types";
export interface ReferencesContext {
addUniqueTaskId: (ids: string[], value: string) => void;
findTask: (id: string) => QueueTask | null;
nowIso: () => string;
referenceInjectionMaxRounds: number | null;
referenceTaskIdsFromPrompt: (prompt: string) => string[];
}
let context: ReferencesContext | null = null;
export function configureReferences(runtimeContext: ReferencesContext): void {
context = runtimeContext;
}
function ctx(): ReferencesContext {
if (context === null) throw new Error("references module is not configured");
return context;
}
function taskReferenceIds(task: QueueTask): string[] {
const ids: string[] = [];
for (const id of task.referenceTaskIds ?? []) ctx().addUniqueTaskId(ids, id);
for (const id of ctx().referenceTaskIdsFromPrompt(task.basePrompt || userPromptForDisplay(task.prompt))) ctx().addUniqueTaskId(ids, id);
return ids;
}
function taskBasePrompt(task: QueueTask): string {
return (task.basePrompt || userPromptForDisplay(task.prompt)).trimEnd();
}
function referenceSummaryItem(task: QueueTask, round: number, roundIndex: number, viaTaskId: string | null): ReferenceInjectionSummaryItem {
const lastMessage = lastAssistantMessage(task) as Record<string, unknown>;
const lastText = typeof lastMessage.text === "string" ? lastMessage.text : "";
return {
round,
roundIndex,
taskId: task.id,
viaTaskId,
status: task.status,
providerId: task.providerId,
model: task.model,
cwd: task.cwd,
createdAt: task.createdAt,
updatedAt: task.updatedAt,
promptChars: taskBasePrompt(task).length,
finalResponseChars: lastText.trimEnd().length,
finalResponseAt: typeof lastMessage.at === "string" ? lastMessage.at : null,
finalResponseSource: typeof lastMessage.source === "string" ? lastMessage.source : "unknown",
referenceTaskIds: taskReferenceIds(task),
cliHint: `bun scripts/cli.ts codex task ${task.id}`,
};
}
function collectReferenceGraph(rootIds: string[], maxRounds: number | null, finder: (id: string) => QueueTask | null = ctx().findTask): { items: ReferenceInjectionSummaryItem[]; tasks: QueueTask[]; truncated: boolean } {
const seen = new Set<string>();
let frontier = rootIds.map((id) => ({ id, viaTaskId: null as string | null }));
const rawItems: Array<{ task: QueueTask; depth: number; viaTaskId: string | null; discoveryIndex: number }> = [];
let truncated = false;
let discoveryIndex = 0;
for (let depth = 1; frontier.length > 0; depth += 1) {
if (maxRounds !== null && depth > maxRounds) {
truncated = frontier.some((entry) => !seen.has(entry.id));
break;
}
const next: Array<{ id: string; viaTaskId: string | null }> = [];
for (const entry of frontier) {
if (seen.has(entry.id)) continue;
const task = finder(entry.id);
if (task === null) continue;
seen.add(entry.id);
discoveryIndex += 1;
rawItems.push({ task, depth, viaTaskId: entry.viaTaskId, discoveryIndex });
for (const childId of taskReferenceIds(task)) {
if (!seen.has(childId)) next.push({ id: childId, viaTaskId: task.id });
}
}
frontier = next;
}
if (frontier.some((entry) => !seen.has(entry.id))) truncated = true;
const sorted = rawItems.sort((left, right) => {
if (left.depth !== right.depth) return right.depth - left.depth;
const createdDelta = Date.parse(left.task.createdAt) - Date.parse(right.task.createdAt);
if (Number.isFinite(createdDelta) && createdDelta !== 0) return createdDelta;
return left.discoveryIndex - right.discoveryIndex;
});
const depthToRound = new Map<number, number>();
Array.from(new Set(sorted.map((item) => item.depth))).forEach((depth, index) => depthToRound.set(depth, index + 1));
const roundCounts = new Map<number, number>();
const items = sorted.map((item) => {
const round = depthToRound.get(item.depth) ?? item.depth;
const roundIndex = (roundCounts.get(round) ?? 0) + 1;
roundCounts.set(round, roundIndex);
return referenceSummaryItem(item.task, round, roundIndex, item.viaTaskId);
});
const tasks = sorted.map((item) => item.task);
return { items, tasks, truncated };
}
function referenceRoundSeparator(round: number, totalRounds: number, items: ReferenceInjectionSummaryItem[]): string {
const createdTimes = items.map((item) => item.createdAt).filter(Boolean).sort();
const updatedTimes = items.map((item) => item.updatedAt).filter(Boolean).sort();
return [
`----- Reference Round ${round}/${totalRounds} -----`,
`order: upstream/oldest context first; direct references appear in the last round`,
`tasks: ${items.length}`,
`createdRange: ${createdTimes[0] ?? "--"} -> ${createdTimes.at(-1) ?? "--"}`,
`updatedRange: ${updatedTimes[0] ?? "--"} -> ${updatedTimes.at(-1) ?? "--"}`,
"--------------------------------",
].join("\n");
}
function referencedTaskContext(task: QueueTask, summary: ReferenceInjectionSummaryItem): string {
const lastMessage = lastAssistantMessage(task) as Record<string, unknown>;
const lastMessageText = typeof lastMessage.text === "string" ? lastMessage.text : "";
return [
`## Round ${summary.round}.${summary.roundIndex} referenced task ${task.id}`,
`- via: ${summary.viaTaskId ?? "direct"}`,
`- status/provider/model/cwd: ${task.status} / ${task.providerId} / ${task.model} / ${task.cwd}`,
`- created/updated: ${task.createdAt} / ${task.updatedAt}`,
`- cli: bun scripts/cli.ts codex task ${task.id}`,
"",
"### Initial prompt",
taskBasePrompt(task) || "(empty)",
"",
"### Final/last response",
lastMessageText.trimEnd() || "(none yet)",
"",
"### Query more context",
`Run: bun scripts/cli.ts codex task ${task.id}`,
].join("\n");
}
function injectReferencedTaskContext(request: QueueTaskRequest, finder: (id: string) => QueueTask | null = ctx().findTask, injectedAt = ctx().nowIso()): QueueTaskRequest {
const ids = request.referenceTaskIds ?? [];
if (ids.length === 0 || request.prompt.includes(resolvedReferenceContextTitle)) return request;
if (ids.length > 5) throw new Error(`referenceTaskIds supports at most 5 task ids, got ${ids.length}`);
const referencedTasks = ids.map((id) => finder(id));
const missing = ids.filter((_id, index) => referencedTasks[index] === null);
if (missing.length > 0) throw new Error(`referenced Code Queue task not found: ${missing.join(", ")}`);
const userPrompt = request.basePrompt ?? userPromptForDisplay(request.prompt);
const graph = collectReferenceGraph(ids, ctx().referenceInjectionMaxRounds, finder);
const injection: ReferenceInjectionRecord = {
version: 2,
injectedAt,
basePrompt: userPrompt,
directReferenceTaskIds: ids,
maxRounds: ctx().referenceInjectionMaxRounds,
truncated: graph.truncated,
itemCount: graph.items.length,
items: graph.items,
};
const taskById = new Map(graph.tasks.map((task) => [task.id, task]));
const groupedItems = Array.from(new Set(graph.items.map((item) => item.round))).map((round) => ({
round,
items: graph.items.filter((item) => item.round === round),
}));
const context = [
resolvedReferenceContextTitle,
`injectedAt: ${injectedAt}`,
`directReferences: ${ids.join(", ")}`,
`referenceGraphItems: ${graph.items.length}${graph.truncated ? " (truncated)" : ""}`,
"说明：Code Queue 后端只读取每个被引用任务的结构化 basePrompt（注入前 prompt）和 final/last response；不会把历史引用注入块继续套入。多轮引用按上游/最早上下文在前、直接引用在后的顺序注入；中间执行过程不注入，只保留 CLI 查询提示。",
"",
...(groupedItems.flatMap((group) => [
referenceRoundSeparator(group.round, groupedItems.length, group.items),
"",
...group.items.map((item) => {
const task = taskById.get(item.taskId);
return task === undefined ? "" : referencedTaskContext(task, item);
}).filter((text) => text.length > 0),
"",
])),
"",
"# 本次任务",
userPrompt.trim(),
].join("\n");
return { ...request, prompt: context, basePrompt: userPrompt, referenceTaskIds: ids, referenceInjection: injection };
}
export { injectReferencedTaskContext, taskReferenceIds };
src/components/microservices/code-queue/src/self-tests.ts
+402
View File
@@ -0,0 +1,402 @@
// 重构前 index.ts 只读参考：commit 6a04144d3f5103014f75b637d7e6bc2f45bf007f，blob 56e590c1a6b5ca7ad128bf2c992f60e46c355a58；可用 `git show 6a04144d3f5103014f75b637d7e6bc2f45bf007f:src/components/microservices/code-queue/src/index.ts` 查看。
import { minimaxM27Model } from "./code-agent/common";
import { continuePromptSourceBudgetChars, miniMaxJudgeMessages, parsedContinuePromptForJudge, parseJudgeJson, queueRecoveryRetryPrompt, retryPrompt } from "./judge";
import { codeQueueEnvironmentHintTitle, injectCodeQueueEnvironmentHint, promptWithCodeQueueEnvironmentHint, userPromptForDisplay } from "./prompts";
import { buildTaskTranscript, safePreview, transcriptLineSummaryLines } from "./task-view";
import type { ActiveRunSlotWaiter } from "./code-agent/common";
import type { JsonValue, LiveOutput, QueueTask, QueuedStatusReason, QueueTaskRequest, RuntimeConfig, TaskStatus } from "./types";
export interface SelfTestsContext {
config: Pick<RuntimeConfig, "defaultModel" | "defaultReasoningEffort" | "defaultWorkdir" | "mainProviderId" | "maxActiveQueues">;
activeRunSlotCount: () => number;
activeRunSlotReservations: Set<string>;
activeRunSlotWaiters: ActiveRunSlotWaiter[];
availableQueueStartSlotsFor: (activeSlotCount: number, maxActiveQueues?: number) => number;
defaultQueueId: string;
enqueueActiveRunSlotWaiter: (task: QueueTask) => ActiveRunSlotWaiter;
injectReferencedTaskContext: (request: QueueTaskRequest, finder?: (id: string) => QueueTask | null, injectedAt?: string) => QueueTaskRequest;
nextRunnableTaskFrom: (queueId: string, tasks?: QueueTask[]) => QueueTask | null;
normalizeTask: (task: QueueTask) => QueueTask;
nowIso: () => string;
processingQueues: Set<string>;
queueHeadTask: (queueId: string, tasks?: QueueTask[]) => QueueTask | null;
queuedStatusReason: (task: QueueTask, tasks?: QueueTask[]) => QueuedStatusReason | null;
removeActiveRunSlotWaiter: (waiter: ActiveRunSlotWaiter) => void;
resolveReasoningEffort: (model: string, explicit?: string | null) => string | null;
updateProcessingFlag: () => void;
}
let context: SelfTestsContext | null = null;
export function configureSelfTests(runtimeContext: SelfTestsContext): void {
context = runtimeContext;
}
function ctx(): SelfTestsContext {
if (context === null) throw new Error("self-tests module is not configured");
return context;
}
function terminalTask(task: QueueTask): boolean {
return task.status === "succeeded" || task.status === "failed" || task.status === "canceled";
}
function testTask(id: string, prompt: string, finalResponse: string, referenceTaskIds: string[] = [], createdAt = ctx().nowIso()): QueueTask {
return ctx().normalizeTask({
id,
queueId: ctx().defaultQueueId,
queueEnteredAt: createdAt,
prompt,
basePrompt: prompt,
referenceTaskIds,
referenceInjection: null,
providerId: ctx().config.mainProviderId,
cwd: ctx().config.defaultWorkdir,
model: ctx().config.defaultModel,
reasoningEffort: ctx().resolveReasoningEffort(ctx().config.defaultModel, ctx().config.defaultReasoningEffort),
maxAttempts: 1,
status: "succeeded",
createdAt,
updatedAt: createdAt,
startedAt: createdAt,
finishedAt: createdAt,
readAt: null,
currentAttempt: 1,
currentMode: "initial",
codexThreadId: null,
activeTurnId: null,
finalResponse,
lastError: null,
lastJudge: null,
judgeFailCount: 0,
promptHistory: [],
output: finalResponse.length > 0 ? [{ seq: 1, at: createdAt, channel: "assistant", text: finalResponse, method: "item/agentMessage" }] : [],
events: [],
attempts: [],
cancelRequested: false,
nextPrompt: null,
nextMode: null,
});
}
function assertReferenceTest(condition: boolean, message: string): void {
if (!condition) throw new Error(message);
}
function runReferenceInjectionSelfTest(): JsonValue {
const at = "2026-05-08T00:00:00.000Z";
const taskA = testTask("codex_1000_aaaaaa", "A base prompt", "A final", [], at);
const injectedB = ctx().injectReferencedTaskContext({
prompt: "引用 Code Queue 任务 codex_1000_aaaaaa。\n\n本次任务：\nB user prompt",
referenceTaskIds: [taskA.id],
}, (id) => id === taskA.id ? taskA : null, "2026-05-08T00:01:00.000Z");
const taskB = testTask("codex_1001_bbbbbb", injectedB.prompt, "B final", injectedB.referenceTaskIds, "2026-05-08T00:02:00.000Z");
taskB.basePrompt = injectedB.basePrompt ?? "";
taskB.referenceInjection = injectedB.referenceInjection ?? null;
const injectedC = ctx().injectReferencedTaskContext({
prompt: "C user prompt",
referenceTaskIds: [taskB.id],
}, (id) => id === taskA.id ? taskA : id === taskB.id ? taskB : null, "2026-05-08T00:03:00.000Z");
const promptC = injectedC.prompt;
const hintedC = injectCodeQueueEnvironmentHint(injectedC);
assertReferenceTest(injectedB.basePrompt === "B user prompt", "B basePrompt should strip frontend reference hint");
assertReferenceTest(taskB.referenceInjection?.items.length === 1, "B should have one reference item");
assertReferenceTest(injectedC.basePrompt === "C user prompt", "C basePrompt should be raw C prompt");
assertReferenceTest((injectedC.referenceInjection?.items.length ?? 0) === 2, "C should include B and A as two structured graph items");
assertReferenceTest(hintedC.prompt.startsWith(codeQueueEnvironmentHintTitle), "C should include the Code Queue environment hint");
assertReferenceTest(userPromptForDisplay(hintedC.prompt) === "C user prompt", "C display prompt should strip environment and reference injection");
assertReferenceTest(promptWithCodeQueueEnvironmentHint(hintedC.prompt) === hintedC.prompt, "environment hint injection should be idempotent");
const indexA = promptC.indexOf("Round 1.1 referenced task codex_1000_aaaaaa");
const indexB = promptC.indexOf("Round 2.1 referenced task codex_1001_bbbbbb");
assertReferenceTest(indexA >= 0, "C should include upstream A as round 1");
assertReferenceTest(indexB > indexA, "C should include direct B after upstream A");
assertReferenceTest(promptC.includes("----- Reference Round 1/2 -----"), "C should include explicit round 1 separator");
assertReferenceTest(promptC.includes("----- Reference Round 2/2 -----"), "C should include explicit round 2 separator");
assertReferenceTest(promptC.indexOf("----- Reference Round 1/2 -----") < indexA, "round 1 separator should appear before A");
assertReferenceTest(promptC.indexOf("----- Reference Round 2/2 -----") < indexB, "round 2 separator should appear before B");
assertReferenceTest(promptC.includes("### Initial prompt\nB user prompt"), "C should inject B base prompt, not B injected prompt");
assertReferenceTest(!promptC.includes("### Initial prompt\n# Code Queue 已解析引用上下文"), "C should not nest prior injected prompt blocks");
assertReferenceTest(promptC.includes("injectedAt: 2026-05-08T00:03:00.000Z"), "C should include injection timestamp");
assertReferenceTest(promptC.includes("# 本次任务\nC user prompt"), "C should include current user prompt");
const deepTasks: QueueTask[] = [];
for (let index = 0; index < 8; index += 1) {
const id = `codex_${2000 + index}_${"abcdef".slice(0, 6 - String(index).length)}${index}`;
const parent = deepTasks.at(-1);
deepTasks.push(testTask(id, `deep prompt ${index}`, `deep final ${index}`, parent === undefined ? [] : [parent.id], `2026-05-08T00:${String(10 + index).padStart(2, "0")}:00.000Z`));
}
const deepById = new Map(deepTasks.map((task) => [task.id, task]));
const injectedDeep = ctx().injectReferencedTaskContext({
prompt: "Deep user prompt",
referenceTaskIds: [deepTasks.at(-1)?.id ?? ""],
}, (id) => deepById.get(id) ?? null, "2026-05-08T00:30:00.000Z");
assertReferenceTest(injectedDeep.referenceInjection?.itemCount === 8, "deep reference chain should not truncate at six rounds");
assertReferenceTest(injectedDeep.referenceInjection?.truncated === false, "deep reference chain should be marked complete");
assertReferenceTest(injectedDeep.prompt.includes("----- Reference Round 8/8 -----"), "deep reference chain should expose all eight rounds");
const retryTask = testTask("codex_3000_retry", injectedDeep.prompt, "", injectedDeep.referenceTaskIds, "2026-05-08T00:31:00.000Z");
retryTask.basePrompt = injectedDeep.basePrompt ?? "";
retryTask.referenceInjection = injectedDeep.referenceInjection ?? null;
const retryAfterDeepReference = retryPrompt(retryTask, { decision: "retry", confidence: 1, reason: "Service restarted while task was active", source: "fallback" });
const recoveryAfterDeepReference = queueRecoveryRetryPrompt(retryTask, "Service restarted while task was active");
const explicitLongContinuePrompt = [
"请保留并完成以下所有验收点，不要截断：",
...Array.from({ length: 80 }, (_, index) => `验收点 ${index + 1}: 基于当前 thread 上文补齐缺失证据，并在最终 response 中写出真实命令/API/UI 结果。`),
].join("\n");
const explicitRetryPrompt = retryPrompt(retryTask, { decision: "retry", confidence: 1, reason: "Long MiniMax feedback fixture", continuePrompt: explicitLongContinuePrompt, source: "minimax" });
let longMiniMaxPromptRejectedAtSource = false;
try {
parsedContinuePromptForJudge({ continuePrompt: `${"x".repeat(continuePromptSourceBudgetChars + 1)}` }, "retry");
} catch {
longMiniMaxPromptRejectedAtSource = true;
}
assertReferenceTest(retryAfterDeepReference.length < 2600, "retry prompt should stay compact for referenced tasks");
assertReferenceTest(recoveryAfterDeepReference.length < 2200, "queue recovery prompt should stay compact for referenced tasks");
assertReferenceTest(!retryAfterDeepReference.includes("Reference Round"), "retry prompt should not re-inject reference rounds");
assertReferenceTest(!recoveryAfterDeepReference.includes("Reference Round"), "queue recovery prompt should not re-inject reference rounds");
assertReferenceTest(explicitRetryPrompt === explicitLongContinuePrompt, "explicit continuePrompt should not be tail-truncated");
assertReferenceTest(!explicitRetryPrompt.includes("已截断"), "explicit continuePrompt should not include truncation marker");
assertReferenceTest(longMiniMaxPromptRejectedAtSource, "over-budget MiniMax continuePrompt should be rejected for source repair");
return {
ok: true,
cases: [
{ name: "strip_frontend_hint_to_basePrompt", ok: true },
{ name: "multi_round_reference_graph", ok: true, itemCount: injectedC.referenceInjection?.itemCount ?? 0 },
{ name: "no_nested_injection_block", ok: true },
{ name: "chronological_round_order", ok: true },
{ name: "timestamp_and_round_separators", ok: true },
{ name: "environment_hint_injected_and_stripped_from_display", ok: true },
{ name: "deep_reference_graph_not_six_round_truncated", ok: true, itemCount: injectedDeep.referenceInjection?.itemCount ?? 0 },
{ name: "retry_prompt_does_not_reinject_reference_graph", ok: true, chars: retryAfterDeepReference.length },
{ name: "queue_recovery_prompt_is_compact", ok: true, chars: recoveryAfterDeepReference.length },
{ name: "explicit_continue_prompt_not_tail_truncated", ok: true, chars: explicitRetryPrompt.length },
{ name: "over_budget_minimax_continue_prompt_requires_source_repair", ok: true, budgetChars: continuePromptSourceBudgetChars },
],
promptPreview: safePreview(promptC, 1200),
};
}
function queueOrderTestTask(id: string, status: TaskStatus, createdAt: string, queueEnteredAt: string): QueueTask {
const task = testTask(id, `${id} prompt`, status === "succeeded" ? `${id} final` : "", [], createdAt);
task.queueId = "queue_order_test";
task.queueEnteredAt = queueEnteredAt;
task.status = status;
task.updatedAt = queueEnteredAt;
task.startedAt = status === "running" || status === "judging" ? queueEnteredAt : null;
task.finishedAt = terminalTask(task) ? queueEnteredAt : null;
task.currentAttempt = status === "queued" ? 0 : 1;
task.currentMode = status === "queued" ? null : "retry";
task.nextMode = status === "retry_wait" ? "retry" : null;
task.nextPrompt = status === "retry_wait" ? "continue" : null;
return ctx().normalizeTask(task);
}
function runQueueOrderingSelfTest(): JsonValue {
const activeRetry = queueOrderTestTask("codex_4000_active", "retry_wait", "2026-05-11T09:00:00.000Z", "2026-05-11T09:00:00.000Z");
const movedOlderCreated = queueOrderTestTask("codex_3999_moved", "queued", "2026-05-11T08:00:00.000Z", "2026-05-11T08:00:00.000Z") as QueueTask & { queueEnteredAt?: string };
delete (movedOlderCreated as Partial<QueueTask>).queueEnteredAt;
movedOlderCreated.output.push({ seq: 2, at: "2026-05-11T09:30:00.000Z", channel: "system", text: "moved from queue=default to queue=queue_order_test\n", method: "queue/move" });
ctx().normalizeTask(movedOlderCreated as QueueTask);
const blockedByRetry = [movedOlderCreated, activeRetry];
const runningHead = queueOrderTestTask("codex_4100_running", "running", "2026-05-11T10:00:00.000Z", "2026-05-11T10:00:00.000Z");
const queuedBehindRunning = queueOrderTestTask("codex_4101_queued", "queued", "2026-05-11T10:01:00.000Z", "2026-05-11T10:01:00.000Z");
const terminalAhead = queueOrderTestTask("codex_4200_done", "succeeded", "2026-05-11T11:00:00.000Z", "2026-05-11T11:00:00.000Z");
const queuedAfterTerminal = queueOrderTestTask("codex_4201_queued", "queued", "2026-05-11T11:01:00.000Z", "2026-05-11T11:01:00.000Z");
const originalMaxActiveQueues = ctx().config.maxActiveQueues;
assertReferenceTest(ctx().queueHeadTask("queue_order_test", blockedByRetry)?.id === activeRetry.id, "retry_wait head must keep blocking a moved older-created task");
assertReferenceTest(ctx().nextRunnableTaskFrom("queue_order_test", blockedByRetry)?.id === activeRetry.id, "next runnable should be the retry_wait head");
assertReferenceTest(ctx().nextRunnableTaskFrom("queue_order_test", [queuedBehindRunning, runningHead]) === null, "running head must block queued tasks behind it");
assertReferenceTest(ctx().nextRunnableTaskFrom("queue_order_test", [queuedAfterTerminal, terminalAhead])?.id === queuedAfterTerminal.id, "terminal head should not block later queued task");
assertReferenceTest(ctx().queuedStatusReason(queuedBehindRunning, [runningHead, queuedBehindRunning])?.label === "PREV TASK", "queued task behind an active same-queue task should expose PREV TASK reason");
assertReferenceTest(ctx().availableQueueStartSlotsFor(8, 0) === Number.POSITIVE_INFINITY, "maxActiveQueues=0 should leave queue-to-queue concurrency unbounded");
assertReferenceTest(ctx().availableQueueStartSlotsFor(0, 1) === 1, "empty active run slots should leave one slot available");
assertReferenceTest(ctx().availableQueueStartSlotsFor(1, 1) === 0, "one active run slot should exhaust maxActiveQueues=1");
try {
const marker = "__queue_order_idle_processing_self_test__";
const beforeSlotCount = ctx().activeRunSlotCount();
const hadProcessingMarker = ctx().processingQueues.has(marker);
const hadReservationMarker = ctx().activeRunSlotReservations.has(marker);
ctx().processingQueues.add(marker);
assertReferenceTest(ctx().activeRunSlotCount() === beforeSlotCount, "processing idle queue must not consume an active run slot");
ctx().activeRunSlotReservations.add(marker);
assertReferenceTest(ctx().activeRunSlotCount() === beforeSlotCount + (hadReservationMarker ? 0 : 1), "reserved running queue must consume an active run slot");
if (!hadProcessingMarker) ctx().processingQueues.delete(marker);
if (!hadReservationMarker) ctx().activeRunSlotReservations.delete(marker);
} finally {
ctx().config.maxActiveQueues = originalMaxActiveQueues;
ctx().updateProcessingFlag();
}
{
const waiterCount = ctx().activeRunSlotWaiters.length;
const firstWaiter = ctx().enqueueActiveRunSlotWaiter(activeRetry);
const secondWaiter = ctx().enqueueActiveRunSlotWaiter(queuedAfterTerminal);
try {
assertReferenceTest(ctx().activeRunSlotWaiters[waiterCount]?.id === firstWaiter.id, "first active run slot waiter should keep FIFO position");
assertReferenceTest(ctx().activeRunSlotWaiters[waiterCount + 1]?.id === secondWaiter.id, "second active run slot waiter should not jump ahead");
} finally {
ctx().removeActiveRunSlotWaiter(firstWaiter);
ctx().removeActiveRunSlotWaiter(secondWaiter);
}
}
return {
ok: true,
cases: [
{ name: "retry_wait_head_blocks_moved_older_created_task", ok: true, head: activeRetry.id, moved: movedOlderCreated.id },
{ name: "running_head_blocks_later_queued_task", ok: true },
{ name: "terminal_task_does_not_block_queue", ok: true },
{ name: "queued_reason_prev_task", ok: true },
{ name: "max_active_queues_zero_is_unbounded", ok: true },
{ name: "idle_processing_queue_does_not_consume_active_run_slot", ok: true },
{ name: "active_run_slot_waiters_are_fifo", ok: true },
],
};
}
function opencodeTraceOutput(seq: number, tool: string, input: Record<string, JsonValue>, output: string, status = "completed", metadata: Record<string, JsonValue> | null = null): LiveOutput {
return {
seq,
at: "2026-05-12T00:00:00.000Z",
channel: "tool",
method: "opencode/tool",
text: `${JSON.stringify({
type: "tool_use",
sessionID: "ses_trace_self_test",
part: {
type: "tool",
tool,
id: `prt_trace_${seq}`,
state: {
status,
input,
output,
...(metadata === null ? {} : { metadata }),
time: { start: 1000, end: 1337 },
},
},
})}\n`,
itemId: `prt_trace_${seq}`,
};
}
function partialOpencodeTraceOutput(seq: number): LiveOutput {
const raw = JSON.stringify({
type: "tool_use",
sessionID: "ses_trace_self_test",
part: {
type: "tool",
tool: "bash",
id: `prt_trace_${seq}`,
state: {
status: "completed",
input: { command: "git diff -- src/components/frontend/src/trace.tsx" },
output: `diff --git a/src/components/frontend/src/trace.tsx b/src/components/frontend/src/trace.tsx\n${"x".repeat(3000)}`,
},
},
});
return {
seq,
at: "2026-05-12T00:00:00.000Z",
channel: "tool",
method: "opencode/tool",
text: `${raw.slice(0, 700)}...`,
itemId: `prt_trace_${seq}`,
};
}
function runTracePortSelfTest(): JsonValue {
const task = testTask("codex_5000_trace", "trace prompt", "", [], "2026-05-12T00:00:00.000Z");
task.model = minimaxM27Model;
task.output = [
{ seq: 1, at: "2026-05-12T00:00:00.000Z", channel: "system", method: "queue", text: "attempt 1/1 queue=default provider=main-server cwd=/root/unidesk mode=initial model=minimax-m2.7 port=opencode\n" },
{ seq: 2, at: "2026-05-12T00:00:00.000Z", channel: "system", method: "opencode/step-start", text: "opencode run started session=ses_trace_self_test\n" },
opencodeTraceOutput(3, "grep", { command: "rg -n trace src/components/microservices/code-queue/src/index.ts" }, "src/components/microservices/code-queue/src/index.ts:1:trace"),
{ seq: 4, at: "2026-05-12T00:00:00.000Z", channel: "system", method: "opencode/step-finish", text: "opencode run finished reason=tool-calls\n" },
opencodeTraceOutput(5, "edit", { filePath: "src/components/frontend/src/trace.tsx" }, "Edit applied successfully.", "completed", {
diff: "Index: src/components/frontend/src/trace.tsx\n===================================================================\n--- src/components/frontend/src/trace.tsx\n+++ src/components/frontend/src/trace.tsx\n@@ -1,1 +1,2 @@\n const before = true;\n+const after = true;\n",
}),
opencodeTraceOutput(6, "bash", { command: "bunx tsc -p scripts/tsconfig.json --noEmit" }, "ok"),
partialOpencodeTraceOutput(7),
{ seq: 8, at: "2026-05-12T00:00:00.000Z", channel: "reasoning", method: "opencode/reasoning", text: "hidden reasoning\n" },
{ seq: 9, at: "2026-05-12T00:00:00.000Z", channel: "assistant", method: "opencode/text", text: "<think>hidden reasoning</think>\n" },
];
const transcript = buildTaskTranscript(task, 20, 0);
const explored = transcript.find((line) => line.seq === 3);
const edited = transcript.find((line) => line.seq === 5);
const ran = transcript.find((line) => line.seq === 6);
const partial = transcript.find((line) => line.seq === 7);
if (explored === undefined || edited === undefined || ran === undefined || partial === undefined) throw new Error("opencode trace self-test transcript lines missing");
assertReferenceTest(explored.kind === "explored", "opencode grep tool should normalize to explored trace line");
assertReferenceTest(edited.kind === "edited", "opencode edit tool should normalize to edited trace line");
assertReferenceTest(ran.kind === "ran", "opencode bash command should normalize to ran trace line");
assertReferenceTest(partial.kind === "explored", "truncated opencode tool JSON should still normalize from command preview");
assertReferenceTest(Number(explored.durationMs ?? 0) === 337, "opencode tool duration should be preserved");
assertReferenceTest(transcriptLineSummaryLines(edited).some((line) => line.includes("trace.tsx")), "summary lines should expose edited path");
assertReferenceTest(String(edited.bodyPreview || "").includes("+const after = true;"), "opencode edit should use metadata diff for line diff display");
assertReferenceTest(!transcript.some((line) => line.status === "opencode/step-start" || line.status === "opencode/step-finish"), "opencode step boundaries should stay out of trace");
assertReferenceTest(!transcript.some((line) => String(line.bodyPreview || "").includes("<think>hidden reasoning</think>")), "reasoning-only opencode assistant text should not duplicate reasoning");
return {
ok: true,
cases: [
{ name: "opencode_tool_to_explored", ok: true, title: explored?.title ?? null },
{ name: "opencode_tool_to_edited", ok: true, title: edited?.title ?? null },
{ name: "opencode_tool_to_ran", ok: true, title: ran?.title ?? null },
{ name: "partial_opencode_tool_to_explored", ok: true, title: partial?.title ?? null },
{ name: "step_boundaries_filtered", ok: true },
{ name: "reasoning_duplicate_filtered", ok: true },
{ name: "duration_preserved", ok: true, durationMs: explored?.durationMs ?? null },
],
transcript: transcript.filter((line) => line.seq >= 2).map((line) => ({
seq: line.seq,
kind: line.kind,
title: line.title,
status: line.status,
commandPreview: line.commandPreview,
summaryLines: transcriptLineSummaryLines(line),
durationMs: line.durationMs ?? null,
})),
} as unknown as JsonValue;
}
function runJudgeInfraSelfTest(): JsonValue {
const thinkThenJson = [
"<think>The tool command seems to be garbled. Let me inspect the file.</think>",
"只能根据 evidence 判定，最终 JSON 如下：",
"{\"decision\":\"complete\",\"confidence\":0.91,\"reason\":\"证据完整\",\"continuePrompt\":\"\"}",
].join("\n");
const fencedJson = [
"```json",
"{\"decision\":\"retry\",\"confidence\":0.8,\"reason\":\"缺少 live 验证\",\"continuePrompt\":\"继续补齐 live 验证证据。\"}",
"```",
].join("\n");
const labeledContinue = "json:\n{\"decision\":\"continue\",\"confidence\":0.7,\"reason\":\"还要继续\",\"continuePrompt\":\"继续执行剩余验收。\"}";
const parsedThink = parseJudgeJson(thinkThenJson);
const parsedFenced = parseJudgeJson(fencedJson);
const parsedContinue = parseJudgeJson(labeledContinue);
assertReferenceTest(parsedThink.value.decision === "complete", "judge parser should extract JSON after think/tool-like prose");
assertReferenceTest(parsedFenced.value.decision === "retry", "judge parser should extract fenced JSON");
assertReferenceTest(parsedContinue.value.decision === "continue", "judge parser should accept continue alias");
const repairMessages = miniMaxJudgeMessages("{\"instruction\":\"fixture\"}", {
error: "MiniMax judge did not return parseable JSON after denoise",
previousAnswerRaw: "<think>Let me just look at the trace.tsx file.</think>\nLet me inspect files first.",
});
assertReferenceTest(repairMessages.length === 3, "repair request should include system, original user, and repair user messages");
assertReferenceTest(repairMessages.every((message) => message.role !== "assistant"), "repair request must not echo malformed output as assistant history");
assertReferenceTest(repairMessages[0]?.content.includes("没有工具访问") === true, "system prompt should prohibit tool/file inspection");
assertReferenceTest(repairMessages[2]?.content.includes("previousAnswerRaw") === true, "repair request should preserve the bad answer as inert data");
assertReferenceTest(repairMessages[2]?.content.includes("不要延续") === true, "repair request should explicitly stop continuing bad agent-like output");
return {
ok: true,
cases: [
{ name: "parse_think_then_json", ok: true, source: parsedThink.source },
{ name: "parse_fenced_json", ok: true, source: parsedFenced.source },
{ name: "parse_continue_alias", ok: true, source: parsedContinue.source },
{ name: "repair_without_assistant_echo", ok: true, roles: repairMessages.map((message) => message.role) },
{ name: "repair_blocks_tool_like_continuation", ok: true },
],
};
}
export { runJudgeInfraSelfTest, runQueueOrderingSelfTest, runReferenceInjectionSelfTest, runTracePortSelfTest };
src/components/microservices/code-queue/src/task-output.ts
+158
View File
@@ -0,0 +1,158 @@
// 重构前 index.ts 只读参考：commit 6a04144d3f5103014f75b637d7e6bc2f45bf007f，blob 56e590c1a6b5ca7ad128bf2c992f60e46c355a58；可用 `git show 6a04144d3f5103014f75b637d7e6bc2f45bf007f:src/components/microservices/code-queue/src/index.ts` 查看。
import { appendFileSync, existsSync, mkdirSync, readFileSync, statSync } from "node:fs";
import { resolve } from "node:path";
import type { ArchivedLiveOutput, JsonValue, LiveOutput, OutputChannel, QueueTask, RuntimeConfig } from "./types";
export interface TaskOutputContext {
config: Pick<RuntimeConfig, "maxInMemoryOutputRecords" | "outputArchiveDir">;
allocateSeq: () => number;
errorToJson: (error: unknown) => JsonValue;
logger: (level: "debug" | "info" | "warn" | "error", message: string, data?: JsonValue) => void;
markTaskDirty: (taskId: string) => void;
nowIso: () => string;
schedulePersistState: () => void;
}
const outputArchiveSeededTasks = new Set<string>();
let context: TaskOutputContext | null = null;
export function configureTaskOutput(runtimeContext: TaskOutputContext): void {
context = runtimeContext;
}
function ctx(): TaskOutputContext {
if (context === null) throw new Error("task-output module is not configured");
return context;
}
function taskOutputArchivePath(taskId: string): string {
return resolve(ctx().config.outputArchiveDir, `${taskId}.jsonl`);
}
function serializeArchivedOutput(output: LiveOutput, op: ArchivedLiveOutput["op"], text: string): string {
const record: ArchivedLiveOutput = {
seq: output.seq,
at: output.at,
channel: output.channel,
text,
...(output.method === undefined ? {} : { method: output.method }),
...(output.itemId === undefined ? {} : { itemId: output.itemId }),
op,
};
return `${JSON.stringify(record)}\n`;
}
function ensureTaskOutputArchiveSeeded(task: QueueTask): void {
if (outputArchiveSeededTasks.has(task.id)) return;
mkdirSync(ctx().config.outputArchiveDir, { recursive: true });
const path = taskOutputArchivePath(task.id);
if (!existsSync(path) && task.output.length > 0) {
const seed = task.output.map((output) => serializeArchivedOutput(output, "set", output.text)).join("");
appendFileSync(path, seed, "utf8");
}
outputArchiveSeededTasks.add(task.id);
}
function appendOutputArchive(task: QueueTask, output: LiveOutput, op: ArchivedLiveOutput["op"], text: string): void {
try {
mkdirSync(ctx().config.outputArchiveDir, { recursive: true });
appendFileSync(taskOutputArchivePath(task.id), serializeArchivedOutput(output, op, text), "utf8");
} catch (error) {
ctx().logger("error", "codex_output_archive_write_failed", { taskId: task.id, error: ctx().errorToJson(error) });
}
}
function archiveRecordToOutput(value: unknown): ArchivedLiveOutput | null {
if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
const record = value as Record<string, unknown>;
const seq = Number(record.seq);
if (!Number.isFinite(seq)) return null;
const channel = String(record.channel || "system") as OutputChannel;
if (!["system", "user", "assistant", "reasoning", "command", "diff", "tool", "error"].includes(channel)) return null;
return {
seq,
at: typeof record.at === "string" ? record.at : ctx().nowIso(),
channel,
text: typeof record.text === "string" ? record.text : "",
...(typeof record.method === "string" ? { method: record.method } : {}),
...(typeof record.itemId === "string" ? { itemId: record.itemId } : {}),
op: record.op === "append" ? "append" : "set",
};
}
function archivedTaskOutput(task: QueueTask): LiveOutput[] {
const path = taskOutputArchivePath(task.id);
if (!existsSync(path)) return [];
const bySeq = new Map<number, LiveOutput>();
try {
const text = readFileSync(path, "utf8");
for (const line of text.split(/\r?\n/u)) {
if (line.trim().length === 0) continue;
const record = archiveRecordToOutput(JSON.parse(line) as unknown);
if (record === null) continue;
const existing = bySeq.get(record.seq);
if (record.op === "append" && existing !== undefined) {
existing.text += record.text;
existing.at = record.at;
existing.channel = record.channel;
existing.method = record.method;
existing.itemId = record.itemId;
} else {
const { op: _op, ...output } = record;
bySeq.set(record.seq, output);
}
}
} catch (error) {
ctx().logger("warn", "codex_output_archive_read_failed", { taskId: task.id, error: ctx().errorToJson(error) });
return [];
}
return Array.from(bySeq.values()).sort((left, right) => Number(left.seq) - Number(right.seq));
}
function taskFullOutput(task: QueueTask): LiveOutput[] {
const bySeq = new Map<number, LiveOutput>();
for (const output of archivedTaskOutput(task)) bySeq.set(output.seq, output);
for (const output of task.output) bySeq.set(output.seq, output);
return Array.from(bySeq.values()).sort((left, right) => Number(left.seq) - Number(right.seq));
}
function outputArchiveSignature(task: QueueTask): string {
try {
const stat = statSync(taskOutputArchivePath(task.id));
return `${stat.size}:${Math.floor(stat.mtimeMs)}`;
} catch {
return "none";
}
}
function appendOutput(task: QueueTask, channel: OutputChannel, text: string, method?: string, itemId?: string, append = false): LiveOutput | null {
if (text.length === 0) return null;
try {
ensureTaskOutputArchiveSeeded(task);
} catch (error) {
ctx().logger("error", "codex_output_archive_seed_failed", { taskId: task.id, error: ctx().errorToJson(error) });
}
const last = task.output[task.output.length - 1];
let output: LiveOutput;
let archiveOp: ArchivedLiveOutput["op"] = "set";
let archiveText = text;
if (append && last !== undefined && last.channel === channel && last.itemId === itemId && last.method === method && last.text.length < 24_000) {
last.text += text;
last.at = ctx().nowIso();
output = last;
archiveOp = "append";
} else {
output = { seq: ctx().allocateSeq(), at: ctx().nowIso(), channel, text, method, itemId };
task.output.push(output);
}
appendOutputArchive(task, output, archiveOp, archiveText);
if (ctx().config.maxInMemoryOutputRecords > 0 && task.output.length > ctx().config.maxInMemoryOutputRecords) task.output.splice(0, task.output.length - ctx().config.maxInMemoryOutputRecords);
task.updatedAt = ctx().nowIso();
ctx().markTaskDirty(task.id);
ctx().schedulePersistState();
return output;
}
export { appendOutput, appendOutputArchive, archivedTaskOutput, outputArchiveSignature, taskFullOutput };
src/components/microservices/code-queue/src/task-view.ts
+2111
View File
File diff suppressed because it is too large Load Diff
src/components/microservices/code-queue/src/types.ts
+411
View File
@@ -0,0 +1,411 @@
// 重构前 index.ts 只读参考：commit 6a04144d3f5103014f75b637d7e6bc2f45bf007f，blob 56e590c1a6b5ca7ad128bf2c992f60e46c355a58；可用 `git show 6a04144d3f5103014f75b637d7e6bc2f45bf007f:src/components/microservices/code-queue/src/index.ts` 查看。
export type JsonValue = string | number | boolean | null | JsonValue[] | { [key: string]: JsonValue };
export type TaskStatus = "queued" | "running" | "judging" | "retry_wait" | "succeeded" | "failed" | "canceled";
export interface QueuedStatusReason {
code: string;
label: string;
message: string;
blockerTaskId?: string | null;
blockerQueueId?: string | null;
waitPosition?: number | null;
activeRunSlotCount?: number | null;
maxActiveQueues?: number | null;
memory?: JsonValue;
}
export type RunMode = "initial" | "retry";
export type JudgeDecision = "complete" | "retry" | "fail";
export type OutputChannel = "system" | "user" | "assistant" | "reasoning" | "command" | "diff" | "tool" | "error";
export type TerminalStatus = "completed" | "interrupted" | "failed" | null;
export type TranscriptKind = "ran" | "explored" | "edited" | "plan" | "message" | "system" | "error";
export interface RuntimeConfig {
host: string;
port: number;
dataDir: string;
outputArchiveDir: string;
logFile: string;
defaultWorkdir: string;
mainProviderId: string;
remoteDefaultWorkdir: string;
executionProviderIds: string[];
remoteCodexEnvKeys: string[];
codexHome: string;
opencodeXdgDir: string;
sourceCodexConfig: string;
codexSqliteLogExportEnabled: boolean;
codexSqliteLogExportIntervalMs: number;
codexSqliteLogExportBatchSize: number;
codexSqliteLogMaxBytes: number;
memoryWatchdogThresholdBytes: number;
memoryWatchdogIntervalMs: number;
defaultModel: string;
codexModels: string[];
defaultReasoningEffort: string | null;
modelReasoningEfforts: Record<string, string>;
sandbox: "read-only" | "workspace-write" | "danger-full-access";
approvalPolicy: "untrusted" | "on-failure" | "on-request" | "never";
defaultMaxAttempts: number;
codeModels: string[];
minimaxApiKey: string;
minimaxApiBase: string;
minimaxModel: string;
judgeTimeoutMs: number;
judgeRepairAttempts: number;
judgeMaxTokens: number;
turnNoActivityTimeoutMs: number;
databaseUrl: string;
databaseFlushIntervalMs: number;
notifyClaudeQqEnabled: boolean;
notifyClaudeQqBaseUrl: string;
notifyClaudeQqTargetType: "private" | "group";
notifyClaudeQqUserId: string;
notifyClaudeQqGroupId: string;
notifyClaudeQqMaxResponseChars: number;
notifyClaudeQqTimeoutMs: number;
notifyClaudeQqSendAttempts: number;
notifyClaudeQqRetryIntervalMs: number;
notifyClaudeQqMaxOutboxItems: number;
maxInMemoryOutputRecords: number;
maxInMemoryEventRecords: number;
maxActiveQueues: number;
devContainerMasterHost: string;
devContainerDefaultProviderId: string;
devContainerImage: string;
devContainerWorkdir: string;
}
export interface QueueTaskRequest {
prompt: string;
queueId?: string;
providerId?: string;
cwd?: string;
model?: string;
reasoningEffort?: string;
maxAttempts?: number;
referenceTaskIds?: string[];
basePrompt?: string;
referenceInjection?: ReferenceInjectionRecord | null;
}
export interface LiveOutput {
seq: number;
at: string;
channel: OutputChannel;
text: string;
method?: string;
itemId?: string;
}
export interface ArchivedLiveOutput extends LiveOutput {
op?: "set" | "append";
}
export interface TranscriptLine {
seq: number;
at: string;
durationMs?: number;
kind: TranscriptKind;
title: string;
status?: string;
commandPreview?: string;
commandOmittedLines?: number;
bodyPreview?: string;
bodyOmittedLines?: number;
stdoutPreview?: string;
stdoutOmittedLines?: number;
stderrPreview?: string;
stderrOmittedLines?: number;
rawSeqs: number[];
fullPrompt?: string;
fullPromptLines?: number;
fullPromptChars?: number;
foldedReferencePrompt?: boolean;
}
export interface CodexEventSummary {
at: string;
method: string;
itemType?: string;
status?: string;
message?: string;
textPreview?: string;
}
export interface AttemptSummary {
index: number;
mode: RunMode;
startedAt: string;
finishedAt: string;
terminalStatus: TerminalStatus;
transportClosedBeforeTerminal: boolean;
appServerExitCode: number | null;
appServerSignal: string | null;
error: string | null;
inputPrompt?: string;
inputPromptPreview?: string;
inputPromptChars?: number;
inputPromptLines?: number;
finalResponse?: string;
finalResponsePreview: string;
finalResponseChars?: number;
judge?: JudgeResult | null;
judgeAt?: string | null;
judgeSeq?: number | null;
feedbackPrompt?: string;
feedbackPromptPreview?: string;
feedbackPromptChars?: number;
feedbackPromptLines?: number;
feedbackPromptSource?: string;
feedbackPromptForAttempt?: number | null;
stderrTail: string;
outputStartSeq?: number | null;
outputEndSeq?: number | null;
errorCount?: number;
}
export interface JudgeResult {
decision: JudgeDecision;
confidence: number;
reason: string;
continuePrompt?: string;
source: "minimax" | "fallback";
raw?: JsonValue;
}
export interface FeedbackPromptRecord {
text: string;
preview: string;
chars: number;
lines: number;
source: string;
forAttempt: number | null;
truncated: boolean;
}
export interface ParsedJudgeJson {
value: Record<string, unknown>;
source: string;
}
export interface MiniMaxJudgeResponse {
rawText: string;
content: string;
}
export interface ReferenceInjectionSummaryItem {
round: number;
roundIndex: number;
taskId: string;
viaTaskId: string | null;
status: TaskStatus;
providerId: string;
model: string;
cwd: string;
createdAt: string;
updatedAt: string;
promptChars: number;
finalResponseChars: number;
finalResponseAt: string | null;
finalResponseSource: string;
referenceTaskIds: string[];
cliHint: string;
}
export interface ReferenceInjectionRecord {
version: 2;
injectedAt: string;
basePrompt: string;
directReferenceTaskIds: string[];
maxRounds: number | null;
truncated: boolean;
itemCount: number;
items: ReferenceInjectionSummaryItem[];
}
export interface PromptHistoryItem {
seq: number;
at: string;
method: "turn/steer";
text: string;
}
export interface QueueTask {
id: string;
queueId: string;
queueEnteredAt: string;
prompt: string;
basePrompt: string;
referenceTaskIds: string[];
referenceInjection: ReferenceInjectionRecord | null;
providerId: string;
cwd: string;
model: string;
reasoningEffort: string | null;
maxAttempts: number;
status: TaskStatus;
createdAt: string;
updatedAt: string;
startedAt: string | null;
finishedAt: string | null;
readAt: string | null;
currentAttempt: number;
currentMode: RunMode | null;
codexThreadId: string | null;
activeTurnId: string | null;
finalResponse: string;
lastError: string | null;
lastJudge: JudgeResult | null;
judgeFailCount: number;
promptHistory: PromptHistoryItem[];
output: LiveOutput[];
events: CodexEventSummary[];
attempts: AttemptSummary[];
cancelRequested: boolean;
nextPrompt: string | null;
nextMode: RunMode | null;
}
export interface PersistedState {
version: 1;
updatedAt: string;
nextSeq: number;
queues: QueueRecord[];
tasks: QueueTask[];
}
export interface ClaudeQqNotificationItem {
id: string;
kind: string;
dedupKey: string;
target: string;
message: string;
createdAt: string;
updatedAt: string;
attempts: number;
nextAttemptAt: string;
lastError: string | null;
sentAt: string | null;
}
export interface ClaudeQqNotificationOutboxState {
version: 1;
updatedAt: string;
items: ClaudeQqNotificationItem[];
}
export interface ClaudeQqNotificationRow {
id: string;
kind: string;
dedup_key: string;
target: string;
message: string;
created_at: Date | string;
updated_at: Date | string;
attempts: number;
next_attempt_at: Date | string;
last_error: string | null;
sent_at: Date | string | null;
}
export interface QueueRecord {
id: string;
name: string;
createdAt: string;
updatedAt: string;
}
export interface AppServerExit {
code: number | null;
signal: string | null;
stderrTail: string;
}
export interface CodexRunResult {
threadId: string | null;
turnId: string | null;
finalResponse: string;
terminalStatus: TerminalStatus;
terminalError: string | null;
transportClosedBeforeTerminal: boolean;
appServerExit: AppServerExit;
events: CodexEventSummary[];
}
export interface SessionFileChange {
callId: string;
at: string;
name: string;
input: string;
output: string;
}
export interface SessionCommandOutput {
callId: string;
at: string;
stdout: string;
stderr: string;
output: string;
exitCode: number | null;
}
export interface JudgeProbeCase {
id: string;
prompt: string;
finalResponse: string;
expected: JudgeDecision;
expectedContinuePromptIncludes?: string[];
expectedContinuePromptExcludes?: string[];
expectedContinuePromptMaxChars?: number;
expectedContinuePromptMaxLines?: number;
terminalStatus: TerminalStatus;
cancelRequested?: boolean;
transportClosedBeforeTerminal?: boolean;
terminalError?: string | null;
stderrTail?: string;
outputs?: Array<{ channel: OutputChannel; text: string; method?: string }>;
events?: CodexEventSummary[];
}
export interface DevContainerPlan {
providerId: string;
containerName: string;
image: string;
workdir: string;
containerWorkdir: string;
remoteCodexHome: string;
remoteOpencodeXdgDir: string;
masterHost: string;
tunId: number;
tunName: string;
serverIp: string;
clientIp: string;
natChain: string;
keyDir: string;
masterKeyPath: string;
}
export interface DevContainerCommandLog {
name: string;
providerId: string | null;
exitCode: number | null;
signal: NodeJS.Signals | null;
durationMs: number;
stdout: string;
stderr: string;
}
export interface CgroupMemoryUsage {
currentBytes: number;
inactiveFileBytes: number;
workingSetBytes: number;
swapCurrentBytes: number;
swapMaxBytes: number | null;
}