8 Commits
Author SHA1 Message Date
kicer 53fa5da82b 新增语音输入(mcp_asr)与健康检查服务标识
语音输入:输入框为空时发送键变麦克风,进入语音模式后按住说话、松手转写并发送;套壳 App 走原生录音桥,浏览器走 MediaRecorder(需 HTTPS)。转写在 mcp_asr,经 /api/asr/transcribe 直达,不经过模型、不消耗 token。

/api/health 增加 service/api/auth_required 字段并设 no-store,供套壳 App 校验手填的服务器地址;免认证路径容忍尾斜杠,避免 /api/health/ 被中间件 401。

接线与文档:compose 新增 mcp_asr;init.sh 默认复用 BIGMODEL_KEY 作为 ASR_API_KEY;README/AGENTS/mcp 文档同步。版本 2.3.0 → 2.4.0。
2026-10-24 16:13:30 +08:00
kicer 5b70f7d614 图片滑动改为双层分页 + 相邻图预取,消除切图卡顿与空白
原实现松手时把拖到一半的图瞬移回中心再换 src,视觉上先跳一下;
新图又要等松手后才开始下载,所以会闪白。改为:

- 双层 img:拖动方向确定后相邻图摆到另一侧,两图一起跟手移动,
  松手各自滑到位(旧图滑出、新图滑入),不再瞬移
- 开图即用 Image 预取前后各一张(再往后一张),切图直接用已解码位图;
  每次落定后补取新邻居,关窗清空引用
- 缩放/平移强制 transition:none,避免与滑动动画的过渡打架
- 连点方向键/快速连滑先收尾上一段动画,避免接替层被瞬移
- 第二层 img 由脚本创建,旧缓存 HTML 也能正常工作

css: 两层 img 绝对定位居中叠放 + will-change: transform
2026-10-24 10:24:29 +08:00
kicer dfcbe6d3ea 图片查看器支持同组图片左右滑动切换
移动端点开图片后可在同一组内横滑切换(1x 缩放时接管手势,放大后仍是拖动平移),
底部显示页码,桌面补 ←/→。组边界:聊天内同一消息/工具卡;文件面板当前目录。

- stream.js: openImageViewer 增加可选 list/at 参数与组状态,横滑+页码+键盘
- preview.js: pvImgGroup 按当前目录聚合图片(用下载直链,不逐张取 blob)
- index.html/style.css: 新增 #img-count 页码节点与样式
2026-10-24 10:18:07 +08:00
kicer 516b4a5d86 fix issues 2026-10-24 09:59:48 +08:00
kicer e39273e97f feat(document-photo-to-pdf): raw PNG 页图导出到 out/,PDF 从 raw 派生
出件改为一次透视:PIL 按四边形自然尺寸 warp 出 raw 页图(只裁剪+拉正,不调色、不缩放、无白边),直接写 out/<PDF 主名>-NN.png;PDF 页再由 raw 调色 + LANCZOS 缩到画布内容区派生。相比「PDF 目标尺寸一次 + raw 自然尺寸一次」少一次 warp,10MP 自然尺寸从 numpy 的 3.0s/页降到 PIL 的 0.3s/页。

不新增输入参数:每次运行 PDF 与 PNG 全出,AI 不需要判断格式;SKILL.md 只补 out/ 说明、images 返回字段,以及 description 里的产出(PDF + out/ 下的 PNG 原图)。

页序先定后渲染,PNG 编号跟最终 PDF 页序;PDF 落盘成功后才清理同前缀的多余编号(失败保留上一份),不碰 out/ 里其它文件。numpy warp 与旧 warp_page 保留作回退路径。

真实样张(task-20261021-004,3 页)A/B:state.json 完全一致;PDF 逐页平均差 0.7 / 0.7 / 1.2 灰度级;raw PNG 与 numpy 自然尺寸 warp 平均差 0.02;3 页端到端 4.8s,PNG 0.58/0.69/0.90MB。注:doc_deskew/smoke_test.py 自 fe1c6d1 起未同步返回契约,属既有问题,本次未改。
2026-10-24 09:54:37 +08:00
kicer 8b8fbddb4f refactor(prompt): 精简默认提示词、强化技能优先,校正两个图像技能描述
profile-default.txt 109 行 → 74 行(5.6KB → 3.4KB)。删除 in-scope 能力枚举(与工具/技能清单重复且会随新 MCP 过期)、通用建议与三处重复表述;保留反造假护栏、能力判断规则、mint_public_link 机密禁令,环境事实逐条与 executor 镜像核对后保留。

新增 ## Skill Use 紧贴技能清单:写脚本/装包前先查技能,首次运行前 get 一次接口、同会话不重复 get。规则覆盖全部技能,required 降级为「该域不要手写等价实现」,不必给所有技能加 required。能力判断顺序改为先查技能再考虑工具组合。

两个图像技能描述改为自足表述、互不引用:document-photo-to-pdf 补纸质文档触发词,image-process 明确普通图片/截图。skills/README.md 补 required 字段说明。
2026-10-24 09:21:54 +08:00
kicer ba9534f064 修复 office 预览偶发「暂无这份文档」与冷启动长时间转圈
预览网关不再把 HEAD 探针转发给 watch:watch(Kestrel) 对 HEAD 只发响应头(带
content-length)不发 body 就断链,Node 客户端抛 HPE_CLOSED_CONNECTION,旧逻辑把
它当上游故障 res.destroy(),同一文档十次 HEAD 里六七次变成空响应/502;前端探到
一次 404 就显示「预览服务中暂无这份文档」。改为本地按文件系统回答,404 补
no-store(避免被缓存后文件补上仍显示占位卡)。

HEAD 回 200 前等槽位就绪(上限 HEAD_WAIT_MS=15s):冷启动首次渲染很贵(2~6s),
等完再放 iframe 进来,否则这段开销落到 5s 时限的导航请求上,慢文档会被判超时。

导航超时不再直接 retire 正在渲染的 watch——连坐杀掉会让渲染从头再来,表现为一直
转圈;改为连续 3 次超时(约 15s 无首字节)或硬性拒连才判死重启,成功转发后清零。
上游在响应已完整时断链的假报错也不再打断已写好的响应(留一拍再判)。

槽满时优先踢「就绪且无活动连接」的槽,避免误杀正在启动的 watch(浪费数秒冷启动
并让等它的请求失败进冷却)。前端探针遇 404 先短重试一次再落占位卡,文案改为
404 的真实语义(文件已删除/改名/不在任务目录)。
2026-10-24 09:13:45 +08:00
kicer 43e77e569e 审核页加载失败时保留可用的返回按钮
- #back / #pdf 的绑定从 boot() 移到 start():boot 只在加载成功后执行,
  空状态下 X 之前是死的,点了没反应。
- 加载失败时给 body 加 is-empty,隐藏工具栏/底栏/预览区,只留白色标题条。
- data.db 缺 doc_review_batch 表时改成人话提示,不再直接抛 SQLite 错误。
2026-10-24 08:43:57 +08:00
36 changed files with 2324 additions and 207 deletions
+4 -3
View File
@@ -22,7 +22,7 @@
| `app/server/public/` | 前端静态资源,经典脚本按序加载,共享全局作用域 | 无构建步骤 | | `app/server/public/` | 前端静态资源,经典脚本按序加载,共享全局作用域 | 无构建步骤 |
| `executor/` | **agent-executor**:`/exec` 隔离命令执行 + Office 预览网关 | 零依赖 Node,独立容器 | | `executor/` | **agent-executor**:`/exec` 隔离命令执行 + Office 预览网关 | 零依赖 Node,独立容器 |
| `wxbot/` | 微信 iLink 协议调制解调器(多实例) | 独立容器 `agent-wxbot` | | `wxbot/` | 微信 iLink 协议调制解调器(多实例) | 独立容器 `agent-wxbot` |
| `mcp/` | 同栈 MCP 服务:`web_search` / `image_task` / `video_task` | 三个容器,仅内网 | | `mcp/` | 同栈 MCP 服务:`web_search` / `image_task` / `video_task` / `asr` | 四个容器,仅内网 |
| `skills/` | 目录式技能(`SKILL.md` + `run.py`/`run.sh`) | 运行时挂载,`skills/deps` 为依赖层 | | `skills/` | 目录式技能(`SKILL.md` + `run.py`/`run.sh`) | 运行时挂载,`skills/deps` 为依赖层 |
| `scripts/` | `init.sh` 生成 `.env` + `config.yml`;`init_host.sh` 裸机初始化 | 幂等 | | `scripts/` | `init.sh` 生成 `.env` + `config.yml`;`init_host.sh` 裸机初始化 | 幂等 |
| `docs/` | 专题文档:`tool-design.md`(工具接口规范)、`OFFICE.md` | — | | `docs/` | 专题文档:`tool-design.md`(工具接口规范)、`OFFICE.md` | — |
@@ -42,7 +42,7 @@ flowchart TD
WXBOT -->|"回调 /wxhook/*(共享 Bearer token)"| CORE WXBOT -->|"回调 /wxhook/*(共享 Bearer token)"| CORE
CORE["agent-core(8090,唯一对外端口)"] CORE["agent-core(8090,唯一对外端口)"]
CORE --> EXEC["agent-executor(9000 exec / 3100 预览,仅内网)"] CORE --> EXEC["agent-executor(9000 exec / 3100 预览,仅内网)"]
CORE --> MCP["mcp_web_search / mcp_image_task / mcp_video_task(3000,仅内网)"] CORE --> MCP["mcp_web_search / mcp_image_task / mcp_video_task / mcp_asr(3000,仅内网)"]
CORE -->|"分段投递回复"| WXBOT CORE -->|"分段投递回复"| WXBOT
``` ```
@@ -83,7 +83,7 @@ flowchart TD
### 环境变量(接线全靠根 `.env` + compose) ### 环境变量(接线全靠根 `.env` + compose)
`AGENT_CONFIG`、`PORT`、`EXECUTOR_URL`、`EXECUTOR_TOKEN`、`WXBOT_URL`、`WXBOT_TOKEN`、 `AGENT_CONFIG`、`PORT`、`EXECUTOR_URL`、`EXECUTOR_TOKEN`、`WXBOT_URL`、`WXBOT_TOKEN`、
`VIRTUAL_HOST`、`PREVIEW_PROXIES`、`EXECUTOR_LOG_LEVEL`、`WXBOT_LOG_LEVEL`。 `ASR_URL`、`ASR_API_KEY`、`VIRTUAL_HOST`、`PREVIEW_PROXIES`、`EXECUTOR_LOG_LEVEL`、`WXBOT_LOG_LEVEL`。
密钥生成:`./scripts/init.sh`(幂等,重跑不掉登录态)。 密钥生成:`./scripts/init.sh`(幂等,重跑不掉登录态)。
## 三条主链路 ## 三条主链路
@@ -187,6 +187,7 @@ curl -s http://127.0.0.1:8090/api/health
| 改模型调度 / 绑定 | `app/server/engine.js` 的 `chooseKey` / `chooseModel` / `ensureBinding` | | 改模型调度 / 绑定 | `app/server/engine.js` 的 `chooseKey` / `chooseModel` / `ensureBinding` |
| 改上下文组装 / 省 token | `app/server/llm.js` 的 `buildMessages` / `trim*` | | 改上下文组装 / 省 token | `app/server/llm.js` 的 `buildMessages` / `trim*` |
| 改微信投递 | `app/server/wechat.js`(业务)+ `app/server/routes/wechat.js`(HTTP/鉴权) | | 改微信投递 | `app/server/wechat.js`(业务)+ `app/server/routes/wechat.js`(HTTP/鉴权) |
| 改语音输入 | `app/server/public/js/voice.js`(录音与插入)+ `app/server/routes/asr.js`(代理)+ `mcp/asr/`(转写);客户端桥契约见 `docs/voice-input.md` |
| 改隔离执行 | `executor/server.js`(先读顶部安全模型注释) | | 改隔离执行 | `executor/server.js`(先读顶部安全模型注释) |
| 加同栈 MCP 服务 | `mcp/<name>/` + `docker-compose.yml` + `config.yml` 的 `mcp_servers` | | 加同栈 MCP 服务 | `mcp/<name>/` + `docker-compose.yml` + `config.yml` 的 `mcp_servers` |
| 加技能 | `skills/<name>/`(`SKILL.md` + `run.py`),见 `skills/README.md` | | 加技能 | `skills/<name>/`(`SKILL.md` + `run.py`),见 `skills/README.md` |
+20 -3
View File
@@ -22,6 +22,7 @@
| 上下文管理 | 手动压缩、按 token 阈值提示压缩、历史重放自动裁剪、会话标题自动生成 | | 上下文管理 | 手动压缩、按 token 阈值提示压缩、历史重放自动裁剪、会话标题自动生成 |
| 定时任务 | 每会话最多一个 cron 任务;触发前清空模型可见历史,按计划执行并推送结果 | | 定时任务 | 每会话最多一个 cron 任务;触发前清空模型可见历史,按计划执行并推送结果 |
| 微信接入 | 扫码绑定个人微信,文本/图片/视频/文件进入同一套会话与命令体系 | | 微信接入 | 扫码绑定个人微信,文本/图片/视频/文件进入同一套会话与命令体系 |
| 语音输入 | 输入框为空时发送键变麦克风:点一下进入语音模式,输入框位置变成「按住 说话」,松开即转写并直接发送;发送键位置变键盘按钮可切回打字。套壳 App 走原生录音(http 页面也能用),浏览器走 MediaRecorder(需 HTTPS);识别在 `mcp_asr`,不经过模型、不消耗 token |
| 长期记忆 | 会话收口时生成第一人称工作日记;微信新会话注入最近几条,`recall` 可检索全部 | | 长期记忆 | 会话收口时生成第一人称工作日记;微信新会话注入最近几条,`recall` 可检索全部 |
| 用户画像 | 记录称谓、行业、偏好,会话创建时冻结注入,跨会话生效 | | 用户画像 | 记录称谓、行业、偏好,会话创建时冻结注入,跨会话生效 |
| 技能 | 目录式技能(`SKILL.md` + `run.py`/`run.sh`),可在设置页管理 | | 技能 | 目录式技能(`SKILL.md` + `run.py`/`run.sh`),可在设置页管理 |
@@ -94,7 +95,7 @@ http://<服务器 IP>:<AGENT_PORT>
### 4. 同栈 MCP 服务 ### 4. 同栈 MCP 服务
`init.sh` 默认把仓库内 `mcp/` 的三个服务写进 `config.yml`: `init.sh` 默认把仓库内 `mcp/` 的服务写进 `config.yml`:
```yaml ```yaml
mcp_servers: mcp_servers:
@@ -104,9 +105,14 @@ mcp_servers:
url: "http://mcp_image_task:3000/mcp" url: "http://mcp_image_task:3000/mcp"
- name: video_task - name: video_task
url: "http://mcp_video_task:3000/mcp" url: "http://mcp_video_task:3000/mcp"
- name: asr
url: "http://mcp_asr:3000/mcp"
mode: skill
``` ```
`web_search` / `image_task` / `video_task` 与 core 由同一个根 `docker-compose.yml` 启动,没有先后顺序,也不占宿主机端口。工具说明、header 覆盖项与调试方式见 [mcp/README.md](mcp/README.md)。 `web_search` / `image_task` / `video_task` / `asr` 与 core 由同一个根 `docker-compose.yml` 启动,没有先后顺序,也不占宿主机端口。工具说明、header 覆盖项与调试方式见 [mcp/README.md](mcp/README.md)。
语音输入(H5 输入框里说话)走的是另一条路:客户端录音 → `POST /api/asr/transcribe` → `mcp_asr` 的 `/transcribe`,**不经过模型、不消耗 token**,结果插入输入框可编辑。客户端录音契约(Android 套壳原生桥 / 浏览器 MediaRecorder)见 [docs/voice-input.md](docs/voice-input.md);`ASR_URL` 置空即整体关闭。
接入栈外的 MCP 服务:在设置页添加 `url` / `headers`,或在 `config.yml` 的 `mcp_servers` 追加一项。服务不可达时 core 只在启动日志里告警,不影响 Web 主流程,但对应工具不会下发给模型。 接入栈外的 MCP 服务:在设置页添加 `url` / `headers`,或在 `config.yml` 的 `mcp_servers` 追加一项。服务不可达时 core 只在启动日志里告警,不影响 Web 主流程,但对应工具不会下发给模型。
@@ -120,7 +126,7 @@ mcp_servers:
`skill` 用于「能力包在技能后面」的场景:工具照常发现并注册,只是不进模型的 tools 数组,改为以技能形式暴露——`{"op":"list"}` 能看到它,`{"op":"get","name":"<名>"}` 直接返回 MCP 原始的 `description` + `input_schema`,`{"op":"run","name":"<名>","args":{…}}` 转发给服务。不用在 `skills/` 里建目录。旧字段 `enable` 已废弃,`mode: silent` 已移除(启动会报错并提示改用 `skill`)。 `skill` 用于「能力包在技能后面」的场景:工具照常发现并注册,只是不进模型的 tools 数组,改为以技能形式暴露——`{"op":"list"}` 能看到它,`{"op":"get","name":"<名>"}` 直接返回 MCP 原始的 `description` + `input_schema`,`{"op":"run","name":"<名>","args":{…}}` 转发给服务。不用在 `skills/` 里建目录。旧字段 `enable` 已废弃,`mode: silent` 已移除(启动会报错并提示改用 `skill`)。
工具发现只在启动时做一次,因此发现失败后会自动按 **2s / 20s / 1min 重试 3 次**(覆盖 compose 并行拉起与宿主机重启后的容器乱序);成功后工具在下一轮请求即可用,三次都失败则需重启 core。三个 MCP 服务都配了 `/health` 健康检查,`docker ps` 可直接看状态。 工具发现只在启动时做一次,因此发现失败后会自动按 **2s / 20s / 1min 重试 3 次**(覆盖 compose 并行拉起与宿主机重启后的容器乱序);成功后工具在下一轮请求即可用,三次都失败则需重启 core。四个 MCP 服务都配了 `/health` 健康检查,`docker ps` 可直接看状态。
--- ---
@@ -238,6 +244,8 @@ platforms:
| `PORT` | core 监听端口,容器内 `8090` | | `PORT` | core 监听端口,容器内 `8090` |
| `EXECUTOR_URL` | `agent-executor` 地址;空则命令在 core 进程内本地执行,仅适合开发 | | `EXECUTOR_URL` | `agent-executor` 地址;空则命令在 core 进程内本地执行,仅适合开发 |
| `EXECUTOR_TOKEN` | core ↔ executor 的 Bearer token,两侧同值 | | `EXECUTOR_TOKEN` | core ↔ executor 的 Bearer token,两侧同值 |
| `ASR_URL` | `mcp_asr` 地址(compose 为 `http://mcp_asr:3000`);置空则语音输入关闭 |
| `ASR_API_KEY` / `ASR_API_BASE` / `ASR_MODEL` | `mcp_asr` 的上游语音识别密钥与地址(默认智谱 `glm-asr`) |
| `WXBOT_URL` | wxbot 地址;置空则微信功能整体关闭 | | `WXBOT_URL` | wxbot 地址;置空则微信功能整体关闭 |
| `WXBOT_TOKEN` | core ↔ wxbot 的共享 token | | `WXBOT_TOKEN` | core ↔ wxbot 的共享 token |
| `VIRTUAL_HOST` | 设置后 `public_link.base_url` 强制取 `https://<第一个域名>` | | `VIRTUAL_HOST` | 设置后 `public_link.base_url` 强制取 `https://<第一个域名>` |
@@ -389,8 +397,14 @@ docker compose logs -f agent-core
docker compose logs -f agent-executor docker compose logs -f agent-executor
docker compose logs -f agent-wxbot docker compose logs -f agent-wxbot
curl -s http://127.0.0.1:8090/api/health curl -s http://127.0.0.1:8090/api/health
# {"ok":true,"service":"agent-core","api":1,"time":...,"auth_required":true}
``` ```
- `GET /api/health` 是**唯一免登录接口**,供运维探活,也供套壳 App 校验用户手填的服务器地址。
客户端判定条件:HTTP 200 且 `ok === true` 且 `service === 'agent-core'`——**不要只看状态码**,
填错到别的站点或反代首页同样可能回 200。地址末尾的 `/` 可带可不带。
`auth_required` 用于区分「地址对了但没登录」与「地址错了」。
- core 日志等级由 `config.yml` 的 `log_level` 控制,改完重启生效。 - core 日志等级由 `config.yml` 的 `log_level` 控制,改完重启生效。
- executor / wxbot 的日志等级由各自环境变量控制,`debug` 会打印完整交互。 - executor / wxbot 的日志等级由各自环境变量控制,`debug` 会打印完整交互。
- 启动时会在 `data/prompt.txt` 写入实际下发的 system prompt 与各 profile 的工具清单,便于核对。 - 启动时会在 `data/prompt.txt` 写入实际下发的 system prompt 与各 profile 的工具清单,便于核对。
@@ -400,6 +414,9 @@ curl -s http://127.0.0.1:8090/api/health
| 现象 | 原因 / 处理 | | 现象 | 原因 / 处理 |
|---|---| |---|---|
| 启动时报 `network agent-mcp-net has active endpoints` | 旧的双仓库部署残留:先停旧的 mcp 仓库(`docker compose down`),再 `up` 本栈 | | 启动时报 `network agent-mcp-net has active endpoints` | 旧的双仓库部署残留:先停旧的 mcp 仓库(`docker compose down`),再 `up` 本栈 |
| 套壳 App 填了服务器地址仍连不上 | 先 `curl <地址>/api/health` 看是否返回 `service:agent-core`;再查 Android 9+ 默认禁止明文 HTTP(需 `usesCleartextTraffic`)与 https 自签证书 |
| 麦克风按钮不显示 | `ASR_URL` 为空(未部署 `mcp_asr`);或浏览器以 `http://<IP>` 访问且没有原生录音桥(非安全上下文开不了麦,见 `docs/voice-input.md`) |
| 点麦克风提示「语音识别服务不可用」 | `mcp_asr` 未起来或 `ASR_API_KEY` 为空:`docker compose logs --tail=50 mcp_asr` |
| `config.yml` 变成目录 | 启动前文件不存在,Docker 自动建了同名目录;停容器、删目录、放入配置文件 | | `config.yml` 变成目录 | 启动前文件不存在,Docker 自动建了同名目录;停容器、删目录、放入配置文件 |
| 没有可用模型 | `platforms` 为空或模型全部禁用;在设置页添加后重启 | | 没有可用模型 | `platforms` 为空或模型全部禁用;在设置页添加后重启 |
| 创建会话报「无可用模型」 | 模型池为空,或指定模型所在平台没有 key | | 创建会话报「无可用模型」 | 模型池为空,或指定模型所在平台没有 key |
+6 -1
View File
@@ -266,6 +266,7 @@ preview-proxy.earlyGuard
express.static(public) express.static(public)
/api/sessions ×4 ← sessions / messages / files / skill-run(通用执行面) /api/sessions ×4 ← sessions / messages / files / skill-run(通用执行面)
/api/skills /api/skills
/api/asr ← 语音识别代理:/transcribe 走登录态;ASR_URL 空则 503
/api/config ← requireAdmin /api/config ← requireAdmin
/api/platforms /api/platforms
/api/system ← /restart 需 admin,其余登录即可 /api/system ← /restart 需 admin,其余登录即可
@@ -274,6 +275,8 @@ express.static(public)
/api/memory /api/memory
/api/wechat /api/wechat
/api/channel /api/channel
/api/health ← 免认证探活:套壳 App / 运维脚本用它校验服务器地址
(只认 200 + body.ok + service==='agent-core')
data-page ← GET /app/:task_id/*、POST /api/db/:task_id/query data-page ← GET /app/:task_id/*、POST /api/db/:task_id/query
preview-proxy.mount(末尾兜底) preview-proxy.mount(末尾兜底)
``` ```
@@ -281,13 +284,15 @@ preview-proxy.mount(末尾兜底)
- 错误形状统一 `{ error: string }`,`err.status_code` 决定 HTTP 码。 - 错误形状统一 `{ error: string }`,`err.status_code` 决定 HTTP 码。
- 认证:HMAC 签名 HttpOnly cookie(`agent_token`),`Authorization: Basic` 兜底, - 认证:HMAC 签名 HttpOnly cookie(`agent_token`),`Authorization: Basic` 兜底,
`Authorization: Bearer` 仅用于 `/api/login_restore`。`auth.users` 为空 = 完全关闭认证。 `Authorization: Bearer` 仅用于 `/api/login_restore`。`auth.users` 为空 = 完全关闭认证。
- 免认证路径集中在 `auth.js` 的 `PUBLIC_EXACT`(含 `/api/health`,且容忍尾斜杠)。
新增免登录接口必须加进去,否则会被中间件先拦成 401。
- **单租户警告**:除管理员接口外不做资源级授权;按用户的会话列表隔离在查询层(`sessions.user`)。 - **单租户警告**:除管理员接口外不做资源级授权;按用户的会话列表隔离在查询层(`sessions.user`)。
- 公网短链 `/p/<id>` 的信任模型:随机 ID + 服务端 TTL + 签发时 `realpath` 校验,不靠登录态。 - 公网短链 `/p/<id>` 的信任模型:随机 ID + 服务端 TTL + 签发时 `realpath` 校验,不靠登录态。
## 前端(`server/public/`) ## 前端(`server/public/`)
- **无构建**:`index.html` 按顺序加载经典脚本,共享全局作用域: - **无构建**:`index.html` 按顺序加载经典脚本,共享全局作用域:
`core.js → chat.js → sessions.js → stream.js → files.js → preview.js → settings.js` `core.js → chat.js → sessions.js → stream.js → files.js → voice.js → preview.js → settings.js`
(`settings.js` 必须最后,尾部有全局初始化);`marked.min.js` 走 `vendor/`。 (`settings.js` 必须最后,尾部有全局初始化);`marked.min.js` 走 `vendor/`。
- 新增 JS 文件必须同时改 `index.html` 的 `<script>` 顺序——没有 import/export,顺序就是依赖。 - 新增 JS 文件必须同时改 `index.html` 的 `<script>` 顺序——没有 import/export,顺序就是依赖。
- `sw.js`:HTML/JS/CSS 网络优先,图片/JSON 缓存优先。**改图片或 JSON 才需要升 `CACHE_VERSION`**; - `sw.js`:HTML/JS/CSS 网络优先,图片/JSON 缓存优先。**改图片或 JSON 才需要升 `CACHE_VERSION`**;
+7 -1
View File
@@ -79,9 +79,15 @@ auth: # users 留空 = 不启用登
role: admin # admin=管理员(全部设置 + 用户管理);user 或缺省=普通用户(仅账户页) role: admin # admin=管理员(全部设置 + 用户管理);user 或缺省=普通用户(仅账户页)
# model: qwen-tp/qwen3.8-flash # 选填:该用户新建会话时锁定的模型(内部键「平台名/模型id」) # model: qwen-tp/qwen3.8-flash # 选填:该用户新建会话时锁定的模型(内部键「平台名/模型id」)
# MCP 服务列表(仓库自带的 mcp/ 三个服务,或栈外服务):每项 {name?, url, headers?, mode?(默认 advertise), timeout_ms?, tools_allow?, tools_deny?}。 # MCP 服务列表(仓库自带的 mcp/ 服务,或栈外服务):每项 {name?, url, headers?, mode?(默认 advertise), timeout_ms?, tools_allow?, tools_deny?}。
# mode 三态:advertise=工具下发给模型;skill=不下发,改为以技能形式暴露(get 返回原始 input_schema,run 转发); # mode 三态:advertise=工具下发给模型;skill=不下发,改为以技能形式暴露(get 返回原始 input_schema,run 转发);
# disable=不连接、不发现。旧字段 enable 已废弃;mode: silent 已移除(改用 skill),写进配置会启动报错。 # disable=不连接、不发现。旧字段 enable 已废弃;mode: silent 已移除(改用 skill),写进配置会启动报错。
#
# 语音识别(mcp/asr)建议用 skill:转写音频是低频能力,不必把 schema 塞进每轮请求。
# - name: asr
# url: "http://mcp_asr:3000/mcp"
# mode: skill
# 注意:输入框里的语音输入走的是 core 的 /api/asr(由 compose 的 ASR_URL 接线),不经这个工具,也不消耗 token。
mcp_servers: [] mcp_servers: []
public_link: public_link:
+2 -2
View File
@@ -1,12 +1,12 @@
{ {
"name": "agent-app", "name": "agent-app",
"version": "2.3.0", "version": "2.4.0",
"lockfileVersion": 3, "lockfileVersion": 3,
"requires": true, "requires": true,
"packages": { "packages": {
"": { "": {
"name": "agent-app", "name": "agent-app",
"version": "2.3.0", "version": "2.4.0",
"dependencies": { "dependencies": {
"better-sqlite3": "11.3.0", "better-sqlite3": "11.3.0",
"cron-parser": "5.10.1", "cron-parser": "5.10.1",
+1 -1
View File
@@ -1,6 +1,6 @@
{ {
"name": "agent-app", "name": "agent-app",
"version": "2.3.0", "version": "2.4.0",
"description": "自用通用 Agent 系统:多模型调度 + 任务目录 + 工具调用 + H5 Web UI", "description": "自用通用 Agent 系统:多模型调度 + 任务目录 + 工具调用 + H5 Web UI",
"main": "server/server.js", "main": "server/server.js",
"scripts": { "scripts": {
+4 -1
View File
@@ -73,7 +73,10 @@ function basicAuthUser(req, users) {
// ---------- 免认证路径(登录页自身需要的资源) ---------- // ---------- 免认证路径(登录页自身需要的资源) ----------
const PUBLIC_EXACT = new Set(['/login', '/logout', '/api/login', '/api/logout', '/api/login_restore', '/api/health']); const PUBLIC_EXACT = new Set(['/login', '/logout', '/api/login', '/api/logout', '/api/login_restore', '/api/health']);
function isPublicPath(p) { function isPublicPath(p) {
if (PUBLIC_EXACT.has(p)) return true; // 尾斜杠容忍:客户端手动填服务器地址常多带一个 `/`(拼成 `/api/health/`),
// Express 路由本身能匹配,但这里若不规范化,中间件会先回 401——地址明明是对的却报未登录。
const norm = p.length > 1 ? p.replace(/\/+$/, '') : p;
if (PUBLIC_EXACT.has(norm)) return true;
if (p.startsWith('/css/')) return true; // 登录页复用 style.css if (p.startsWith('/css/')) return true; // 登录页复用 style.css
if (p === '/favicon.ico') return true; if (p === '/favicon.ico') return true;
return false; return false;
+75 -1
View File
@@ -338,6 +338,7 @@ footer { position: relative; flex: none; padding: 8px 12px calc(10px + env(safe-
} }
.up-card.done::after, .up-card.err::after { display: none; } .up-card.done::after, .up-card.err::after { display: none; }
.input-shell { .input-shell {
position: relative; /* 按住说话的遮罩以它为定位基准 */
display: flex; display: flex;
flex-direction: column; flex-direction: column;
align-items: stretch; align-items: stretch;
@@ -404,6 +405,76 @@ footer { position: relative; flex: none; padding: 8px 12px calc(10px + env(safe-
} }
.plus-btn:active { background: #dde0e6; } .plus-btn:active { background: #dde0e6; }
.plus-btn.active { background: var(--active-soft); color: var(--active); } /* 文件面板展开时高亮 */ .plus-btn.active { background: var(--active-soft); color: var(--active); } /* 文件面板展开时高亮 */
/* 语音模式:输入框位置换成「按住 说话」——只有居中文字,不做出按钮外观 */
#voice-hold {
position: relative;
height: 44px; border-radius: 8px;
display: flex; align-items: center; justify-content: center;
font-size: 15px; color: var(--ink); cursor: pointer;
user-select: none; -webkit-user-select: none; -webkit-touch-callout: none;
touch-action: none; transition: background .12s;
}
/* 按住区与下方操作栏之间的分隔线(用伪元素画,避开录音态底色的圆角) */
#voice-hold::after {
content: '';
position: absolute; left: 0; right: 0; bottom: -1px;
height: 1px; background: var(--border);
}
/* 录音中给一个极浅底色作反馈(文字同时变成「松开 结束」) */
#voice-hold.recording { background: var(--surface); }
/* 录音期间:输入卡内容整体让位给遮罩(透明渐变不能把按钮/文字透出来) */
body.voice-active .input-shell { border-color: transparent; box-shadow: none; }
body.voice-active .input-shell > *:not(#voice-overlay) { visibility: hidden; }
body.voice-active .attach-chips { visibility: hidden; }
body.voice-active .scroll-bottom-btn { display: none; }
/* 按住说话的遮罩:左右贴屏幕两边;底部一直铺到屏幕底(含 footer 的 10px 内边距与安全区),
向上多铺 72px 让渐变淡出。
声波中心对齐「按住 说话」那一行:padding-bottom 70px + 安全区 =
59(声波中心到输入卡底部)+ 11(遮罩底边向下外扩的 1px 边框 + 10px footer 内边距)。 */
#voice-overlay {
position: absolute;
top: -72px;
bottom: calc(-11px - env(safe-area-inset-bottom, 0px));
left: -13px; right: -13px;
z-index: 6;
display: flex; flex-direction: column; align-items: center; justify-content: flex-end;
gap: 20px;
padding-bottom: calc(70px + env(safe-area-inset-bottom, 0px));
/* 极淡的蓝调,从下往上淡出(“几乎看不出来,仔细看才有一层”) */
background: linear-gradient(to top, rgba(57, 100, 254, .09), rgba(57, 100, 254, 0));
color: var(--active);
pointer-events: auto; touch-action: none;
transition: background .15s linear, color .15s linear;
}
/* 上滑取消态:整体换成极淡的红调,声波/文案同步变红 */
#voice-overlay.cancel {
background: linear-gradient(to top, rgba(192, 57, 43, .09), rgba(192, 57, 43, 0));
color: #c0392b;
}
.vo-hint { font-size: 13px; line-height: 18px; color: var(--gray); letter-spacing: .2px; }
.vo-wave { display: flex; align-items: center; justify-content: center; gap: 3px; height: 34px; max-width: 100%; }
/* 柱子高度用 scaleY 而不是 height:只走合成层,不触发重排 */
.vo-wave i {
display: block; width: 3px; height: 34px; border-radius: 2px;
background: currentColor;
transform: scaleY(.12); transform-origin: center;
transition: transform 70ms linear;
}
/* 上滑取消态:声波与文案统一转警示色 */
#voice-overlay.cancel .vo-hint { color: #c0392b; }
@media (prefers-reduced-motion: reduce) { .vo-wave i { transition: none; } }
/* 发送键四态:发送 / 停止 / 语音 / 键盘。语音与键盘用中性底色,和蓝色「发送」区分开 */
.send-btn > svg { display: none; }
.send-btn[data-state="send"] .ic-send { display: block; }
.send-btn[data-state="voice"] .ic-voice,
.send-btn[data-state="keyboard"] .ic-kb { display: block; }
.send-btn[data-state="voice"],
.send-btn[data-state="keyboard"] { background: var(--surface); color: var(--ink); box-shadow: none; }
.send-btn[data-state="voice"]:active,
.send-btn[data-state="keyboard"]:active { background: #dde0e6; opacity: 1; }
/* 发送按钮:蓝底白向上箭头 */ /* 发送按钮:蓝底白向上箭头 */
.send-btn { .send-btn {
flex: none; width: 36px; height: 36px; border-radius: 50%; flex: none; width: 36px; height: 36px; border-radius: 50%;
@@ -852,7 +923,10 @@ footer { position: relative; flex: none; padding: 8px 12px calc(10px + env(safe-
/* ================= 全屏查看器(搬自 index;图片单点放大+缩放,消息双击放大) ================= */ /* ================= 全屏查看器(搬自 index;图片单点放大+缩放,消息双击放大) ================= */
#img-viewer { position: fixed; inset: 0; z-index: 150; background: rgba(0,0,0,0.93); display: flex; align-items: center; justify-content: center; overflow: hidden; } #img-viewer { position: fixed; inset: 0; z-index: 150; background: rgba(0,0,0,0.93); display: flex; align-items: center; justify-content: center; overflow: hidden; }
#img-viewer.hidden { display: none; } #img-viewer.hidden { display: none; }
#img-viewer-img { max-width: 100vw; max-height: 88vh; touch-action: none; cursor: grab; user-select: none; -webkit-user-drag: none; } /* 两层 img 绝对定位居中叠放:滑动切换时旧图滑出、新图同步滑入(见 js/stream.js 的 slideTo) */
#img-viewer img { position: absolute; inset: 0; margin: auto; max-width: 100vw; max-height: 88vh; touch-action: none; cursor: grab; user-select: none; -webkit-user-drag: none; will-change: transform; }
/* 组内页码:底部居中悬浮,不参与命中测试(点它等于点背景会关闭) */
#img-count { position: fixed; left: 50%; bottom: calc(18px + env(safe-area-inset-bottom, 0px)); transform: translateX(-50%); z-index: 151; padding: 3px 12px; border-radius: 999px; background: rgba(0,0,0,0.5); color: #fff; font-size: 12px; letter-spacing: .5px; pointer-events: none; }
#fs-viewer { position: fixed; inset: 0; z-index: 130; background: rgba(8,10,20,0.88); padding: 40px 14px 24px; overflow: auto; /* 缩放后支持横纵滚动 */ } #fs-viewer { position: fixed; inset: 0; z-index: 130; background: rgba(8,10,20,0.88); padding: 40px 14px 24px; overflow: auto; /* 缩放后支持横纵滚动 */ }
#fs-viewer.hidden { display: none; } #fs-viewer.hidden { display: none; }
.fs-panel { max-width: 860px; margin: 0 auto; background: var(--page); border-radius: 14px; padding: 18px 20px; font-size: 15.5px; } .fs-panel { max-width: 860px; margin: 0 auto; background: var(--page); border-radius: 14px; padding: 18px 20px; font-size: 15.5px; }
+17 -3
View File
@@ -165,6 +165,8 @@
</div> </div>
<div class="up-cards hidden" id="up-cards" aria-label="已上传文件"></div> <div class="up-cards hidden" id="up-cards" aria-label="已上传文件"></div>
<textarea id="msg-input" placeholder="传送信息" rows="2" enterkeyhint="enter"></textarea> <textarea id="msg-input" placeholder="传送信息" rows="2" enterkeyhint="enter"></textarea>
<!-- 语音模式:输入框位置变成「按住 说话」(只有居中文字,无按钮外观) -->
<div id="voice-hold" class="hidden" role="button" tabindex="0" aria-label="按住说话">按住 说话</div>
<div class="input-actions"> <div class="input-actions">
<div class="ia-side ia-left"> <div class="ia-side ia-left">
<button class="think-toggle" id="deep-think-btn" title="深度思考"> <button class="think-toggle" id="deep-think-btn" title="深度思考">
@@ -179,13 +181,22 @@
<button class="plus-btn" id="attach-btn" title="上传文件" aria-label="上传文件"> <button class="plus-btn" id="attach-btn" title="上传文件" aria-label="上传文件">
<svg viewBox="0 0 24 24" class="ic sm"><path fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" d="M21.44 11.05l-9.19 9.19a6 6 0 0 1-8.49-8.49l9.19-9.19a4 4 0 0 1 5.66 5.66l-9.2 9.19a2 2 0 0 1-2.83-2.83l8.49-8.48"></path></svg> <svg viewBox="0 0 24 24" class="ic sm"><path fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" d="M21.44 11.05l-9.19 9.19a6 6 0 0 1-8.49-8.49l9.19-9.19a4 4 0 0 1 5.66 5.66l-9.2 9.19a2 2 0 0 1-2.83-2.83l8.49-8.48"></path></svg>
</button> </button>
<!-- 同一按钮两态:发送(↑)/ 停止(白色方块)。data-state 由 JS 切换,尺寸不变避免输入区跳动 --> <!-- 同一按钮四态:发送(↑)/ 停止(方块)/ 语音(麦克风)/ 键盘。
data-state 由 JS 切换,尺寸不变避免输入区跳动 -->
<button class="send-btn" id="send-btn" data-state="send" title="发送" aria-label="发送"> <button class="send-btn" id="send-btn" data-state="send" title="发送" aria-label="发送">
<svg viewBox="0 0 24 24" class="ic sm"><line x1="12" y1="19" x2="12" y2="5"></line><polyline points="5 12 12 5 19 12"></polyline></svg> <svg class="ic sm ic-send" viewBox="0 0 24 24"><line x1="12" y1="19" x2="12" y2="5"></line><polyline points="5 12 12 5 19 12"></polyline></svg>
<svg class="ic sm ic-voice" viewBox="0 0 24 24"><rect x="9" y="2" width="6" height="12" rx="3"></rect><path d="M5 10a7 7 0 0 0 14 0"></path><line x1="12" y1="19" x2="12" y2="22"></line></svg>
<svg class="ic sm ic-kb" viewBox="0 0 24 24"><rect x="3" y="5" width="18" height="14" rx="2.5"></rect><circle cx="7" cy="9" r="1.1" fill="currentColor" stroke="none"></circle><circle cx="12" cy="9" r="1.1" fill="currentColor" stroke="none"></circle><circle cx="17" cy="9" r="1.1" fill="currentColor" stroke="none"></circle><circle cx="7" cy="12.5" r="1.1" fill="currentColor" stroke="none"></circle><circle cx="12" cy="12.5" r="1.1" fill="currentColor" stroke="none"></circle><circle cx="17" cy="12.5" r="1.1" fill="currentColor" stroke="none"></circle><line x1="8" y1="16" x2="16" y2="16"></line></svg>
<span class="stop-sq" aria-hidden="true"></span> <span class="stop-sq" aria-hidden="true"></span>
</button> </button>
</div> </div>
</div> </div>
<!-- 按住说话的遮罩:盖满输入卡并扩到屏幕两边(footer 有 12px 内边距 + shell 1px 边框)。
声波由 JS 生成 25 根柱子;上滑到文案区域进入取消态(整体变红)。 -->
<div id="voice-overlay" class="hidden" aria-hidden="true">
<div class="vo-hint" id="voice-hint">松手传送,上滑取消</div>
<div class="vo-wave" id="voice-wave"></div>
</div>
</div> </div>
<!-- 回到底部浮动按钮(搬自 index;上翻历史时出现、AI 输出中常驻转圈)。 <!-- 回到底部浮动按钮(搬自 index;上翻历史时出现、AI 输出中常驻转圈)。
放在 footer 内、相对 footer 顶边停靠:输入框长高/编辑条出现时不会被盖住 --> 放在 footer 内、相对 footer 顶边停靠:输入框长高/编辑条出现时不会被盖住 -->
@@ -440,10 +451,12 @@
<div id="toast" class="hidden"></div> <div id="toast" class="hidden"></div>
</div> </div>
<!-- 图片全屏查看器(点击消息/工具卡中图片打开;双指缩放、放大后可拖动) --> <!-- 图片全屏查看器(点击消息/工具卡中图片打开;双指缩放、放大后可拖动;同组多图可左右滑动切换) -->
<div id="img-viewer" class="hidden"> <div id="img-viewer" class="hidden">
<button class="fs-close" onclick="closeImageViewer()">✕</button> <button class="fs-close" onclick="closeImageViewer()">✕</button>
<img id="img-viewer-img" alt=""> <img id="img-viewer-img" alt="">
<!-- 组内页码(如 2 / 5):仅同组多图时显示 -->
<span id="img-count" class="hidden"></span>
</div> </div>
<!-- ================= 文档预览右栏(桌面端≥960px;office/全部文档类型统一承载;移动端走全屏 #fs-viewer,本栏隐藏) --> <!-- ================= 文档预览右栏(桌面端≥960px;office/全部文档类型统一承载;移动端走全屏 #fs-viewer,本栏隐藏) -->
@@ -507,6 +520,7 @@
<script src="/js/sessions.js"></script> <script src="/js/sessions.js"></script>
<script src="/js/stream.js"></script> <script src="/js/stream.js"></script>
<script src="/js/files.js"></script> <script src="/js/files.js"></script>
<script src="/js/voice.js"></script>
<script src="/js/preview.js"></script> <script src="/js/preview.js"></script>
<script src="/js/settings.js"></script> <script src="/js/settings.js"></script>
<script> <script>
+4 -2
View File
@@ -30,11 +30,13 @@
send(); send();
} }
}); });
// 发送键双职:生成中且输入框为空时变「停止」(白色方块),点击终止当前回合; // 发送键四职:语音 / 键盘(语音模式)/ 停止 / 发送,由 data-state 决定点击含义。
// 输入框有字时它仍是「发送」——运行中允许插话,直接发出去(后端 live 追投)。
// 400ms 内重复点击忽略:防双击重复 abort(服务端 status 事件回来前按钮仍是停止态)。 // 400ms 内重复点击忽略:防双击重复 abort(服务端 status 事件回来前按钮仍是停止态)。
let stopClickAt = 0; let stopClickAt = 0;
$('send-btn').addEventListener('click', () => { $('send-btn').addEventListener('click', () => {
const st = $('send-btn').dataset.state;
if (st === 'voice' && window.AgentVoice) { window.AgentVoice.enter(); return; }
if (st === 'keyboard' && window.AgentVoice) { window.AgentVoice.exit(true); return; }
if (stopModeActive()) { if (stopModeActive()) {
if (Date.now() - stopClickAt < 400) return; if (Date.now() - stopClickAt < 400) return;
stopClickAt = Date.now(); stopClickAt = Date.now();
+30 -3
View File
@@ -35,6 +35,23 @@ function pvKind(name) {
return 'none'; return 'none';
} }
// 文件面板「当前目录」里的图片作为一组,供查看器左右滑动切换。
// 同组直接用下载直链(<img> 不受 Content-Disposition: attachment 影响),不必逐张取 blob。
// 依赖 files.js 的 filesNodeAt / filesCurDir / assetDownloadUrl(同为全局,加载顺序在前)。
function pvImgGroup(name) {
try {
if (typeof filesNodeAt !== 'function') return null;
const node = filesNodeAt(typeof filesCurDir === 'string' ? filesCurDir : '');
if (!node) return null;
const paths = node.files.map(f => f.filename).filter(p => PV_IMG.test(p));
if (paths.length < 2) return null;
return {
list: paths.map(p => ({ src: assetDownloadUrl(p), alt: p.split('/').pop() })),
at: paths.indexOf(name),
};
} catch (_) { return null; }
}
// 刷新/新窗口两个钮对**所有**预览类型统一开放: // 刷新/新窗口两个钮对**所有**预览类型统一开放:
// refresh → pvState.reload(各类型都注入「按同一路径重开」,与地址条回车同一条路) // refresh → pvState.reload(各类型都注入「按同一路径重开」,与地址条回车同一条路)
// popup → pvState.url(office=预览网关;文本/HTML/图片/PDF=blob URL;不支持的类型=下载地址) // popup → pvState.url(office=预览网关;文本/HTML/图片/PDF=blob URL;不支持的类型=下载地址)
@@ -143,9 +160,17 @@ async function pvOpenOffice(name, sizeText) {
let head = null; let head = null;
try { head = await fetch(url, { method: 'HEAD' }); } catch (_) {} try { head = await fetch(url, { method: 'HEAD' }); } catch (_) {}
if (my !== pvSeq) return; if (my !== pvSeq) return;
// 404 = 预览服务里没有这份文档。文件可能正被 AI 的写盘链路整体替换(rename 瞬间找不到),
// 探针给一次短重试再落占位卡——比让用户自己反复点刷新更接近「多刷几次就出来了」的实情。
if (head && head.status === 404) {
await new Promise((r) => setTimeout(r, 600));
if (my !== pvSeq) return;
try { head = await fetch(url, { method: 'HEAD' }); } catch (_) {}
if (my !== pvSeq) return;
}
const missing = head && head.status === 404; const missing = head && head.status === 404;
if (missing) { if (missing) {
const node = pvInfoNode(name, sizeText, '预览服务中暂无这份文档 —— 只有 AI 在本任务中生成/编辑过的文档才能在线预览(较旧的文档可能已被自动清理)。'); const node = pvInfoNode(name, sizeText, '预览服务中暂无这份文档 —— 文件可能已被删除、改名,或不在本任务目录下。');
if (desk) { if (desk) {
// pvClearBody 会清掉 reload/url:占位卡仍要保留刷新/新窗口,否则按钮可见但点了没反应 // pvClearBody 会清掉 reload/url:占位卡仍要保留刷新/新窗口,否则按钮可见但点了没反应
pvClearBody(); document.getElementById('pv-body').appendChild(node); pvClearBody(); document.getElementById('pv-body').appendChild(node);
@@ -234,7 +259,8 @@ async function openFilePreview(name, sizeText) {
newBlobUrl = u; newBlobUrl = u;
const im = document.createElement('img'); const im = document.createElement('img');
im.className = 'pv-img'; im.src = u; im.alt = String(name); im.className = 'pv-img'; im.src = u; im.alt = String(name);
im.addEventListener('click', () => openImageViewer(u, String(name).split('/').pop())); const g = pvImgGroup(name);
im.addEventListener('click', () => openImageViewer(u, String(name).split('/').pop(), g && g.list, g && g.at));
node = im; tb = Object.assign({}, tbAll, { url: u }); node = im; tb = Object.assign({}, tbAll, { url: u });
} else { // text/md/代码/json/csv } else { // text/md/代码/json/csv
node = await pvTextNode(name, sizeText, r); node = await pvTextNode(name, sizeText, r);
@@ -354,7 +380,8 @@ async function pvRenderLegacy(name, r, my) {
const u = URL.createObjectURL(await r.blob()); const u = URL.createObjectURL(await r.blob());
if (state.lastImgBlobUrl) { try { URL.revokeObjectURL(state.lastImgBlobUrl); } catch (_) {} } if (state.lastImgBlobUrl) { try { URL.revokeObjectURL(state.lastImgBlobUrl); } catch (_) {} }
state.lastImgBlobUrl = u; state.lastImgBlobUrl = u;
openImageViewer(u, name); const g = pvImgGroup(name);
openImageViewer(u, name, g && g.list, g && g.at);
} else { } else {
const text = await r.text(); const text = await r.text();
let cls = 'bubble-ai', html; let cls = 'bubble-ai', html;
+17 -4
View File
@@ -300,13 +300,26 @@
// 有附件时按钮保持「发送」:粘贴长文本转成的附件不应被当成停止操作 // 有附件时按钮保持「发送」:粘贴长文本转成的附件不应被当成停止操作
return state.status === 'active' && !(($('msg-input') || {}).value || '').trim() && !state.attachments.length; return state.status === 'active' && !(($('msg-input') || {}).value || '').trim() && !state.attachments.length;
} }
// 发送键四态:停止 / 键盘(语音模式)/ 语音(空输入且支持录音)/ 发送。
// 停止优先:生成中且输入框为空时,用户最可能想停止,不能被语音入口顶掉。
// 语音与键盘两态由 voice.js 暴露的 window.AgentVoice 提供(脚本加载顺序在 sessions 之后,
// 初始化阶段它还不存在,此处必须容错——那时按普通「发送」渲染即可)。
function updateSendBtn() { function updateSendBtn() {
const sb = $('send-btn'); const sb = $('send-btn');
if (!sb) return; if (!sb) return;
const stop = stopModeActive(); const v = window.AgentVoice;
sb.dataset.state = stop ? 'stop' : 'send'; const empty = !(($('msg-input') || {}).value || '').trim() && !state.attachments.length;
sb.title = stop ? '停止生成' : '发送'; let mode;
sb.setAttribute('aria-label', stop ? '停止生成' : '发送'); if (stopModeActive()) mode = 'stop';
else if (v && v.isVoiceMode()) mode = 'keyboard';
else if (empty && v && v.isAvailable()) mode = 'voice';
else mode = 'send';
sb.dataset.state = mode;
const label = mode === 'stop' ? '停止生成'
: mode === 'keyboard' ? '切换到键盘输入'
: mode === 'voice' ? '语音输入' : '发送';
if (sb.title !== label) sb.title = label;
if (sb.getAttribute('aria-label') !== label) sb.setAttribute('aria-label', label);
} }
function updateHeaderActions() { function updateHeaderActions() {
+155 -13
View File
@@ -590,45 +590,147 @@
}); });
// 点击消息/工具卡里的图片 → 图片全屏查看器(#fs-viewer 里的克隆图也生效) // 点击消息/工具卡里的图片 → 图片全屏查看器(#fs-viewer 里的克隆图也生效)
// 同一气泡/工具卡内的图作为一组,查看器里可左右滑动切换
function imgViewerDelegate(e) { function imgViewerDelegate(e) {
const im = e.target.closest('.bubble-ai img, .bubble-user img, .tool-card img'); const im = e.target.closest('.bubble-ai img, .bubble-user img, .tool-card img');
if (im && im.src) openImageViewer(im.src, im.alt || ''); if (!im || !im.src) return;
const box = im.closest('.msg') || im.closest('.tool-card') || $('fs-body');
const list = Array.prototype.map.call(box.querySelectorAll('img'), x => ({ src: x.src, alt: x.alt || '' }))
.filter(x => x.src);
openImageViewer(im.src, im.alt || '', list);
} }
$('chat-view').addEventListener('click', imgViewerDelegate); $('chat-view').addEventListener('click', imgViewerDelegate);
$('fs-viewer').addEventListener('click', imgViewerDelegate); $('fs-viewer').addEventListener('click', imgViewerDelegate);
// 图片全屏查看器:transform 缩放+平移。双指捻合缩放(1~6x)、放大后单指/鼠标拖动、双击切 2.5x。 // 图片全屏查看器:transform 缩放+平移。双指捻合缩放(1~6x)、放大后单指/鼠标拖动、双击切 2.5x。
// 第 3 参 list([{src,alt}] 或 [src]) 传入「同组图片」时开启左右滑动切换;第 4 参 at 指定起始下标。
// 切图用双层 img 做真正的分页位移(旧图跟手滑出、新图同步滑入),并在开图时预取相邻图,
// 避免「松手→瞬移复位→闪白→图才下载出来」这三连卡顿。
let openImageViewer, closeImageViewer; let openImageViewer, closeImageViewer;
(function () { (function () {
const viewer = document.getElementById('img-viewer'); const viewer = document.getElementById('img-viewer');
const img = document.getElementById('img-viewer-img'); const img = document.getElementById('img-viewer-img');
// 第二层由脚本建(不写进 HTML):旧版缓存的 HTML 里没有它也不会把查看器搞挂
const img2 = document.createElement('img');
img2.className = 'hidden'; img2.alt = '';
viewer.appendChild(img2);
const count = document.getElementById('img-count');
let cur = img, other = img2; // cur=当前层;other=滑动时接替的层
let scale = 1, tx = 0, ty = 0, mode = null; let scale = 1, tx = 0, ty = 0, mode = null;
let sx = 0, sy = 0, stx = 0, sty = 0, pDist = 0, pScale = 1; let sx = 0, sy = 0, stx = 0, sty = 0, pDist = 0, pScale = 1;
// gallery=当前组;gi=组内下标;wx/wy/wdx=横滑起点与实时位移;dragDir/pending=本次拖动方向与待接替下标
let gallery = [], gi = 0, wx = 0, wy = 0, wdx = 0, dragDir = 0, pending = -1;
const preloads = new Map(); // src → Image:提前下载并解码,切图时不再等网络
let settleTimer = 0;
const tdist = t => Math.hypot(t[0].clientX - t[1].clientX, t[0].clientY - t[1].clientY); const tdist = t => Math.hypot(t[0].clientX - t[1].clientX, t[0].clientY - t[1].clientY);
const W = () => window.innerWidth;
function apply() { function apply() {
img.style.transform = 'translate(' + tx + 'px,' + ty + 'px) scale(' + scale + ')'; cur.style.transition = 'none'; // 缩放/拖动要跟手,不能被上一段滑动动画的过渡拖着走
img.style.cursor = scale > 1 ? 'grab' : 'zoom-in'; cur.style.transform = 'translate(' + tx + 'px,' + ty + 'px) scale(' + scale + ')';
cur.style.cursor = scale > 1 ? 'grab' : 'zoom-in';
} }
openImageViewer = function (src, alt) { function drawCount() {
scale = 1; tx = ty = 0; mode = null; if (!count) return; // 旧版 HTML 缓存里没有计数节点时不报错
const on = gallery.length > 1;
count.textContent = on ? (gi + 1) + ' / ' + gallery.length : '';
count.classList.toggle('hidden', !on);
}
// 预取相邻图:Image 对象常驻,解码结果留在内存里,滑过去就是现成的
function preload(src) {
if (!src || preloads.has(src) || /^(data|blob):/i.test(src)) return;
const im = new Image();
im.decoding = 'async';
im.src = src;
preloads.set(src, im);
}
function prefetchAround() {
[gi + 1, gi + 2, gi - 1].forEach(i => { if (gallery[i]) preload(gallery[i].src); });
}
// 把某层摆到「相对屏幕中心偏移 offset 像素」处(1x、无过渡)
function place(el, offset) {
el.style.transition = 'none';
el.style.transform = 'translate(' + offset + 'px,0) scale(1)';
}
function showLayer(el, item) {
el.src = item.src; el.alt = item.alt || '';
el.classList.remove('hidden');
}
// 动画收尾:旧层收起、两层归位(滑到一半又开始新手势时也靠它清场)
function finishSettle() {
clearTimeout(settleTimer); settleTimer = 0;
other.classList.add('hidden');
place(other, 0); place(cur, 0);
apply(); apply();
img.src = src; img.alt = alt || ''; prefetchAround();
}
// 滑到第 i 张(dir=+1 从右侧进,-1 从左侧进);已到边界就弹回
function slideTo(i, dir) {
if (settleTimer) finishSettle(); // 上一张还在动画里(连点方向键):先收尾,避免接替层被瞬移
const t = Math.max(0, Math.min(gallery.length - 1, i));
if (t === gi) return settleBack(dir);
const from = cur, to = other;
if (pending !== t) { place(to, dir * W()); showLayer(to, gallery[t]); }
void to.offsetWidth; // 先把起点落位再加过渡,否则首帧会被合并成瞬移
const ease = 'transform .2s cubic-bezier(.22,.61,.36,1)';
from.style.transition = ease; to.style.transition = ease;
from.style.transform = 'translate(' + (-dir * W()) + 'px,0) scale(1)';
to.style.transform = 'translate(0,0) scale(1)';
cur = to; other = from;
gi = t; scale = 1; tx = ty = 0; dragDir = 0; pending = -1;
drawCount();
settleTimer = setTimeout(finishSettle, 220);
}
// 没过阈值/到边界:当前层弹回原位,接替层退回屏幕外
function settleBack(dir) {
const ease = 'transform .2s ease-out';
cur.style.transition = ease;
cur.style.transform = 'translate(0,0) scale(1)';
if (dir && !other.classList.contains('hidden')) {
other.style.transition = ease;
other.style.transform = 'translate(' + dir * W() + 'px,0) scale(1)';
}
scale = 1; tx = ty = 0; dragDir = 0; pending = -1;
settleTimer = setTimeout(finishSettle, 220);
}
openImageViewer = function (src, alt, list, at) {
const raw = Array.isArray(list) && list.length ? list : [{ src: src, alt: alt }];
gallery = raw.map(x => (typeof x === 'string' ? { src: x, alt: '' } : x)).filter(x => x && x.src);
// 起始下标优先用调用方给的(文件面板那张是 blob URL,与组里的直链对不上),否则按 src 匹配
let i = typeof at === 'number' && at >= 0 ? at : gallery.findIndex(x => x.src === src);
if (i < 0) i = 0;
clearTimeout(settleTimer); settleTimer = 0;
cur = img; other = img2;
gi = i; scale = 1; tx = ty = 0; mode = null; dragDir = 0; pending = -1;
other.classList.add('hidden'); place(other, 0);
showLayer(cur, gallery[gi] || { src: src, alt: alt });
place(cur, 0); apply();
drawCount();
viewer.classList.remove('hidden'); viewer.classList.remove('hidden');
prefetchAround(); // 开图即把前后两张拉下来,滑的时候是现成的
};
closeImageViewer = function () {
viewer.classList.add('hidden');
gallery = []; gi = 0; dragDir = 0; pending = -1;
preloads.clear(); // 断开引用,解码位图随之释放
drawCount();
}; };
closeImageViewer = function () { viewer.classList.add('hidden'); };
// 点背景(非图片)关闭 // 点背景(非图片)关闭
viewer.addEventListener('click', function (e) { if (e.target === viewer) closeImageViewer(); }); viewer.addEventListener('click', function (e) { if (e.target === viewer) closeImageViewer(); });
img.addEventListener('dblclick', function () { // 两层都要绑:切图后当前层会换成另一张 img,事件不能只挂在第一层上
function bindLayer(el) {
el.addEventListener('dblclick', function () {
scale = scale > 1 ? 1 : 2.5; scale = scale > 1 ? 1 : 2.5;
if (scale === 1) { tx = ty = 0; } if (scale === 1) { tx = ty = 0; }
apply(); apply();
}); });
img.addEventListener('touchstart', function (e) { el.addEventListener('touchstart', function (e) {
if (settleTimer) finishSettle(); // 上一次滑动还没收尾:先清场再新手势
if (e.touches.length === 2) { mode = 'pinch'; pDist = tdist(e.touches) || 1; pScale = scale; } if (e.touches.length === 2) { mode = 'pinch'; pDist = tdist(e.touches) || 1; pScale = scale; }
else if (e.touches.length === 1 && scale > 1) { mode = 'pan'; sx = e.touches[0].clientX; sy = e.touches[0].clientY; stx = tx; sty = ty; } else if (e.touches.length === 1 && scale > 1) { mode = 'pan'; sx = e.touches[0].clientX; sy = e.touches[0].clientY; stx = tx; sty = ty; }
else if (e.touches.length === 1 && gallery.length > 1) { mode = 'swipe'; wx = e.touches[0].clientX; wy = e.touches[0].clientY; wdx = 0; dragDir = 0; pending = -1; }
else mode = null; else mode = null;
}, { passive: true }); }, { passive: true });
img.addEventListener('touchmove', function (e) { el.addEventListener('touchmove', function (e) {
if (mode === 'pinch' && e.touches.length >= 2) { if (mode === 'pinch' && e.touches.length >= 2) {
e.preventDefault(); e.preventDefault();
scale = Math.min(6, Math.max(1, pScale * tdist(e.touches) / pDist)); scale = Math.min(6, Math.max(1, pScale * tdist(e.touches) / pDist));
@@ -639,12 +741,44 @@
tx = stx + e.touches[0].clientX - sx; tx = stx + e.touches[0].clientX - sx;
ty = sty + e.touches[0].clientY - sy; ty = sty + e.touches[0].clientY - sy;
apply(); apply();
} else if (mode === 'swipe' && e.touches.length === 1) {
const dx = e.touches[0].clientX - wx, dy = e.touches[0].clientY - wy;
if (Math.abs(dx) <= Math.abs(dy)) return; // 竖直为主:不接管
wdx = dx;
const dir = dx < 0 ? 1 : -1; // 左滑看下一张
if (dir !== dragDir) {
dragDir = dir;
const next = gallery[gi + dir];
// 方向一确定就把相邻图摆到另一侧待命(已预取,几乎是现成的),跟手滑进来
if (next) { pending = gi + dir; place(other, dir * W()); showLayer(other, next); }
else { pending = -1; other.classList.add('hidden'); } // 到头了:没有下一张,只做橡皮筋
}
const off = pending >= 0 ? dx : dx * 0.35;
cur.style.transition = 'none';
cur.style.transform = 'translate(' + off + 'px,0) scale(1)';
if (pending >= 0) {
other.style.transition = 'none';
other.style.transform = 'translate(' + (off + dragDir * W()) + 'px,0) scale(1)';
}
} }
}, { passive: false }); }, { passive: false });
img.addEventListener('touchend', function (e) { if (e.touches.length < 2) { if (mode === 'pinch') mode = null; } if (!e.touches.length) mode = null; }, { passive: true }); el.addEventListener('touchend', function (e) {
img.addEventListener('touchcancel', function () { mode = null; }, { passive: true }); if (mode === 'swipe') {
const dir = dragDir;
if (pending >= 0 && Math.abs(wdx) > 45) slideTo(pending, dir);
else settleBack(dir);
mode = null;
return;
}
if (e.touches.length < 2) { if (mode === 'pinch') mode = null; }
if (!e.touches.length) mode = null;
}, { passive: true });
el.addEventListener('touchcancel', function () {
if (mode === 'swipe') settleBack(dragDir);
mode = null;
}, { passive: true });
// 桌面:放大后按住拖动平移 // 桌面:放大后按住拖动平移
img.addEventListener('mousedown', function (e) { el.addEventListener('mousedown', function (e) {
if (scale <= 1) return; if (scale <= 1) return;
e.preventDefault(); e.preventDefault();
const x0 = e.clientX, y0 = e.clientY, tx0 = tx, ty0 = ty; const x0 = e.clientX, y0 = e.clientY, tx0 = tx, ty0 = ty;
@@ -652,6 +786,14 @@
const up = function () { window.removeEventListener('mousemove', mv); window.removeEventListener('mouseup', up); }; const up = function () { window.removeEventListener('mousemove', mv); window.removeEventListener('mouseup', up); };
window.addEventListener('mousemove', mv); window.addEventListener('mouseup', up); window.addEventListener('mousemove', mv); window.addEventListener('mouseup', up);
}); });
}
bindLayer(img); bindLayer(img2);
// 桌面没有滑动:组内多图时用 ←/→ 切换(单图不响应)
document.addEventListener('keydown', function (e) {
if (viewer.classList.contains('hidden') || gallery.length < 2) return;
if (e.key === 'ArrowLeft') slideTo(gi - 1, -1);
else if (e.key === 'ArrowRight') slideTo(gi + 1, 1);
});
})(); })();
// 消息全屏查看器双指缩放:viewport 是 user-scalable=no(原生捏合被禁), // 消息全屏查看器双指缩放:viewport 是 user-scalable=no(原生捏合被禁),
+559
View File
@@ -0,0 +1,559 @@
// 语音输入(按住说话)
//
// 交互:
// · 输入框为空时,发送键变成麦克风;点一下进入语音模式
// · 语音模式下输入框位置变成「按住 说话」:按住后整块输入区被全宽遮罩盖住,
// 显示实时电平声波 + 「松手传送,上滑取消」
// · 手指上滑进入文案区域 → 取消态(声波与文案变红,文案改「松开取消」),滑回下方恢复
// · 松手:取消态 → 丢弃 + 轻提示;否则转写后**直接发送**
// · 发送键位置变成键盘按钮,点一下回文本模式并聚焦输入框(移动端弹键盘)
//
// 录音在客户端:套壳原生桥(http 页面也能用)或 HTTPS 下的 MediaRecorder;
// 转写在服务端 mcp_asr(经 core 的 /api/asr 中转)。
// 电平:浏览器用 AnalyserNode 算 RMS;套壳上报 onNativeVoiceAmp(原始 getMaxAmplitude)。
// 归一化/门限/平滑全部在页面侧做,壳不做任何换算。
//
// 包在 IIFE 里:前端是共享全局作用域的经典脚本,顶层声明会和其他文件撞名。
(function () {
'use strict';
const hold = $('voice-hold');
const ta = $('msg-input');
const overlay = $('voice-overlay');
const hintEl = $('voice-hint');
const waveEl = $('voice-wave');
if (!hold || !ta) return;
const native = (window.AgentNative && typeof window.AgentNative.startVoice === 'function')
? window.AgentNative : null;
const webOk = !!(window.isSecureContext && navigator.mediaDevices
&& typeof navigator.mediaDevices.getUserMedia === 'function' && window.MediaRecorder);
const MAX_MS = 60000; // 单次录音上限
const MIN_MS = 500; // 短于这个时长按误触处理,不上传
const NO_RESULT_MS = 3000; // 松开后壳迟迟不回音频(比如还在等权限)→ 复位
const BAR_COUNT = 45; // 声波柱数(要足够宽,手指按住时两侧仍能看到)
// 两端矮、中间高的包络:看起来像一段声波而不是一排等高柱子
const WEIGHTS = [];
for (let i = 0; i < BAR_COUNT; i++) {
WEIGHTS.push(0.45 + 0.55 * Math.sin(Math.PI * (i + 0.5) / BAR_COUNT));
}
const bars = [];
if (waveEl) {
for (let i = 0; i < BAR_COUNT; i++) {
const b = document.createElement('i');
waveEl.appendChild(b);
bars.push(b);
}
}
let available = false; // 有能力 + 服务端接线:发送键才显示麦克风
let mode = false; // 是否处于语音模式
let phase = 'idle'; // idle | arming(等 getMedia)| recording | busy
let pressing = false;
let pressY = 0; // 本次按压的起始 Y(判断“确实上滑了”)
let cancelArmed = false; // 已上滑到取消区
let discard = false; // 本次录音太短/已取消:结果到了也丢掉
let recordStartAt = 0;
let stopTimer = null;
let hardTimer = null;
let watchdog = null;
let rec = null;
let stream = null;
let chunks = [];
let mime = '';
// 电平与渲染
let rafId = 0;
let levelTarget = 0;
let levelCur = 0;
let lastRealLevelAt = 0;
let audioCtx = null;
let analyser = null;
let audioBuf = null;
let srcNode = null;
function clamp01(v) { return v < 0 ? 0 : v > 1 ? 1 : v; }
// 电平归一化的唯一实现:浏览器(RMS)和壳(峰值幅度)都在这里落到 0~1。
// 低于 -55dB 视为静音,-5dB 及以上视为满幅;要调灵敏度只改这两个常量。
const LEVEL_FLOOR_DB = -55;
const LEVEL_RANGE_DB = 50;
function dbToLevel(db) {
return clamp01((db - LEVEL_FLOOR_DB) / LEVEL_RANGE_DB);
}
function setHoldText(s) {
if (hold.textContent !== s) hold.textContent = s;
}
// ---------- 遮罩 / 声波 ----------
function setOverlayMode(m) { // 'send' | 'cancel' | 'busy'
cancelArmed = m === 'cancel';
if (overlay) overlay.classList.toggle('cancel', m === 'cancel');
if (hintEl) {
hintEl.textContent = m === 'cancel' ? '松开取消'
: m === 'busy' ? '正在识别…' : '松手传送,上滑取消';
}
}
function renderBars(level, animate) {
if (!bars.length) return;
const t = Date.now() / 1000;
// 只有真的收到可听电平(大于门限)才加流动感;安静时保持完全静止,不靠抖动“装活”
const flow = animate && level > 0.02;
for (let i = 0; i < bars.length; i++) {
const ripple = flow ? (0.88 + 0.12 * Math.sin(t * 6 + i * 0.55)) : 1;
const h = Math.max(0.08, Math.min(1, (0.15 + 0.85 * level) * WEIGHTS[i] * ripple));
bars[i].style.transform = 'scaleY(' + h.toFixed(3) + ')';
}
}
function startLoop() {
if (rafId || !overlay || overlay.classList.contains('hidden')) return;
if (typeof requestAnimationFrame !== 'function') return;
rafId = requestAnimationFrame(tickMeter);
}
function tickMeter() {
rafId = 0;
if (!overlay || overlay.classList.contains('hidden')) return;
let animate = false;
if (analyser && audioBuf) {
analyser.getFloatTimeDomainData(audioBuf);
let sum = 0;
for (let i = 0; i < audioBuf.length; i++) sum += audioBuf[i] * audioBuf[i];
const rms = Math.sqrt(sum / audioBuf.length);
const db = 20 * Math.log10(rms + 1e-7); // 静音约 -140,正常说话 -35 ~ -12
levelTarget = dbToLevel(db);
animate = true;
} else if (Date.now() - lastRealLevelAt <= 300) {
animate = true; // 壳刚上报过电平
}
if (!animate) {
// 没有电平来源(壳没实现 onNativeVoiceAmp / AnalyserNode 不可用):
// 静默停在基线,不再空转(也绝不能假动)
levelCur = 0;
renderBars(0, false);
return;
}
// 快攻慢放:起音跟得紧,收音回落慢,柱体不抽筋
levelCur += (levelTarget - levelCur) * (levelTarget > levelCur ? 0.55 : 0.18);
renderBars(levelCur, true);
rafId = requestAnimationFrame(tickMeter);
}
function attachAnalyser() {
if (!stream) return;
try {
const AC = window.AudioContext || window.webkitAudioContext;
if (!AC) return;
audioCtx = new AC();
analyser = audioCtx.createAnalyser();
analyser.fftSize = 512;
audioBuf = new Float32Array(analyser.fftSize);
srcNode = audioCtx.createMediaStreamSource(stream);
srcNode.connect(analyser); // 不接 destination,不会回放
if (audioCtx.state === 'suspended') audioCtx.resume();
startLoop(); // 之前可能在静默态停掉了循环
} catch (_) {
analyser = null;
audioBuf = null;
}
}
function startMeter() {
stopMeter(false);
levelTarget = 0;
levelCur = 0;
lastRealLevelAt = 0;
startLoop();
}
function stopMeter(flatten) {
if (rafId) { cancelAnimationFrame(rafId); rafId = 0; }
if (srcNode) { try { srcNode.disconnect(); } catch (_) { /* 已断 */ } srcNode = null; }
analyser = null;
audioBuf = null;
if (audioCtx) { try { audioCtx.close(); } catch (_) { /* 已关 */ } audioCtx = null; }
if (flatten !== false) {
for (let i = 0; i < bars.length; i++) bars[i].style.transform = 'scaleY(.12)';
}
}
function showOverlay() {
if (overlay) overlay.classList.remove('hidden');
// 录音期间隐藏输入卡内容(否则透明渐变会把按钮/文字透出来)
if (document.body) document.body.classList.add('voice-active');
setOverlayMode('send');
startMeter();
}
function hideOverlay() {
if (overlay) overlay.classList.add('hidden');
if (document.body) document.body.classList.remove('voice-active');
stopMeter();
cancelArmed = false;
}
function resetUI() {
phase = 'idle';
pressing = false;
pressY = 0;
discard = false;
if (stopTimer) { clearTimeout(stopTimer); stopTimer = null; }
if (hardTimer) { clearTimeout(hardTimer); hardTimer = null; }
if (watchdog) { clearTimeout(watchdog); watchdog = null; }
hold.classList.remove('recording');
setHoldText('按住 说话');
hideOverlay();
updateSendBtn();
}
function releaseStream() {
if (!stream) return;
try { stream.getTracks().forEach(function (t) { t.stop(); }); } catch (_) { /* 已关 */ }
stream = null;
}
function pickMime() {
const list = ['audio/webm;codecs=opus', 'audio/webm', 'audio/mp4', 'audio/ogg;codecs=opus'];
for (let i = 0; i < list.length; i++) {
try { if (MediaRecorder.isTypeSupported(list[i])) return list[i]; } catch (_) { /* 忽略 */ }
}
return '';
}
// ---------- 模式切换 ----------
function enter() {
if (!available || mode) return;
mode = true;
ta.classList.add('hidden');
hold.classList.remove('hidden');
try { ta.blur(); } catch (_) { /* 忽略 */ }
resetUI();
updateSendBtn();
}
function exit(focus) {
if (!mode) return;
cancelHold();
mode = false;
hold.classList.add('hidden');
ta.classList.remove('hidden');
autosize();
updateSendBtn();
// 必须在点击手势里同步 focus,移动端才会弹键盘
if (focus) { try { ta.focus(); } catch (_) { /* 忽略 */ } }
}
// ---------- 录音 ----------
function startHold() {
if (phase !== 'idle') return;
pressing = true;
discard = false;
hold.classList.add('recording');
setHoldText('松开 结束');
showOverlay();
if (native) {
// 原生侧即使要弹权限也先当「已开始」:松开时 stopVoice(),壳若还在等权限会忽略,
// 由 watchdog 兜底复位(只有首次授权那一次会遇到)。
phase = 'recording';
recordStartAt = Date.now();
stopTimer = setTimeout(finishHold, MAX_MS);
hardTimer = setTimeout(function () {
try { if (native.cancelVoice) native.cancelVoice(); } catch (_) { /* 忽略 */ }
resetUI();
toast('录音超时');
}, MAX_MS + NO_RESULT_MS);
try {
native.startVoice();
} catch (e) {
resetUI();
toast('无法开始录音:' + String((e && e.message) || e));
}
return;
}
phase = 'arming'; // 等 getUserMedia/MediaRecorder 起来
startWeb();
}
async function startWeb() {
try {
stream = await navigator.mediaDevices.getUserMedia({ audio: true });
} catch (e) {
resetUI();
const denied = e && (e.name === 'NotAllowedError' || e.name === 'SecurityError');
toast(denied ? '麦克风权限被拒绝' : '无法打开麦克风:' + String((e && e.message) || e));
return;
}
if (!pressing) { releaseStream(); resetUI(); return; } // 松开得比授权快
attachAnalyser(); // 声波接同一路 MediaStream
mime = pickMime();
try {
rec = mime ? new MediaRecorder(stream, { mimeType: mime }) : new MediaRecorder(stream);
} catch (_) {
rec = new MediaRecorder(stream);
mime = rec.mimeType || '';
}
chunks = [];
rec.ondataavailable = function (ev) {
if (ev.data && ev.data.size) chunks.push(ev.data);
};
rec.onstop = function () {
const type = mime || 'audio/webm';
const blob = new Blob(chunks, { type: type });
chunks = [];
rec = null;
releaseStream();
if (discard) { discard = false; resetUI(); toast('说话时间太短'); return; }
upload(blob);
};
rec.onerror = function () {
releaseStream();
resetUI();
toast('录音出错');
};
try {
rec.start();
} catch (e) {
releaseStream();
resetUI();
toast('无法开始录音:' + String((e && e.message) || e));
return;
}
phase = 'recording';
recordStartAt = Date.now();
stopTimer = setTimeout(finishHold, MAX_MS);
hardTimer = setTimeout(resetUI, MAX_MS + NO_RESULT_MS);
}
// 松手:结束录音(太短则丢弃)
function finishHold() {
if (phase !== 'recording') return;
if (stopTimer) { clearTimeout(stopTimer); stopTimer = null; }
const held = Date.now() - recordStartAt;
if (held < MIN_MS) discard = true;
phase = 'busy';
hold.classList.remove('recording');
setHoldText(discard ? '按住 说话' : '正在识别…');
// 遮罩留着,文案换成「正在识别…」;柱子停在低位,等结果回来再收
setOverlayMode(discard ? 'send' : 'busy');
stopMeter();
if (native) {
try {
native.stopVoice();
} catch (e) {
resetUI();
toast('结束录音失败:' + String((e && e.message) || e));
return;
}
// 壳若因为权限弹窗没有真正开录,stopVoice() 会被忽略、结果不会回来
watchdog = setTimeout(function () {
if (phase !== 'busy') return;
try { if (native.cancelVoice) native.cancelVoice(); } catch (_) { /* 忽略 */ }
resetUI();
}, NO_RESULT_MS);
return;
}
try {
if (rec && rec.state !== 'inactive') rec.stop();
else { releaseStream(); resetUI(); }
} catch (_) {
releaseStream();
resetUI();
}
}
// 放弃本次录音(切模式 / 离开页面 / 上滑取消 / 壳回调 cancelled)
function cancelHold() {
if (phase === 'idle') return;
const r = rec;
rec = null;
chunks = [];
if (r) { r.onstop = null; r.onerror = null; }
releaseStream();
resetUI();
try {
if (r && r.state !== 'inactive') r.stop();
else if (native && native.cancelVoice) native.cancelVoice();
} catch (_) { /* 已停 */ }
}
// ---------- 上传 + 自动发送 ----------
function upload(blob) {
if (!blob || !blob.size) { resetUI(); toast('没有录到声音'); return; }
phase = 'busy';
setOverlayMode('busy');
req('POST', '/api/asr/transcribe', blob, true, 120000)
.then(function (r) {
const text = String((r && r.text) || '').replace(/\s+/g, ' ').trim();
// 先收遮罩再做后续:toast 固定在 bottom:96px,遮罩还在时弹出来会压住声波
resetUI();
if (!text) { toast('没有识别到内容'); return; }
ta.value = text;
send();
})
.catch(function (e) {
resetUI();
toast('语音识别失败:' + String((e && e.message) || e));
});
}
// ---------- 按住 / 滑动 / 松开 ----------
hold.addEventListener('pointerdown', function (e) {
if (e && e.button != null && e.button !== 0) return; // 只响应左键/触摸
e.preventDefault();
if (phase !== 'idle') return;
pressY = e.clientY || 0;
try { hold.setPointerCapture(e.pointerId); } catch (_) { /* 忽略 */ }
startHold();
});
function onMove(e) {
if (!pressing) return;
if (phase !== 'recording' && phase !== 'arming') return;
if (!overlay || overlay.classList.contains('hidden') || !hintEl) return;
// 阈值取文案元素的实际下沿;同时要求相对按下点确实上滑了一段,
// 否则首次 pointermove 的坐标噪声或极端布局会把状态直接判成取消(一进来就红)。
const line = hintEl.getBoundingClientRect().bottom;
const limit = pressY ? Math.min(line - 4, pressY - 24) : (line - 4);
const y = e.clientY;
if (!cancelArmed && y < limit) setOverlayMode('cancel');
else if (cancelArmed && y > line + 4) setOverlayMode('send');
}
function onRelease(e) {
// 必须先进 pressing 判断:这个监听器也挂在 window 上,
// 对无关的 pointerup 调 preventDefault 会吞掉全局 click 事件。
if (!pressing) return;
if (e) e.preventDefault();
pressing = false;
if (cancelArmed) {
// 不弹提示:toast 会盖住声波(取消本身已经有颜色/文案反馈)
cancelHold();
return;
}
if (phase === 'recording') finishHold();
else if (phase === 'arming') cancelHold(); // 还没真正开录:当误触
}
hold.addEventListener('pointerup', onRelease);
hold.addEventListener('pointercancel', onRelease);
hold.addEventListener('pointermove', onMove);
// 兜底:个别环境下 setPointerCapture 不生效,手指移出按钮后也要跟手
window.addEventListener('pointerup', onRelease);
window.addEventListener('pointercancel', onRelease);
window.addEventListener('pointermove', onMove);
// 长按不弹系统菜单(移动端)
hold.addEventListener('contextmenu', function (e) { e.preventDefault(); });
// 键盘可达:空格/回车按下开始,松开结束
hold.addEventListener('keydown', function (e) {
if (e.repeat) return;
if (e.key !== ' ' && e.key !== 'Enter') return;
e.preventDefault();
if (!pressing) startHold();
});
hold.addEventListener('keyup', function (e) {
if (e.key !== ' ' && e.key !== 'Enter') return;
e.preventDefault();
onRelease(null);
});
// 录音中离开页面:释放麦克风
window.addEventListener('pagehide', cancelHold);
// ---------- 原生桥回调(契约见 docs/voice-input.md) ----------
// 实时幅度:套壳每 ~100ms 上报一次 MediaRecorder.getMaxAmplitude() 的**原始值**(0~32767)。
// 换算、门限、平滑全部在页面侧做——规则只存在这一份,壳不要做任何数学。
function onNativeAmp(raw) {
if (!native) return;
const amp = Number(raw);
if (!isFinite(amp)) return;
lastRealLevelAt = Date.now();
if (amp <= 0) {
levelTarget = 0;
} else {
const db = 20 * Math.log10(Math.min(amp, 32767) / 32767);
levelTarget = dbToLevel(db);
}
startLoop(); // 静默态下循环已停,下一帧数据到了再启
}
window.onNativeVoiceAmp = onNativeAmp;
window.onNativeVoiceLevel = onNativeAmp; // 旧名兼容:同样按原始幅度解释
window.onNativeVoiceResult = function (b64, mimeType) {
if (phase !== 'busy' && phase !== 'recording') return;
if (watchdog) { clearTimeout(watchdog); watchdog = null; }
if (discard) { discard = false; resetUI(); toast('说话时间太短'); return; }
try {
const bin = atob(String(b64 || ''));
const arr = new Uint8Array(bin.length);
for (let i = 0; i < bin.length; i++) arr[i] = bin.charCodeAt(i);
upload(new Blob([arr], { type: mimeType || 'audio/mp4' }));
} catch (_) {
resetUI();
toast('语音数据解析失败');
}
};
window.onNativeVoiceState = function (s) {
if (!native || s !== 'recording' || phase !== 'recording') return;
// 真正开录:60s 与「太短」判定从这一刻算(首次授权弹窗的时间不算)
recordStartAt = Date.now();
if (stopTimer) clearTimeout(stopTimer);
stopTimer = setTimeout(finishHold, MAX_MS);
if (!pressing) finishHold(); // 弹窗期间已经松手:立刻收口(held≈0 → 丢弃)
};
window.onNativeVoiceError = function (code, message) {
if (phase === 'idle') return;
resetUI();
// 生命周期打断(切后台/换页)属预期,不弹提示
if (code === 'cancelled' || code === 'canceled') return;
toast(code === 'too_short'
? '说话时间太短,请按住再说'
: '录音失败:' + String(message || code || '未知错误'));
};
// ---------- 对外暴露给发送键 / sessions.js 的状态查询 ----------
window.AgentVoice = {
isAvailable: function () { return available; },
isVoiceMode: function () { return mode; },
enter: enter,
exit: exit
};
// 能力判定:桥优先;没有桥就得是安全上下文(浏览器不允许 http 页面开麦)
if (!native && !webOk) {
console.info('[voice] 语音入口未启用:没有 window.AgentNative,且当前不是安全上下文(需 HTTPS,或由套壳 App 注入原生桥)');
return;
}
// 服务端没接线(core 的 ASR_URL 为空)就不给入口;探测失败则照常启用
req('GET', '/api/asr/status').then(function (s) {
if (s && s.enabled === false) {
console.info('[voice] 语音入口未启用:服务端未配置语音识别(agent-core 的 ASR_URL 为空)');
return;
}
available = true;
updateSendBtn();
}).catch(function () {
available = true;
updateSendBtn();
});
})();
+71
View File
@@ -0,0 +1,71 @@
// 语音识别代理:浏览器 / 套壳 App 录好的音频 → agent-core → mcp_asr → 文字。
//
// 为什么要 core 中转、而不是前端直连 ASR 容器:mcp_asr 只挂在 agent-mcp-net 内网、
// 一个宿主端口都不占(它自身没有鉴权,暴露即被白嫖)。对外唯一的入口仍是 core,
// 鉴权沿用全局登录态(auth.middleware 已挂在 /api 之前)。
//
// 开关:core 的 ASR_URL 为空 = 未部署语音识别,本路由一律 503,前端据此不显示麦克风。
const express = require('express');
const log = require('../log');
const router = express.Router();
const ASR_URL = String(process.env.ASR_URL || '').trim().replace(/\/+$/, '');
// 与 mcp_asr 的上限保持一致(60s 的 AAC 约 240KB,这里给长音频留余量)
const MAX_BYTES = 20 * 1024 * 1024;
const TIMEOUT_MS = 120000;
// 只接音频二进制。全局 express.json(2mb) 只解析 application/json,两者不冲突。
// 注意 WebView 可能发 audio/mp4、audio/webm;codecs=opus,统一按 audio/* 接。
const rawAudio = express.raw({
type: ['audio/*', 'application/octet-stream', 'application/mp4'],
limit: '20mb',
});
// 前端可用性探测(按钮是否显示)。不碰网络,纯看接线。
router.get('/status', function (req, res) {
res.json({ enabled: !!ASR_URL, max_bytes: MAX_BYTES });
});
router.post('/transcribe', rawAudio, async function (req, res) {
if (!ASR_URL) {
return res.status(503).json({ error: '语音识别未配置(core 未设置 ASR_URL)' });
}
const buf = req.body;
if (!Buffer.isBuffer(buf) || !buf.length) {
return res.status(400).json({ error: '未收到音频数据(Content-Type 需为 audio/*)' });
}
try {
const r = await fetch(ASR_URL + '/transcribe', {
method: 'POST',
headers: { 'Content-Type': req.headers['content-type'] || 'application/octet-stream' },
body: buf,
signal: AbortSignal.timeout(TIMEOUT_MS),
});
const text = await r.text();
if (!r.ok) {
// ASR 服务回的是 {error:string}:解出来再转,不然前端会看到两层套嵌的 JSON
let msg = text.slice(0, 300);
try { msg = JSON.parse(text).error || msg; } catch (_) { /* 非 JSON 保留原文 */ }
log.warn('asr', '识别失败 HTTP ' + r.status + ':' + msg);
// 4xx(静音 / 坏音频 / 过载)原样透传;5xx 统一当上游故障
const code = r.status >= 400 && r.status < 500 ? r.status : 502;
return res.status(code).json({ error: msg });
}
// 原样透传 ASR 的 {text, ms, backend}
res.type('application/json').send(text);
} catch (e) {
log.warn('asr', '调用 ASR 服务失败:' + String(e && e.message || e));
res.status(502).json({ error: '语音识别服务不可用:' + String(e && e.message || e) });
}
});
// express.raw 超限时抛 entity.too.large,默认会回 HTML;这里翻成前端能读的 JSON。
router.use(function (err, req, res, next) {
if (err && (err.type === 'entity.too.large' || err.status === 413)) {
return res.status(413).json({ error: '音频过大(上限 ' + Math.round(MAX_BYTES / 1048576) + 'MB)' });
}
next(err);
});
module.exports = router;
+1 -1
View File
@@ -15,7 +15,7 @@ const router = express.Router();
const STARTED_AT = Date.now(); const STARTED_AT = Date.now();
// 版本以本文件字面量为准:容器部署只挂载 app/server,镜像里的 package.json 可能是旧的, // 版本以本文件字面量为准:容器部署只挂载 app/server,镜像里的 package.json 可能是旧的,
// 读它会一直显示发版时的版本号(之前 2.1.0 改完仍显 2.0.0 即此因)。发版时记得同步这里。 // 读它会一直显示发版时的版本号(之前 2.1.0 改完仍显 2.0.0 即此因)。发版时记得同步这里。
const VERSION = '2.3.0'; const VERSION = '2.4.0';
// git 提交号单独返回(提交时 post-commit 钩子自动生成),前端只显示简洁版本号 // git 提交号单独返回(提交时 post-commit 钩子自动生成),前端只显示简洁版本号
const VERSION_COMMIT = versionInfo.commit || ''; const VERSION_COMMIT = versionInfo.commit || '';
+19 -1
View File
@@ -71,6 +71,9 @@ app.use('/api/sessions', require('./routes/files'));
// 与 /api/db 对称;执行核心仍复用 tools/skills.runSkill,core 不感知具体技能。 // 与 /api/db 对称;执行核心仍复用 tools/skills.runSkill,core 不感知具体技能。
app.use('/api/sessions', require('./routes/skill-run')); app.use('/api/sessions', require('./routes/skill-run'));
app.use('/api/skills', require('./routes/skills')); app.use('/api/skills', require('./routes/skills'));
// 语音识别(可选):录音在客户端(套壳 App 原生桥或浏览器 MediaRecorder),转写在 mcp_asr。
// ASR_URL 为空时接口回 503,前端据此不显示麦克风按钮(见 routes/asr.js)。
app.use('/api/asr', require('./routes/asr'));
// 系统配置含全部用户(脱敏密码)与平台密钥,且可整份改写 YAML:仅管理员可访问。 // 系统配置含全部用户(脱敏密码)与平台密钥,且可整份改写 YAML:仅管理员可访问。
app.use('/api/config', auth.requireAdmin, require('./routes/config')); app.use('/api/config', auth.requireAdmin, require('./routes/config'));
app.use('/api/platforms', require('./routes/platforms')); app.use('/api/platforms', require('./routes/platforms'));
@@ -145,7 +148,22 @@ app.get('/api/models', (req, res) => {
res.json(rows); res.json(rows);
}); });
app.get('/api/health', (req, res) => res.json({ ok: true, time: Date.now() })); // 探活 + 服务器地址校验(免认证,见 auth.js 的 PUBLIC_EXACT)。
// 套壳 App / 运维脚本会手动填服务器地址,必须能判断“这个地址到底是不是本服务”:
// 只认 HTTP 200 + body.ok===true + service==='agent-core',不能只看状态码——
// 填到别的站点、反代首页或劫持页同样可能回 200。
// no-store:避免 WebView / 反向代理 / Service Worker 把旧响应当成“服务在线”。
// auth_required 让客户端区分“连上了但没登录”和“地址填错了”。
app.get('/api/health', (req, res) => {
res.setHeader('Cache-Control', 'no-store');
res.json({
ok: true,
service: 'agent-core',
api: 1, // 接口代际:未来出现不兼容改动时升,客户端据此提示升级
time: Date.now(),
auth_required: !!(cfg.auth && cfg.auth.users && cfg.auth.users.length),
});
});
const PORT = process.env.PORT || cfg.port; const PORT = process.env.PORT || cfg.port;
+57 -92
View File
@@ -1,109 +1,74 @@
You are a general-purpose task assistant running on a private server via a web You are a general-purpose task assistant on a private server, reached through a
interface. You help with file generation, data processing, web fetching, web interface. You help with file generation, data processing, web fetching,
running commands, writing scripts, and similar tasks. running commands, writing scripts, and similar tasks.
You have a dedicated working directory for each conversation. All file paths in Each conversation has its own working directory; tool paths are relative to it
tool calls are relative to that directory unless otherwise specified. unless stated otherwise. Uploaded files appear there.
## Scope & Capability Boundaries ## Capabilities
You are a file / data / information processing assistant. The tools available Your capabilities are exactly what the live tool list and the skills list below
to you vary by session — always check the live tool list before answering. expose — they vary by session, so check them before answering. Do not assume a
capability that isn't there.
In scope: understanding images (describe, OCR, read charts); deterministic image Never fake results: no placeholder files, no claiming a file was created, no
operations (format conversion, resize, crop, watermark); generative image crude substitutes (ASCII art, hand-drawn SVG) for what the user actually wants.
creation and editing when an image skill/tool is available; charts and diagrams
from data; document processing and conversion (PDF / Markdown / Word / Excel /
PowerPoint); data processing; running scripts and commands; fetching and
summarizing web information; audio/video transcoding and basic editing;
generative media when a tool or skill for it is present in the current session
(read that tool's or skill's own description for its capabilities and limits);
SQLite operations.
Out of scope: capabilities no available tool exposes in this session. Do not If something seems impossible, check relevant skills first, then whether tools
fake results — no placeholder files, no claiming a file was created, no crude can be combined, or whether the work can be split with the user's own
substitutes (ASCII art, hand-drawn SVG) for what the user actually wants. environment (their browser or device). If it truly can't be done, say so in one
or two sentences and offer whatever part is doable; do not call tools just to
When the user asks for something that seems out of scope: reject a request.
- Before concluding you can't do it, check for combinations: chaining tools, or
combining tools with the user's own environment (their browser or device).
Some requests are impossible from the server alone but become possible when
the work is split between the server and the user's side.
- If an available skill might handle it, check the skill before declaring it out
of scope.
- If it truly can't be done, say so in one or two sentences and stop — do not
call tools just to reject a request, do not over-apologize. If a third-party
tool covers it, mention one briefly. If part of the request is doable, offer
that part.
## Communication
- Be concise and direct. Use plain language; format with Markdown when useful.
- Be truthful. If unsure, say so.
- Do not over-apologize.
## Work Principles ## Work Principles
- **Choose the simplest reliable path.** Prefer standard library or built-in - Choose the simplest reliable path; do not write a script where a few commands
tools. If a required package is missing, install it into a session-local venv suffice.
when possible; otherwise use a fallback or report the limitation. - If the same approach fails twice, switch approaches or report the failure —
- **Stop after repeated failures.** If the same approach fails more than once or do not keep retrying.
twice, switch to a different approach or report failure. Do not keep retrying - For multi-step work, state the plan briefly and give periodic updates.
the same method. - Match effort to the task: one basic check that the output is usable is enough.
- **Report progress.** If a task will take many steps, state your plan briefly
first and give periodic updates. Do not run silently for a long stretch.
- **Match effort to the task.** Do not write complex scripts where a few
commands suffice, and do not verify more deeply than the task requires. One
basic check that the output is usable is enough.
## Tool Use ## Tools
- Use the most appropriate tool for each step. - Independent calls can run in parallel. Parameters are top-level fields of the
- Independent tool calls can be made in parallel. tool call arguments — follow the schema exactly.
- Follow the parameter schemas exactly; parameters are passed as top-level - `mint_public_link` makes a file publicly reachable without authentication —
fields of the tool call arguments. never use it for files containing secrets.
- Skills marked **required** in the skill list below must be used for their
scope — do not hand-write scripts to accomplish what a required skill already ## Skill Use
does. For other skills, prefer them when they match the task.
- `mint_public_link` creates a public, unauthenticated URL — never use it for Before writing a script or installing a package, check the skill list below.
files containing secrets. For image editing, minting the reference image is If a skill covers the task, use it instead of reimplementing the same job in
the intended path; the link is temporary but publicly reachable. ad-hoc code — skills already handle the server-specific pitfalls. Read its
interface with the `skill` tool (`{"op":"get","name":"<skill>"}`) before the
first run, once per skill per conversation. `required` marks the skills whose
domain must never be hand-rolled.
{APP_SKILLS_SECTION} {APP_SKILLS_SECTION}
## File Management ## Communication
- Work inside the working directory. Use clear file names. - Be concise and direct; Markdown when useful. If unsure, say so. Don't
- Uploaded files appear in the working directory; check with `terminal` (e.g. over-apologize.
`ls`) if needed. - When done, briefly state what was done and list created/modified files. Offer
follow-ups only when useful.
## Completion ## Environment
- After finishing, briefly state what was done and list created/modified files. - Linux container, isolated per conversation: you see the working directory, a
- Offer follow-up options only if useful; do not do extra work automatically. session-scoped `/tmp`, read-only `/workspace/skills`, and system paths — never
other sessions.
## System Environment - `terminal` runs POSIX sh (`/bin/sh` is dash); use `bash` for scripts.
- `/tmp` persists across calls in a conversation; `/dev/shm` and `/var/tmp` are
- OS: linux. Shell commands run under POSIX sh (`/bin/sh` is dash); use `bash` wiped on every call.
for scripts (`run.sh`). Keep `terminal` one-liners POSIX-compatible. - Python 3.11; system packages are read-only. Add packages in a venv in the
- Isolated container: a command can access the session working directory, a working directory: `python3 -m venv --system-site-packages .venv`, then
session-scoped `/tmp`, read-only `/workspace/skills`, and read-only system `.venv/bin/pip` / `.venv/bin/python`. Don't reinstall packages that are
paths. It cannot see other sessions. already importable.
- `/tmp` is usable for scratch across `terminal` calls in the same conversation. - System packages can't be installed at runtime (`apt-get` fails). A missing CLI
`/dev/shm` and `/var/tmp` reset on every `terminal` call — do not use them to tool must be added on the server — tell the user.
carry state across calls. - No C/C++ compiler or `make`: `pip install` only works for pure-Python or
- Python 3.11 is available; the system Python and its packages are read-only. prebuilt-wheel packages.
To add packages, create a virtualenv inside the working directory - Chinese text in matplotlib: set `font.sans-serif` to `Noto Sans CJK SC`. For
(`python3 -m venv --system-site-packages .venv`, then `.venv/bin/pip` and `.venv/bin/python`). ZIPs with GBK filenames, use `unar` or `7z x` to avoid garbled names.
Keep it in the working directory, not `/tmp`.
The venv inherits system packages; do not reinstall packages that are
already importable. Only install what is missing.
- System packages cannot be installed at runtime (`apt-get install` fails on the
read-only root filesystem). If a required CLI tool is missing, tell the user
it must be added on the server.
- No C/C++ compiler or `make` — `pip install` works only for packages that ship
a prebuilt wheel or are pure Python.
- For Chinese text in matplotlib: set `font.sans-serif` to `Noto Sans CJK SC`.
- For Chinese ZIP files with GBK filenames, prefer `unar` or `7z x` to avoid
garbled names; in Python, use automatic encoding detection.
+26
View File
@@ -24,6 +24,8 @@ services:
# 微信接入 # 微信接入
- WXBOT_URL=http://agent-wxbot:8093 - WXBOT_URL=http://agent-wxbot:8093
- WXBOT_TOKEN=${WXBOT_TOKEN:?WXBOT_TOKEN not set - run scripts/init.sh} - WXBOT_TOKEN=${WXBOT_TOKEN:?WXBOT_TOKEN not set - run scripts/init.sh}
# 语音识别(可选):mcp_asr 的内网地址。置空 = 不启用,前端不显示麦克风按钮。
- ASR_URL=http://mcp_asr:3000
networks: networks:
- agent-mcp-net - agent-mcp-net
@@ -206,6 +208,30 @@ services:
networks: networks:
- agent-mcp-net - agent-mcp-net
# 语音识别:录音在客户端(套壳 App 原生桥 / 浏览器 MediaRecorder),转写在这里。
# 同进程两个入口(见 mcp/asr/src/server.js 头注释):
# POST /transcribe ← agent-core 的 /api/asr 转发(输入框,低延迟、不经过模型)
# POST /mcp ← 模型的 MCP 工具 transcribe_audio({url})(转写任务目录里的音频)
# 转写走上游 OpenAI 兼容的 /audio/transcriptions(默认智谱 glm-asr,换平台改 ASR_API_* 即可)。
mcp_asr:
build: ./mcp/asr
container_name: mcp_asr
restart: unless-stopped
healthcheck:
test: ["CMD", "node", "-e", "fetch('http://127.0.0.1:3000/health').then(r => process.exit(r.ok ? 0 : 1)).catch(() => process.exit(1))"]
interval: 10s
timeout: 5s
retries: 5
start_period: 5s
environment:
- ASR_API_KEY=${ASR_API_KEY:-}
- ASR_API_BASE=${ASR_API_BASE:-https://open.bigmodel.cn/api/paas/v4}
- ASR_MODEL=${ASR_MODEL:-glm-asr}
- ASR_LOG_LEVEL=${ASR_LOG_LEVEL:-info}
- TZ=Asia/Shanghai
networks:
- agent-mcp-net
networks: networks:
# 全部服务共用一个网络;由本仓库创建(固定名字,避免被加上 compose 项目名前缀)。 # 全部服务共用一个网络;由本仓库创建(固定名字,避免被加上 compose 项目名前缀)。
# - core 与 executor 靠它按容器名访问 MCP 服务(如 http://mcp_web_search:3000/) # - core 与 executor 靠它按容器名访问 MCP 服务(如 http://mcp_web_search:3000/)
+393
View File
@@ -0,0 +1,393 @@
# 语音输入:客户端录音契约
链路是「按住说话 → 客户端录音 → `POST /api/asr/transcribe` → 转写结果**自动发送**」。
服务端只收音频字节,不关心是谁录的。`public/js/voice.js` 按能力自己选录音方式:
| 页面环境 | 录音方式 | 说明 |
|---|---|---|
| Android 套壳 App(WebView) | **原生录音 + JS 桥** | WebView 没有 Web Speech API;http 页面也允许 `getUserMedia` 的替代路径 |
| 浏览器 / PWA(HTTPS) | `MediaRecorder` | 标准 `getUserMedia`,不用改壳 |
| 纯浏览器(`http://<IP>`) | 不可用 | 非安全上下文,浏览器拒绝开麦 |
**发送键的四种状态**(`sessions.js` 的 `updateSendBtn` 决定):
| `data-state` | 什么时候 | 点击行为 |
|---|---|---|
| `stop` | 生成中且输入框为空 | 停止当前回合(优先级最高,不被语音入口顶掉) |
| `voice` | 空闲、无文字无附件、且语音可用 | 进入语音模式 |
| `keyboard` | 已在语音模式 | 回键盘模式,聚焦输入框(移动端弹键盘) |
| `send` | 其余情况 | 发送 |
「语音可用」= ①有录音能力(原生桥,或安全上下文下的 `MediaRecorder`)②`GET /api/asr/status`
返回 `enabled !== false`。所以**套壳 App 里即使页面是 `http://`,只要桥注入成功,麦克风入口照样出现**;
纯浏览器 `http://<IP>` 不会出现(非安全上下文,浏览器禁止开麦)。
语音模式下输入框被 `#voice-hold` 取代(只有居中文字,无按钮外观):按住后整块输入区被
**全宽遮罩**盖住(`#voice-overlay`,向左右各扩到屏幕边缘),遮罩里是「实时电平声波 + 提示文案」。
手指上滑进入文案区域 → 取消态(声波与文案变红,文案改为「松开取消」),滑回下方恢复;
松手时取消态则**直接丢弃**(不弹 toast——它会盖住声波,取消本身已经有变色/文案反馈),否则转写并直接发送。
松手后遮罩保持到识别结束,文案换成「正在识别…」。发送键变成键盘按钮。
---
## 一、桥的契约
### 1. 注入时机
必须在 **`loadUrl()` 之前**注册,不要在 `onPageFinished` 里用 `evaluateJavascript` 注入:
```java
webView.setWebViewClient(/* ... */);
webView.addJavascriptInterface(new VoiceBridge(activity, webView), "AgentNative");
webView.loadUrl(startUrl);
```
`addJavascriptInterface` 的绑定对所有后续导航生效;在 `onPageFinished` 里再注入,首屏那次
加载会拿不到 `window.AgentNative`(页面脚本已经跑完了)。
### 2. 方法(壳实现)
```js
window.AgentNative = {
startVoice(), // 开始录音;失败/拒绝通过 onNativeVoiceError 回报
stopVoice(), // 结束录音;结果通过 onNativeVoiceResult 回传
cancelVoice() // 放弃本次录音(无回调;页面自己已经把状态复位了)
};
```
**线程模型**:这三个方法都跑在 WebView 的 JavaBridge 子线程上,**不是主线程**。
`MediaRecorder` 的所有调用必须收敛到主线程:方法入口先 `mainHandler.post(...)`,
读临时文件 + Base64 才放回子线程。
### 3. 回调(页面定义,壳调用)
```js
window.onNativeVoiceResult(base64, mime) // mime 例:'audio/mp4'
window.onNativeVoiceError(code, message) // 见下方错误码表
window.onNativeVoiceState('recording') // 建议实现:真正开始录时调一次
window.onNativeVoiceAmp(amp) // 建议实现:原始幅度 0~32767,驱动遮罩里的声波
```
- `onNativeVoiceAmp(amp)`:壳只上报 `MediaRecorder.getMaxAmplitude()` 的**原始值**
(0~32767,主线程每 100ms 一次),**不要做任何换算**。dB 归一化、静音门限、快攻慢放平滑
全部在页面侧——浏览器(RMS)和壳(峰值)两条路的规则只存在一份。
旧名 `onNativeVoiceLevel` 仍作为别名接受(同样按原始幅度解释)。
不实现也能用:声波静默停在基线上(不空转、不假动)。
JS 侧还要自己做快攻慢放平滑,壳不需要平滑。
- `onNativeVoiceState('recording')`:**按住说话的时长判定依赖它**。页面用这个回调重置
「60 秒上限」和「太短丢弃」的起点,避免首次授权弹窗的时间被算进录音。不实现也不会崩:
页面按点击时刻计时,代价是首次授权那一次会被当成「太短」丢弃(用户再按一次即可)。
- 页面收到 `onNativeVoiceResult` 后会直接发送消息(不经过输入框、不可编辑)。
- 所有回调都必须在**主线程**调 `webView.evaluateJavascript`。
- 字符串一律用 `JSONObject.quote(...)` 拼,不要手写 `'` 转义——异常 message 里可能有
`\`、换行、U+2028,会把整段脚本打断。
### 4. 状态机与错误码
壳侧状态:`IDLE → (WAITING_PERMISSION) → RECORDING → ENCODING → IDLE`。
`startVoice` 只在 `IDLE` 生效,`stopVoice` 只在 `RECORDING` 生效(其余静默忽略)。
| code | 触发时机 | 页面表现 |
|---|---|---|
| `no_permission` | 用户拒绝 / 取消授权弹窗 | toast「需要麦克风权限」 |
| `start_failed` | `prepare()` / `start()` 抛异常(含回退 MIC 后仍失败) | toast |
| `too_short` | `stop()` 抛异常(录音 < ~1s) | toast「说话时间太短,请按住再说」,**不上传** |
| `read_failed` | 读临时文件失败 | toast |
| `cancelled` | 生命周期打断(切后台 / 换页) | **静默复位,不弹提示** |
| 其他未知 code | — | toast 里显示 `message`,没有就显示 code |
**取消语义**:页面在 `stopVoice()` 之后会一直等结果(直到点击后 90 秒的硬超时),
所以壳在生命周期里取消录音时**必须**回调 `onNativeVoiceError('cancelled','')`,
否则按钮会卡在「录音中」。`cancelVoice()` 是页面主动发起的,壳不需要回报。
### 5. 体积与时序
- 16kHz / 32kbps / 单声道 AAC:60 秒 ≈ **240KB**,Base64 后 ≈ **320KB**。
- `evaluateJavascript` 走 Binder,单次约 1MB 上限;320KB 安全,但**不要再延长单次时长**。
真要 2 分钟以上,改成按段回传或本地 HTTP 回传。
- 松开后页面最多等 3 秒拿音频(等不到就复位,覆盖「壳还在等权限」的情况);
拿到后上传+识别,正常 1~2 秒。
- 按住时间 < 500ms 视为误触:页面直接丢弃,不上传;壳自己的 `too_short` 是第二道保险。
---
## 二、Java 参考骨架(纯 Java / minSdk 21)
只演示契约要求的部分;`UrlPolicy`、埋点、通知等按各自工程接。
```java
// AndroidManifest.xml
// <uses-permission android:name="android.permission.RECORD_AUDIO" />
public final class VoiceBridge {
private static final int REQ_MIC = 1001;
private static final long MAX_MS = 60_000;
private enum State { IDLE, WAITING_PERMISSION, RECORDING, ENCODING }
private final Activity activity;
private final WebView webView;
private final Handler main = new Handler(Looper.getMainLooper());
private final Runnable autoStop = this::stopOnMain;
// 实时电平:每 100ms 读一次 getMaxAmplitude() 交给页面画声波
private static final long LEVEL_INTERVAL_MS = 100;
private final Runnable levelTick = this::tickLevel;
private void tickLevel() {
MediaRecorder r = recorder;
if (state != State.RECORDING || r == null) return;
int amp = 0;
try { amp = r.getMaxAmplitude(); } catch (Exception ignored) { }
// 原始幅度直接给页面:dB 归一化/门限/平滑全在 JS,壳不做任何数学
js("window.onNativeVoiceAmp && window.onNativeVoiceAmp(" + amp + ")");
main.postDelayed(levelTick, LEVEL_INTERVAL_MS);
}
private State state = State.IDLE;
private MediaRecorder recorder;
private File file;
public VoiceBridge(Activity activity, WebView webView) {
this.activity = activity;
this.webView = webView;
}
// ---- JS 入口:JavaBridge 线程 → 主线程 ----
@JavascriptInterface public void startVoice() { main.post(this::startOnMain); }
@JavascriptInterface public void stopVoice() { main.post(this::stopOnMain); }
@JavascriptInterface public void cancelVoice() { main.post(() -> cancelOnMain(true)); }
// ---- 生命周期:由 Activity / WebViewClient 调用 ----
// 注意:只取消真正在录/在编码的状态。授权弹窗期间某些 ROM 会走 onPause,
// 那里如果一并取消,首次授权的两段式流程就断了。
public void onPause() {
main.post(() -> {
if (state == State.RECORDING || state == State.ENCODING) cancelOnMain(true);
});
}
public void onDestroy() { main.post(() -> cancelOnMain(false)); }
public void onPageChanged() { main.post(() -> cancelOnMain(true)); }
public void onRequestPermissionsResult(int requestCode, int[] grantResults) {
if (requestCode != REQ_MIC) return;
main.post(() -> {
if (state != State.WAITING_PERMISSION) return;
state = State.IDLE;
boolean ok = grantResults != null && grantResults.length > 0
&& grantResults[0] == PackageManager.PERMISSION_GRANTED;
if (!ok) { fail("no_permission", "需要麦克风权限"); return; }
beginRecording(); // 授权后直接开录(体验优先,不要求用户再点一次)
});
}
private void startOnMain() {
if (state != State.IDLE) return;
// 第三方 CDN 脚本同样能调这个桥:只允许自家页面 + 前台时录音
if (!UrlPolicy.isAllowed(webView.getUrl()) || !activity.hasWindowFocus()) {
fail("forbidden", "当前页面不允许录音");
return;
}
if (ContextCompat.checkSelfPermission(activity, Manifest.permission.RECORD_AUDIO)
!= PackageManager.PERMISSION_GRANTED) {
state = State.WAITING_PERMISSION;
ActivityCompat.requestPermissions(
activity, new String[]{Manifest.permission.RECORD_AUDIO}, REQ_MIC);
return;
}
beginRecording();
}
@SuppressLint("NewApi")
private void beginRecording() {
// VOICE_RECOGNITION 关掉 AGC/降噪,对 ASR 更友好;个别机型不支持则回退 MIC
int[] sources = {MediaRecorder.AudioSource.VOICE_RECOGNITION,
MediaRecorder.AudioSource.MIC};
for (int source : sources) {
File f = null;
MediaRecorder r = null;
try {
f = File.createTempFile("voice", ".m4a", activity.getCacheDir());
r = Build.VERSION.SDK_INT >= 31
? new MediaRecorder(activity) // 无参构造在 API 31 起废弃
: new MediaRecorder();
r.setAudioSource(source);
r.setOutputFormat(MediaRecorder.OutputFormat.MPEG_4);
r.setAudioEncoder(MediaRecorder.AudioEncoder.AAC);
r.setAudioSamplingRate(16000);
r.setAudioEncodingBitRate(32000);
r.setAudioChannels(1);
r.setOutputFile(f.getAbsolutePath());
r.prepare();
r.start();
recorder = r;
file = f;
state = State.RECORDING;
main.postDelayed(autoStop, MAX_MS);
main.postDelayed(levelTick, LEVEL_INTERVAL_MS);
// 让页面的 60s 从“真的开始录”算(授权弹窗的时间不算)
js("window.onNativeVoiceState && window.onNativeVoiceState('recording')");
// 不要再额外弹原生 Toast:页面遮罩已经给了全部反馈,弹窗会压住声波
return;
} catch (Exception e) {
// 局部变量释放:失败时 recorder 字段还没赋值,releaseQuietly() 管不到它
if (r != null) {
try { r.stop(); } catch (Exception ignored) { }
try { r.release(); } catch (Exception ignored) { }
}
delete(f);
}
}
state = State.IDLE;
fail("start_failed", "无法开始录音");
}
private void stopOnMain() {
if (state != State.RECORDING) return;
main.removeCallbacks(autoStop);
main.removeCallbacks(levelTick); // 停止上报电平
state = State.ENCODING;
MediaRecorder r = recorder;
File f = file;
recorder = null;
file = null;
boolean stopped = true;
try { r.stop(); } catch (RuntimeException e) { stopped = false; } // 太短会抛
try { r.release(); } catch (Exception ignored) { }
if (!stopped) {
delete(f);
state = State.IDLE;
fail("too_short", "没有录到声音");
return;
}
new Thread(() -> {
try {
byte[] bytes = readAll(f);
String b64 = Base64.encodeToString(bytes, Base64.NO_WRAP);
delete(f);
main.post(() -> {
state = State.IDLE;
js("window.onNativeVoiceResult(" + JSONObject.quote(b64) + ",'audio/mp4')");
});
} catch (Exception e) {
delete(f);
main.post(() -> { state = State.IDLE; fail("read_failed", "读取录音失败"); });
}
}, "voice-encode").start();
}
/** notify=true:页面在等结果,必须回 cancelled 让它复位;onDestroy 时页面已走,不必回。 */
private void cancelOnMain(boolean notify) {
main.removeCallbacks(autoStop);
main.removeCallbacks(levelTick);
boolean wasActive = state != State.IDLE;
releaseQuietly();
delete(file);
file = null;
state = State.IDLE;
if (notify && wasActive) js("window.onNativeVoiceError('cancelled','')");
}
private void releaseQuietly() {
if (recorder == null) return;
try { recorder.stop(); } catch (Exception ignored) { }
try { recorder.release(); } catch (Exception ignored) { }
recorder = null;
}
private void fail(String code, String message) {
js("window.onNativeVoiceError(" + JSONObject.quote(code) + ","
+ JSONObject.quote(message) + ")");
}
private void js(String script) {
webView.post(() -> webView.evaluateJavascript(script, null));
}
private static byte[] readAll(File f) throws Exception {
try (FileInputStream in = new FileInputStream(f);
ByteArrayOutputStream out = new ByteArrayOutputStream()) {
byte[] buf = new byte[8192];
int n;
while ((n = in.read(buf)) > 0) out.write(buf, 0, n);
return out.toByteArray();
}
}
private static void delete(File f) {
if (f != null) f.delete();
}
}
```
接线:
```java
// setupWebView() 里,loadUrl 之前
webView.addJavascriptInterface(new VoiceBridge(this, webView), "AgentNative");
@Override public void onRequestPermissionsResult(int code, String[] p, int[] r) {
super.onRequestPermissionsResult(code, p, r);
bridge.onRequestPermissionsResult(code, r);
}
@Override protected void onPause() { bridge.onPause(); super.onPause(); }
@Override protected void onDestroy() { bridge.onDestroy(); super.onDestroy(); }
// WebViewClient.onPageStarted:URL 变了就 bridge.onPageChanged()
```
---
## 三、壳侧必须同步的清单
| 项 | 内容 |
|---|---|
| `AndroidManifest.xml` | `<uses-permission android:name="android.permission.RECORD_AUDIO" />` |
| `proguard-rules.pro` | 保留桥:`-keepclassmembers class * { @android.webkit.JavascriptInterface <methods>; }`,并删掉「本项目未使用 addJavascriptInterface」的注释 |
| README 安全表 | 从「不使用 JS 桥」改为「仅暴露语音桥:三个无参方法,无文件/存储读取能力」 |
| README 权限行 | 「只有 INTERNET」→「INTERNET + RECORD_AUDIO」 |
| 桥的防护 | `UrlPolicy.isAllowed(webView.getUrl())` + `activity.hasWindowFocus()` + 单实例状态机;建议再加一个原生 Toast 提示录音已开始(外部 CDN 脚本与页面同源,能调桥,但用户至少看得见) |
| 页面导航 | `onPageStarted` 且 URL 变化时取消,避免 base64 打到新页面的回调上 |
> 触摸时间戳门槛(最近 N 秒内有触摸才允许录音)能进一步防静默录音,但会让无障碍操作不可用,
> 不建议默认开。
---
## 四、iOS(以后若有 WKWebView 壳)
契约相同,换注入方式:
```swift
// 注入:WKUserScript(source: "window.AgentNative = {...}", injectionTime: .atDocumentStart, ...)
// 录音:AVAudioRecorder(16kHz / 单声道 / m4a)
// 回传:webView.evaluateJavaScript("window.onNativeVoiceResult('\(b64)','audio/mp4')")
```
`Info.plist` 需要 `NSMicrophoneUsageDescription`。
## 五、服务端接口
```http
POST /api/asr/transcribe
Content-Type: audio/mp4 # 或 audio/webm / audio/wav / application/octet-stream
Cookie: <登录态> # 与页面同一份 HttpOnly cookie
<音频二进制>
```
```json
{ "text": "打开今天的日报", "ms": 842, "model": "glm-asr" }
```
- 上限 20MB,超时 120s;识别失败返回 `{"error": "..."}`(前端直接 toast 出来)。
- `GET /api/asr/status` → `{"enabled": true}`:`ASR_URL` 没接线时为 `false`。
## 六、为什么不用浏览器的 Web Speech API
- Android WebView 没有实现 `SpeechRecognition`;iOS WKWebView 同样不可用(只有 Safari 有)。
- 桌面 Chrome 的识别走 Google 服务,国内基本报 `network`。
- 三端行为不一致、错误码各异,最后还是要留一条服务端通路——不如只留一条。
+65 -8
View File
@@ -36,6 +36,11 @@ const IDLE_MS = Number(process.env.OFFICE_IDLE_MS || 6 * 3600 * 1000);
const RESPOND_TIMEOUT_MS = 15000; // 数据请求(资源/API/SSE)等待 watch 首响应包的时限;拒连/超时走自愈重试 const RESPOND_TIMEOUT_MS = 15000; // 数据请求(资源/API/SSE)等待 watch 首响应包的时限;拒连/超时走自愈重试
const NAV_TIMEOUT_MS = 5000; // 导航请求等就绪页面首响应:更短——失败立刻转中转页,不白屏干等 const NAV_TIMEOUT_MS = 5000; // 导航请求等就绪页面首响应:更短——失败立刻转中转页,不白屏干等
const COOLDOWN_MS = 8000; // 启动失败拉黑该文件一段时间:中转页自动刷新不成 spawn 风暴(二进制缺失/坏文件早退) const COOLDOWN_MS = 8000; // 启动失败拉黑该文件一段时间:中转页自动刷新不成 spawn 风暴(二进制缺失/坏文件早退)
// 探针(HEAD)等「首帧可用」的上限:watch 冷启动 = 起进程 + 首次渲染,实测 2~6s(大文档更久)。
// 等不到就照回 200,把后续交给导航侧的中转页 + 自愈,探针不无限挂着。
const HEAD_WAIT_MS = 15000;
// 导航请求连续超时多少次才判死重启:单次超时只是「还没渲染完」(见 route 里的注释)。
const NAV_TIMEOUT_RETRIES = 3;
const BIN = process.env.OFFICECLI_BIN || '/workspace/skills/office/bin/officecli'; const BIN = process.env.OFFICECLI_BIN || '/workspace/skills/office/bin/officecli';
const TOKEN = String(process.env.EXECUTOR_TOKEN || ''); const TOKEN = String(process.env.EXECUTOR_TOKEN || '');
const EXTS = new Set(['.docx', '.xlsx', '.pptx']); const EXTS = new Set(['.docx', '.xlsx', '.pptx']);
@@ -164,10 +169,13 @@ async function spawnWatch(abs) {
const page = pageOf(abs); const page = pageOf(abs);
let slot = -1; let slot = -1;
for (let i = 0; i < SLOTS; i++) if (!slots.has(i)) { slot = i; break; } for (let i = 0; i < SLOTS; i++) if (!slots.has(i)) { slot = i; break; }
if (slot < 0) { // 槽满:优先踢「无活动连接且最久未用」;全开着页面才抢最冷的 if (slot < 0) { // 槽满:优先踢「就绪且无活动连接」里最久未用的;正在启动的槽最后才动
// (踢掉一个还没就绪的槽 = 白白浪费数秒冷启动,且会让等它的那一路请求失败并进冷却)
const ent = [...slots.entries()]; const ent = [...slots.entries()];
const idleReady = ent.filter(([, s]) => !s.conns && s.ready);
const idle = ent.filter(([, s]) => !s.conns); const idle = ent.filter(([, s]) => !s.conns);
slot = (idle.length ? idle : ent).sort((a, b) => a[1].lastUsed - b[1].lastUsed)[0][0]; slot = (idleReady.length ? idleReady : (idle.length ? idle : ent))
.sort((a, b) => a[1].lastUsed - b[1].lastUsed)[0][0];
stop(slot); // 端口按代轮转,新 watch 不会落在被踢者的旧口上,无需等其回收 stop(slot); // 端口按代轮转,新 watch 不会落在被踢者的旧口上,无需等其回收
} }
const wp = await allocPort(); const wp = await allocPort();
@@ -293,6 +301,18 @@ function matchPage(rel) {
return best; return best;
} }
// 探针预热:把槽位等到「就绪」(= 首帧渲染完成,portUp 探的就是页面本身),复用时直接返回。
// 与并发请求共用同一次 startWatch(starting 去重);任何失败/超时都静默——就绪与否不影响 200。
async function warmSlot(rr) {
let timer;
try {
await Promise.race([
waitReady(rr),
new Promise((r) => { timer = setTimeout(r, HEAD_WAIT_MS); }),
]);
} catch (_) {} finally { clearTimeout(timer); }
}
// 未命中兜底:请求路径本身就是存在的会话文档 → 回收/挤掉后就地复活;不行 = 维持 404。 // 未命中兜底:请求路径本身就是存在的会话文档 → 回收/挤掉后就地复活;不行 = 维持 404。
async function revive(rel) { async function revive(rel) {
const rr = (rel || '').replace(/\/+$/, ''); const rr = (rel || '').replace(/\/+$/, '');
@@ -354,10 +374,12 @@ function tryForward(entry, req, res, innerPath, respondTimeoutMs) {
res.once('close', release); res.once('close', release);
res.once('finish', release); res.once('finish', release);
let started = false; let started = false;
let upRes = null;
const upstream = http.request( const upstream = http.request(
{ host: '127.0.0.1', port: entry.port, path: encodeURI(inner) + search, method: req.method, headers: fwd }, { host: '127.0.0.1', port: entry.port, path: encodeURI(inner) + search, method: req.method, headers: fwd },
(up) => { (up) => {
started = true; started = true;
upRes = up;
clearTimeout(watchdog); clearTimeout(watchdog);
const h = Object.assign({}, up.headers); const h = Object.assign({}, up.headers);
const isSSE = String(h['content-type'] || '').includes('text/event-stream'); const isSSE = String(h['content-type'] || '').includes('text/event-stream');
@@ -385,8 +407,14 @@ function tryForward(entry, req, res, innerPath, respondTimeoutMs) {
upstream.on('error', () => { upstream.on('error', () => {
clearTimeout(watchdog); clearTimeout(watchdog);
release(); release();
if (!started && !res.headersSent) reject(new Error('watch 不可达')); if (!started && !res.headersSent) { reject(new Error('watch 不可达')); return; }
else res.destroy(); // 已开始回写后上游报错:不立刻销毁客户端响应。watch 会在响应其实已完整时断链
//(对 HEAD 必现,见 route 里的注释),Node 客户端的报错早于 'end' 一拍到达,直接
// destroy 会把马上要 flush 的响应打断。留一拍再判,真断裂照样收掉,不把半截响应当成功。
setTimeout(() => {
if (res.writableEnded) return;
try { res.destroy(); } catch (_) {}
}, upRes && upRes.complete ? 0 : 120);
}); });
req.pipe(upstream); req.pipe(upstream);
}); });
@@ -517,7 +545,8 @@ function fail502(res) {
} }
function notFound(res) { function notFound(res) {
res.writeHead(404, { 'content-type': 'text/plain; charset=utf-8' }) // no-store:前端拿 HEAD 当探针,404 一旦被浏览器缓存,文件补上后还会继续显示「暂无文档」
res.writeHead(404, { 'content-type': 'text/plain; charset=utf-8', 'cache-control': 'no-store' })
.end('无匹配预览(文档不存在/不在会话目录下,或不是 .docx/.xlsx/.pptx)'); .end('无匹配预览(文档不存在/不在会话目录下,或不是 .docx/.xlsx/.pptx)');
} }
@@ -534,6 +563,24 @@ async function route(req, res) {
if (u === PREFIX + '/' || u.startsWith(PREFIX + '/')) { if (u === PREFIX + '/' || u.startsWith(PREFIX + '/')) {
const rel = u.slice(PREFIX.length) || '/'; const rel = u.slice(PREFIX.length) || '/';
const rr = rel.replace(/\/+$/, ''); const rr = rel.replace(/\/+$/, '');
// HEAD = 前端预览窗的「这份文档能不能预览」探针。文档在不在只在本地按文件系统回答,绝不上探 watch:
// 实测 watch(Kestrel) 对 HEAD 只发响应头(带 content-length)不发 body 就断链,Node 客户端抛
// HPE_CLOSED_CONNECTION;旧逻辑把它当上游故障 res.destroy(),同一文档十次 HEAD 里六七次变成
// 空响应/502。
// 但回 200 前要等槽位就绪(有上限):冷启动的首次渲染很贵,旧实现由 HEAD 自己把这段等掉,
// iframe 一挂上就是渲染好的页面;若秒回 200,这段开销就落到随后 5s 时限的导航请求上,
// 慢文档会被判超时,表现为冷启动转圈很久。等不到也照回 200(见 HEAD_WAIT_MS)。
if (req.method === 'HEAD') {
let abs = null;
try { abs = guard(path.join(WORKSPACE, rr)); } catch (_) {}
if (abs) {
await warmSlot(rr);
res.writeHead(200, { 'content-type': 'text/plain; charset=utf-8', 'cache-control': 'no-store', 'content-length': '0' }).end();
return;
}
// 只有办公文档路径由本网关判定存在性;页面资源等其它 HEAD 仍走原转发逻辑
if (EXTS.has(path.extname(rr).toLowerCase())) return notFound(res);
}
if (isNav(req)) { if (isNav(req)) {
// 导航请求 = 用户正盯着这一刻:绝不为启动/自愈阻塞首字节。 // 导航请求 = 用户正盯着这一刻:绝不为启动/自愈阻塞首字节。
// 槽位不在或未就绪 → 中转页 + 后台热槽(startWatch 去重,在途就等它);就绪槽位转发失败 → 同样中转页。 // 槽位不在或未就绪 → 中转页 + 后台热槽(startWatch 去重,在途就等它);就绪槽位转发失败 → 同样中转页。
@@ -546,10 +593,20 @@ async function route(req, res) {
if (fileChanged(m.entry)) { dropChanged(m.entry); startWatch(abs).catch(() => {}); return loading(res); } if (fileChanged(m.entry)) { dropChanged(m.entry); startWatch(abs).catch(() => {}); return loading(res); }
if (m.exact && !u.endsWith('/')) { res.writeHead(301, { location: (req.url || u) + '/' }).end(); return; } // 相对资源解析需要尾斜杠 if (m.exact && !u.endsWith('/')) { res.writeHead(301, { location: (req.url || u) + '/' }).end(); return; } // 相对资源解析需要尾斜杠
const cut = PREFIX.length + m.entry.pageDec.length; // 剥掉「前缀+页面路径」才是 watch 的内层路径 const cut = PREFIX.length + m.entry.pageDec.length; // 剥掉「前缀+页面路径」才是 watch 的内层路径
try { await tryForward(m.entry, req, res, u.length > cut ? u.slice(cut) : '/', NAV_TIMEOUT_MS); return; } try { await tryForward(m.entry, req, res, u.length > cut ? u.slice(cut) : '/', NAV_TIMEOUT_MS); m.entry.navTimeouts = 0; return; }
catch (e) { catch (e) {
retire(m.entry, String(e && e.message || e)); const msg = String(e && e.message || e);
if (!res.headersSent) { startWatch(abs).catch(() => {}); return loading(res); } // 超时 ≠ 死:watch 可能只是首次渲染还没完(大文档 >5s)。一超时就摘掉会把在跑的渲染连坐杀掉,
// 中转页刷新后从头再来——用户看到的就是「冷启动一直转圈」。单次超时保留槽位,
// 连续 NAV_TIMEOUT_RETRIES 次(约 15s 无首字节)才判死重启,兼顶真卡死。
m.entry.navTimeouts = /超时/.test(msg) ? (m.entry.navTimeouts || 0) + 1 : NAV_TIMEOUT_RETRIES;
if (m.entry.navTimeouts < NAV_TIMEOUT_RETRIES) {
log(`slot 保留:导航超时第 ${m.entry.navTimeouts} 次(${msg})`);
} else {
retire(m.entry, msg);
startWatch(abs).catch(() => {});
}
if (!res.headersSent) return loading(res);
return; return;
} }
} }
+12 -3
View File
@@ -1,12 +1,13 @@
# MCP 服务集合 # MCP 服务集合
三个 MCP(Model Context Protocol)服务,各占一个目录,由仓库根 `docker-compose.yml` 统一编排: 四个 MCP(Model Context Protocol)服务,各占一个目录,由仓库根 `docker-compose.yml` 统一编排:
| 目录 | 容器名 | 作用 | 容器内端口 | MCP 端点 | | 目录 | 容器名 | 作用 | 容器内端口 | MCP 端点 |
|---|---|---|---|---| |---|---|---|---|---|
| `web_search/` | `mcp_web_search` | 免费网页搜索(Parallel / Exa,无需 key) | `3000` | `POST /` | | `web_search/` | `mcp_web_search` | 免费网页搜索(Parallel / Exa,无需 key) | `3000` | `POST /` |
| `image_task/` | `mcp_image_task` | 图片生成 / 编辑(智谱原生或任意 OpenAI 兼容 `/images/generations`,单工具 op=create/get) | `3000` | `POST /mcp` | | `image_task/` | `mcp_image_task` | 图片生成 / 编辑(智谱原生或任意 OpenAI 兼容 `/images/generations`,单工具 op=create/get) | `3000` | `POST /mcp` |
| `video_task/` | `mcp_video_task` | 智谱 CogVideo 视频生成(异步,单工具 op=create/get) | `3000` | `POST /mcp` | | `video_task/` | `mcp_video_task` | 智谱 CogVideo 视频生成(异步,单工具 op=create/get) | `3000` | `POST /mcp` |
| `asr/` | `mcp_asr` | 语音转文字(上游 OpenAI 兼容 `/audio/transcriptions`),**额外带一个给输入框用的 `POST /transcribe`** | `3000` | `POST /mcp` |
**这些服务一个宿主机端口都不占**——它们只挂在 `agent-mcp-net` 上,由 `agent-core` / `agent-executor` **这些服务一个宿主机端口都不占**——它们只挂在 `agent-mcp-net` 上,由 `agent-core` / `agent-executor`
按容器名访问。所以整台服务器对外只需要开 agent-core 那一个端口(`AGENT_PORT`,默认 8090)。 按容器名访问。所以整台服务器对外只需要开 agent-core 那一个端口(`AGENT_PORT`,默认 8090)。
@@ -31,16 +32,23 @@ mcp_servers:
url: "http://mcp_image_task:3000/mcp" url: "http://mcp_image_task:3000/mcp"
- name: video_task - name: video_task
url: "http://mcp_video_task:3000/mcp" url: "http://mcp_video_task:3000/mcp"
# 可选:语音转写(低频,建议 skill 模式,不占每轮工具表)
- name: asr
url: "http://mcp_asr:3000/mcp"
mode: skill
``` ```
服务没起来时,core 只在启动日志里告警,不影响 Web 主流程,但对应工具不会下发给模型。工具发现只在启动时做一次,失败后会自动按 2s / 20s / 1min 重试 3 次;三次都失败则需重启 core。三个服务都配了 `/health` 健康检查,`docker ps` 可直接看状态。 服务没起来时,core 只在启动日志里告警,不影响 Web 主流程,但对应工具不会下发给模型。工具发现只在启动时做一次,失败后会自动按 2s / 20s / 1min 重试 3 次;三次都失败则需重启 core。四个服务都配了 `/health` 健康检查,`docker ps` 可直接看状态。
> 从旧的「agent + mcp 双仓库」部署升级:先在旧 mcp 仓库目录 `docker compose down`(只需一次,否则同名容器与网络会冲突),再 `up` 本栈。 > 从旧的「agent + mcp 双仓库」部署升级:先在旧 mcp 仓库目录 `docker compose down`(只需一次,否则同名容器与网络会冲突),再 `up` 本栈。
`image_task` / `video_task` 的 token **不由服务端保存**——每个请求从 `Authorization` header 读取 `image_task` / `video_task` 的 token **不由服务端保存**——每个请求从 `Authorization` header 读取
(agent 侧配在 `config.yml` 的 `mcp_servers[].headers`)。`video_task` 用智谱 token; (agent 侧配在 `config.yml` 的 `mcp_servers[].headers`)。`video_task` 用智谱 token;
`image_task` 用对应上游(智谱或 OpenAI 兼容网关)的 token,上游地址与模型分别由 `image_task` 用对应上游(智谱或 OpenAI 兼容网关)的 token,上游地址与模型分别由
`X-Image-Task-Base-Url` / `X-Image-Task-Model` 指定。所以这里不用配任何密钥。 `X-Image-Task-Base-Url` / `X-Image-Task-Model` 指定。所以这两个服务不用配任何密钥。
`asr` 是例外:输入框那条路(`agent-core` → `POST /transcribe`)不经过 MCP 调用,拿不到 header,
所以它自己的上游密钥由容器 env `ASR_API_KEY` 提供(写在根 `.env`,已 gitignore,不挂给其他容器)。
### 调试端口 ### 调试端口
@@ -78,6 +86,7 @@ AI 把拿到的 URL 当 image_url 交给 video_task:3000/mcp
| `mcp_web_search` | 无 | 服务端无鉴权,**永远不要映射出去**(会被白嫖搜索额度);agent 走内网访问 | | `mcp_web_search` | 无 | 服务端无鉴权,**永远不要映射出去**(会被白嫖搜索额度);agent 走内网访问 |
| `mcp_image_task` | 无 | token 由调用方自带,暴露后可被拿去消耗你的上游图片额度 | | `mcp_image_task` | 无 | token 由调用方自带,暴露后可被拿去消耗你的上游图片额度 |
| `mcp_video_task` | 无 | 它需要的公开临时 URL 由 agent 侧集成的工具提供,自己不占端口 | | `mcp_video_task` | 无 | 它需要的公开临时 URL 由 agent 侧集成的工具提供,自己不占端口 |
| `mcp_asr` | 无 | `/mcp` 与 `/transcribe` 都无鉴权,只能由 core 经内网调用;它持有上游 ASR 密钥 |
## 单独调试 ## 单独调试
+2
View File
@@ -0,0 +1,2 @@
node_modules
*.md
+18
View File
@@ -0,0 +1,18 @@
FROM node:22-slim
# ffmpeg 只装在这里(core 镜像保持干净):WebView 录出来是 webm/opus,iOS 是 mp4/aac,
# 云端只认 wav/mp3——统一在容器内转成 16k 单声道 wav,前端与引擎两头都不用关心格式。
RUN apt-get update \
&& apt-get install -y --no-install-recommends ffmpeg ca-certificates \
&& rm -rf /var/lib/apt/lists/*
WORKDIR /app
# 零依赖:不需要 npm install(也就没有 registry 慢/被墙的问题)
COPY package.json ./
COPY src ./src
ENV PORT=3000
EXPOSE 3000
CMD ["node", "src/server.js"]
+87
View File
@@ -0,0 +1,87 @@
# mcp/asr — 语音识别服务
一个容器,两个入口,共用同一套转写实现:
| 入口 | 谁在用 | 说明 |
|---|---|---|
| `POST /transcribe` | `agent-core` 的 `/api/asr/transcribe`(H5 输入框) | 普通 HTTP,音频二进制进、`{text}` 出。**不经过模型、不消耗 token、1~3s** |
| `POST /mcp` | 模型(MCP 工具 `transcribe_audio`) | 转写任务目录里已有的音频,参数是公网 URL(与 `video_task` 的 `image_url` 同构) |
| `GET /health` | compose healthcheck | `{ok, model, configured}` |
端口 `3000` **只在 `agent-mcp-net` 内网**,不映射宿主机——本服务自身没有鉴权,暴露即被白嫖。
对外唯一入口仍是 `agent-core`(`/api/asr` 走登录态鉴权)。
## 为什么不是「录音 → 上传附件 → 模型调工具」
那要额外一次完整模型往返(3~10s + token),识别结果落进聊天记录而不是输入框,用户还没法改错字。
输入法级别的功能必须绕开模型;`/mcp` 那个口只留给「转写一段已上传的录音」这种低频需求。
## 部署
```bash
# 1) 配上游密钥(写进仓库根 .env,已 gitignore)
# ASR_API_KEY=你的智谱 token
# 2) 起服务
docker compose up -d --build mcp_asr
docker compose restart agent-core # core 要在启动时读到 ASR_URL
curl -s http://127.0.0.1:8090/api/asr/status # {"enabled":true,...}
```
`agent-core` 的环境变量 `ASR_URL`(compose 里固定为 `http://mcp_asr:3000`)是开关:置空即
不启用,`/api/asr/*` 回 503,前端不显示麦克风按钮。
## 上游
任何 OpenAI 兼容的 `/audio/transcriptions` 都能用;默认智谱:
| 变量 | 默认 |
|---|---|
| `ASR_API_BASE` | `https://open.bigmodel.cn/api/paas/v4` |
| `ASR_API_KEY` | 空(空则 `/transcribe` 回 503) |
| `ASR_MODEL` | `glm-asr` |
常驻内存约 35~40MB,CPU 基本为 0。没有本地模型可选:2 vCPU / 2GB 的机器跑不动能用的
whisper(固定 30 秒窗口,`small` 单次要 15~30 秒),需要私有化就把这个容器放到另一台机器,
只改 core 的 `ASR_URL` 指向它。
## HTTP 接口
```bash
# 任意格式(webm / mp4 / mp3 / wav / ogg / aac / flac),服务端用 ffmpeg 归一化
curl -s -X POST http://mcp_asr:3000/transcribe \
-H 'Content-Type: audio/webm' \
--data-binary @voice.webm
# → {"text":"打开今天的日报","ms":842,"model":"glm-asr"}
```
- 上限 20MB;超过 `ASR_MAX_CHUNK_SEC`(默认 25s)的音频自动切片后逐段识别再拼接
(多数云端 ASR 单次只吃 ~30s)。
- 同时最多 `ASR_MAX_CONCURRENT`(默认 2)个转写,超了回 429。
## MCP 工具
```yaml
# config.yml
mcp_servers:
- name: asr
url: "http://mcp_asr:3000/mcp"
mode: skill # 低频能力,别每轮都发 schema
```
`transcribe_audio({ url })`:本地文件先用内置工具 `mint_public_link` 换成公网短链,
再把链接传进来(和 `video_task` 要 `image_url` 是同一套路)。
## 环境变量速查
| 变量 | 默认 | 说明 |
|---|---|---|
| `ASR_API_BASE` / `ASR_API_KEY` / `ASR_MODEL` | 见上 | 上游语音识别 |
| `ASR_MAX_BYTES` | 20971520 | 单次上传上限 |
| `ASR_MAX_CHUNK_SEC` | `25` | 超长音频切片长度,`0` = 不切 |
| `ASR_MAX_CONCURRENT` | `2` | 并发转写数 |
| `ASR_LOG_LEVEL` | `info` | debug / info / warn / error / none |
## 客户端怎么录音
浏览器侧只有 HTTPS 才允许开麦;**Android 套壳 App 用原生录音再把 base64 交给页面**,
http 页面也能用。桥的契约与 Kotlin 示例见 [docs/voice-input.md](../../docs/voice-input.md)。
+10
View File
@@ -0,0 +1,10 @@
{
"name": "mcp_asr",
"version": "1.0.0",
"description": "ASR service: POST /transcribe for the H5 composer, POST /mcp for the model (tool transcribe_audio). Zero dependencies.",
"type": "module",
"main": "src/server.js",
"scripts": {
"start": "node src/server.js"
}
}
+433
View File
@@ -0,0 +1,433 @@
#!/usr/bin/env node
// ASR(语音转文字)服务。一个进程两个入口,共用同一套转写实现:
//
// POST /transcribe 普通 HTTP —— 给 agent-core 的输入框用:录完音直接拿文字,
// 不经过模型、不花 token、延迟 1~3s。
// POST /mcp Streamable HTTP MCP —— 工具 transcribe_audio({url}),给模型转写
// 会话目录里的音频(本地文件先 mint_public_link 换公网短链,与 video_task 同构)。
//
// 为什么不直接用 MCP 工具做语音输入:MCP 是模型协议,走一次工具调用要多一轮模型往返
//(3~10s + token),识别结果还会落进聊天记录而不是输入框,用户没法改错字。输入法级别的
// 功能必须绕开模型。
//
// 为什么零依赖(不用 express / MCP SDK):core 的 MCP 客户端只发 initialize / tools/list /
// tools/call 三种请求,手写这几十行 JSON-RPC 就够;本机内存只有 2G,省掉 SDK 与 express
// 的常驻开销(本服务空载约 35MB)。
//
// 转写走上游的 OpenAI 兼容 /audio/transcriptions(默认智谱 glm-asr,换平台改 env 即可)。
// 音频一律先经 ffmpeg 归一化成 16kHz 单声道 wav:WebView 录出来是 webm/opus,iOS 是 mp4/aac,
// 上游只认 wav/mp3,归一化后两端都自由。
import http from 'node:http';
import { spawn } from 'node:child_process';
import { randomUUID } from 'node:crypto';
import fs from 'node:fs/promises';
import os from 'node:os';
import path from 'node:path';
// ── 配置(全部走 env,不读 config.yml:本容器按仓库惯例只拿 env) ──────────────
const PORT = Number(process.env.PORT || 3000);
// 上游:任何 OpenAI 兼容的 /audio/transcriptions(智谱 glm-asr、OpenAI whisper-1 等)
const API_BASE = String(process.env.ASR_API_BASE || 'https://open.bigmodel.cn/api/paas/v4').trim().replace(/\/+$/, '');
const API_KEY = String(process.env.ASR_API_KEY || '').trim();
const API_MODEL = String(process.env.ASR_MODEL || 'glm-asr').trim();
// 单次上传上限。60s 的 AAC 约 240KB、16k wav 约 1.9MB,20MB 是给长音频留的余量。
const MAX_BYTES = Math.max(1024 * 1024, Number(process.env.ASR_MAX_BYTES || 20 * 1024 * 1024));
// 云端多数 ASR 单次只吃 ~30s:超长音频按这个秒数切片后逐段识别再拼接(0 = 不切)。
// 16k/16bit 单声道 wav 恒为 32000 B/s,所以用文件大小就能估时长,不用再起 ffprobe。
const CHUNK_SEC = Math.max(0, Number(process.env.ASR_MAX_CHUNK_SEC || 25));
// 同时转写数:2 vCPU 上并发再高只会互相拖慢。
const MAX_CONCURRENT = Math.max(1, Number(process.env.ASR_MAX_CONCURRENT || 2));
const FFMPEG = String(process.env.FFMPEG_BIN || 'ffmpeg').trim();
const LOG_LEVEL = String(process.env.ASR_LOG_LEVEL || 'info').toLowerCase();
const LEVELS = { debug: 10, info: 20, warn: 30, error: 40, none: 99 };
function log(level, msg) {
if ((LEVELS[level] || 20) < (LEVELS[LOG_LEVEL] == null ? 20 : LEVELS[LOG_LEVEL])) return;
console.log('[asr ' + level + '] ' + msg);
}
// ── 子进程:统一超时 + 收 stdout/stderr ────────────────────────────────────
function run(cmd, args, timeoutMs) {
return new Promise((resolve, reject) => {
let child;
try {
child = spawn(cmd, args, { stdio: ['ignore', 'pipe', 'pipe'] });
} catch (e) {
return reject(e);
}
let out = '';
let err = '';
let settled = false;
const timer = setTimeout(() => {
if (settled) return;
settled = true;
try { child.kill('SIGKILL'); } catch (_) { /* 已退出 */ }
reject(new Error(cmd + ' 超时(' + timeoutMs + 'ms)'));
}, timeoutMs);
timer.unref();
child.stdout.on('data', (d) => { out += d; });
child.stderr.on('data', (d) => { err += d; });
child.on('error', (e) => {
if (settled) return;
settled = true;
clearTimeout(timer);
reject(e); // ENOENT:二进制没装(如没装 ffmpeg)
});
child.on('close', (code) => {
if (settled) return;
settled = true;
clearTimeout(timer);
if (code === 0) resolve({ stdout: out, stderr: err });
else reject(new Error(cmd + ' 退出码 ' + code + ':' + ((err || out).slice(-400) || '无输出')));
});
});
}
// ── 音频:归一化成 16k 单声道 wav(再把超长音频切片) ───────────────────────
async function toWav(buf, ext) {
const id = randomUUID();
const inPath = path.join(os.tmpdir(), 'asr-in-' + id + (ext ? '.' + ext : ''));
const wavPath = path.join(os.tmpdir(), 'asr-out-' + id + '.wav');
try {
await fs.writeFile(inPath, buf);
await run(FFMPEG, [
'-hide_banner', '-loglevel', 'error', '-y',
'-i', inPath,
'-vn', '-ac', '1', '-ar', '16000', '-c:a', 'pcm_s16le', '-f', 'wav',
wavPath,
], 60000);
return wavPath;
} catch (e) {
await fs.rm(inPath, { force: true }).catch(() => {});
await fs.rm(wavPath, { force: true }).catch(() => {});
// ffmpeg 的 stderr 很有用(定位是封装不对还是文件截断),但只进日志——
// 回给前端的长英文堆栈对用户毫无意义,toast 里只会显示第一行。
log('warn', '音频解码失败:' + String(e && e.message || e));
const err = new Error('音频解码失败(格式不支持或文件损坏)');
err.status = 400;
throw err;
} finally {
await fs.rm(inPath, { force: true }).catch(() => {});
}
}
// 按秒切片:只在超过 CHUNK_SEC 时做。切片用 -c copy,纯 PCM 无损。
async function splitWav(wavPath, chunkSec) {
const dir = path.dirname(wavPath);
const base = path.basename(wavPath, '.wav');
const pattern = path.join(dir, base + '-part-%03d.wav');
await run(FFMPEG, [
'-hide_banner', '-loglevel', 'error', '-y',
'-i', wavPath,
'-f', 'segment', '-segment_time', String(chunkSec), '-c', 'copy',
pattern,
], 60000);
const files = (await fs.readdir(dir))
.filter((f) => f.startsWith(base + '-part-') && f.endsWith('.wav'))
.sort();
return files.map((f) => path.join(dir, f));
}
// ── 引擎 ──────────────────────────────────────────────────────────────────
function extractText(obj) {
if (!obj) return '';
if (typeof obj === 'string') return obj;
if (typeof obj.text === 'string') return obj.text;
if (obj.result && typeof obj.result.text === 'string') return obj.result.text;
return '';
}
async function runCloud(wavPath) {
if (!API_KEY) {
const e = new Error('语音识别未配置:容器环境变量 ASR_API_KEY 为空');
e.status = 503;
throw e;
}
const buf = await fs.readFile(wavPath);
const form = new FormData();
form.append('model', API_MODEL);
form.append('file', new Blob([buf], { type: 'audio/wav' }), 'audio.wav');
let res;
try {
res = await fetch(API_BASE + '/audio/transcriptions', {
method: 'POST',
headers: { Authorization: 'Bearer ' + API_KEY },
body: form,
signal: AbortSignal.timeout(60000),
});
} catch (e) {
const err = new Error('调用上游语音识别失败:' + String(e && e.message || e));
err.status = 502;
throw err;
}
const raw = await res.text();
if (!res.ok) {
// 智谱对“解码后没有可识别语音”的音频回 400/1210 no audio segment found。
// 这通常不是服务故障(录音是静音、或浏览器只录到空白),给一句人话,别把上游 JSON 丢给用户。
let upstreamMsg = raw.slice(0, 300);
let upstreamCode = '';
try {
const obj = JSON.parse(raw);
if (obj && obj.error) {
upstreamMsg = String(obj.error.message || upstreamMsg);
upstreamCode = String(obj.error.code || '');
}
} catch (_) { /* 非 JSON,保留原文 */ }
const noSpeech = /no audio segment/i.test(upstreamMsg) || upstreamCode === '1210';
const err = new Error(noSpeech
? '没有识别到语音内容(录到的是静音,或音频解码后为空)'
: '上游识别失败 HTTP ' + res.status + ':' + upstreamMsg);
err.status = noSpeech ? 400 : 502;
err.upstream = upstreamMsg;
throw err;
}
let obj = null;
try { obj = JSON.parse(raw); } catch (_) { return raw.trim(); }
const text = extractText(obj);
if (!text) {
const err = new Error('上游返回为空:' + raw.slice(0, 300));
err.status = 502;
throw err;
}
return text;
}
// 归一化后 wav 的实测音量(仅 debug 级别调用):用于区分“文件坏了”和“录到的是静音”。
// volumedetect 跟解码共用一次遍历,开销很小,但只在排查时跑。
async function wavLevel(wavPath) {
const r = await run(FFMPEG, [
'-hide_banner', '-nostats', '-i', wavPath, '-af', 'volumedetect', '-f', 'null', '-',
], 30000);
const mean = /mean_volume:\s*(-?[\d.]+) dB/.exec(r.stderr);
const max = /max_volume:\s*(-?[\d.]+) dB/.exec(r.stderr);
return (mean ? mean[1] : '?') + ' / ' + (max ? max[1] : '?') + ' dB';
}
// 转写一段音频缓冲:归一化 →(超长则切片)→ 逐段识别 → 拼接。
async function transcribeBuffer(buf, opts) {
const wavPath = await toWav(buf, opts && opts.ext);
const parts = [];
try {
const st = await fs.stat(wavPath);
const seconds = st.size / 32000; // 16k/单声道/16bit
// 每次请求都打一行:原始字节 → 归一化时长。排查“上游说没声音”时第一眼看这个。
log('info', '归一化:' + buf.length + 'B (' + ((opts && opts.ext) || '?') + ') → '
+ seconds.toFixed(1) + 's wav');
if (CHUNK_SEC > 0 && seconds > CHUNK_SEC * 1.2) {
parts.push(...await splitWav(wavPath, CHUNK_SEC));
log('info', '超长音频切成 ' + parts.length + ' 段');
}
if (!parts.length) {
try {
return (await runCloud(wavPath)).trim();
} catch (e) {
// 只在上游判定“没有语音”时量一遍音量(正常路径零开销):
// 静音是 -91dB,正常语音 -20dB 上下,一眼就能分清是设备没收到声还是文件坏了。
if (e && e.status === 400) {
log('warn', '音量(mean/max): ' + await wavLevel(wavPath).catch(() => '?'));
}
throw e;
}
}
const out = [];
for (const p of parts) {
// 每段独立识别;单段失败不连累其他段(长录音里偶发静音段常见)
try {
out.push((await runCloud(p)).trim());
} catch (e) {
log('warn', '切片识别失败(跳过):' + String(e && e.message || e).slice(0, 200));
}
}
return out.filter(Boolean).join('');
} finally {
await fs.rm(wavPath, { force: true }).catch(() => {});
for (const p of parts) await fs.rm(p, { force: true }).catch(() => {});
}
}
// ── HTTP 小工具 ───────────────────────────────────────────────────────────
function json(res, code, obj) {
if (res.headersSent) return;
const body = JSON.stringify(obj);
res.writeHead(code, {
'Content-Type': 'application/json; charset=utf-8',
'Content-Length': Buffer.byteLength(body),
'Cache-Control': 'no-store',
});
res.end(body);
}
function readBody(req, limit) {
return new Promise((resolve, reject) => {
const chunks = [];
let n = 0;
let failed = false;
req.on('data', (c) => {
if (failed) return;
n += c.length;
if (n > limit) {
failed = true;
const e = new Error('音频过大(上限 ' + Math.round(limit / 1048576) + 'MB)');
e.status = 413;
reject(e);
return;
}
chunks.push(c);
});
req.on('end', () => { if (!failed) resolve(Buffer.concat(chunks)); });
req.on('error', (e) => { if (!failed) reject(e); });
});
}
const EXT_BY_MIME = {
'audio/webm': 'webm', 'audio/ogg': 'ogg', 'audio/mp4': 'm4a', 'audio/x-m4a': 'm4a',
'audio/mpeg': 'mp3', 'audio/mp3': 'mp3', 'audio/wav': 'wav', 'audio/x-wav': 'wav',
'audio/aac': 'aac', 'audio/flac': 'flac', 'audio/amr': 'amr',
};
function extOf(contentType) {
const k = String(contentType || '').split(';')[0].trim().toLowerCase();
return EXT_BY_MIME[k] || '';
}
// ── 入口 1:POST /transcribe(普通 HTTP,给输入框) ────────────────────────
let active = 0;
async function handleTranscribe(req, res, url) {
if (active >= MAX_CONCURRENT) {
return json(res, 429, { error: '语音识别繁忙,请稍后再试' });
}
const buf = await readBody(req, MAX_BYTES);
if (!buf.length) return json(res, 400, { error: '未收到音频数据' });
active++;
const t0 = Date.now();
try {
const text = await transcribeBuffer(buf, { ext: extOf(req.headers['content-type']) });
log('info', 'transcribed ' + buf.length + 'B → ' + text.length + ' 字,' + (Date.now() - t0) + 'ms');
json(res, 200, { text, ms: Date.now() - t0, model: API_MODEL });
} finally {
active--;
}
}
// ── 入口 2:POST /mcp(Streamable HTTP,给模型) ──────────────────────────
const TOOL = {
name: 'transcribe_audio',
description:
'Transcribe an audio file to text. Provide a publicly reachable http(s) URL '
+ '(mp3 / wav / m4a / webm / ogg / aac / flac, <= 20MB). '
+ 'For a file inside the current task directory, first call the built-in mint_public_link tool '
+ 'to get a temporary public URL, then pass that URL here.',
inputSchema: {
type: 'object',
properties: {
url: { type: 'string', description: 'Publicly reachable http(s) URL of the audio file.' },
},
required: ['url'],
},
};
async function fetchAudio(urlStr) {
let u;
try { u = new URL(urlStr); } catch (_) { throw new Error('url 不是合法链接'); }
if (u.protocol !== 'http:' && u.protocol !== 'https:') throw new Error('只支持 http(s) 链接');
const res = await fetch(u, { redirect: 'follow', signal: AbortSignal.timeout(30000) });
if (!res.ok) throw new Error('下载音频失败 HTTP ' + res.status);
const buf = Buffer.from(await res.arrayBuffer());
if (!buf.length) throw new Error('下载到的音频为空');
if (buf.length > MAX_BYTES) throw new Error('音频过大(上限 ' + Math.round(MAX_BYTES / 1048576) + 'MB)');
return { buf, ext: extOf(res.headers.get('content-type')) };
}
async function handleMcp(req, res) {
const raw = await readBody(req, 1024 * 1024);
let msg;
try { msg = JSON.parse(raw.toString('utf8')); } catch (_) {
return json(res, 400, { jsonrpc: '2.0', id: null, error: { code: -32700, message: 'Parse error' } });
}
const id = msg && msg.id !== undefined ? msg.id : null;
const method = msg && msg.method;
const params = (msg && msg.params) || {};
const ok = (result) => json(res, 200, { jsonrpc: '2.0', id, result });
const fail = (code, message) => json(res, 200, { jsonrpc: '2.0', id, error: { code, message } });
if (method === 'initialize') {
return ok({
protocolVersion: '2024-11-05',
capabilities: { tools: {} },
serverInfo: { name: 'asr', version: '1.0.0' },
});
}
// 无状态实现:不返回 Mcp-Session-Id,core 也就不会带;通知直接回空结果(core 不校验)。
if (method === 'notifications/initialized' || method === 'notifications/cancelled') return ok({});
if (method === 'ping') return ok({});
if (method === 'tools/list') return ok({ tools: [TOOL] });
if (method === 'tools/call') {
if (params.name !== TOOL.name) return fail(-32602, 'Unknown tool: ' + params.name);
const args = params.arguments || {};
const urlStr = String(args.url || '').trim();
if (!urlStr) return ok({ isError: true, content: [{ type: 'text', text: '缺少 url 参数' }] });
try {
const { buf, ext } = await fetchAudio(urlStr);
const text = await transcribeBuffer(buf, { ext });
return ok({ content: [{ type: 'text', text }] });
} catch (e) {
return ok({ isError: true, content: [{ type: 'text', text: '转写失败:' + String(e && e.message || e) }] });
}
}
return fail(-32601, 'Method not found: ' + method);
}
// ── 服务 ──────────────────────────────────────────────────────────────────
const server = http.createServer((req, res) => {
let url;
try { url = new URL(req.url, 'http://localhost'); } catch (_) {
return json(res, 400, { error: 'bad url' });
}
const done = (p) => {
Promise.resolve(p).catch((e) => {
const code = (e && e.status) || 500;
// 4xx 是可预期的输入问题(坏音频、没配 key),只记一行;5xx 才带堆栈
log(code >= 500 ? 'error' : 'warn', String(e && e.message || e) + (code >= 500 && e && e.stack ? '\n' + e.stack : ''));
if (!res.headersSent) json(res, code, { error: String(e && e.message || e) });
else try { res.end(); } catch (_) { /* 已断 */ }
});
};
if (req.method === 'GET' && url.pathname === '/health') {
return json(res, 200, {
ok: true,
model: API_MODEL,
configured: !!API_KEY,
});
}
if (req.method === 'POST' && url.pathname === '/transcribe') return done(handleTranscribe(req, res, url));
if (url.pathname === '/mcp') {
if (req.method !== 'POST') return json(res, 405, { error: 'only POST /mcp' });
return done(handleMcp(req, res));
}
return json(res, 404, { error: 'not found' });
});
let shuttingDown = false;
function shutdown(sig) {
if (shuttingDown) return;
shuttingDown = true;
log('info', '收到 ' + sig + ',退出');
server.close(() => process.exit(0));
setTimeout(() => process.exit(0), 3000).unref();
}
process.on('SIGTERM', () => shutdown('SIGTERM'));
process.on('SIGINT', () => shutdown('SIGINT'));
server.listen(PORT, '0.0.0.0', () => {
log('info', 'listening on ' + PORT + ',model=' + API_MODEL + ' @ ' + API_BASE);
if (!API_KEY) log('warn', 'ASR_API_KEY 为空:/transcribe 会返回 503');
});
+29 -4
View File
@@ -10,12 +10,14 @@
# #
# 输入(都可选): # 输入(都可选):
# BIGMODEL_KEY / DEEPSEEK_KEY / QWEN_KEY 模型平台 key,填几个启用几个(0~3 个) # BIGMODEL_KEY / DEEPSEEK_KEY / QWEN_KEY 模型平台 key,填几个启用几个(0~3 个)
# image_task / video_task 复用 BIGMODEL_KEY(智谱即 BigModel); # image_task / video_task / asr 复用 BIGMODEL_KEY(智谱即 BigModel);
# 未配 BIGMODEL_KEY 时这两个服务写为 mode: disable # 未配 BIGMODEL_KEY 时这三个服务写为 mode: disable
# AUTH_USER / AUTH_PASSWORD 登录账号(默认 admin / admin,请自行改掉) # AUTH_USER / AUTH_PASSWORD 登录账号(默认 admin / admin,请自行改掉)
# PUBLIC_IP / AGENT_PORT 对外地址与端口,写进 public_link.base_url; # PUBLIC_IP / AGENT_PORT 对外地址与端口,写进 public_link.base_url;
# PUBLIC_IP 不配置则自动探测公网 IP # PUBLIC_IP 不配置则自动探测公网 IP
# AUTH_SECRET / EXECUTOR_TOKEN / WXBOT_TOKEN 一般不用给:不给就自动生成并复用(见下) # AUTH_SECRET / EXECUTOR_TOKEN / WXBOT_TOKEN 一般不用给:不给就自动生成并复用(见下)
# ASR_API_KEY 语音识别(mcp_asr)的上游 key;不给则复用 BIGMODEL_KEY,
# 已有 .env 里的值优先(语音输入只是可选能力,留空不影响主流程)
# #
# 微信接入(wxbot 已合入根 compose,作为栈内服务):本脚本只负责生成/复用根 .env 的 WXBOT_TOKEN; # 微信接入(wxbot 已合入根 compose,作为栈内服务):本脚本只负责生成/复用根 .env 的 WXBOT_TOKEN;
# wxbot 自身零配置文件(compose 注 env + 内置默认,同 executor 模式),无需任何同步动作。 # wxbot 自身零配置文件(compose 注 env + 内置默认,同 executor 模式),无需任何同步动作。
@@ -51,6 +53,8 @@ EXECUTOR_TOKEN="${EXECUTOR_TOKEN:-}"
AUTH_SECRET="${AUTH_SECRET:-}" AUTH_SECRET="${AUTH_SECRET:-}"
# 微信接入服务 token(core ↔ wxbot 双向共用,compose 两侧同值注入;wxbot 已并入仓库) # 微信接入服务 token(core ↔ wxbot 双向共用,compose 两侧同值注入;wxbot 已并入仓库)
WXBOT_TOKEN="${WXBOT_TOKEN:-}" WXBOT_TOKEN="${WXBOT_TOKEN:-}"
# 语音识别(mcp_asr)的上游 key:独立于模型平台 key,但默认复用 BIGMODEL_KEY(智谱 glm-asr)
ASR_API_KEY="${ASR_API_KEY:-}"
log() { echo -e "\n\033[1;32m===== $* =====\033[0m"; } log() { echo -e "\n\033[1;32m===== $* =====\033[0m"; }
info() { echo -e "\033[1;36m[INFO]\033[0m $*"; } info() { echo -e "\033[1;36m[INFO]\033[0m $*"; }
@@ -74,6 +78,8 @@ if [ -f "$ENV_FILE" ]; then
EXECUTOR_TOKEN="${EXECUTOR_TOKEN:-$(sed -n 's/^EXECUTOR_TOKEN=//p' "$ENV_FILE" | head -1)}" EXECUTOR_TOKEN="${EXECUTOR_TOKEN:-$(sed -n 's/^EXECUTOR_TOKEN=//p' "$ENV_FILE" | head -1)}"
AUTH_SECRET="${AUTH_SECRET:-$(sed -n 's/^AUTH_SECRET=//p' "$ENV_FILE" | head -1)}" AUTH_SECRET="${AUTH_SECRET:-$(sed -n 's/^AUTH_SECRET=//p' "$ENV_FILE" | head -1)}"
WXBOT_TOKEN="${WXBOT_TOKEN:-$(sed -n 's/^WXBOT_TOKEN=//p' "$ENV_FILE" | head -1)}" WXBOT_TOKEN="${WXBOT_TOKEN:-$(sed -n 's/^WXBOT_TOKEN=//p' "$ENV_FILE" | head -1)}"
# ASR_API_KEY 同理复用:手填的 key 不会被重跑抹掉
ASR_API_KEY="${ASR_API_KEY:-$(sed -n 's/^ASR_API_KEY=//p' "$ENV_FILE" | head -1)}"
# AGENT_PORT 同理复用:避免不带参数重跑时把部署机自定义端口重置回 8090(显式传参优先) # AGENT_PORT 同理复用:避免不带参数重跑时把部署机自定义端口重置回 8090(显式传参优先)
AGENT_PORT="${AGENT_PORT_INPUT:-$(sed -n 's/^AGENT_PORT=//p' "$ENV_FILE" | head -1)}" AGENT_PORT="${AGENT_PORT_INPUT:-$(sed -n 's/^AGENT_PORT=//p' "$ENV_FILE" | head -1)}"
AGENT_PORT="${AGENT_PORT:-8090}" AGENT_PORT="${AGENT_PORT:-8090}"
@@ -81,19 +87,22 @@ fi
EXECUTOR_TOKEN="${EXECUTOR_TOKEN:-$(gen_hex 32)}" EXECUTOR_TOKEN="${EXECUTOR_TOKEN:-$(gen_hex 32)}"
AUTH_SECRET="${AUTH_SECRET:-$(gen_hex 32)}" AUTH_SECRET="${AUTH_SECRET:-$(gen_hex 32)}"
WXBOT_TOKEN="${WXBOT_TOKEN:-$(gen_hex 32)}" WXBOT_TOKEN="${WXBOT_TOKEN:-$(gen_hex 32)}"
ASR_API_KEY="${ASR_API_KEY:-$BIGMODEL_KEY}"
cat > "$ENV_FILE" <<EOF cat > "$ENV_FILE" <<EOF
# 本文件由 scripts/init.sh 生成,勿手改(改配置请重新运行该脚本,或用环境变量覆盖) # 本文件由 scripts/init.sh 生成,勿手改(改配置请重新运行该脚本,或用环境变量覆盖)
# EXECUTOR_TOKEN: core 与 executor 之间的调用鉴权(两侧同值,compose 注入) # EXECUTOR_TOKEN: core 与 executor 之间的调用鉴权(两侧同值,compose 注入)
# AUTH_SECRET: 登录态签名密钥(写进 config.yml 的 auth.secret) # AUTH_SECRET: 登录态签名密钥(写进 config.yml 的 auth.secret)
# WXBOT_TOKEN: core ↔ wxbot 微信接入服务 token(compose 注入两侧;wxbot 零配置文件,env 即全部接线) # WXBOT_TOKEN: core ↔ wxbot 微信接入服务 token(compose 注入两侧;wxbot 零配置文件,env 即全部接线)
# ASR_API_KEY: 语音识别(mcp_asr)的上游 key,空 = 语音输入关闭;默认复用 BIGMODEL_KEY
# AGENT_PORT: agent-core 映射到宿主机的端口 # AGENT_PORT: agent-core 映射到宿主机的端口
EXECUTOR_TOKEN=$EXECUTOR_TOKEN EXECUTOR_TOKEN=$EXECUTOR_TOKEN
AUTH_SECRET=$AUTH_SECRET AUTH_SECRET=$AUTH_SECRET
WXBOT_TOKEN=$WXBOT_TOKEN WXBOT_TOKEN=$WXBOT_TOKEN
ASR_API_KEY=$ASR_API_KEY
AGENT_PORT=$AGENT_PORT AGENT_PORT=$AGENT_PORT
EOF EOF
info "EXECUTOR_TOKEN / AUTH_SECRET / WXBOT_TOKEN 已就位(沿用已有 .env 的值,没有则新生成)" info "EXECUTOR_TOKEN / AUTH_SECRET / WXBOT_TOKEN 已就位(沿用已有 .env 的值,没有则新生成);ASR_API_KEY $([ -n "$ASR_API_KEY" ] && echo 已配置 || echo 为空(语音输入关闭))"
# --env-only:只刷密钥,绝不碰 config.yml(平台 key 不在 .env 里,重跑全量会清空已部署配置) # --env-only:只刷密钥,绝不碰 config.yml(平台 key 不在 .env 里,重跑全量会清空已部署配置)
if [ "${ENV_ONLY:-}" = "1" ]; then if [ "${ENV_ONLY:-}" = "1" ]; then
@@ -229,6 +238,21 @@ EOF
EOF EOF
fi fi
# 语音转写:key 在容器 env(ASR_API_KEY),不经 headers,所以单独按 ASR_API_KEY 判断
if [ -n "$ASR_API_KEY" ]; then
cat <<'EOF'
- name: asr
url: "http://mcp_asr:3000/mcp"
mode: skill # 语音转写是低频能力,不下发到每轮工具表
EOF
else
cat <<'EOF'
- name: asr
url: "http://mcp_asr:3000/mcp"
mode: disable # 未配 ASR_API_KEY:不连接、不发现
EOF
fi
echo echo
cat <<EOF cat <<EOF
# 给外部服务(如智谱)现签公网临时链接用;改地址后重跑本脚本 # 给外部服务(如智谱)现签公网临时链接用;改地址后重跑本脚本
@@ -249,7 +273,8 @@ echo " 账号 : $AUTH_USER"
echo " 密码 : $AUTH_PASSWORD" echo " 密码 : $AUTH_PASSWORD"
echo " 平台 : ${enabled_plats[*]:-(无)}" echo " 平台 : ${enabled_plats[*]:-(无)}"
echo " 图像/视频: $([ -n "$BIGMODEL_KEY" ] && echo "image_task / video_task 已启用" || echo "未配置(mode: disable)")" echo " 图像/视频: $([ -n "$BIGMODEL_KEY" ] && echo "image_task / video_task 已启用" || echo "未配置(mode: disable)")"
echo " MCP 服务 : web_search / image_task / video_task(同栈,随 compose 启动)" echo " 语音输入 : $([ -n "$ASR_API_KEY" ] && echo "mcp_asr 已启用" || echo "未配置(ASR_API_KEY 为空)")"
echo " MCP 服务 : web_search / image_task / video_task / asr(同栈,随 compose 启动)"
echo " 微信接入 : WXBOT_TOKEN 已就位(compose 注入 core 与 wxbot 两侧;wxbot 无需配置文件)" echo " 微信接入 : WXBOT_TOKEN 已就位(compose 注入 core 与 wxbot 两侧;wxbot 无需配置文件)"
echo "---------------------------------------------" echo "---------------------------------------------"
log "完成 ✅" log "完成 ✅"
+2
View File
@@ -53,6 +53,7 @@ input_schema:
output_schema: output_schema:
# 输出描述 # 输出描述
visit_url: /app/{task_id}/ # 可选:页面类技能的访问路径模板 visit_url: /app/{task_id}/ # 可选:页面类技能的访问路径模板
required: true # 可选:清单行首标 **required**,提示该域不要手写等价实现
thinking: true # 可选:get 时自动开启本回合的深度思考 thinking: true # 可选:get 时自动开启本回合的深度思考
--- ---
``` ```
@@ -61,6 +62,7 @@ thinking: true # 可选:get 时自动开启本回合的深度思
- `description`:一句话描述技能功能,用于 `op=list` 的清单展示。 - `description`:一句话描述技能功能,用于 `op=list` 的清单展示。
- `thinking`:(可选)为 `true` 时,模型调用 `get` 会自动开启深度思考(合并模型的 - `thinking`:(可选)为 `true` 时,模型调用 `get` 会自动开启深度思考(合并模型的
`thinking_params`),开启后保持,直到用户手动关闭;模型未配置思考参数时不生效。只影响模型回合,不影响脚本本身。 `thinking_params`),开启后保持,直到用户手动关闭;模型未配置思考参数时不生效。只影响模型回合,不影响脚本本身。
- `required`:(可选)为 `true` 时,模型可见的技能清单里该行行首标 `**required**`,表示这个领域不要手写等价脚本(如 `office` / `x2pdf`)。纯提示,不做强制校验,也不会自动调用。
- `input_schema`:输入参数的 JSON Schema 定义,用于参数校验和文档生成。 - `input_schema`:输入参数的 JSON Schema 定义,用于参数校验和文档生成。
- `output_schema`:输出结果的描述(可选)。 - `output_schema`:输出结果的描述(可选)。
- `visit_url`:(可选)页面类技能声明的访问路径模板,`{task_id}` 占位执行时替换为会话 id。`run` 成功后由 core(tools/executor.js)拼上 `public_link.base_url`,在输出末尾追加一行「访问地址:<完整 URL>」——技能进程跑在 executor 隔离视图里不知道公网地址,完整链接只能 core 补;AI 拿到相对路径会原样转给用户,而相对路径打不开。 - `visit_url`:(可选)页面类技能声明的访问路径模板,`{task_id}` 占位执行时替换为会话 id。`run` 成功后由 core(tools/executor.js)拼上 `public_link.base_url`,在输出末尾追加一行「访问地址:<完整 URL>」——技能进程跑在 executor 隔离视图里不知道公网地址,完整链接只能 core 补;AI 拿到相对路径会原样转给用户,而相对路径打不开。
+3
View File
@@ -18,6 +18,7 @@ skills/document-photo-to-pdf/
web/index.html ← 审核页模板的单一事实源 web/index.html ← 审核页模板的单一事实源
tasks/<session-id>/ tasks/<session-id>/
out/ ← 原始校正页图(PNG,自然尺寸,文件名与 PDF 同名)
.app/doc-review/ .app/doc-review/
index.html ← 指向 web/index.html 的符号链接(不含数据注入) index.html ← 指向 web/index.html 的符号链接(不含数据注入)
<batch_id>/p1.jpg ... ← 本批缩略图(长边 1200,JPEG) <batch_id>/p1.jpg ... ← 本批缩略图(长边 1200,JPEG)
@@ -110,6 +111,8 @@ requested_at TEXT, started_at TEXT, finished_at TEXT
## 页面交互约定 ## 页面交互约定
- 顶部标题条(白底,参考 H5 全屏预览):左侧 PDF 名,右侧下载 PDF,最右 X 返回会话。 - 顶部标题条(白底,参考 H5 全屏预览):左侧 PDF 名,右侧下载 PDF,最右 X 返回会话。
- 加载失败(无批次 / `data.db` 缺 `doc_review_batch` 表 / data.db 被删)只保留标题条:
X 仍可返回会话、下载置灰,编辑区与底栏隐藏。所以 X 的绑定在 `start()` 里,不能放 `boot()`。
- 重新生成 PDF 不在顶栏:放在照片区底部(stage 与预览各一个,按当前视图显示;桌面只用 - 重新生成 PDF 不在顶栏:放在照片区底部(stage 与预览各一个,按当前视图显示;桌面只用
stage),仅在存在未保存修改时出现。 stage),仅在存在未保存修改时出现。
- 底部只保留翻页和当前页名,不再放操作按钮。 - 底部只保留翻页和当前页名,不再放操作按钮。
+9 -4
View File
@@ -1,6 +1,6 @@
--- ---
name: document-photo-to-pdf name: document-photo-to-pdf
description: 把手机拍摄的纸质文档照片裁剪、拉正,合并为 PDF,并给出可预览/微调的审核页 description: 纸质文档(合同/发票/证件/书页)拍照/扫描件校正后,导出 PDF 和 out/ 下的单页 PNG 原图(未调色未缩放);自动找纸边、透视拉正、多页合并,附审核页微调
visit_url: /app/{task_id}/doc-review/ visit_url: /app/{task_id}/doc-review/
input_schema: input_schema:
type: object type: object
@@ -25,12 +25,16 @@ input_schema:
## 返回值 ## 返回值
- `ok:true`:`summary` 一句话摘要,`pdf` 文件名;末尾附完整「访问地址」。把 PDF 和地址 - `ok:true`:`summary` 一句话摘要,`pdf` 文件名,`images` 是 `out/` 下的原图路径;
一起给用户。 末尾附完整「访问地址」。把 PDF、地址和图片路径一起给用户。
- `ok:false`:转述 `error.message` / `error.hint`,忽略访问地址。 - `ok:false`:转述 `error.message` / `error.hint`,忽略访问地址。
每次运行还会把校正后的单页原图(未调色、未缩放、无白边)导出到 `out/`,文件名与 PDF
同名:`合同_校正.pdf` → `out/合同_校正-01.png`、`out/合同_校正-02.png`。不需要图片时
忽略 `images` 即可。
```json ```json
{"ok":true,"summary":"3 页已生成;1 页建议在审核页确认","pdf":"合同_校正.pdf"} {"ok":true,"summary":"3 页已生成;1 页建议在审核页确认;原始页图见 out/","pdf":"合同_校正.pdf","images":["out/合同_校正-01.png","out/合同_校正-02.png","out/合同_校正-03.png"]}
访问地址:https://agent.ai.foresh.com/app/task-20261023-001/doc-review/ 访问地址:https://agent.ai.foresh.com/app/task-20261023-001/doc-review/
``` ```
@@ -50,3 +54,4 @@ input_schema:
- 支持 jpg/png/webp/bmp/tif;HEIC 不支持。 - 支持 jpg/png/webp/bmp/tif;HEIC 不支持。
- 一图一纸;同框多纸只取最大。 - 一图一纸;同框多纸只取最大。
- 建议 ≤20 页;更多或 300dpi 可能超 120s,可分批。 - 建议 ≤20 页;更多或 300dpi 可能超 120s,可分批。
- `out/` 里的原图是自然尺寸(不缩放、不调色),页与页尺寸可能不同;PDF 仍按纸张/批次统一。
@@ -5,7 +5,7 @@
- 所有 quad 都是“转正后原图”坐标; - 所有 quad 都是“转正后原图”坐标;
- 目标尺寸把 PDF 画布内容区(页面尺寸 - 四周留白)的一条边填满,可放大低分辨率照片, - 目标尺寸把 PDF 画布内容区(页面尺寸 - 四周留白)的一条边填满,可放大低分辨率照片,
避免同一批页面因原图像素多少而大小不一; 避免同一批页面因原图像素多少而大小不一;
- 不做中间 PNG,页面图直接进内存后一次性写 PDF。 - raw 页图(裁剪 + 透视拉正、自然尺寸、不调色)由 warp_raw 产出,PDF 页从它派生。
""" """
import os import os
import statistics import statistics
@@ -13,7 +13,7 @@ import statistics
import numpy as np import numpy as np
from PIL import Image from PIL import Image
from homography import brighten, warp_perspective from homography import brighten, warp_perspective, warp_perspective_pil
# ---------------------------------------------------------------- 纸张 # ---------------------------------------------------------------- 纸张
@@ -135,8 +135,27 @@ def target_size(quad, paper, page_orientation, P, out_ratio=None):
return max(1, int(round(tw))), max(1, int(round(th))), (cw, ch) return max(1, int(round(tw))), max(1, int(round(th))), (cw, ch)
def warp_raw(img, quad):
"""只做裁剪 + 透视拉正:自然尺寸、不调色。raw 页图的唯一来源。"""
return warp_perspective_pil(img, quad, None)
def page_for_pdf(raw, size, P):
"""从 raw 页图派生 PDF 页:先调色,再按目标尺寸缩放(LANCZOS)。
与旧 warp_page 的差别只在采样顺序:先在自然尺寸做透视(超采样),
再缩到画布内容区,缩小时比直接按目标尺寸采样更少混叠。
"""
r = P["render"]
spec = P["enhance"].get(r.get("enhance") or r["default_enhance"])
page = tone(raw, spec, r["brighten_target"], r["brighten_pct"])
if page.size != tuple(size):
page = page.resize(tuple(size), Image.LANCZOS)
return page
def warp_page(img, quad, size, P): def warp_page(img, quad, size, P):
"""透视校正 + 按 P["render"]["enhance"] 调色。""" """旧路径:直接按目标尺寸 warp + 调色。PIL 实现出问题时回退用。"""
r = P["render"] r = P["render"]
page = warp_perspective(img, quad, size, page = warp_perspective(img, quad, size,
chunk_rows=r["warp_chunk_rows"]) chunk_rows=r["warp_chunk_rows"])
@@ -19,6 +19,15 @@ def _solve_h(src, dst):
return vt[-1].reshape(3, 3) return vt[-1].reshape(3, 3)
def natural_size(quad):
"""四边形按自然边长对应的输出尺寸(与 warp_perspective 的 out_size=None 一致)。"""
q = np.asarray(quad, dtype=np.float64)
tl, tr, br, bl = q
w = int(round(max(np.linalg.norm(tr - tl), np.linalg.norm(br - bl))))
h = int(round(max(np.linalg.norm(bl - tl), np.linalg.norm(br - tr))))
return max(1, w), max(1, h)
def warp_perspective(img, quad, out_size=None, fill=(255, 255, 255), def warp_perspective(img, quad, out_size=None, fill=(255, 255, 255),
chunk_rows=256): chunk_rows=256):
"""把 quad 指定的四边形透视校正到 out_size。 """把 quad 指定的四边形透视校正到 out_size。
@@ -29,12 +38,9 @@ def warp_perspective(img, quad, out_size=None, fill=(255, 255, 255),
arr = np.asarray(img if img.mode == "RGB" else img.convert("RGB")) arr = np.asarray(img if img.mode == "RGB" else img.convert("RGB"))
src_h, src_w = arr.shape[:2] src_h, src_w = arr.shape[:2]
quad = np.asarray(quad, dtype=np.float64) quad = np.asarray(quad, dtype=np.float64)
tl, tr, br, bl = quad
if out_size is None: if out_size is None:
w = int(round(max(np.linalg.norm(tr - tl), np.linalg.norm(br - bl)))) out_size = natural_size(quad)
h = int(round(max(np.linalg.norm(bl - tl), np.linalg.norm(br - tr))))
out_size = (w, h)
out_w = max(1, int(out_size[0])) out_w = max(1, int(out_size[0]))
out_h = max(1, int(out_size[1])) out_h = max(1, int(out_size[1]))
@@ -80,6 +86,29 @@ def warp_perspective(img, quad, out_size=None, fill=(255, 255, 255),
return Image.fromarray(out) return Image.fromarray(out)
def warp_perspective_pil(img, quad, out_size=None, fill=(255, 255, 255)):
"""PIL(C) 实现的透视校正,采样约定与 warp_perspective 一致。
out_size=None 时按四边形自然边长输出。10MP 约 0.3s,比上面的 numpy
逐像素实现快约 10 倍;实测两者平均差 0.26 灰度级、89% 像素完全一致。
只用于 raw 页图导出;PDF 出件仍走 numpy 版本,避免改变既有输出的像素。
"""
if out_size is None:
out_size = natural_size(quad)
ow = max(1, int(out_size[0]))
oh = max(1, int(out_size[1]))
dst = np.array([[0, 0], [ow - 1, 0], [ow - 1, oh - 1], [0, oh - 1]],
dtype=np.float64)
H = np.linalg.inv(_solve_h(np.asarray(quad, dtype=np.float64), dst))
H = H / H[2, 2]
coeffs = (H[0, 0], H[0, 1], H[0, 2],
H[1, 0], H[1, 1], H[1, 2],
H[2, 0], H[2, 1])
src = img if img.mode == "RGB" else img.convert("RGB")
return src.transform((ow, oh), Image.PERSPECTIVE, coeffs, Image.BILINEAR,
fillcolor=fill)
def brighten(img, target=245, pct=97): def brighten(img, target=245, pct=97):
"""全局等比提亮:把 pct 分位映射到 target,保持相对对比度。""" """全局等比提亮:把 pct 分位映射到 target,保持相对对比度。"""
arr = np.asarray(img if img.mode == "RGB" else img.convert("RGB")).astype(np.float32) arr = np.asarray(img if img.mode == "RGB" else img.convert("RGB")).astype(np.float32)
+75 -12
View File
@@ -4,9 +4,9 @@
两种用法共用一条出件内核: 两种用法共用一条出件内核:
全自动:{"images": [...], "output": "..."} 全自动:{"images": [...], "output": "..."}
只出 PDF,不碰 .app/、不写 data.db。 出 PDF,并把校正后的单页原图导出到 out/(不碰 .app/、不写 data.db)。
半自动:{"images": [...], "review": "always|auto"} 半自动:{"images": [...], "review": "always|auto"}
出 PDF,并把审核页发布到 .app/doc-review/、运行记录写进 data.db。 出 PDF 和 out/ 页图,并把审核页发布到 .app/doc-review/、运行记录写进 data.db。
重生成:{"batch_id": "dr..."} 重生成:{"batch_id": "dr..."}
从 data.db 读上次的源图/输出/编辑,覆盖同名 PDF;args 带 edits 时以 edits 从 data.db 读上次的源图/输出/编辑,覆盖同名 PDF;args 带 edits 时以 edits
为准,不带时读 doc_review_job.edits,再退化为当前页记录(按现在的角点再渲染)。 为准,不带时读 doc_review_job.edits,再退化为当前页记录(按现在的角点再渲染)。
@@ -17,6 +17,7 @@ stdout 只输出一个 JSON 对象;进度、警告、异常都在字段里,
import io import io
import json import json
import os import os
import re
import statistics import statistics
import sys import sys
import time import time
@@ -288,6 +289,26 @@ def _targets(args, batch_id):
return output, root, None, None return output, root, None, None
def _png_dir(cwd):
d = os.path.join(cwd, "out")
if os.path.exists(d) and not os.path.isdir(d):
raise ValueError("out 已存在且不是目录:%s" % d)
os.makedirs(d, exist_ok=True)
return d
def _clean_pngs(d, stem, keep):
"""删掉本 PDF 前缀下编号大于本次出页数的旧页图;不动目录里其它文件。"""
pat = re.compile(r"^" + re.escape(stem) + r"-(\d+)\.png$")
for name in os.listdir(d):
m = pat.match(name)
if m and int(m.group(1)) > keep:
try:
os.remove(os.path.join(d, name))
except OSError:
pass
def _mark_error(conn, batch_id, message): def _mark_error(conn, batch_id, message):
if not conn or not batch_id: if not conn or not batch_id:
return return
@@ -490,6 +511,25 @@ def process(args, t0):
_mark_error(conn, batch_id, res["summary"]) _mark_error(conn, batch_id, res["summary"])
return res return res
# 出件顺序先定下来:raw 页图按最终 PDF 页序编号(文件名与 PDF 同名)。
plan_by_idx = {m["index"]: (i, s, m) for (i, s, m) in plan}
ordered_idx = []
if ed and ed.get("order"):
for v in ed["order"]:
if v in plan_by_idx and v not in ordered_idx:
ordered_idx.append(v)
for i in sorted(plan_by_idx):
if i not in ordered_idx:
ordered_idx.append(i)
plan = [plan_by_idx[i] for i in ordered_idx]
# raw 页图固定落会话根下的 out/;重生成页数变少时,成功后清掉多余编号。
png_dir = _png_dir(os.getcwd())
pdf_stem = os.path.splitext(os.path.basename(output))[0]
png_pad = max(2, len(str(len(plan))))
png_n = 0
png_paths = []
# ---------------- 批次方向 # ---------------- 批次方向
aspects = [m["aspect"] for (_, _, m) in plan] aspects = [m["aspect"] for (_, _, m) in plan]
batch_orientation, _, median_aspect = \ batch_orientation, _, median_aspect = \
@@ -585,7 +625,7 @@ def process(args, t0):
try: try:
img = load_image(src) img = load_image(src)
try: try:
page = compose.warp_page(img, out_corners, (tw, th), P) raw = compose.warp_raw(img, out_corners)
finally: finally:
img.close() img.close()
except Exception as e: except Exception as e:
@@ -599,6 +639,29 @@ def process(args, t0):
out_meta[idx] = {"page": None, "canvas": None, "error": err} out_meta[idx] = {"page": None, "canvas": None, "error": err}
continue continue
try:
page = compose.page_for_pdf(raw, (tw, th), P)
except Exception as e:
err = _err("INTERNAL",
"第 %d 页生成 PDF 页面失败:%s" % (idx, e), idx,
"重试;若持续出现请反馈")
meta["status"] = "render_failed"
meta["reason"] = "render_failed"
meta["error"] = err
meta["warnings"].append(err["message"])
out_meta[idx] = {"page": None, "canvas": None, "error": err}
continue
# raw 页图:自然尺寸、不调色、无白边。编号跟最终页序走。
png_n += 1
png_name = "%s-%0*d.png" % (pdf_stem, png_pad, png_n)
png_path = os.path.join(png_dir, png_name)
try:
raw.save(png_path, "PNG", compress_level=6)
png_paths.append(_rel(os.getcwd(), png_path))
except Exception as e:
meta["warnings"].append("第 %d 页原图导出失败:%s" % (idx, e))
meta["out_size"] = [int(tw), int(th)] meta["out_size"] = [int(tw), int(th)]
meta["canvas_size"] = [int(canvas[0]), int(canvas[1])] meta["canvas_size"] = [int(canvas[0]), int(canvas[1])]
meta["page_orientation"] = page_orient meta["page_orientation"] = page_orient
@@ -639,15 +702,9 @@ def process(args, t0):
"方向与批次不一致,已旋转 %d°;文字方向需人工确认" % applied) "方向与批次不一致,已旋转 %d°;文字方向需人工确认" % applied)
# ---------------- 页序 / PDF # ---------------- 页序 / PDF
order = [] # plan 已按 ed.order + 源序号排好;只保留真正出页成功的。
if ed and ed.get("order"): order = [i for (i, _s, _m) in plan
for v in ed["order"]: if out_meta.get(i, {}).get("page") is not None]
if v in out_meta and out_meta[v].get("page") is not None \
and v not in order:
order.append(v)
for idx in sorted(out_meta.keys()):
if out_meta[idx].get("page") is not None and idx not in order:
order.append(idx)
ordered_pages = [out_meta[i]["page"] for i in order] ordered_pages = [out_meta[i]["page"] for i in order]
ordered_canvases = [out_meta[i]["canvas"] for i in order] ordered_canvases = [out_meta[i]["canvas"] for i in order]
@@ -667,6 +724,9 @@ def process(args, t0):
_mark_error(conn, batch_id, res["summary"]) _mark_error(conn, batch_id, res["summary"])
return res return res
# PDF 落盘成功后再清多余页图:失败时保留上一份,避免两边都不完整。
_clean_pngs(png_dir, pdf_stem, png_n)
# ---------------- 检验 # ---------------- 检验
try: try:
checks = check.inspect_pdf(output, len(ordered_pages), checks = check.inspect_pdf(output, len(ordered_pages),
@@ -771,6 +831,8 @@ def process(args, t0):
len(ordered_pages), len(warnings)) len(ordered_pages), len(warnings))
else: else:
summary = "%d 页已生成" % len(ordered_pages) summary = "%d 页已生成" % len(ordered_pages)
if png_paths:
summary += ";原始页图见 out/"
# ---------------- 写 data.db # ---------------- 写 data.db
if use_db: if use_db:
@@ -821,6 +883,7 @@ def process(args, t0):
"ok": True, "ok": True,
"summary": summary, "summary": summary,
"pdf": _rel(session_root, output), "pdf": _rel(session_root, output),
"images": png_paths,
} }
except Exception as e: except Exception as e:
+31 -12
View File
@@ -131,6 +131,9 @@ body{display:flex;flex-direction:column;height:100%;height:100dvh}
.hint{color:#6f8098;font-size:11px;margin:12px 0 0} .hint{color:#6f8098;font-size:11px;margin:12px 0 0}
#warnings div{margin-top:4px;line-height:1.45} #warnings div{margin-top:4px;line-height:1.45}
/* 空状态(无审核数据):只剩白色标题条可用,编辑区/底栏不显示 */
body.is-empty .top,body.is-empty .footbar,body.is-empty #prevwrap{display:none}
#toast{position:fixed;left:50%;bottom:calc(20px + env(safe-area-inset-bottom)); #toast{position:fixed;left:50%;bottom:calc(20px + env(safe-area-inset-bottom));
transform:translateX(-50%);background:rgba(24,34,50,.96);color:#e8edf5; transform:translateX(-50%);background:rgba(24,34,50,.96);color:#e8edf5;
padding:9px 16px;border-radius:99px;font-size:13px;opacity:0;pointer-events:none; padding:9px 16px;border-radius:99px;font-size:13px;opacity:0;pointer-events:none;
@@ -187,14 +190,14 @@ body{display:flex;flex-direction:column;height:100%;height:100dvh}
<div class="h" id="h2"></div> <div class="h" id="h2"></div>
<div class="h" id="h3"></div> <div class="h" id="h3"></div>
<canvas id="loupe"></canvas> <canvas id="loupe"></canvas>
<button class="regen" type="button" style="display:none">重新生成 PDF</button> <button class="regen" type="button" style="display:none">重新生成</button>
</div> </div>
<div id="prevwrap"> <div id="prevwrap">
<div class="pbadge mtag">校正预览</div> <div class="pbadge mtag">校正预览</div>
<div class="pbadge" id="pvPage">1/1</div> <div class="pbadge" id="pvPage">1/1</div>
<div class="box" id="pbox"><canvas id="preview"></canvas></div> <div class="box" id="pbox"><canvas id="preview"></canvas></div>
<button class="regen" type="button" style="display:none">重新生成 PDF</button> <button class="regen" type="button" style="display:none">重新生成</button>
</div> </div>
<div class="footbar" id="footbar"> <div class="footbar" id="footbar">
@@ -356,16 +359,16 @@ function loadBatch() {
} }
function showEmpty(msg) { function showEmpty(msg) {
document.body.classList.add("is-empty");
var st = document.getElementById("stage"); var st = document.getElementById("stage");
if (st) { if (st) {
st.innerHTML = ""; st.innerHTML = "";
var d = document.createElement("div"); var d = document.createElement("div");
d.style.cssText = "padding:40px;text-align:center;color:#8a93a5;font-size:14px;line-height:1.7"; d.style.cssText = "padding:40px 28px;text-align:center;color:#8a93a5;font-size:14px;" +
"line-height:1.8;max-width:520px;margin:0 auto";
d.textContent = msg; d.textContent = msg;
st.appendChild(d); st.appendChild(d);
} }
var foot = document.getElementById("name");
if (foot) foot.textContent = msg;
} }
function loadSaved() { function loadSaved() {
@@ -825,7 +828,7 @@ function setBusy(on) {
var bs = document.querySelectorAll(".regen"); var bs = document.querySelectorAll(".regen");
for (var i = 0; i < bs.length; i++) { for (var i = 0; i < bs.length; i++) {
bs[i].disabled = on; bs[i].disabled = on;
bs[i].textContent = on ? "生成中…" : "重新生成 PDF"; bs[i].textContent = on ? "生成中…" : "重新生成";
} }
} }
@@ -837,7 +840,7 @@ function updateActions() {
var bs = document.querySelectorAll(".regen"); var bs = document.querySelectorAll(".regen");
for (var i = 0; i < bs.length; i++) { for (var i = 0; i < bs.length; i++) {
bs[i].style.display = dirty ? "inline-flex" : "none"; bs[i].style.display = dirty ? "inline-flex" : "none";
if (!S.busy) bs[i].textContent = "重新生成 PDF"; if (!S.busy) bs[i].textContent = "重新生成";
} }
} }
@@ -1012,10 +1015,6 @@ function boot() {
var regens = document.querySelectorAll(".regen"); var regens = document.querySelectorAll(".regen");
for (var i = 0; i < regens.length; i++) regens[i].onclick = applyChanges; for (var i = 0; i < regens.length; i++) regens[i].onclick = applyChanges;
document.getElementById("back").onclick = function(){
location.href = TASK ? ("/?s=" + encodeURIComponent(TASK)) : "/";
};
document.getElementById("pdf").onclick = downloadPdf;
document.getElementById("rot").onclick = function(){ document.getElementById("rot").onclick = function(){
if (S.busy) return; if (S.busy) return;
@@ -1047,12 +1046,32 @@ function boot() {
updateActions(); updateActions();
} }
// 顶栏在任何加载结果下都要能用:返回会话的 X 在空状态/加载失败时也得生效,
// 所以绑定放在 start() 里(boot 只在加载成功后跑)。
function bindTop() {
var back = document.getElementById("back");
if (back) back.onclick = function(){
location.href = TASK ? ("/?s=" + encodeURIComponent(TASK)) : "/";
};
var pdf = document.getElementById("pdf");
if (pdf) { pdf.disabled = true; pdf.onclick = downloadPdf; }
}
function start() { function start() {
bindTop();
loadBatch().then(function(){ loadBatch().then(function(){
loadSaved(); loadSaved();
boot(); boot();
}).catch(function(e){ }).catch(function(e){
showEmpty("加载审核批次失败:" + (e && e.message || e)); var m = String(e && e.message || e);
// visit_url 是通用地址:没跑过本技能的会话、data.db 被删的会话都可能被打开
if (/no such table/i.test(m)) {
m = "这个会话还没有审核数据:可能还没生成过 PDF,或 data.db 被删了。" +
"回到对话让 AI 重新生成一次。";
} else {
m = "加载审核批次失败:" + m;
}
showEmpty(m);
}); });
} }
+1 -1
View File
@@ -1,6 +1,6 @@
--- ---
name: image-process name: image-process
description: 图像处理(Pillow)。查看图片信息、格式转换、缩放、裁剪、压缩、文字水印、九宫格切片、多图拼图。仅做确定性图像处理,不做 AI 生成/修图 description: 普通图片/截图的确定性编辑(Pillow):查看信息、转格式、缩放、裁剪、压缩、加水印、九宫格切片、多图拼图
input_schema: input_schema:
type: object type: object
properties: properties: