Author SHA1 Message Date
kicer 29be7bd9d7 feat(shell): 抽出执行后端,Windows 用 git-bash / busybox 跑命令
POSIX 上 spawn('/bin/sh') + kill(-pid) 是刻意选的最强约束:/bin/sh 固定
(不读 $SHELL,否则用户把 shell 设成 fish 后模型写的 POSIX 语法全废),
进程组让「停止」能一次带走孙进程。Windows 这三样都没有,同一个写法从
「有效」变成「静默失效」,detached 还会多弹一个控制台。

把三种能力收敛到 app/server/shell.js(resolve / spawnShell / killTree),
terminal、技能、engine 的取消都改走它,上层不再出现 process.platform 分支:

  - POSIX 分支逐字节不变,Linux / macOS / OpenWrt 行为与拆分前一致
  - Windows 依次探测 git-bash、busybox-w32,都没有就明确报错,不静默退到
    cmd.exe——cmd 的语法与模型写的 POSIX 差太远,降级只会让它反复试错
  - killTree 在 Windows 走 taskkill /T:child.kill() 只杀 shell 本身,
    模型起的 node/python/ffmpeg 孙进程会留下来继续占端口
  - detached 在 Windows 关闭(会新建控制台,且让子进程脱离 taskkill 的父子树)
  - 三级覆盖:AGENT_SHELL > config.terminal.shell > 自动探测;
    AGENT_SHELL_ARGS 可改参数模板(bash 想读 rc 时写 -lc)

新增 local/start-win.mjs:start.sh 那 1100 多行 bash 靠 lsof / pgrep /
readlink -f / nohup / setsid / 进程组信号,Windows 一个都没有。启动器这层
本来就只做进程管理,用 Node 重写更省事;业务代码一行都不分平台。首次运行
自动把 busybox-w32(单文件 600KB)下到 local/bin/,生成 local/config.win.yml,
之后不再覆盖。

验证(macOS 实跑):普通命令 / 超时 704ms / 取消 403ms 三条路径正常,进程组
3 个进程 kill 后归 0,procs 无残留;真实 core 启动 health 200,日志多一行
terminal=/bin/sh -c ← default。win32 分支只做了逻辑模拟(无 shell 的报错
文案、有 busybox 时解析为 busybox sh -c),真机待验。

未做:Windows 启动器未拉起四个同栈 MCP 与 office 预览网关,配置里
mcp_servers 暂为空,terminal / 文件工具 / 技能不受影响。
2026-11-19 11:27:17 +08:00
kicer ae9b78c661 chore(engine): 模型调用重试加日志
原来重试完全静默,出问题时看不出来。现在每次重试打一行 warn:
  <session> 第 1/2 次重试:上游返回 429: {...}

重试用的是同一份 messages,所以增量上下文会发空 body(约 200 字节),
这行日志正好用来对上 relay 里那笔 delta=0 的账。
2026-11-17 23:46:50 +08:00
kicer ca8099b158 perf(增量上下文): 数组未变时发空增量,不再整段重传
两个场景会重建出与上一轮完全相同的数组:
  - engine 的重试循环(429 / 5xx / 流中断)复用同一份 messages
  - 会话中途切模型,cid 不含模型名,消息数不变

原来这两种都走 Reset 全量(1.5MB),而 relay 里明明有一模一样的缓存。
现在发空 messages 数组,relay 用缓存原样转发,上传约 200 字节。
缓存不在时 relay 回 409,走既有的重试分支(带 Reset 全量),自愈。

六条路径回归:首轮全量 / 正常追加 1 条 / 切模型 0 条 / 纯重试 0 条 /
编辑截断全量 / 空增量遇 409 回落全量;__rowId 全程零泄漏。
2026-11-17 23:41:26 +08:00
kicer e55d209f59 fix(增量上下文): 409 重试路径泄漏内部键 __rowId
上一版改锚点判时,409 重试分支仍是 body.messages = messages(原始数组),
而 buildMessages 现在给每行都挂了 __rowId。结果重试那次把 __rowId 一路发到上游。

修复:map 完先存一份「已剥键的全量数组」strippedFull,
增量分支切 strippedFull.slice(st.len),409 重试用 strippedFull。

实测四条路径(假上游捕获请求体):
  首轮      → 3 条 + Reset
  正常追加  → 1 条,无 Reset
  编辑截断  → 4 条 + Reset
  作废指针  → 全量 + Reset
  __rowId 全程零泄漏
2026-11-17 23:38:03 +08:00
kicer 8096d42926 fix(engine): 历史被改后不再错切增量上下文,避免上游 tool_call_mismatch
ctx-relay 只是把 delta 接到缓存屁股后面再转发,自己没有校正能力(Reset 才整段替换)。
能不能只发新增全靠 core 判断,而原来的判据只有「长度」:messages.length > st.len。
编辑消息会丢弃其后全部历史,新内容随后又长出来,长度可能反而更大 —— 判据照样通过,
slice(st.len) 的切点却落到了旧历史的中间,relay concat 出一份错位数组(assistant 带
tool_calls 但紧跟的回执属于别的批次),上游以 tool_call_mismatch 400 拒收。

改成锚点判:ctxState 从 {len} 变成 {len, lastRowId},lastRowId 是本轮发出去的数组里
最后一个来自数据库的行的 messages.id(末尾可能是合成的图片提示行,往前找)。下一轮检查
messages[st.len-1].__rowId 是否还是它 —— 是则前缀原封未动,只发 slices;否则整段重发。
__rowId 是内部键,序列化前统一剥掉(复用原 __reasoning 的 map,增量分支改用已剥的
body.messages 而不是原始 messages,否则会把内部键发给上游)。

历史被改只有两种形态:尾部截断(编辑/清空/压缩)必然让锚点失效;中间挖洞(删单条)
后面的行位置变了但末尾 id 没变,锚点查不出 —— 所以 deleteMessage / deleteToolMessage /
clearSessionMessages / editUserMessage 都调 invalidateContext(cid) 直接作废指针,
下一轮走 X-Context-Reset 全量重建。压缩不用调:archived_cnt +1 会让 cid 自变。

端到端验过四种场景(假上游捕获实际请求体):首轮 Reset 全量、正常追加只发 1 条、
编辑截断回落 Reset、作废指针回落 Reset;__rowId 零泄漏。
2026-11-17 23:36:15 +08:00
kicer 4aa8f01610 feat(trim): terminal 输出加裁剪规则,阈值 1500
terminal 回执占了本会话上下文的 69%(313KB/460KB),但单条都不大(最大 10KB),
默认规则里却没覆盖它,等于每轮都在重发全部命令输出。

实测阈值拐点:>1500 裁 55 条省 43%,>2000 只裁 35 条省 33%。
rounds:5 比其它规则更晚动手(terminal 输出经常还要回头看),turns:2 保证当前回合绝不裁。
2026-11-17 23:34:47 +08:00
kicer 488734641d feat(渲染): 支持 LaTeX 数学公式,KaTeX 本地化
聊天消息与 md 文件预览都支持 $...$ 行内与 $$...$$ 块级。

实现:占位符往返,不用 marked 扩展
- 解析前把公式抠成 @@MATHn@@(跳过围栏代码与行内代码)
- marked 正常解析后把占位换回 KaTeX 输出
- 这样公式里的 * _ \ { } 不会被 marked 当成强调/转义

行内 $ 的边界判断:前后紧邻字母/数字时不识别,避免「花了 $5 和 $6」被当公式。

KaTeX 0.16.11 本地 vendor(592KB,含 20 个 woff2 字体),不走 CDN。
md 预览的新窗口用根绝对路径引入 CSS,blob 文档的相对路径找不到字体。
2026-11-17 22:42:48 +08:00
kicer 85984e1ee2 fix(增量上下文): 全量请求带 X-Context-Reset: 1
relay 新协议用显式头区分全量/增量,hash 已移除:
- 全量(首轮/进程重启/压缩后新 id/409 重试)→ 带 Reset 头,relay 整段替换缓存
- 增量 → 不带,relay 缓存不存在则 409(core 重试一次带 Reset)
2026-11-17 22:27:50 +08:00
kicer 71b83bb523 refactor(增量上下文): 用 archived_cnt 代替 hash 校验
原来每轮算 messages 的 sha256 传给 relay 校验,但裁剪会随轮次推移改写历史
(read_file 等回执换成占位符),导致 hash 必然对不上、每次都 409 回退全量。

改成把「压缩代数」编进 context_id:
  <core_id>:<user>:<session_id>:<archived_cnt>
archived_cnt 是已被压缩掉的行数,压缩时自增 → id 自变 → relay 缓存自然失效。
裁剪只改内容不删行,不改变 id,所以不会打断增量(relay 里保留完本文,模型看到的信息更多)。

core 侧不再算 hash(省掉每轮全量序列化),relay 侧只判缓存存在与否。
2026-11-17 22:13:51 +08:00
kicer 45e4720453 revert: relay 移出 agent 仓库
relay 是 workbuddy2api 的前缀组件,跟着网关走才合理,放到 tools/workbuddy-api。
2026-11-17 20:40:02 +08:00
kicer 424bdcbd52 feat(设置页): 模型卡片加「增量上下文」开关
模型编辑弹窗里新增勾选框,对应配置里的 store: true。
放在「启用」旁边而不是高级区,因为它是决定请求形态的常用开关。

- 勾选/取消只增删 store 键,缺省不写(与 max_context 同一口径)
- 新增平台时缺省不勾
2026-11-17 20:34:27 +08:00
kicer bba42ae2ca feat(llm): 支持增量上下文,为模型加 store: true 即走 relay
- 新增 instance.js:data_root/instance-id,首次启动生成 12 位 hex,跨 core 唯一
- engine 传 context_id = <core_id>:<user>:<session_id>,三层定位不撞车
- callModel 对 store: true 的模型只发新增消息 + X-Context-Id/Hash,
  409 时改发全量重试一次;指针存内存,重启自动回落全量
- config.js 把 store 字段透传到模型对象(以前会被丢掉)
- 未配 store 的模型行为完全不变
2026-11-17 20:29:16 +08:00
kicer 05d03f0836 feat(relay): 新增上下文缓存中继,支持增量上传
每轮只发新增的 user/tool 消息,relay 查表拼接后再转发上游,慢上行链路省掉 90%+ 上传。

- 协议:X-Context-Id + X-Context-Hash(空 = 全量替换),不命中回 409 由客户端重发全量
- 不带 header 或模型没开白名单 → 完全透明转发
- 单会话上限与总量 LRU 两个阈值,不设条数上限(会在最需要增量时打回全量)
- 响应原样 pipe,不解析 SSE、不改帧、不缓冲
- 零依赖,纯 node:http
2026-11-17 20:23:04 +08:00
kicer e928fd7cb0 refactor(文件面板): 去掉目录名黑名单,out/dist 等不再灰显
当初列 node_modules/.git/dist/build/out 等名字,是因为文件树一次性拉全量
(1.4MB)怕撑爆;现在已改成按目录懒加载、单层最多 500 条,这个限制没意义了,
反而误伤项目自己的 out/(两个文件也点不开)。

- 后端 /tree 不再返回 ignored 字段,排序回到「目录在前、文件在后」
- 前端去掉 is-ignored 的样式、勾选框排除与点击拦截
- CSS 删掉 .tree-row.is-ignored
2026-11-17 16:45:35 +08:00
kicer 3139108838 refactor(video_task): 改成通用 OpenAI 兼容形态,不绑定任何厂商
照 image_task 的口径:Base-Url / 模型 / 凭据全部由调用方每个请求用 header 带入
(X-Video-Task-Base-Url / X-Video-Task-Model / Authorization),服务端不存密钥、
不预设默认模型、不认任何厂商专有字段。

- 提交 POST {base}/videos/generations(wait=false,立刻回 task_id)
- 查询 GET  {base}/videos/{task_id}
- 缺 header 同步报错,不打上游
- 上游只需回 task_id/id 与 status(completed 时带 videos[].url)
- presets.json 与 README 同步改成通用描述
2026-11-17 16:28:44 +08:00
kicer c750393c81 fix(video_task): 无域前缀的模型名回落到默认,兼容旧配置 2026-11-17 16:26:33 +08:00
kicer 6bd1fa48f8 feat(video_task): 上游从智谱换成 WorkBuddy 网关
智谱 cogvideox-flash 是免费模型,实测连续 429「访问量过大」,基本调不通。
改接 wb.ai 的 OpenAI 兼容视频接口(/v1/videos/generations + /v1/videos/{id}):
- 默认模型 cn:minimax-video-h3(4s 约 62 积分 / 128s),可切 cn:kling-video-v3
- 参数换成网关口径:seconds / aspect_ratio / resolution / negative_prompt / enable_audio
- 鉴权改为 wb.ai 的 API Key,服务端仍不存密钥
- presets.json 的视频预设同步改默认模型与说明

实测:提交→轮询→出片 2.1MB MP4 全链路通过,op=get 与错误路径均正常。
2026-11-17 16:24:27 +08:00
kicer 6a0aed2611 fix(tunnel): client 加心跳看门狗,半死链路 75s 主动重连
Mac 睡眠/切网后 TCP 半死,close 事件永远不来,client 会一直停在「已连接」而服务端早已踢掉。
新增:记录最近收帧时间,75s(连丢 3 个 25s 心跳)无任何帧即 terminate 走既有重连。
顺带把 client 日志时间从 UTC 改为东八区。
2026-11-17 15:01:54 +08:00
kicer af0575dddd chore: gitignore 加 .imgcache/(读图压缩缓存,工作目录为仓库根时会落在仓库里) 2026-11-15 15:21:32 +08:00
kicer 25133f90ed fix(tunnel): SSE 断开时没通知家里停掉上游请求
server.js 原来用 req.on('aborted') 发 abort,但 SSE 是 GET 无 body,
这个事件只在传输请求体时触发(Node 也已废弃它),实际永远不触发。

后果:前端切会话时 es.close() 关掉旧 SSE,隧道这边收不到 abort,client 继续
读流、继续往 WS 灌数据,core 那边的 SSE 连接也没断。切到正在运行的会话就是
新旧两条流同时推,把单条 WS 占满,后发的 detail 请求只能排队 —— 表现为白屏 1-2 秒。

改挂 res.on('close'):正常结束时 pending 已删会直接返回,只在客户端提前断开时发 abort。
2026-11-15 15:19:19 +08:00
kicer ac052d6997 docs: 补齐 tunnel 模块,更新 SSE 合并与文件面板懒加载
- README:组成表加 tunnel/;本机运行补隧道 client;安全边界补隧道
- AGENTS:仓库结构、运行时拓扑、端口表、数据持久化、同步清单、常见任务补 tunnel
- local/README:可选能力与安全边界补隧道
- app/AGENTS:sse.js 补高频事件合并;前端补文件面板按目录懒加载
2026-11-15 15:16:54 +08:00
kicer 67d3355f44 perf(sse): 合并高频流式事件,减少 TCP 小包
LLM 每吐一个 token 就是一条 assistant_delta,sse.js 每次都直接 res.write,
而 Node 的 HTTP server 默认开 TCP_NODELAY —— 每个 token 就是一个 TCP 包。
手机热点 / 跨境链路上包数比字节数更伤(每个包都要射频调度,拥塞窗口也容易被
小包拖住),表现就是流式输出时整个界面卡顿。

改成对 assistant_delta / reasoning_delta / tool_call_args 三类高频事件做缓冲:
攒 50ms 或 8 条合并成一次 write。其他事件(status / done / tool_call /
assistant_message / error 等)立即发,但发前先 flush 待发的 delta,保证顺序不乱。

预期:流式输出期间包数从 50-100/s 降到 10-20/s,首字延迟 +50ms(打字机效果感知不到)。
所有客户端受益(隧道、局域网直连、微信桥接)。
2026-11-15 15:11:00 +08:00
53 changed files with 1349 additions and 546 deletions
+6
View File
@@ -10,12 +10,18 @@ skills/*/.deps_installed
# 本地端(local/):运行期产物与生成的配置都不入库(含密钥,见 local/README.md)
local/.runtime/
local/config.local.yml
local/config.win.yml
# busybox-w32:Windows 启动器下载的 shell 二进制(不进 git)
local/bin/
# officecli 二进制资产:skills/office/install.sh 运行期拉取,不进 git
skills/office/bin/
skills/**/__pycache__/
*.log
# 读图压缩缓存(会话工作目录 = 仓库根时落在仓库里)
.imgcache/
.DS_Store
app/server/version.json
*.apk
# 部署配置真身(含密钥,模板见 scripts/deploy.conf.example);
deploy.conf
relay/config.json
+10 -2
View File
@@ -24,7 +24,8 @@
| `wxbot/` | 微信 iLink 协议调制解调器(多实例) | 独立容器 `agent-wxbot` |
| `mcp/` | 同栈 MCP 服务:`web_search` / `image_task` / `video_task` / `asr` | 四个容器,仅内网 |
| `skills/` | 目录式技能(`SKILL.md` + `run.py`/`run.sh`) | 运行时挂载,`skills/deps` 为依赖层 |
| `local/` | **本地端启动器**:同一份代码跑在本机(不起 Docker / executor),`start.sh` 负责探测、装依赖、守护 | 独立于 compose,见 `docs/local-mode.md` |
| `local/` | **本地端启动器**:同一份代码跑在本机(不起 Docker / executor)。`start.sh`(macOS/Linux)与 `start-win.mjs`(Windows)负责探测、装依赖、守护 | 独立于 compose,见 `docs/local-mode.md` |
| `tunnel/` | **反向隧道**:服务器端 `server.js` 按 Host / 固定端口 / 通配路由转发,本机 `client.js` 承接 | 独立 compose,见 `tunnel/README.md` |
| `scripts/` | `init.sh` 生成 `.env` + 首次创建 `config.yml`(仅初始管理员);`init_host.sh` 裸机初始化 | 幂等,**不覆盖已有配置** |
| `docs/` | 专题文档:`tool-design.md`(工具接口规范)、`OFFICE.md` | — |
| `tasks/` | **运行时数据**:每个会话一个工作目录 | gitignore |
@@ -38,10 +39,13 @@
```mermaid
flowchart TD
CORE["agent-core(8090,唯一对外端口)"]
B["浏览器 / PWA"] -->|"HTTP + SSE"| CORE
M["手机 / 外网"] -->|"HTTPS"| TUN["tunnel server(19000,仅回环)"]
TUN -->|"WebSocket"| TC["tunnel client(本机)"]
TC -->|"HTTP"| CORE
W["微信客户端"] --> WXBOT["agent-wxbot(8093,仅内网)"]
WXBOT -->|"回调 /wxhook/*(共享 Bearer token)"| CORE
CORE["agent-core(8090,唯一对外端口)"]
CORE --> EXEC["agent-executor(9000 exec / 3100 预览,仅内网)"]
CORE --> MCP["mcp_web_search / mcp_image_task / mcp_video_task / mcp_asr(3000,仅内网)"]
CORE -->|"分段投递回复"| WXBOT
@@ -59,6 +63,7 @@ flowchart TD
| 服务 | 端口 | 可见性 |
|---|---|---|
| `agent-core` | 8090 | 宿主机映射,**唯一对外** |
| `tunnel` server | 19000 | 仅 `127.0.0.1`,对外经 nginx 反代 |
| `agent-executor` | 9000(exec)、3100(预览网关) | 仅 `expose`,内网 |
| `agent-wxbot` | 8093 | 仅内网 |
| `mcp_*` | 3000 | 仅内网 |
@@ -72,6 +77,7 @@ flowchart TD
| `./skills/` | `/workspace/skills` | `/workspace/skills:ro` | 技能与共享依赖 |
| `./config.yml` | `/app/config.yml` | 不挂、不读 | 平台密钥、登录密钥 |
| `./app/server/` | `/app/server` | — | 后端代码(**热挂载**) |
| `./tunnel/data/` | — | — | 隧道服务端配置 `server.yml`(首次启动自动生成,含 token) |
| `./wxbot/data/` | — | `/data`(wxbot) | 微信登录凭证 |
推论:
@@ -163,6 +169,7 @@ curl -s http://127.0.0.1:8090/api/health
| 配置默认值 | `app/server/config.js` 的 `DEFAULTS` ↔ `app/config.example.yml` |
| 内置工具 | `app/server/tools/definitions.json` ↔ `app/AGENTS.md` / README 工具表 ↔ `docs/tool-design.md` 规范 |
| 新增服务 / 端口 / 卷 | `docker-compose.yml` ↔ `README.md` 的部署与安全章节 |
| 隧道 token | `tunnel/data/server.yml`(自动生成)↔ `tunnel/client.yml`(手写),两边必须一致 |
| 新增环境变量 | compose ↔ README「环境变量」 |
| 发版号 | `app/package.json` 的 `version` ↔ `app/server/routes/system.js` 的 `VERSION` 字面量(两者不自动同步) |
| 技能格式 | `skills/README.md` ↔ `app/server/tools/skills.js` 的解析 |
@@ -197,5 +204,6 @@ curl -s http://127.0.0.1:8090/api/health
| 改微信投递 | `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`(先读顶部安全模型注释) |
| 改隧道路由 / 转发 | `tunnel/server.js`(按 Host / 端口匹配)+ `tunnel/client.js`(本地服务映射) |
| 加同栈 MCP 服务 | `mcp/<name>/` + `docker-compose.yml` + `config.yml` 的 `mcp_servers` |
| 加技能 | `skills/<name>/`(`SKILL.md` + `run.py`),见 `skills/README.md` |
+4
View File
@@ -28,6 +28,8 @@ macOS / Linux,Node 20+,不需要 Docker:
首次运行会让你选一个工作目录(技能、会话、数据库都在里面)。命令直接在本机执行,没有沙箱隔离,只监听 `127.0.0.1`。
需要从外网访问时,配好 [`tunnel/client.yml`](tunnel/README.md) 后 `start.sh` 会一并拉起隧道 client;未配置则跳过。
## 组成
| 目录 | 说明 |
@@ -38,6 +40,7 @@ macOS / Linux,Node 20+,不需要 Docker:
| [`mcp/`](mcp/README.md) | 四个 MCP 服务:网页搜索、图片生成、视频生成、语音转写 |
| [`skills/`](skills/README.md) | 内置技能 |
| [`local/`](local/README.md) | 本机模式启动器 |
| [`tunnel/`](tunnel/README.md) | 反向隧道:把本机服务经服务器中转,供外网访问 |
## 配置
@@ -68,6 +71,7 @@ docker compose up -d --build
## 安全
- 对外只开 agent-core 一个端口,其余服务只在 Docker 内网
- 隧道只经服务器 nginx(TLS)对外,宿主机端口仅绑 `127.0.0.1`;`server.yml` 与 `client.yml` 的 token 必须一致
- 命令在 executor 容器里执行,只挂当前会话目录,根文件系统只读
- 单租户设计:除管理员接口外不做用户级资源隔离,不要开放给互不信任的人
- `config.yml`、`.env`、`wxbot/data/` 存密钥,已加入 `.gitignore`
+12 -1
View File
@@ -51,7 +51,7 @@ AGENT_CONFIG=./config.yml node server/server.js
| `server/wechat.js` | 微信绑定、媒体落盘、上下文注入、SSE→微信分段投递、任务通知 |
| `server/routes/channel.js` | 文本命令层(`/new` `/switch` `/think` …),微信与外部接入端共用 |
| `server/routes/*.js` | HTTP API,按资源分文件 |
| `server/sse.js` | 按会话分组的 SSE 总线(`addClient`/`emit`/`onInternal`) |
| `server/sse.js` | 按会话分组的 SSE 总线(`addClient`/`emit`/`onInternal`);`assistant_delta` / `reasoning_delta` / `tool_call_args` 攒 50ms 或 8 条合并写入 |
| `server/auth.js` | HMAC cookie 登录、Basic 兜底、`requireAdmin`、免认证路径 |
| `server/memory.js` | 长期记忆(日记碎片)读写与检索,仅依赖 `time.js` |
| `server/time.js` | 业务时区单一入口:`TZ`、`dayString`、`stampString`、`fmtTime`、`fmtIso` |
@@ -59,6 +59,7 @@ AGENT_CONFIG=./config.yml node server/server.js
| `server/public-files.js` | `mint_public_link` 的短链签发与解析(进程内 Map) |
| `server/download-token.js` | 浏览器下载链接的 HMAC 签名(密钥进程内随机) |
| `server/remote-exec.js` | 调 `agent-executor` 的 `/exec`(SSE)与预览槽清理 |
| `server/shell.js` | **执行后端**:解析用哪个 POSIX shell 跑命令(POSIX 直接 `/bin/sh`;Windows 依次 git-bash → busybox-w32)、跨平台杀进程树。平台差异只允许出现在这里 |
| `server/log.js` | 分级日志 `log.debug/info/warn/error(category, ...)` |
| `server/balance.js` | 平台余额查询适配器(按 `platform.type` 分发) |
| `server/version.js` | git commit/date:优先读 `version.json`(post-commit 钩子生成),宿主机有 git 时兜底 `git rev-parse`;页面版本号另外由 `routes/system.js` 的 `VERSION` 字面量决定 |
@@ -211,6 +212,11 @@ IM 用户在实时对话,回合中插话应当“当前这步跑完就插”
`{content, reasoning, tool_calls, finish_reason, usage, aborted, sseFrames}`;正文开头混入的
`<think>` 块会被 `splitInlineThinking` 剥离到 reasoning。
增量上下文(模型配了 `store: true` 且带 `opts.context_id`):只发上次之后新增的消息,带
`X-Context-Id` / `X-Context-Hash`;relay 回 409 说明缓存对不上(压缩、relay 重启、TTL 过期),
改发全量重试**一次**。指针存 `ctxState`(进程内存,只存 hash + 条数),进程重启即失效 →
下一轮自动全量。上游仍然是全量,语义不变。
## 工具层
- 工具全集 = `definitions.json`(14 个内置)+ MCP 发现结果;再依次叠 profile 的 `tools_allow`
@@ -354,6 +360,8 @@ preview-proxy.mount(末尾兜底)
JS/CSS 改动不需要。
- 另有 `login.html`、`memory.html`(日记调试页)。
- API 调用统一走 `core.js` 的 `req()`;SSE 用 `EventSource` + 前端看门狗。
- 文件面板(`files.js`)按目录懒加载:只请求 `GET /api/sessions/:id/tree?dir=<rel>` 的当前层,
进入子目录才拉下一层;会话详情接口不返回全量 `files`。
## 扩展指南
@@ -396,6 +404,9 @@ preview-proxy.mount(末尾兜底)
## 陷阱清单(都是踩过的)
- **平台差异只允许出现在 `server/shell.js`**:`terminal` / 技能 / `engine.killRunProcs` 一律走
`shell.spawnShell` / `shell.killTree`,上层不写 `process.platform` 分支。POSIX 分支的行为
(`/bin/sh -c` + 进程组 + `kill(-pid)`)不能变——它是「模型按 POSIX 写就一定能跑」的保证。
- **循环依赖**:`engine` 绝不 `require('./wechat')` 或 `require('./scheduler')`,否则拿到半成品
exports。通知面/engine 引用一律由 `server.js` 注入。`executor → scheduler` 是单向的,安全。
- **tool_call 配对**:删 assistant 必须连带删该轮的 `tool` 回执;删单条 `tool` 回执必须从父
+3
View File
@@ -33,6 +33,9 @@ log_level: "info" # debug < info < warn < error
terminal:
default_timeout_ms: 30000 # 命令默认超时(ms)
max_output_chars: 10000 # 回传模型的最大输出字符数
# shell: '' # 跑命令的 POSIX shell;空 = 自动探测
# POSIX:/bin/sh;Windows:git-bash → busybox-w32
# env AGENT_SHELL 优先级更高,AGENT_SHELL_ARGS 可改参数模板
fetch:
timeout_ms: 30000 # 抓取总超时(ms),覆盖响应头到 body 读完
+11 -1
View File
@@ -76,7 +76,9 @@ const DEFAULTS = {
db_path: '',
// executor / 微信接入(wxbot)均不占配置字段:两组件接线纯 env(compose 经根 .env 注入,见 parseAndValidate);
// 本配置文件内含密钥,只给 core 进程读,executor/wxbot 一律不挂不读。
terminal: { default_timeout_ms: 30000, max_output_chars: 10000 },
// terminal.shell:跑命令用的 POSIX shell(空 = 自动探测:POSIX 直接 /bin/sh;Windows 依次找
// git-bash、busybox-w32)。env AGENT_SHELL 优先级更高,AGENT_SHELL_ARGS 覆盖参数模板(默认 -c)。
terminal: { default_timeout_ms: 30000, max_output_chars: 10000, shell: '' },
// fetch:timeout_ms 覆盖请求发出到 body 读完的全生命周期;max_bytes 为流式抓取字节上限(超限即断开)。
// 下载与返回两上限解耦:下载不进上下文可宽松,返回默认收紧(max_chars),模型显式传 max_chars 时
// 夹在 max_chars_hard 硬帽内;超窗尾部提示 offset,续读走 ctx.run 上的回合缓存不重抓。
@@ -102,6 +104,10 @@ const DEFAULTS = {
{ tool: 'fetch', side: 'result', rounds: 2, turns: 1, status_regex: '^HTTP (\\d{3})' },
{ tool: 'read_file', side: 'result', rounds: 2, turns: 1 },
{ tool: 'web_search', side: 'result', rounds: 2, turns: 1 },
// terminal 输出占了会话上下文的大头(实测 69%),但单条都不大(最大 10KB),
// 所以阈值降到 1500(实测拐点:>1500 裁 43%,>2000 只裁 33%)。
// rounds:5 比其它规则更晚动手——terminal 输出经常还要回头看;turns:2 保证当前回合绝不裁。
{ tool: 'terminal', side: 'result', rounds: 5, turns: 2, min_chars: 1500 },
],
} },
// 大图上传预处理(浏览器端 canvas 压缩,参数经 /api/system/status 下发前端)。
@@ -236,6 +242,9 @@ function normalizePlatforms(rawPlatforms, profileNames) {
// 非空时发请求前给历史 assistant 行挂该字段;空(缺省)= 不回传。纯发送侧旋钮,
// 与接收解析无关(接收早已兼容 reasoning/reasoning_content 双名)。
reasoning_ack_field: typeof m.reasoning_ack_field === 'string' ? m.reasoning_ack_field.trim() : '',
// 选填:该模型的请求走增量上下文(context relay),只有配合 relay 生效。
// 不配 = 每轮重传全量,和以前完全一样。
store: m.store === true,
// 选填:自动压缩阈值(用户自定义的「上下文用量线」,**不是**模型真实窗口)。
// 回合内 In token 峰值达到它即自动压缩上下文(见 engine.runLoopInner 循环顶部);0/未配 = 不启用。
max_context: Math.max(0, parseInt(m.max_context, 10) || 0),
@@ -363,6 +372,7 @@ function parseAndValidate(rawText, configPath) {
extra_params: m.extra_params, thinking_params: m.thinking_params,
reasoning_ack_field: m.reasoning_ack_field,
max_context: m.max_context,
store: m.store,
profile: m.profile,
url: p.url, api_key: k.api_key, platform: p.name, type: p.type, concurrency: k.concurrency,
platform_index: pi, key_index: ki, model_index: mi,
+40 -4
View File
@@ -2,11 +2,13 @@
// 单进程内存模型:JS 单线程 + better-sqlite3 同步 API,不存在跨进程竞争。
const fs = require('fs');
const path = require('path');
const { buildMessages, callModel, encodeBlocks, decodeBlocks, compressMessages, titleMessages, setProfilePrompts, patchImageReceipt } = require('./llm');
const { buildMessages, callModel, encodeBlocks, decodeBlocks, compressMessages, titleMessages, setProfilePrompts, patchImageReceipt, invalidateContext } = require('./llm');
const { instanceId } = require('./instance');
const { executeTool, resolveInTask } = require('./tools/executor');
const publicFiles = require('./public-files');
const mcp = require('./mcp');
const rexec = require('./remote-exec');
const shell = require('./shell'); // 执行后端:killTree 的平台差异(进程组 / taskkill)不往引擎里渗
const log = require('./log');
const profile = require('./user-profile');
const memory = require('./memory');
@@ -109,6 +111,21 @@ function loadHistory(sessionId) {
return db.prepare('SELECT * FROM messages WHERE session_id = ? ORDER BY id').all(sessionId);
}
// 已被压缩掉的行数 = 「压缩代数」。压缩时会把摘要之前的所有行标成 archived,
// 所以这个数单调递增;用它做增量上下文的 id 后缀,压缩后 id 自变,relay 缓存自然失效。
function archivedCount(history) {
let n = 0;
for (const r of history || []) if (r.type === 'archived') n++;
return n;
}
// 增量上下文 id 的拼法(与 llm.js 的 X-Context-Id 一致):<core_id>:<user>:<session_id>:<archived_cnt>。
// 删除消息后要把这个 key 作废,让下一轮走全量重建。
function contextIdOf(session) {
return instanceId(cfg.data_root) + ':' + (session.user || '-') + ':' + session.id +
':' + archivedCount(session.history);
}
function saveMessage(sessionId, msg) {
const info = db.prepare(
'INSERT INTO messages (session_id, role, content, reasoning, tool_calls, tool_call_id, name, type, is_error, usage, created_at) VALUES (?,?,?,?,?,?,?,?,?,?,?)'
@@ -552,9 +569,8 @@ function killRunProcs(run) {
for (const proc of run.procs) {
// 远端 executor 任务句柄(remote-exec.js):发 DELETE 取消,不能本地 kill。
if (typeof proc.remoteKill === 'function') { try { proc.remoteKill(); } catch (_) {} continue; }
try { process.kill(-proc.pid, 'SIGKILL'); } catch (_) {
try { proc.kill('SIGKILL'); } catch (__) {}
}
// 平台差异交给执行后端:POSIX 杀进程组,Windows 走 taskkill /T。
shell.killTree(proc);
}
run.procs.clear();
}
@@ -859,6 +875,10 @@ async function runLoopInner(sessionId, run) {
lastErr = err;
const retriable = !err.upstream_status || err.upstream_status === 429 || err.upstream_status >= 500;
if (!retriable || attempt === cfg.agent.max_retries) break;
// 重试用的是同一份 messages(数组一字未变),所以增量上下文会发空 body,
// 只花百来字节就能让 relay 用缓存重发。这行日志是用来对上那笔账的。
log.warn('model', sessionId + ' 第 ' + (attempt + 1) + '/' + cfg.agent.max_retries +
' 次重试:' + String(err.message || '').slice(0, 100));
await sleep(2000 * (attempt + 1));
}
}
@@ -1159,6 +1179,11 @@ async function streamAssistant(sessionId, run, session, messages, tools) {
// key_slot 定位会话占用的具体 key 副本(model_id 只到「平台/模型」)
const result = await callModel(cfg, session.model_id, messages, tools, {
key_slot: session.model_slot,
// 增量上下文用:<core_id>:<user>:<session_id>:<archived_cnt>。
// archived_cnt = 已被压缩掉的行数,它就是「压缩代数」:压缩后自增 → id 自变 →
// relay 找不到缓存并回 409 → 发全量重建。裁剪不改它(只换内容不删行),
// 所以裁剪不会打断增量。只有带 store: true 的模型才真的用它(llm.js 判断)。
context_id: contextIdOf(session),
signal: run.abortController.signal,
shouldCancel: () => run.cancelled,
onText: delta => bus.emit(sessionId, 'assistant_delta', { text: delta }),
@@ -1835,7 +1860,9 @@ function clearSessionMessages(sessionId) {
}
runs.delete(sessionId);
clearPendings(sessionId); // 历史清零:队列里的消息也没了着落,一并作废
const cid = contextIdOf(session); // 删行不影响 archived_cnt,先算后算等价
db.prepare('DELETE FROM messages WHERE session_id = ?').run(sessionId);
invalidateContext(cid); // 历史清零:增量指针也得跟着作废
wipeSessionTmp(sessionId); // 会话级 /tmp 随清空一并抹掉(尽力而为,失败只记日志不阻断)
autoCompressProposed.delete(sessionId); // 历史清零,恢复自动压缩提议额度
// 标题随历史一并清零:旧标题描述的是已删除的对话,留着会让新对话文不对题;
@@ -1871,6 +1898,7 @@ function deleteMessage(sessionId, messageId) {
const row = db.prepare('SELECT * FROM messages WHERE id = ? AND session_id = ?').get(messageId, sessionId);
if (!row) throw Object.assign(new Error('消息不存在'), { status_code: 404 });
if (row.role === 'tool') return deleteToolMessage(sessionId, row);
const cid = contextIdOf(session); // 删之前先算:archived_cnt 不受删行影响,两者等价,但先算更直观
let removed = 0;
if (row.tool_calls) {
let calls = [];
@@ -1882,6 +1910,9 @@ function deleteMessage(sessionId, messageId) {
}
}
db.prepare('DELETE FROM messages WHERE id = ?').run(messageId);
// 删中间一条:后面的行位置全变,但末尾行 id 没变,锚点查不出来——主动作废增量指针,
// 下一轮改发 X-Context-Reset 全量重建,否则 relay 缓存里还留着被删那行,增量拼出来会错位。
invalidateContext(cid);
return { ok: true, id: messageId, removed: removed + 1 };
}
@@ -1899,6 +1930,8 @@ function editUserMessage(sessionId, messageId, content, opts) {
// 先确保能开跑:无可用模型时抛 503,避免删完历史却发不出去
ensureBinding(session);
const removed = db.prepare('DELETE FROM messages WHERE session_id = ? AND id >= ?').run(sessionId, messageId).changes;
// 尾部截断:锚点本就能查出,但这里紧接着就重新发消息,一并作废指针更直接
invalidateContext(contextIdOf(session));
const r = postUserMessage(sessionId, content, opts);
log.info('msg', sessionId + ' 编辑消息 ' + messageId + ',丢弃其后 ' + Math.max(0, removed - 1) + ' 条历史');
return Object.assign({ removed: removed }, r);
@@ -1929,6 +1962,9 @@ function deleteToolMessage(sessionId, row) {
}
break; // id 唯一,命中即止
}
// 同上:回执被删、父调用也改过 tool_calls,历史已被控——作废增量指针
const s = getSession(sessionId);
if (s) invalidateContext(contextIdOf(s));
return { ok: true, id: row.id, removed };
}
+29
View File
@@ -0,0 +1,29 @@
'use strict';
// 实例标识:跨 core 隔离用,作 relay 的 X-Context-Id 前缀。
// 首次启动生成并落盘到 <data_root>/instance-id,之后只读同一个值。
// 删了数据目录会换新 id —— 旧缓存成孤儿,由 relay 的 TTL 自行清理,不影响正确性。
const fs = require('node:fs');
const path = require('node:path');
const crypto = require('node:crypto');
const cache = new Map(); // dataRoot -> id
function instanceId(dataRoot) {
const root = path.resolve(String(dataRoot || '.'));
if (cache.has(root)) return cache.get(root);
const file = path.join(root, 'instance-id');
let id = '';
try {
id = fs.readFileSync(file, 'utf8').trim();
} catch (_) {}
if (!/^[0-9a-f]{12}$/.test(id)) {
id = crypto.randomBytes(6).toString('hex');
try {
fs.writeFileSync(file, id + '\n');
} catch (_) {}
}
cache.set(root, id);
return id;
}
module.exports = { instanceId };
+93 -9
View File
@@ -3,6 +3,11 @@
const fs = require('fs');
const path = require('path');
// 增量上下文:context_id -> { len }(本进程认为 relay 已存到第几条)。
// 只存指针不存正文;进程重启即清空 → 下一轮发全量,relay 整段替换,行为正确。
// 不存 hash:id 里已经带 archived_cnt(压缩代数),压缩后 id 自变、缓存自然对不上。
const ctxState = new Map();
const SYSTEM_PROMPT_TEMPLATE = fs.readFileSync(path.join(__dirname, 'templates', 'profile-default.txt'), 'utf8');
// 上下文压缩提示词(templates/prompt-compress.txt):点「压缩」时不插入指令消息。
@@ -308,7 +313,7 @@ function buildMessages(session, language, mintUrl, profile, withProfile, trimOn)
// summarize_request(旧版遗留行):仅在未收尾的旧压缩回合内发给模型,其余一律跳过
if (row.type === 'summarize_request') {
if (i > lastClosingAssistant && (row.content || '').trim()) {
messages.push({ role: 'user', content: row.content });
messages.push({ role: 'user', content: row.content, __rowId: row.id });
}
return;
}
@@ -338,7 +343,7 @@ function buildMessages(session, language, mintUrl, profile, withProfile, trimOn)
});
return;
}
const m = { role: 'assistant', content: row.content || '' };
const m = { role: 'assistant', content: row.content || '', __rowId: row.id };
// 思维链回传原料:存库 reasoning 随原样带给 callModel(中性内部键,按模型
// reasoning_ack_field 改名注入后此键必被剥除,不会泄往上游)。
if (row.reasoning) m.__reasoning = row.reasoning;
@@ -419,9 +424,9 @@ function buildMessages(session, language, mintUrl, profile, withProfile, trimOn)
}
if (row.role === 'tool') {
if (trimActive && typeof content === 'string') content = trimToolContent(content, row, callById, roundsAfter, turnsAfter);
messages.push({ role: 'tool', tool_call_id: row.tool_call_id, name: row.name, content });
messages.push({ role: 'tool', tool_call_id: row.tool_call_id, name: row.name, content, __rowId: row.id });
} else {
messages.push({ role: row.role, content });
messages.push({ role: row.role, content, __rowId: row.id });
}
});
// 未消费图片合并发送:图上文字置顶、图块紧随(同序)。
@@ -649,6 +654,14 @@ function splitInlineThinking(raw) {
return { content: text.trim(), reasoning: think.trim() };
}
// 剥离内部键 __rowId(锚点用):有才拷贝,没就原样返回,避免每行都新建对象
function stripRowId(m) {
if (!m || m.__rowId == null) return m;
const c = Object.assign({}, m);
delete c.__rowId;
return c;
}
// 调模型一次。onText(textDelta) 回调流式文本。
// 返回 { content, tool_calls: [{id,name,arguments(string)}], finish_reason, usage, aborted }
// 可选回调 opts.onToolCallStart({id,name}):某 tool_call 首次凑齐 id+name 时触发一次;
@@ -686,20 +699,23 @@ async function callModel(cfg, modelId, messages, tools, options) {
// 思维链回传(逐模型 opt-in):开思考时把 buildMessages 挂的内部键 __reasoning 按
// reasoning_ack_field 写回 assistant 行;关思考时整段不发。带 tool_calls 的行缺思维链
// 时用空串占位(缺失会被上游 400,空串实测通过)。__reasoning 是内部键,任何情况都剥。
// __rowId(锚点用的库行 id)同样是内部键:没想发也不该发给上游,任何行有就剥。
if (body.messages && body.messages.length) {
const ack = modelCfg.reasoning_ack_field;
const send = !!(ack && opts.deepThink);
body.messages = body.messages.map(mm => {
if (!mm || mm.role !== 'assistant') return mm;
if (!mm || mm.role !== 'assistant') return stripRowId(mm);
if (!mm.__reasoning) {
if (!send || !mm.tool_calls) return mm;
if (!send || !mm.tool_calls) return stripRowId(mm);
const c = Object.assign({}, mm);
c[ack] = '';
delete c.__rowId; // 内部键,不发给上游
return c;
}
const c = Object.assign({}, mm);
if (send) c[ack] = mm.__reasoning;
delete c.__reasoning;
delete c.__rowId;
return c;
});
}
@@ -714,18 +730,78 @@ async function callModel(cfg, modelId, messages, tools, options) {
opts.onFetchParams(logBody);
}
const res = await fetch(modelCfg.url + '/chat/completions', {
// ---- 增量上下文(context relay)----
// 仅对显式 store: true 的模型生效,且必须带 opts.context_id。
// id 尾部的 archived_cnt 就是「压缩代数」:压缩会把老行标 archived,代数一变 id 就变,
// relay 自然找不到缓存并回 409,不需要额外传 hash。
// 裁剪不改 id(只换内容不删行),所以它不会打断增量:relay 里留着完本文,模型读到的信息更多。
//
// 能不能只发新增,靠「锚点」判:上一轮发出去的最后一条库行(其 messages.id)还在不在
// 本轮数组的同一位置上。历史被改只有两种形态——尾部截断(编辑/清空/压缩后)与中间挖洞
//(删单条,由 invalidateContext 另行作废)——前者必然让锚点对不上。
// 只比长度是不行的:编辑台丢弃历史后新内容又长出来,长度可能反而更大,切点就错位了,
// relay 忠实 concat 出一份错位数组,上游按 tool_call_mismatch 拒收。
const cid = opts.context_id;
const storeOn = !!(modelCfg.store && cid);
const fullBody = JSON.stringify(body);
// 已剥内部键的全量数组(上面 map 的产物,保序保长)。增量分支会把它替换成尾部切片,
// 所以先存一份:409 重试要拿它重发全量,不能拿原始 messages(那上面挂着 __rowId)。
const strippedFull = body.messages;
if (storeOn) {
const st = ctxState.get(cid);
headers['X-Context-Id'] = cid;
// 锚点:上一轮发出去的数组里最后一条库行的 messages.id。
const anchor = st && st.len > 0 ? messages[st.len - 1] : null;
const anchorOk = !!(st && anchor && anchor.__rowId === st.lastRowId);
if (anchorOk && messages.length === st.len) {
// 数组与上次一模一样(错误重试 / 切模型但没新增消息):发空增量,
// relay 用缓存原样转发即可。缓存不在时它会回 409,下面重试一次全量。
body.messages = [];
} else if (anchorOk && messages.length > st.len) {
// 前缀没动:只发新增。strippedFull 与 messages 同序同长,索引可直接沿用。
body.messages = strippedFull.slice(st.len);
} else {
// 全量:首轮 / 进程重启 / 压缩后新 id / 历史被改
headers['X-Context-Reset'] = '1';
}
}
let res = await fetch(modelCfg.url + '/chat/completions', {
method: 'POST',
headers,
body: JSON.stringify(body),
body: storeOn ? JSON.stringify(body) : fullBody,
signal: controller.signal,
});
// 409 = relay 那边没有这个 id 的缓存(重启 / TTL / LRU / 压缩换了 id):改发全量重试一次。
// 只重试一次:重发的是全量(带 Reset 头),relay 会整段存下,不可能再 409。
if (storeOn && res.status === 409) {
body.messages = strippedFull; // 已剥内部键的全量,不能拿原始 messages
headers['X-Context-Reset'] = '1';
res = await fetch(modelCfg.url + '/chat/completions', {
method: 'POST',
headers,
body: JSON.stringify(body),
signal: controller.signal,
});
}
if (!res.ok) {
const text = await res.text().catch(() => '');
const err = new Error('上游返回 ' + res.status + ': ' + text.slice(0, 500));
err.upstream_status = res.status;
throw err;
}
// 成功才更新“relay 已存到几条”:失败下一轮自然重发全量。
// lastRowId 取本轮发出去的数组里最后一个「来自数据库的行」的 id(末尾可能是合成的
// 图片提示行,没有 __rowId,要往前找):它就是下一轮比对的锚点。
if (storeOn) {
let lastRowId = null;
for (let i = messages.length - 1; i >= 0; i--) {
if (messages[i] && messages[i].__rowId != null) { lastRowId = messages[i].__rowId; break; }
}
ctxState.set(cid, { len: messages.length, lastRowId: lastRowId });
}
let content = '';
let reasoning = '';
@@ -815,4 +891,12 @@ async function callModel(cfg, modelId, messages, tools, options) {
return { content, reasoning, tool_calls: Array.from(toolCalls.values()), finish_reason: finishReason, usage, aborted, sseFrames };
}
module.exports = { callModel, buildMessages, buildSystemPrompt, systemPromptText, setSkillListText, setEnvMode, setPayloadTrim, setProfilePrompts, encodeBlocks, decodeBlocks, compressMessages, titleMessages, patchImageReceipt };
// 作废某会话的增量上下文指针:下一轮直接走 X-Context-Reset 全量重建。
// 用在「历史被挖了一个洞」的地方——删中间某条消息时,后面的行位置没变、
// 锚点(末尾行 id)查不出异常,但 relay 缓存里还留着被删那行,增量拼出来就错位了。
// 压缩不用调:压缩会改 cid(archived_cnt +1),自然回落。
function invalidateContext(cid) {
if (cid) ctxState.delete(cid);
}
module.exports = { callModel, buildMessages, buildSystemPrompt, systemPromptText, setSkillListText, setEnvMode, setPayloadTrim, setProfilePrompts, encodeBlocks, decodeBlocks, compressMessages, titleMessages, patchImageReceipt, invalidateContext };
+11 -3
View File
@@ -95,7 +95,7 @@
{
"key": "video_task",
"label": "视频生成",
"desc": "智谱 BigModel 异步视频接口",
"desc": "文生视频 / 图生视频",
"url": "http://mcp_video_task:3000/mcp",
"mode": "skill",
"fields": [
@@ -105,12 +105,20 @@
"secret": true,
"prefix": "Bearer ",
"required": true,
"placeholder": "智谱 API Key"
"placeholder": "API Key"
},
{
"header": "X-Video-Task-Base-Url",
"label": "地址",
"required": true,
"placeholder": "https://<host>/v1",
"hint": "OpenAI 兼容 videos / generations"
},
{
"header": "X-Video-Task-Model",
"label": "模型",
"default": "cogvideox-flash"
"required": true,
"placeholder": "上游的模型 id"
}
]
},
+6 -1
View File
@@ -483,6 +483,12 @@ main { flex: 1; min-height: 0; display: flex; flex-direction: column; }
/* markdown 排版(v1 同款;仅当 marked 渲染成功时加 .md 类,否则保留 pre-wrap 原文) */
.bubble-ai.md, .bubble-user.md { white-space: normal; }
/* KaTeX 公式:块级单独占行、超宽可横滚;行内不折行避免断在半截 */
.math-block { display: block; margin: 12px 0; overflow-x: auto; overflow-y: hidden; }
.math-block .katex-display { margin: 0; }
.math-inline { display: inline; white-space: nowrap; }
.math-fallback, .math-error { font-family: ui-monospace, Menlo, Consolas, monospace; color: #b45309; }
.math-error { text-decoration: underline dotted; }
.bubble-ai.md > :first-child, .bubble-user.md > :first-child { margin-top: 0; }
.bubble-ai.md > :last-child, .bubble-user.md > :last-child { margin-bottom: 0; }
.bubble-ai.md p, .bubble-user.md p { margin: 6px 0; }
@@ -1159,7 +1165,6 @@ body.voice-active .scroll-bottom-btn { display: none; }
font-size: 13px; color: var(--ink); white-space: nowrap;
}
.tree-row:hover { background: var(--surface); }
.tree-row.is-ignored { color: var(--gray-light); cursor: default; }
.tree-row.is-link { color: var(--gray); }
.tree-ico { flex: none; width: 16px; height: 16px; display: inline-flex; color: var(--gray); }
.tree-ico svg { width: 16px; height: 16px; fill: none; stroke: currentColor; stroke-width: 1.8; stroke-linecap: round; stroke-linejoin: round; }
+3
View File
@@ -8,6 +8,8 @@
<meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no, viewport-fit=cover, interactive-widget=resizes-content">
<title>Agent 任务台</title>
<script src="/vendor/marked.min.js"></script>
<script src="/vendor/katex/katex.min.js"></script>
<script src="/js/math.js"></script>
<script src="/vendor/prism.min.js"></script>
<meta name="theme-color" content="#3964FE">
<!-- 主题首屏:先落 data-theme,避开刷新时的白屏闪一下。默认浅色,手动切过后存 localStorage -->
@@ -29,6 +31,7 @@
<link rel="manifest" href="/manifest.json">
<link rel="apple-touch-icon" href="/icons/apple-touch-icon.png">
<link rel="icon" type="image/png" sizes="192x192" href="/icons/icon-192.png">
<link rel="stylesheet" href="/vendor/katex/katex.min.css">
<link rel="stylesheet" href="/css/style.css">
<style>
/* 「压缩」摘要卡片:与 .msg-ctx(画像快照/渠道/记忆)同一套视觉——淡蓝底、蓝边蓝字、
+7 -1
View File
@@ -48,7 +48,13 @@
if (typeof marked !== 'undefined') marked.setOptions({ breaks: true, gfm: true });
function mdHtml(text) {
if (typeof marked === 'undefined') return { html: esc(text), fmt: false };
try { return { html: marked.parse(text || ''), fmt: true }; }
try {
// 公式先抠成占位、marked 解析完再填回 KaTeX 输出(见 math.js)
const html = typeof mdParseWithMath === 'function'
? mdParseWithMath(text || '', marked)
: marked.parse(text || '');
return { html: html, fmt: true };
}
catch (_) { return { html: esc(text), fmt: false }; }
}
function fmtTime(ts) {
+5 -10
View File
@@ -98,13 +98,12 @@
if (expanded.has(ent.rel)) row.classList.add('open');
}
if (ent.type === 'link') row.classList.add('is-link');
if (ent.ignored) row.classList.add('is-ignored');
// 不画展开箭头:文件夹图标已经说明可以点,点行任意位置都能展开/收起。
// 勾选框:hover 或已选中时淡入,但占位始终在,避免 hover 时文件名左右跳。
// 忽略的大目录和软链不参与批量操作(后端也不让删),所以不给勾选框。
if (!ent.ignored && ent.type !== 'link') {
// 软链不参与批量操作(后端也不让删),所以不给勾选框。
if (ent.type !== 'link') {
const chk = document.createElement('span');
chk.className = 'tree-check';
chk.setAttribute('role', 'checkbox');
@@ -125,10 +124,6 @@
name.textContent = ent.name;
row.appendChild(name);
if (ent.ignored) {
row.title = ent.rel + '(已忽略的大目录/构建产物)';
return row;
}
// 行内动作:服务器形态给「下载 / 删除」;local 本就跑在同一台机器上,
// 「下载」到本地是多余的(用 Finder 直接看原文件更顺),所以换成「在 Finder 中显示」。
// @ 引用排最前:它是「往输入框送东西」的动作,和后面的下载 / Finder / 删除(对文件本身动手)分开
@@ -149,7 +144,7 @@
if (!list.length && !rel) tip(frag, '(空目录)');
for (const ent of list) {
frag.appendChild(rowFor(ent, depth));
if (ent.type === 'dir' && !ent.ignored && expanded.has(ent.rel)) {
if (ent.type === 'dir' && expanded.has(ent.rel)) {
const kids = document.createElement('div');
kids.className = 'tree-children';
frag.appendChild(kids);
@@ -246,7 +241,7 @@
const body = $('tree-body');
if (!body) return [];
return Array.from(body.querySelectorAll('.tree-row')).filter(function (r) {
return !r.classList.contains('is-ignored') && r.dataset.type !== 'link';
return r.dataset.type !== 'link';
});
}
@@ -386,7 +381,7 @@
else if (a === 'at') insertPathRef(rel, isDir);
return;
}
if (row.classList.contains('is-ignored') || row.dataset.type === 'link') return;
if (row.dataset.type === 'link') return;
if (isDir) {
if (expanded.has(rel)) expanded.delete(rel); else expanded.add(rel);
renderBody();
+116
View File
@@ -0,0 +1,116 @@
// 数学公式渲染(KaTeX 本地化,vendor/katex/)。
// 所有 markdown 入口(聊天气泡 / md 文件预览 / 流式增量)都走 core.js 的 mdHtml(),
// 公式处理收在这一个文件里,不散落到各处。
//
// 支持:
// $$...$$ 块级(可换行)
// $...$ 行内($ 后不能是空白、前不能是数字/字母,避免「$5 ... $6」被当公式)
//
// 实现方式:占位符往返,而不是 marked 扩展。
// 1) markdown 解析前,把公式抠成 @@MATHn@@ 占位(跳过围栏代码与行内代码)
// 2) 交给 marked 正常解析
// 3) 输出 HTML 里把占位换回 KaTeX 渲染结果
// 这样公式里的 * _ \ { } 不会被 marked 当成强调/转义吃掉。
const MATH_PH = /@@MATH(\d+)@@/g;
// 从 markdown 源里抠出公式,返回 { md, store }
function mathExtract(src) {
const text = String(src || '');
const store = [];
let out = '';
let i = 0;
while (i < text.length) {
// 围栏代码块整段跳过(三个反引号)
if (text.startsWith('```', i)) {
const end = text.indexOf('```', i + 3);
const stop = end < 0 ? text.length : end + 3;
out += text.slice(i, stop);
i = stop;
continue;
}
// 行内代码跳过
if (text[i] === '`') {
const end = text.indexOf('`', i + 1);
if (end > i) {
out += text.slice(i, end + 1);
i = end + 1;
continue;
}
}
// 块级 $$...$$
if (text.startsWith('$$', i)) {
const end = text.indexOf('$$', i + 2);
if (end > i + 2) {
const latex = text.slice(i + 2, end).trim();
if (latex) {
store.push({ latex: latex, display: true });
out += '@@MATH' + (store.length - 1) + '@@';
i = end + 2;
continue;
}
}
}
// 行内 $...$
if (text[i] === '$') {
const m = /^\$(?!\s)((?:\\.|[^$\\\n])+?)(?<!\s)\$/.exec(text.slice(i));
if (m) {
const before = i > 0 ? text[i - 1] : '';
const after = text[i + m[0].length] || '';
// 前后紧邻字母/数字时不当公式:$5 和 $6、a$b$c 之类
if (!/[0-9A-Za-z]/.test(before) && !/[0-9A-Za-z]/.test(after)) {
store.push({ latex: m[1], display: false });
out += '@@MATH' + (store.length - 1) + '@@';
i += m[0].length;
continue;
}
}
}
out += text[i];
i++;
}
return { md: out, store: store };
}
function mathEsc(s) {
return String(s == null ? '' : s).replace(/[&<>"]/g, function (c) {
return { '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;' }[c];
});
}
// 单个公式 → HTML。KaTeX 不存在或 LaTeX 有错时原样吐回,用户能看见哪里写错了。
function mathRenderOne(latex, display) {
const wrap = display ? '$$' : '$';
if (typeof katex === 'undefined') {
return '<span class="math-fallback">' + wrap + mathEsc(latex) + wrap + '</span>';
}
try {
const html = katex.renderToString(latex, {
displayMode: display,
throwOnError: false,
output: 'html',
strict: false,
});
// 块级公式自己占一行;行内公式保持内联
return display ? '<span class="math-block">' + html + '</span>' : '<span class="math-inline">' + html + '</span>';
} catch (e) {
return '<span class="math-error" title="' + mathEsc(String((e && e.message) || e)) + '">' +
wrap + mathEsc(latex) + wrap + '</span>';
}
}
// 把 HTML 里的占位换回渲染结果
function mathExpand(html, store) {
if (!store || !store.length) return html;
return String(html || '').replace(MATH_PH, function (all, idx) {
const item = store[Number(idx)];
return item ? mathRenderOne(item.latex, item.display) : all;
});
}
// 一步到位:markdown → 含公式的 HTML。markedRef 由调用方传入(core.js 里的全局 marked)
function mdParseWithMath(text, markedRef) {
const r = mathExtract(text);
const html = markedRef.parse(r.md);
return mathExpand(html, r.store);
}
+7 -2
View File
@@ -497,17 +497,22 @@ function pvCloseOverlayQuiet() { const fs = document.getElementById('fs-viewer')
// 其余按 text/plain 原样打开——服务端文件响应一律 attachment,直接导航只会触发下载。
// md 里原样透传的 <script> 在面板(innerHTML)本就不执行,但 blob 文档会执行,故先剔除以保持一致。
function pvMdDoc(html, name) {
// KaTeX 样式表用根绝对路径引入:blob 文档的 base 是 blob:,相对路径找不到字体
const css =
'body{margin:0;padding:24px 32px 48px;max-width:900px;font:15px/1.7 -apple-system,BlinkMacSystemFont,"Segoe UI","PingFang SC","Microsoft YaHei",sans-serif;color:#1f2328;background:#fff}' +
'img{max-width:100%;height:auto}pre{background:#f6f8fa;padding:12px 14px;border-radius:8px;overflow:auto}' +
'code{font-family:ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;font-size:.92em}' +
'table{border-collapse:collapse}th,td{border:1px solid #d8dee4;padding:6px 10px}' +
'blockquote{margin:0;padding:0 14px;color:#57606a;border-left:3px solid #d8dee4}' +
'a{color:#0969da}';
'a{color:#0969da}' +
'.math-block{display:block;text-align:center;margin:14px 0;overflow-x:auto;overflow-y:hidden}';
const title = esc(String(name || '').split('/').pop() || '预览');
const origin = (typeof location !== 'undefined' && location.origin) ? location.origin : '';
return '<!DOCTYPE html><html><head><meta charset="utf-8">' +
'<meta name="viewport" content="width=device-width,initial-scale=1">' +
'<title>' + title + '</title><style>' + css + '</style></head><body>' +
'<title>' + title + '</title>' +
'<link rel="stylesheet" href="' + origin + '/vendor/katex/katex.min.css">' +
'<style>' + css + '</style></head><body>' +
html.replace(/<script\b[\s\S]*?(?:<\/script\s*>|$)/gi, '') + '</body></html>';
}
function pvTextUrl(text) { return URL.createObjectURL(new Blob([text], { type: 'text/plain;charset=utf-8' })); }
+10 -1
View File
@@ -1260,7 +1260,7 @@
}
function pfNewModel() {
const r = { ref: null, id: '', vision: true, enable: true, display_name: '', profile: '',
extra_params: '', thinking_params: '', reasoning_ack_field: '', max_context: 0, adv: false };
extra_params: '', thinking_params: '', reasoning_ack_field: '', max_context: 0, store: false, adv: false };
if (pfEdit) applyModelDefaults(r, pfEdit.preset);
return r;
}
@@ -1284,6 +1284,7 @@
thinking_params: pfJsonText(m.thinking_params),
reasoning_ack_field: m.reasoning_ack_field || '',
max_context: Number(m.max_context) || 0,
store: m.store === true,
adv: false,
})),
};
@@ -1374,6 +1375,7 @@
'<div class="mpe-cks">' +
'<label class="mpe-ck"><input type="checkbox"' + (r.vision ? ' checked' : '') + ' onchange="sUI.mModVision(' + i + ',this.checked)">图片输入</label>' +
'<label class="mpe-ck"><input type="checkbox"' + (r.enable !== false ? ' checked' : '') + ' onchange="sUI.mModEnable(' + i + ',this.checked)">启用</label>' +
'<label class="mpe-ck" title="只发新增消息,需上游有 context relay"><input type="checkbox"' + (r.store ? ' checked' : '') + ' onchange="sUI.mModField(' + i + ',\'store\',this.checked)">增量上下文</label>' +
'<button type="button" class="mpe-adv-btn" onclick="sUI.mAdvToggle(' + i + ')">' + (r.adv ? '收起' : '高级') + '</button>' +
'</div>' + adv +
'</div>';
@@ -1430,6 +1432,7 @@
if (ra) nv.reasoning_ack_field = ra;
const mc = Math.max(0, parseInt(r.max_context, 10) || 0);
if (mc) nv.max_context = mc;
if (r.store === true) nv.store = true; // 缺省 false,只在勾选时写
return nv;
}
// 根据工作态算批量编辑:原地改(值变更项) → 删行(降序) → 新增行(append)。
@@ -1512,6 +1515,12 @@
if (mc !== curMc) {
edits.push(mc ? { path: mp.concat('max_context'), value: mc } : { path: mp.concat('max_context'), op: 'delete' });
}
// 增量上下文:缺省不写,只在勾选时落键,取消勾选则删键
const curSt = om.store === true;
const st = r.store === true;
if (st !== curSt) {
edits.push(st ? { path: mp.concat('store'), value: true } : { path: mp.concat('store'), op: 'delete' });
}
} else {
edits.push({ op: 'append', path: ['platforms', pfEdit.idx, 'models'], value: pfModelValue(r) });
}
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
+2 -7
View File
@@ -81,10 +81,6 @@ router.post('/:id/files', upload.array('files', 10), function (req, res) {
// 为什么不复用 GET /:id/files:那个接口同步递归整棵目录,会话里一旦有大项目 /
// node_modules,单线程 core 会被卡死(连 SSE 一起挂)。这里一律「一次一层」、
// 忽略大目录、限量返回,客户端展开才请求下一层。
const TREE_IGNORE_DIRS = new Set([
'node_modules', '.git', 'dist', 'build', 'out', 'target', '.venv', 'venv',
'__pycache__', '.next', '.cache', 'coverage', '.idea', '.vscode',
]);
const TREE_MAX = 500;
// 相对路径 → 会话根内的绝对路径。字面 + realpath 双重校验,防符号链接跳出会话目录。
@@ -122,7 +118,7 @@ router.get('/:id/tree', function (req, res) {
// mtimeMs 给前端判断空目录是否还是空的:目录内增删子项会更新它
let mtimeMs = null;
try { mtimeMs = fs.statSync(path.join(abs, e.name)).mtimeMs; } catch (_) {}
entries.push({ name: e.name, rel: childRel, type: 'dir', ignored: TREE_IGNORE_DIRS.has(e.name), mtimeMs: mtimeMs });
entries.push({ name: e.name, rel: childRel, type: 'dir', mtimeMs: mtimeMs });
} else if (e.isFile()) {
let size = null, mtimeMs = null;
try { const st = fs.statSync(path.join(abs, e.name)); size = st.size; mtimeMs = st.mtimeMs; } catch (_) {}
@@ -132,9 +128,8 @@ router.get('/:id/tree', function (req, res) {
} catch (err) {
return res.status(500).json({ error: String((err && err.message) || err) });
}
// 排序:正常目录 → 正常文件 → 被忽略的大目录(灰显沉底);同类按名称
// 排序:目录在前、文件在后;同类按名称
entries.sort((a, b) =>
(a.ignored ? 1 : 0) - (b.ignored ? 1 : 0) ||
(a.type === 'dir' ? 0 : 1) - (b.type === 'dir' ? 0 : 1) ||
(a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
res.json({
+5
View File
@@ -14,6 +14,7 @@ const wechat = require('./wechat');
const llm = require('./llm');
const mcp = require('./mcp');
const skills = require('./tools/skills');
const shellBackend = require('./shell');
const log = require('./log');
const cfg = loadConfig(process.env.AGENT_CONFIG);
@@ -243,6 +244,10 @@ mcp.init(cfg).then(async () => {
log.info('startup', ' auth=' + (auth.enabled ? 'login: ' + cfg.auth.users.map(u => u.user).join(', ') : '(disabled)'));
log.info('startup', ' wxbot=' + (cfg.wxbot.url && cfg.wxbot.token ? cfg.wxbot.url : '(未启用)'));
log.info('startup', ' log_level=' + cfg.log_level);
// 模型命令到底交给谁跑。硬定 shell 时这里是唯一的凭据(Windows 上尤其要看到);
// 探测不到就降成 warn——服务能起,但 terminal 工具会一片红。
if (shellBackend.resolve(cfg)) log.info('startup', ' terminal=' + shellBackend.describe(cfg));
else log.warn('startup', ' terminal=' + shellBackend.describe(cfg));
// 微信实例恢复 fire-and-forget:wxbot 没起只留日志,绝不阻塞/抛错影响启动。
wechat.restore().catch(e => log.warn('wechat', '启动恢复异常:' + (e && e.message || e)));
// prompt dump 失败不影响服务:只是核对用产物。
+226
View File
@@ -0,0 +1,226 @@
// 执行后端:全仓唯一处理「用哪个 shell 跑命令」「怎么杀整棵进程树」的地方。
//
// 为什么单开一层:POSIX 上 spawn('/bin/sh') + kill(-pid) 是刻意选的最强约束——
// /bin/sh 固定(不读 $SHELL,否则用户把 shell 设成 fish 后模型写的 POSIX 语法全废),
// 进程组让「停止」能一次带走模型起的孙进程(npm / python / ffmpeg 留下的才是麻烦)。
// Windows 没有 /bin/sh、没有进程组、也没有可发送的信号:同一个写法在那边从「有效」
// 变成「静默失效」,detached 还会多弹一个控制台。三种能力收敛成
// resolve / spawnShell / killTree,上层(terminal、skill、engine 取消)就不必出现平台分支。
//
// 默认行为与拆分前逐字节一致:不配任何 env 时仍是 /bin/sh -c + 进程组 +
// process.kill(-pid)。Windows 才走探测分支,探测不到就明确报错,绝不静默退回
// cmd.exe——cmd 的语法与模型写的 POSIX 差太远,静默降级只会让模型在报错里反复试错。
//
// 解析顺序(前面的赢,结果进程内缓存一次,与 config.js 的冷加载约定一致):
// 1. env AGENT_SHELL 显式指定可执行文件(绝对路径或 PATH 里的名字)
// 2. config.terminal.shell 同上,给不想碰 env 的部署方式
// 3. 自动探测 Windows:git-bash → busybox-w32 → 无
// POSIX :/bin/sh
// 4. env AGENT_SHELL_ARGS 覆盖参数模板(默认 -c,如 bash 想读 rc 可写 -lc)
// 另:env AGENT_GIT_BASH / AGENT_BUSYBOX 可指定各自的固定位置(便携安装用)。
const fs = require('fs');
const path = require('path');
const { spawn } = require('child_process');
const IS_WIN = process.platform === 'win32';
const INSTALL_HINT = IS_WIN
? 'Windows 需要 POSIX shell:装 Git for Windows(自带 bash),或把 busybox-w32 放到 local/bin/busybox.exe,'
+ '或用环境变量 AGENT_SHELL 指定 shell 路径'
: '需要 POSIX shell(/bin/sh 不存在)';
// MSYS(Git for Windows)默认会把「看起来像 Unix 路径」的参数改写成 Windows 路径
// (/c/foo → C:\foo)。模型的命令里 /tmp、/c、相对路径都可能被它悄悄改掉,
// 排查起来像"命令没生效"。关掉自动转换,让字节原样过去。
const MSYS_ENV = {
MSYS_NO_PATHCONV: '1', // Git for Windows 旧变量
MSYS2_ARG_CONV_EXCL: '*', // MSYS2 新变量
};
let cacheKey = null;
let cached; // 解析结果;null = 解析过但没有可用 shell
function trimStr(v) { return typeof v === 'string' ? v.trim() : ''; }
// 参数模板按 shell 习惯切成数组(支持引号),默认 ['-c']。
function splitArgs(s) {
const out = [];
let cur = '';
let quote = null;
for (const ch of String(s)) {
if (quote) { if (ch === quote) quote = null; else cur += ch; continue; }
if (ch === '"' || ch === "'") { quote = ch; continue; }
if (/\s/.test(ch)) { if (cur) { out.push(cur); cur = ''; } continue; }
cur += ch;
}
if (cur) out.push(cur);
return out;
}
function shellArgs() {
const custom = trimStr(process.env.AGENT_SHELL_ARGS);
return custom ? splitArgs(custom) : ['-c'];
}
function existsExec(p) {
try {
if (!fs.statSync(p).isFile()) return false;
if (!IS_WIN) fs.accessSync(p, fs.constants.X_OK);
return true;
} catch (_) {
return false;
}
}
// 自己遍历 PATH,不调 where.exe:少一次进程启动,也避开 where 的输出编码差异。
function whichWin(name) {
const exts = /\.\w+$/.test(name) ? [''] : ['', '.exe', '.cmd', '.bat'];
for (const dir of String(process.env.PATH || '').split(path.delimiter)) {
if (!dir) continue;
for (const ext of exts) {
const p = path.join(dir, name + ext);
if (existsExec(p)) return p;
}
}
return null;
}
// Git for Windows 的 bash。C:\Windows\System32\bash.exe 是 WSL 启动器,明确排除:
// 它的 -c 之后是 Linux 命令,路径全在另一个文件系统里,拿它当 shell 会让每个命令都跑偏。
function findGitBash() {
const e = process.env;
const cands = [
e.AGENT_GIT_BASH,
e.ProgramFiles && path.join(e.ProgramFiles, 'Git', 'bin', 'bash.exe'),
e['ProgramFiles(x86)'] && path.join(e['ProgramFiles(x86)'], 'Git', 'bin', 'bash.exe'),
e.LOCALAPPDATA && path.join(e.LOCALAPPDATA, 'Programs', 'Git', 'bin', 'bash.exe'),
e.USERPROFILE && path.join(e.USERPROFILE, 'scoop', 'apps', 'git', 'current', 'bin', 'bash.exe'),
e.ProgramData && path.join(e.ProgramData, 'chocolatey', 'bin', 'bash.exe'),
whichWin('bash.exe'),
];
for (const c of cands) {
if (!c) continue;
if (/\\windows\\(system32|winsxs)\\/i.test(c) || /\\windowsapps\\/i.test(c)) continue;
if (existsExec(c)) return c;
}
return null;
}
// busybox-w32:单文件原生 exe(约 600KB),需要 `busybox sh -c` 的 applet 形式。
// 固定位置放在仓库 local/bin/,由启动器下载——不进系统 PATH,卸载即净。
function findBusybox() {
const e = process.env;
const cands = [
e.AGENT_BUSYBOX,
path.join(__dirname, '..', '..', 'local', 'bin', 'busybox.exe'),
whichWin('busybox.exe'),
];
for (const c of cands) {
if (c && existsExec(c)) return c;
}
return null;
}
function posixDefault() {
return { cmd: '/bin/sh', args: shellArgs(), kind: 'sh', source: 'default', env: null, detached: true };
}
function fromExplicit(p) {
const args = shellArgs();
const busybox = /busybox/i.test(path.basename(p));
return {
cmd: p,
// busybox 是多 applet 单文件:必须点名 sh,否则 argv[0] 是 busybox 时它会当自己的子命令解析。
args: busybox ? ['sh', ...args] : args,
kind: busybox ? 'busybox' : 'bash',
source: 'explicit',
env: IS_WIN ? MSYS_ENV : null,
// POSIX 必须 detached(进程组是 killTree 的抓手);Windows 上开 detached 会新建控制台
// 并让子进程脱离 taskkill /T 的父子树,所以那边明确关掉。
detached: !IS_WIN,
};
}
function detectWindows() {
const bash = findGitBash();
if (bash) {
return { cmd: bash, args: shellArgs(), kind: 'bash', source: 'git-bash', env: MSYS_ENV, detached: false };
}
const bb = findBusybox();
if (bb) {
return { cmd: bb, args: ['sh', ...shellArgs()], kind: 'busybox', source: 'busybox-w32', env: null, detached: false };
}
return null;
}
function detect(cfg) {
const explicit = trimStr(process.env.AGENT_SHELL)
|| trimStr(cfg && cfg.terminal && cfg.terminal.shell);
if (explicit) return fromExplicit(explicit);
if (!IS_WIN) return posixDefault();
return detectWindows();
}
// 解析结果(对象形态,含 cmd/args/kind/source/env/detached)。没有可用 shell 时返回 null。
// 缓存键跟着「显式指定」的三个来源走:同一个进程里 cfg 或 env 变了会重新探测,
// 避免第一次调用(可能没有 cfg,比如技能层)把结果钉死。
function resolve(cfg) {
const key = [
trimStr(process.env.AGENT_SHELL),
trimStr(process.env.AGENT_SHELL_ARGS),
trimStr(cfg && cfg.terminal && cfg.terminal.shell),
].join('\u0000');
if (cacheKey !== key) {
cacheKey = key;
cached = detect(cfg);
}
return cached;
}
// 重新探测(测试与「改完立即生效」用;正常运行不需要调)。
function reset() { cacheKey = null; cached = undefined; }
function spawnShell(cfg, command, opts) {
const o = opts || {};
const sh = resolve(cfg);
if (!sh) throw new Error('执行后端不可用:' + INSTALL_HINT);
const env = sh.env ? { ...process.env, ...sh.env, ...(o.env || {}) } : { ...process.env, ...(o.env || {}) };
return spawn(sh.cmd, [...sh.args, String(command)], {
cwd: o.cwd,
env,
detached: sh.detached,
// 仅 Windows 生效:detached 之外的第二道保险,避免每条命令弹一个控制台窗口。
windowsHide: true,
});
}
// 杀整棵进程树。POSIX 走进程组(原来那两行原样保留);Windows 没有进程组,
// 用 taskkill /T 按父子树杀——不能用 child.kill(),那只会杀 shell 本身,
// 模型起的 node/python/ffmpeg 孙进程会留下来继续占端口。
function killTree(child) {
if (!child || !child.pid) return false;
if (!IS_WIN) {
try { process.kill(-child.pid, 'SIGKILL'); return true; } catch (_) {
try { child.kill('SIGKILL'); return true; } catch (__) { return false; }
}
}
try {
const p = spawn('taskkill', ['/T', '/F', '/PID', String(child.pid)], { stdio: 'ignore', windowsHide: true });
p.on('error', () => {});
p.unref();
return true;
} catch (_) {
try { child.kill(); return true; } catch (__) { return false; }
}
}
// 一行诊断(启动日志 / 健康检查用):告诉人「模型命令到底交给谁跑」。
function describe(cfg) {
const sh = resolve(cfg);
if (!sh) return '未找到(' + INSTALL_HINT + ')';
const args = sh.args.join(' ');
return sh.cmd + ' ' + args + ' ← ' + sh.source;
}
module.exports = { resolve, reset, spawnShell, killTree, describe, INSTALL_HINT };
+43 -3
View File
@@ -5,6 +5,31 @@ function createBus() {
const clients = new Map(); // session_id -> Set<res>
const internal = new Set(); // fn(sessionId, event, data)
// 高频事件的合并缓冲:LLM 每吐一个 token 就是一条 assistant_delta,一次 res.write 就是一个
// TCP 包(Node 默认 TCP_NODELAY)。手机热点 / 跨境链路上包数比字节数更伤——每包都要射频调度,
// 拥塞窗口也容易被小包拖住。摍 50ms 或 8 条合并成一次 write。
// 其他事件立即发,但发前先 flush,保证前端看到的顺序和产生顺序一致。
const MERGE_EVENTS = new Set(['assistant_delta', 'reasoning_delta', 'tool_call_args']);
const FLUSH_MS = 50;
const FLUSH_COUNT = 8;
const pending = new Map(); // session_id -> { parts: string[], timer }
function writeAll(sessionId, payload) {
const set = clients.get(sessionId);
if (!set || set.size === 0) return;
for (const res of Array.from(set)) {
try { res.write(payload); } catch (_) { removeClient(sessionId, res); }
}
}
function flush(sessionId) {
const p = pending.get(sessionId);
if (!p) return;
pending.delete(sessionId);
if (p.timer) { clearTimeout(p.timer); p.timer = null; }
if (p.parts.length) writeAll(sessionId, p.parts.join(''));
}
function onInternal(fn) {
internal.add(fn);
return () => internal.delete(fn);
@@ -19,7 +44,10 @@ function createBus() {
const set = clients.get(sessionId);
if (!set) return;
set.delete(res);
if (set.size === 0) clients.delete(sessionId);
if (set.size === 0) {
clients.delete(sessionId);
flush(sessionId); // 没人看了,把还摍着的清掉,避免 pending 常驻
}
}
// event 名称 + 任意 JSON data。无客户端时静默丢弃(消息本身已持久化,重连可回放)。
@@ -32,13 +60,25 @@ function createBus() {
}
const set = clients.get(sessionId);
if (!set || set.size === 0) return;
const payload = 'event: ' + event + '\ndata: ' + JSON.stringify(data) + '\n\n';
for (const res of Array.from(set)) {
try { res.write(payload); } catch (_) { removeClient(sessionId, res); }
if (MERGE_EVENTS.has(event)) {
let p = pending.get(sessionId);
if (!p) { p = { parts: [], timer: null }; pending.set(sessionId, p); }
p.parts.push(payload);
if (p.parts.length >= FLUSH_COUNT) { flush(sessionId); return; }
if (!p.timer) p.timer = setTimeout(() => flush(sessionId), FLUSH_MS);
return;
}
// 非合并事件:先把摍着的发掉,保证顺序不乱
flush(sessionId);
writeAll(sessionId, payload);
}
function closeAll(sessionId) {
flush(sessionId);
const set = clients.get(sessionId);
if (!set) return;
for (const res of Array.from(set)) {
+5 -7
View File
@@ -5,7 +5,7 @@ const path = require('path');
const net = require('net'); // fetch SSRF 防护:IP 字面量/解析结果判私网
const dns = require('dns').promises; // 同上:主机名 → IP 后统一判定
const fsp = require('fs').promises;
const { spawn } = require('child_process');
const shell = require('../shell'); // 执行后端:shell 解析 + 进程树 kill(平台差异只在那边,这里不做分支)
const mcp = require('../mcp');
const skills = require('./skills');
const Database = require('better-sqlite3'); // db 工具:会话目录下的 data.db(同步 API,与单进程模型契合)
@@ -764,7 +764,7 @@ function selectOutput(text, head, tail) {
return parts.join('\n\n');
}
// terminal:spawn + 进程组 kill + 超时 + 输出截断
// terminal:交执行后端起 shell(POSIX 默认 /bin/sh -c,Windows 由 shell.js 探测)+ 超时 + 输出截断
// 通用终端输出 UI 卡片通道:命令行尾部的 ::ui_card {json}:: 标记行 → 从模型面剥离,整块交 ctx.onCard
// (与 MCP 回包 ui_card 块同一协议,见 mcp.js:任何命令行都可产卡,不限 officecli 封装层)。
// JSON 解析失败/无 action/ctx 不带 onCard 时标记行原样保留(宁可见不丢数据)。
@@ -809,7 +809,7 @@ async function toolTerminal(ctx, args) {
}
return new Promise((resolve) => {
const child = spawn('/bin/sh', ['-c', args.command], { cwd, detached: true, env: process.env });
const child = shell.spawnShell(cfg, args.command, { cwd });
ctx.run.procs.add(child);
let out = '';
let killedBy = null; // 'timeout' | 'cancelled'
@@ -853,10 +853,8 @@ async function toolTerminal(ctx, args) {
}
function killGroup(child) {
if (!child.pid) return;
try { process.kill(-child.pid, 'SIGKILL'); } catch (_) {
try { child.kill('SIGKILL'); } catch (__) {}
}
// 平台差异交给执行后端:POSIX 杀进程组,Windows 走 taskkill /T 杀进程树。
shell.killTree(child);
}
// fetch:抓取并转 Markdown。超时/取消覆盖到 body 读取完成(非仅响应头);
+5 -3
View File
@@ -14,6 +14,7 @@ const { spawn } = require('child_process');
const YAML = require('yaml');
const log = require('../log');
const rexec = require('../remote-exec');
const shell = require('../shell'); // 本地 spawn 技能时的进程树 kill(平台差异只在 shell.js)
// mode=skill 的 MCP 工具在 get/run 时由 core 直接转发;mcp.js 只依赖 ./log,不成环。
const mcp = require('../mcp');
@@ -187,7 +188,8 @@ function runEntry(ctx, entry, args, cwd, timeoutMs) {
});
}
return new Promise((resolve, reject) => {
const child = spawn(entry, args, { cwd, env: process.env, detached: true });
// windowsHide:Windows 上 detached 之外的第二道保险,避免弹控制台;POSIX 忽略该选项。
const child = spawn(entry, args, { cwd, env: process.env, detached: true, windowsHide: true });
if (ctx.run && ctx.run.procs) ctx.run.procs.add(child);
let out = '';
let settled = false;
@@ -200,7 +202,7 @@ function runEntry(ctx, entry, args, cwd, timeoutMs) {
settled = true;
clearInterval(cancelCheck);
if (ctx.run && ctx.run.procs) ctx.run.procs.delete(child);
try { process.kill(-child.pid, 'SIGKILL'); } catch (_) { try { child.kill('SIGKILL'); } catch (__) {} }
shell.killTree(child);
reject(new SkillExecutionError('技能执行超时(' + timeoutMs + 'ms)已终止:\n' + out.trim(), -1));
}, timeoutMs);
@@ -209,7 +211,7 @@ function runEntry(ctx, entry, args, cwd, timeoutMs) {
settled = true;
clearTimeout(timer);
if (ctx.run && ctx.run.procs) ctx.run.procs.delete(child);
try { process.kill(-child.pid, 'SIGKILL'); } catch (_) { try { child.kill('SIGKILL'); } catch (__) {} }
shell.killTree(child);
reject(new SkillExecutionError('技能执行被用户终止', -1));
}
}, 200);
+61
View File
@@ -63,6 +63,63 @@ cd agent
这个页面是纯静态文件(不用起服务),所以“node 都没装”的时候也能打开。重跑脚本会重新生成;
即使没自动弹出,文件也一直在那个路径。
## Windows
需要 Node 20+(不需要 Docker,也不需要装 Git):
```bat
node local\start-win.mjs
node local\start-win.mjs --workspace=D:\AgentWork --port=8090
```
首次运行会:
1. 自检 Node 版本
2. **找命令执行环境**:优先用已装的 Git for Windows(自带 bash);没有再自动下载
[busybox-w32](https://frippery.org/busybox)(单文件约 600KB)到 `local/bin/busybox.exe`
3. 建工作目录(默认 `%USERPROFILE%\AgentWork`,`--workspace` 可改)下的 `tasks/` `data/` `skills/`
4. 生成 `local/config.win.yml`(**首次生成,之后永不覆盖**)
5. 把仓库 `skills/` 里的内置技能补过去(只补缺不覆盖)
6. `app/node_modules` 缺失时 `npm install`
7. 起 core 并守护(退出 3 秒后自动重启,连崩 5 次停)
浏览器开 `http://127.0.0.1:8090`,到「设置 → 模型池」加平台和 API Key。
**停止:Ctrl+C**(没有 `stop.sh`,启动器就是前台进程)。`--check` 只做自检不启动。
### 为什么 Windows 是另一条代码路径
`start.sh` 靠 `lsof` / `pgrep` / `readlink -f` / `nohup` / `setsid` / 进程组信号,Windows 一个都没有。
所以那 1100 多行 bash 没有移植,而是用 Node 重写了「启动器」这一层——它本来就只做进程管理,
不需要 shell。**业务代码一行都不分平台**:平台差异只落在两个文件里:
| 文件 | 负责 |
|---|---|
| `app/server/shell.js` | 用哪个 shell 跑命令、怎么杀进程树(POSIX 进程组 / Windows `taskkill /T`) |
| `local/start-win.mjs` | 探测、下载 busybox、生成配置、起进程、守护 |
### 覆盖与排错
| 变量 | 作用 |
|---|---|
| `AGENT_SHELL` | 直接指定 shell(绝对路径或 PATH 名),跳过一切探测 |
| `AGENT_SHELL_ARGS` | 参数模板,默认 `-c`(如 bash 想读 rc 可写 `-lc`) |
| `AGENT_GIT_BASH` | 指定 git-bash 位置(便携版/非标准安装路径) |
| `AGENT_BUSYBOX` | 指定 busybox.exe 位置 |
| `AGENT_BUSYBOX_URL` | 换 busybox 下载源(国内网络) |
命令到底交给了谁跑:启动日志里有一行 `terminal=...`,失败时会写成 `terminal=未找到(...)`。
### Windows 上仍有的限制
- **四个同栈 MCP 没有自动拉起**(配置里 `mcp_servers: []`):网页搜索/图片/视频/语音暂不可用,
`terminal`、文件工具、技能正常。
- **office 预览网关没起**:docx/xlsx/pptx 不能在线预览,但 `office` 技能生成文件不受影响。
- **没有沙箱**:和 macOS/Linux 本地模式一样,AI 的 `terminal` 就是你的 shell,能读写你有权限的任何文件。
工作目录选专用的,别选 `C:\` 或整个仓库。
- **`chmod` / `ln -s` 这类不生效**:Windows 没有 POSIX 权限位;模型写这类命令会“成功但什么都没做”。
- **`/tmp` 不是 Linux 的 `/tmp`**:busybox 会把它当当前盘根目录(`C:\tmp`),git-bash 映射到 `%TEMP%`。
模型最好用相对路径或会话目录。
## 可选能力
| 能力 | 需要 | 没有时的表现 |
@@ -72,6 +129,7 @@ cd agent
| Office 文档(docx/xlsx/pptx) | 首次用到时下载一次 officecli 二进制(约 34MB) | `office` 报 `binary missing` 并给出该技能 `AGENTS.md` 的路径,按它下载即可(不需 root、不需重启);预览面板里直接显示同一份安装说明 |
| 网页搜索 | 无 | 装了 Node 就有(内置免费后端) |
| 图片 / 视频生成 | 设置页给对应 MCP 填上游 key | 调用时报明确的缺参错误 |
| 反向隧道 | `tunnel/client.yml`(服务器地址 + token) | `start.sh` 跳过,不占端口;配置说明见 `tunnel/README.md` |
装完 `ffmpeg` 之后**重跑一次 `./local/start.sh`** 即可生效。`python3` 稍特殊:技能清单本来就在,
只要新装的解释器落在 core 启动时 `PATH` 已包含的目录里(如 brew 的 `/opt/homebrew/bin`)就无需重启;
@@ -144,6 +202,9 @@ git pull
另外,`core` 只监听 `127.0.0.1`,同一局域网的人访问不到。
配了隧道后,core 会经隧道 client 暴露到公网域名。访问控制靠隧道 token + 上游 nginx 的 TLS;
入口仍是 `127.0.0.1:8090`,不额外监听端口。
## 已知限制
- **没 ffmpeg 时 core 日志会有一条 `asr 工具发现失败`**:此时 `mcp_asr` 不启动(它转码要靠
+324
View File
@@ -0,0 +1,324 @@
#!/usr/bin/env node
// Windows 本机模式启动器(macOS / Linux 用 local/start.sh,两者注入同一组环境变量)。
//
// 为什么单独一个 Node 脚本:start.sh 那 1100 多行 bash 靠的是 lsof / pgrep / readlink -f /
// nohup / setsid / 进程组信号,Windows 一个都没有。与其在 Windows 上凑一套半残的 POSIX 环境,
// 不如用 Node 重写"启动器"这一层——它本来就只做进程管理,不需要 shell。
// 业务代码(app/server)一行都不分平台,平台差异只落在 app/server/shell.js 与这个文件里。
//
// 做的事,按顺序:
// 1. 自检(Node 20+)
// 2. 找 POSIX 命令执行环境:git-bash → 已有的 busybox-w32 → 都没有就下载 busybox-w32
// 3. 首次运行生成工作目录与 local/config.win.yml(之后永不覆盖)
// 4. 补技能(只补缺,不覆盖)
// 5. app/node_modules 缺失时 npm install
// 6. 拉起 core 并守护(退出自动重启)
//
// 用法:
// node local/start-win.mjs # 默认工作目录 %USERPROFILE%\AgentWork
// node local/start-win.mjs --workspace=D:\ai # 指定工作目录
// node local/start-win.mjs --check # 只做自检与探测,不启动
// node local/start-win.mjs --port=8090 --no-open
import fs from 'node:fs';
import path from 'node:path';
import os from 'node:os';
import { spawn, spawnSync } from 'node:child_process';
import { createRequire } from 'node:module';
import { fileURLToPath } from 'node:url';
const require = createRequire(import.meta.url);
const shellBackend = require('../app/server/shell.js');
const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
const IS_WIN = process.platform === 'win32';
const BUSYBOX_PATH = path.join(ROOT, 'local', 'bin', 'busybox.exe');
const CONFIG_PATH = path.join(ROOT, 'local', 'config.win.yml');
// ---------- 小工具 ----------
const C = { ok: '\x1b[32m', warn: '\x1b[33m', err: '\x1b[31m', dim: '\x1b[2m', n: '\x1b[0m' };
const say = (s) => console.log(`${C.ok}==>${C.n} ${s}`);
const warn = (s) => console.log(`${C.warn}[!]${C.n} ${s}`);
const dim = (s) => console.log(`${C.dim} ${s}${C.n}`);
function die(s, hint) {
console.error(`${C.err}[x]${C.n} ${s}`);
if (hint) console.error(` ${hint}`);
process.exit(1);
}
// ---------- 参数 ----------
const opt = { workspace: '', port: 8090, open: true, check: false };
for (const a of process.argv.slice(2)) {
if (a.startsWith('--workspace=')) opt.workspace = a.slice('--workspace='.length);
else if (a.startsWith('--port=')) opt.port = Number(a.slice('--port='.length)) || 8090;
else if (a === '--no-open') opt.open = false;
else if (a === '--check') opt.check = true;
else if (a === '-h' || a === '--help') {
console.log('用法: node local/start-win.mjs [--workspace=<目录>] [--port=8090] [--no-open] [--check]');
process.exit(0);
} else die(`未知参数:${a}`);
}
// ---------- 1. 自检 ----------
function checkNode() {
const major = Number(String(process.versions.node).split('.')[0]);
if (major < 20) die(`需要 Node.js 20+,当前 ${process.version}`, '装新版:https://nodejs.org/ 或 winget install OpenJS.NodeJS.LTS');
say(`Node ${process.version}(${process.arch})`);
if (!IS_WIN) warn('当前不是 Windows:这个启动器只是 Windows 用;macOS/Linux 请用 local/start.sh');
}
// ---------- 2. 命令执行环境 ----------
// 优先级由 app/server/shell.js 决定(AGENT_SHELL > 配置 > git-bash > busybox-w32)。
// 这里只负责"没有就补一个":装到 local/bin/busybox.exe,core 那边按固定路径探测得到。
async function ensureShell() {
shellBackend.reset();
const found = shellBackend.resolve({});
if (found) {
say(`命令执行环境:${shellBackend.describe({})}`);
return found;
}
if (!IS_WIN) die('找不到 POSIX shell(/bin/sh)', '这个启动器是 Windows 用的;macOS/Linux 用 local/start.sh');
warn('没有找到 POSIX shell(git-bash 与 busybox-w32 都不在)');
say('下载 busybox-w32(单文件,约 600KB,不需要管理员权限)');
await downloadBusybox();
shellBackend.reset();
const after = shellBackend.resolve({});
if (!after) die('busybox-w32 装好了但仍探测不到', `检查文件是否存在且可执行:${BUSYBOX_PATH}`);
say(`命令执行环境:${shellBackend.describe({})}`);
return after;
}
// busybox-w32 官方发布页永远指向同一个 busybox.exe;国内下载不顺时可自行换源。
// 全部候选都失败就明确报错并给出"手动放文件"的一步操作,不静默降级到 cmd.exe。
async function downloadBusybox() {
const urls = [];
if (process.env.AGENT_BUSYBOX_URL) urls.push(process.env.AGENT_BUSYBOX_URL);
urls.push('https://frippery.org/files/busybox/busybox.exe');
// 备用源:GitHub Release(release 资产名固定为 busybox.exe)。国内直连 GitHub 慢时
// 自动走 gh-proxy 前缀重试,两者都失败才放弃。
try {
const gh = await githubBusyboxUrl();
if (gh) urls.push(gh, 'https://gh-proxy.com/' + gh);
} catch (_) { /* 拿不到 latest 就只试官方源 */ }
fs.mkdirSync(path.dirname(BUSYBOX_PATH), { recursive: true });
const tmp = BUSYBOX_PATH + '.download';
let lastErr = '';
for (const u of urls) {
try {
process.stdout.write(` ${u}\n `);
await fetchToFile(u, tmp);
// 只读前两个字节校验 PE 头,不把整个文件读进内存。
const fd = fs.openSync(tmp, 'r');
const head = Buffer.alloc(2);
fs.readSync(fd, head, 0, 2, 0);
fs.closeSync(fd);
if (head.toString('latin1') !== 'MZ') throw new Error('下载到的不是 Windows 可执行文件(缺 MZ 头)');
fs.renameSync(tmp, BUSYBOX_PATH);
console.log('');
say(`已安装 ${BUSYBOX_PATH}`);
return;
} catch (e) {
lastErr = e.message;
console.log(` 失败:${e.message}`);
try { fs.unlinkSync(tmp); } catch (_) { /* 没下载成功就没有临时文件 */ }
}
}
die('busybox-w32 下载失败:' + lastErr,
`手动下载 https://frippery.org/files/busybox/busybox.exe 存成 ${BUSYBOX_PATH} 后重跑本脚本;`
+ '或先装 Git for Windows(自带 bash,会被自动识别)');
}
async function githubBusyboxUrl() {
const r = await fetch('https://api.github.com/repos/rmyorston/busybox-w32/releases/latest', {
headers: { 'User-Agent': 'agent-local-launcher' },
signal: AbortSignal.timeout(8000),
});
if (!r.ok) return null;
const j = await r.json();
const asset = (j.assets || []).find(a => /busybox\.exe$/i.test(a.name));
return asset ? asset.browser_download_url : null;
}
// 带进度地下载(内容长度已知时打百分比;不知道就只打字节数)。
async function fetchToFile(url, dest) {
const r = await fetch(url, {
headers: { 'User-Agent': 'agent-local-launcher' },
signal: AbortSignal.timeout(120000),
redirect: 'follow',
});
if (!r.ok) throw new Error(`HTTP ${r.status}`);
const total = Number(r.headers.get('content-length') || 0);
const out = fs.createWriteStream(dest);
let got = 0;
for await (const chunk of r.body) {
got += chunk.length;
if (!out.write(chunk)) await new Promise(res => out.once('drain', res));
if (total) process.stdout.write(`\r ${(got / 1024).toFixed(0)}KB / ${(total / 1024).toFixed(0)}KB`);
}
await new Promise((res, rej) => out.end(err => (err ? rej(err) : res())));
if (total && got !== total) throw new Error(`下载不完整(${got}/${total} 字节)`);
if (got < 200 * 1024) throw new Error(`文件太小(${got} 字节),大概率不是 busybox`);
}
// ---------- 3. 工作目录与配置 ----------
function ensureWorkspace() {
const ws = path.resolve(opt.workspace || path.join(os.homedir(), 'AgentWork'));
const dirs = {
root: ws,
tasks: path.join(ws, 'tasks'),
data: path.join(ws, 'data'),
skills: path.join(ws, 'skills'),
};
for (const d of [dirs.tasks, dirs.data, dirs.skills]) fs.mkdirSync(d, { recursive: true });
say(`工作目录:${ws}`);
return dirs;
}
function ensureConfig(dirs) {
if (fs.existsSync(CONFIG_PATH)) {
dim(`复用已有配置 ${CONFIG_PATH}(不会覆盖你在网页里改的模型与密钥)`);
return;
}
// YAML 里统一用正斜杠:Node 与 YAML 都不需要转义,反斜杠反而要写两遍。
const p = (s) => s.replace(/\\/g, '/');
const yml = `# 由 local/start-win.mjs 首次生成,之后不再覆盖。
# 字段含义与服务器版一致(见 app/config.example.yml),这里只列本机模式用到的部分。
port: ${opt.port}
# AI 的工作根:文件工具的根就是它,AI 看不到同级的 data/ 与 skills/。
workspace_root: "${p(dirs.tasks)}"
# SQLite(.agent.db)与启动 prompt dump。
data_root: "${p(dirs.data)}"
skills:
# 内置技能由启动器首次复制过来,之后只补缺不覆盖;pip 装的依赖落在同级的 deps/。
skills_root: "${p(dirs.skills)}"
# 留空:启动后到设置页添加平台与 API Key,再点「重启」(启动器负责把进程拉起来)。
platforms: []
log_level: info
# 同栈 MCP(网页搜索 / 图片 / 视频 / 语音)暂未由 Windows 启动器拉起,
# 需要时在设置页按卡片添加地址,或先用 local/start.sh 的机器上那份配置。
mcp_servers: []
`;
fs.writeFileSync(CONFIG_PATH, yml, 'utf8');
say(`已生成配置 ${CONFIG_PATH}`);
}
// ---------- 4. 技能 ----------
// 只补缺不覆盖:用户改过的技能、自己新建的技能都不能被启动器冲掉(与 start.sh 同语义)。
function syncSkills(dirs) {
const src = path.join(ROOT, 'skills');
if (!fs.existsSync(src)) return;
let copied = 0;
for (const name of fs.readdirSync(src)) {
if (name === 'deps' || name.startsWith('.')) continue; // deps 是依赖层,按技能各自安装
const from = path.join(src, name);
const to = path.join(dirs.skills, name);
if (!fs.statSync(from).isDirectory() || fs.existsSync(to)) continue;
fs.cpSync(from, to, { recursive: true });
copied++;
}
say(copied ? `补齐技能 ${copied} 个` : '技能已是最新(不覆盖已有目录)');
}
// ---------- 5. 依赖 ----------
function ensureDeps() {
const appDir = path.join(ROOT, 'app');
if (fs.existsSync(path.join(appDir, 'node_modules', 'better-sqlite3'))) return;
warn('首次运行需要安装 Node 依赖(app/node_modules 缺失)');
const npm = IS_WIN ? 'npm.cmd' : 'npm';
const r = spawnSync(npm, ['install'], { cwd: appDir, stdio: 'inherit', shell: IS_WIN });
if (r.status !== 0) {
die('npm install 失败',
'国内网络可先换源:npm config set registry https://registry.npmmirror.com 后重试');
}
}
// ---------- 6. 起 core 并守护 ----------
function envFor(shell, dirs) {
const deps = path.join(dirs.skills, 'deps');
fs.mkdirSync(deps, { recursive: true });
return {
...process.env,
PORT: String(opt.port),
HOST: '127.0.0.1', // 本机模式只听回环(与 start.sh 一致)
AGENT_CONFIG: CONFIG_PATH,
AGENT_FILE_SCOPE: 'workspace', // 文件工具的根放宽到工作目录(本地单用户形态)
AGENT_LOCAL_PICK: '1',
AGENT_IMAGE_INLINE: '1', // 回环地址厂商拉不到,读图改内联 base64
PYTHONPATH: deps,
AGENT_SKILLS_DEPS: deps,
// 启动器探测到的 shell 直接钉给 core:两边 PATH 可能略有差异,钉住可避免"启动器说
// 用 git-bash、core 里却探测成 busybox"这种难查的双份事实。
AGENT_SHELL: shell.cmd,
};
}
function openBrowser(url) {
if (!opt.open) return;
try {
if (IS_WIN) spawn('cmd', ['/c', 'start', '', url], { stdio: 'ignore', windowsHide: true, detached: true }).unref();
else if (process.platform === 'darwin') spawn('open', [url], { stdio: 'ignore', detached: true }).unref();
else spawn('xdg-open', [url], { stdio: 'ignore', detached: true }).unref();
} catch (_) { /* 打不开浏览器不影响服务 */ }
}
function startCore(shell, dirs) {
const env = envFor(shell, dirs);
const appDir = path.join(ROOT, 'app');
let stopping = false;
let restarts = 0;
let child = null;
const launch = () => {
child = spawn(process.execPath, ['server/server.js'], { cwd: appDir, env, stdio: 'inherit' });
child.on('exit', (code) => {
if (stopping) return;
restarts++;
// 连续崩 5 次就停:多半是配置错(端口被占 / 模型池空),无限重启只会刷屏。
if (restarts > 5) die(`core 连续退出 5 次(最后退出码 ${code})`, '看上面的报错;常见原因:端口被占用、config.win.yml 写错');
warn(`core 退出了(code=${code}),3 秒后重启(第 ${restarts} 次)`);
setTimeout(launch, 3000);
});
};
const stop = () => {
stopping = true;
if (child && child.pid) shellBackend.killTree(child);
process.exit(0);
};
process.on('SIGINT', stop);
process.on('SIGTERM', stop);
launch();
const url = `http://127.0.0.1:${opt.port}`;
setTimeout(() => openBrowser(url), 1500);
say(`启动完成:${url}(Ctrl+C 停止)`);
}
// ---------- 主流程 ----------
(async () => {
checkNode();
const shell = await ensureShell();
const dirs = ensureWorkspace();
ensureConfig(dirs);
syncSkills(dirs);
if (opt.check) {
say('自检完成(--check 不启动服务)');
dim(`配置:${CONFIG_PATH}`);
dim(`命令执行环境:${shellBackend.describe({})}`);
return;
}
ensureDeps();
startCore(shell, dirs);
})();
+10 -8
View File
@@ -6,7 +6,7 @@
|---|---|---|---|---|
| `web_search/` | `mcp_web_search` | 网页搜索(默认免费 Parallel / Exa,可换成自建 `/search` 上游) | `3000` | `POST /` |
| `image_task/` | `mcp_image_task` | 图片生成 / 编辑(文生图走 `/images/generations`,图生图走 `/images/edits`,单工具 op=create/get) | `3000` | `POST /mcp` |
| `video_task/` | `mcp_video_task` | 智谱 CogVideo 视频生成(异步,单工具 op=create/get) | `3000` | `POST /mcp` |
| `video_task/` | `mcp_video_task` | 视频生成(任意 OpenAI 兼容 `/videos` 上游,异步,单工具 op=create/get) | `3000` | `POST /mcp` |
| `asr/` | `mcp_asr` | 语音转文字(上游 OpenAI 兼容 `/audio/transcriptions`),**额外带一个给输入框用的 `POST /transcribe`** | `3000` | `POST /mcp` |
**这些服务一个宿主机端口都不占**——它们只挂在 `agent-mcp-net` 上,由 `agent-core` / `agent-executor`
@@ -50,7 +50,9 @@ mcp_servers:
> 从旧的「agent + mcp 双仓库」部署升级:先在旧 mcp 仓库目录 `docker compose down`(只需一次,否则同名容器与网络会冲突),再 `up` 本栈。
`image_task` / `video_task` 的 token **不由服务端保存**——每个请求从 `Authorization` header 读取
(agent 侧配在 `config.yml` 的 `mcp_servers[].headers`)。`video_task` 用智谱 token;
(agent 侧配在 `config.yml` 的 `mcp_servers[].headers`)。`video_task` 走任意 OpenAI 兼容的 videos 上游:
提交 `/videos/generations`、查询 `/videos/{task_id}`,地址与模型由 `X-Video-Task-Base-Url` /
`X-Video-Task-Model` 指定(两者都必填);
`image_task` 走任意 OpenAI 兼容的 images 上游:文生图 `/images/generations`、图生图 `/images/edits`,
上游地址与模型分别由 `X-Image-Task-Base-Url` / `X-Image-Task-Model` 指定(两者都必填)。
所以这两个服务不用配任何密钥。
@@ -71,23 +73,23 @@ mcp_servers:
本栈默认不给 MCP 服务映射宿主机端口(它们只在 `agent-mcp-net` 内网可达)。要从宿主机直连,
自行在 `docker-compose.yml` 给对应服务加 `ports` 即可。
## 图片是怎么到智谱手上的(只有 video_task 关心)
## 图片是怎么到上游的(只有 video_task 关心)
智谱服务器生成视频前要**自己来拉参考图**,它不带 cookie、不带 `Authorization`。这套链路里**没有任何人上传文件**:
上游生成视频前要**自己来拉参考图**,它不带 cookie、不带 `Authorization`。这套链路里**没有任何人上传文件**:
```
AI ──调用 agent 内置的「公开临时 URL」工具(直接传文件路径)──► 拿到一条短命公网 URL
│
▼
AI 把拿到的 URL 当 image_url 交给 video_task:3000/mcp
AI 把拿到的 URL 当 image_url 交给 video_task:3000/mcp(转发为上游的 image 字段)
│
▼
智谱 ──匿名 GET──► agent 侧提供的公开临时 URL
那个文件始终躺在 agent 的任务目录里,零拷贝
上游 ──匿名 GET──► agent 侧提供的公开临时 URL
那个文件始终躺在 agent 的任务目录里,零拷贝
```
- 签发与托管全在 agent 侧(它已集成为一个 tool,AI 直接调用即可,不需要 curl 任何内网入口)。
- 链接短命:到期或 agent 重启后失效;智谱只在提交任务那一刻拉一次图,完全够用。
- 链接短命:到期或 agent 重启后失效;上游只在提交任务那一刻拉一次图,完全够用。
- mcp 这三家一个端口都不露,唯一公网可达的东西只有 agent 自己。
## 端口与安全
+101 -228
View File
@@ -1,13 +1,15 @@
# MCP Video Task
基于 [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) 的视频生成服务,对接智谱 BigModel 的视频生成**异步**接口,支持**文生视频**和**图生视频**。只有一个工具 `video_task`,用 `op` 区分动作:`op=create` 提交任务、`op=get` 单次查询结果。Server **不内部轮询**——AI 拿到 `task_id` 后自己决定什么时候用 `op="get"` 复查。
对接**任意 OpenAI 兼容的视频生成端点**:提交走 `POST {base}/videos/generations`,查询走
`GET {base}/videos/{task_id}`。对外只有一个工具 `video_task`,用 `op` 区分动作:
- 协议:MCP **Streamable HTTP**(单端点 `/mcp`,支持 SSE 流)
- 上游:[智谱 BigModel 视频生成(异步)](https://docs.bigmodel.cn/api-reference/模型-api/视频生成异步) + [查询异步结果](https://docs.bigmodel.cn/api-reference/模型-api/查询异步结果)
- 默认模型:`cogvideox-flash`
- 端口:容器内 `3000`(MCP `/mcp` + `/health`,**容器外不映射**,只在 `agent-mcp-net` 内被 agent 访问)
- 鉴权:**无服务端密钥**,每次请求必须从 header 携带智谱 token
- 本地文件需要公网 URL 时:不传字节,AI 直接调用 agent 内置的「公开临时 URL」工具拿到短命链接(见下节)
- `op=create` 提交任务,立刻回 `task_id`
- `op=get` 按 `task_id` 单次查询,**Server 不内部轮询**
- 协议:MCP **Streamable HTTP**(单端点 `/mcp`)
- 端口:容器内 `3000`(`/mcp` + `/health`)
- 鉴权:**服务端不存密钥**,每个请求从 header 读
- 上游:**不预设任何厂商**,Base-Url / 模型 / 凭据全部由调用方带入
---
@@ -22,287 +24,158 @@ cd /root/workspace/tools/agent
docker compose up -d --build mcp_video_task
```
服务容器名 `mcp_video_task`,**默认不占宿主机端口**:由 agent 走 `agent-mcp-net` 按容器名访问
(`http://mcp_video_task:3000/mcp`)。要从宿主机 curl 调试,自行给该服务加 `ports` 映射。
容器名 `mcp_video_task`,不占宿主机端口,由 agent 走 `agent-mcp-net` 按容器名访问。
```bash
# 容器内健康检查(无需占端口)
# 容器内健康检查
docker exec mcp_video_task node -e "fetch('http://localhost:3000/health').then(r=>r.text()).then(console.log)"
# {"status":"ok","service":"video_task","sessions":0}
```
> 下文 curl 示例里的 `localhost:8083` 均指“临时打开了调试端口”的情形。
### MCP 客户端配置
#### Claude Desktop / Cursor 等支持 `headers` 配置的客户端
```jsonc
// Claude Desktop: ~/Library/Application Support/Claude/claude_desktop_config.json
// Cursor: ~/.cursor/mcp.json
{
"mcpServers": {
"video_task": {
"url": "http://localhost:8083/mcp",
"type": "http",
"url": "http://mcp_video_task:3000/mcp",
"headers": {
"Authorization": "Bearer <your-zhipu-api-key>"
"Authorization": "Bearer <上游 API Key>",
"X-Video-Task-Base-Url": "https://<host>/v1",
"X-Video-Task-Model": "<上游模型 id>"
}
}
}
}
```
> 上面的 `localhost:8083` 只是示例:本栈默认不给 MCP 服务映射宿主端口,要直连需自行加 `ports`。
---
> **重要**:客户端必须在 **每一个 HTTP 请求**(`initialize` / `notifications/initialized` / `tools/call`)都带上 `Authorization` header。
## 三个 header
| header | 必填 | 说明 |
|---|---|---|
| `Authorization` | 是 | `Bearer <token>`,原样转给上游 |
| `X-Video-Task-Base-Url` | 是 | 完整 http(s) 地址,填到 `/v1` 即可;直接填到 `/videos/generations` 或 `/videos` 也会被剥回 base |
| `X-Video-Task-Model` | 是 | 上游模型 id,原样透传;不猜缺省值 |
配置缺失或非法时,工具直接回 `isError` 并说明缺哪个 header,不会去打上游。
---
## 工具:video_task
单个工具,`op` 必填,只有两个取值:
| op | 作用 | 同步/异步 |
|---|---|---|
| `create` | 提交一个视频生成任务,立刻返回 `task_id` | 同步(仅提交) |
| `get` | 用 `task_id` 拉一次当前结果 | 同步(单次查询,不轮询) |
### 参数(AI 可见)
| 名称 | 类型 | 必填 | 说明 |
|---|---|---|---|
| `op` | `"create"` \| `"get"` | ✅ | 要执行的操作 |
| `prompt` | string | op=create 时与 `image_url` 二选一 | 视频文本描述,最大 512 字符;与 `image_url` 同传时作为运动/动作描述 |
| `image_url` | string (URL) | ❌ | 参考图 URL(**单张**,不支持数组 / 多张 / 首尾帧)。图片 ≤ 5MB,格式 png/jpeg/jpg。本地文件请先用 agent 内置的公开临时 URL 工具换成公网链接(上一节) |
| `with_audio` | boolean | ❌ | 是否生成 AI 音效,默认 `false`(仅 op=create 使用) |
| `task_id` | string | op=get 时必填 | `op=create` 返回的 `id` |
### 服务端 Header 覆盖项(AI 看不到)
| Header | 类型 | 默认 | 说明 |
|---|---|---|---|
| `X-Video-Task-Model` / `X-Mcp-Model` / `X-Model` | string | `cogvideox-flash` | 覆盖模型 |
| `X-Video-Task-Quality` | string | `speed` | `speed`(速度优先)或 `quality`(质量优先) |
| `X-Video-Task-Fps` | int | `30` | `30` 或 `60` |
| `X-Video-Task-Watermark` | bool | `true` | 是否添加 AI 水印;关闭需先在智谱后台签署免责声明 |
模型名串识别顺序(首个非空值生效):`X-Video-Task-Model` → `X-Mcp-Model` → `X-Model` → 默认。
| 参数 | 类型 | 说明 |
|---|---|---|
| `op` | `create` \| `get` | 必填 |
| `prompt` | string | 视频描述,`create` 时与 `image_url` 至少给一个 |
| `image_url` | string | 参考图(图生视频),公开可访问的 png/jpeg URL |
| `seconds` | int | 时长(秒),留空用上游默认 |
| `aspect_ratio` | string | 画幅,如 `16:9` / `9:16` / `1:1` |
| `resolution` | string | 分辨率,如 `768P` / `1080P` |
| `negative_prompt` | string | 不希望出现的画面 |
| `enable_audio` | bool | 是否生成音频,默认 false(旧名 `with_audio` 同样接受) |
| `task_id` | string | `create` 返回的 id,`get` 时必填 |
### 返回(op=create)
立刻返回智谱提交结果:
```jsonc
{
"content": [
{ "type": "text", "text": "Model: cogvideox-flash\ntask_id: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\nrequest_id: yyyyyyyy-yyyy-yyyy-yyyy-yyyyyyyyyyyy\ntask_status: PROCESSING\n\nVideo generation is asynchronous. Call this tool again with op=\"get\" and task_id=\"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\" to fetch the result." }
]
}
```
task_id: <id>
model: <上游模型 id>
status: queued
`task_status` 通常为 `PROCESSING`,极少数情况下可能直接 `SUCCESS`(极快完成的短任务)。
Video generation is asynchronous. Call this tool again with op="get" and task_id="<id>" to fetch the result.
```
### 返回(op=get)
- **`SUCCESS`**:单个 `text` 块,含 `Video URL`(智谱签名 URL,**24h 左右有效**,需及时转存),以及 `Cover` 封面图:
```jsonc
{
"content": [
{ "type": "text", "text": "task_id: ...\nmodel: cogvideox-flash\ntask_status: SUCCESS\nVideo URL: https://...\nCover: https://..." }
]
}
```
- **`PROCESSING`**:`isError: false`,正文给出当前状态,建议稍候再查。
- **`FAIL`**:`isError: true`,正文含 `task_status` 和智谱返回的 `error` 详情。
任务完成:
```
task_id: <id>
model: <上游模型 id>
status: completed
Video URL: https://...
credit: 62.29
note: <上游附带的提示,如直链有效期>
```
未完成 / 失败:回 `status` 与 `progress`,失败时附上游 `error` 原文,并置 `isError=true`。
---
## 上游要求
只要满足这两条,任何实现都能接(自建网关、云厂商、本地服务):
1. `POST {base}/videos/generations` 返回 `task_id` 或 `id`
2. `GET {base}/videos/{task_id}` 返回 `status`;完成时带 `videos[].url` 或 `data[].url`
`status` 按小写比较:`completed` / `succeeded` / `success` 视为完成,`failed` / `error` /
`cancelled` 视为失败,其余按进行中处理。
---
## 本地文件 → 公网 URL(本服务不搬字节)
`image_url` 必须是一个**公网可达**的 URL(智谱服务器会自己去拉)。图片在本地盘上时,本服务不负责上传:
agent 侧已集成为一个 **tool**,AI 直接传文件路径就能拿到一条公开临时 URL,拿来填 `image_url` 即可,
不需要 curl 任何地址、不需要任何配置。
- 文件始终躺在 agent 的任务目录里,零拷贝;链接短命、到期或 agent 重启后失效。
- 智谱只在提交任务那一刻拉一次图,短命链接完全够用。
---
## 鉴权细节
每个 HTTP 请求必须携带智谱 API Token,server 从以下 header 字段按顺序识别,**首个非空值生效**:
| 优先级 | Header | 说明 |
|---|---|---|
| 1 | `X-Video-Task-Token: <token>` | 直传,避免与客户端自身的 Authorization 冲突 |
| 2 | `X-Mcp-Token: <token>` | 通用兜底 |
| 3 | `Authorization: Bearer <token>` | 标准 OAuth 风格(排最后是为避免误用) |
Token 仅在每次 tool call 时从 header 读取,不写入任何存储、不进 session。
### 错误响应
| 场景 | HTTP 状态 | 表现 |
|---|---|---|
| initialize 时缺 token | `401` | JSON-RPC `error.message` 提示补充 header |
| 智谱 API 4xx/5xx | `200`(MCP 工具返回) | `isError: true`,正文含智谱返回的状态码和 body |
| 网络失败 | `200`(MCP 工具返回) | `isError: true`,正文含 `fetch` 错误信息 |
| 上游挂住不回(超时 >30s) | `200`(MCP 工具返回) | `isError: true`,正文提示 timed out;`fetch` 带 `AbortSignal.timeout`,不会无限卡住工具调用 |
---
## 推荐用法(AI 视角)
图生视频要的是**公网可访问的 URL**,不是字节流。本地文件这样走:
```
1. 如果手头是【本地文件】:先调用 agent 内置的「公开临时 URL」工具拿到一条公网链接(上一节),再进第 2 步
2. 调用 video_task({ op: "create", prompt, image_url?, with_audio? })
3. 拿到 task_id → 等待若干秒(建议 2~5 秒)
4. 调用 video_task({ op: "get", task_id })
- 若 PROCESSING → 等一会再调
- 若 SUCCESS → 拿到 video URL,贴给用户 / 下载 / 二次编辑
- 若 FAIL → 展示错误信息,结束
AI ──调用 agent 内置的「公开临时 URL」工具(直接传文件路径)──► 拿到一条短命公网 URL
│
▼
AI 把 URL 当 image_url 交给 video_task:3000/mcp(转成上游的 image 字段)
│
▼
上游 ──匿名 GET──► agent 侧提供的公开临时 URL(文件始终躺在任务目录里,零拷贝)
```
> `image_url` 必须是公网可达 URL;本地文件走 agent 内置工具,本服务不参与上传。
链接短命:到期或 agent 重启后失效;上游只在提交任务那一刻拉一次图,够用。
---
## 用 curl 手工调试
MCP Streamable HTTP 不是普通 REST,**必须按顺序**:`initialize` → `notifications/initialized` → `tools/call`。下面用一行版串起来:
```bash
# 把 <your-zhipu-api-key> 替换成你智谱的 API Key
TOKEN="<your-zhipu-api-key>"
URL=http://127.0.0.1:3000/mcp # 容器内;宿主机调试需自行映射端口
H=(-H 'Content-Type: application/json' -H 'Accept: application/json, text/event-stream'
-H 'Authorization: Bearer <token>'
-H 'X-Video-Task-Base-Url: https://<host>/v1'
-H 'X-Video-Task-Model: <model>')
# 1. initialize 拿 sessionId
SESSION=$(curl -s -D - -X POST http://localhost:8083/mcp \
-H "Content-Type: application/json" \
-H "Accept: application/json, text/event-stream" \
-H "Authorization: Bearer $TOKEN" \
-d '{
"jsonrpc": "2.0",
"id": 1,
"method": "initialize",
"params": {
"protocolVersion": "2024-11-05",
"capabilities": {},
"clientInfo": { "name": "curl", "version": "1.0" }
}
}' | grep -i '^mcp-session-id:' | awk '{print $2}' | tr -d '\r\n')
# 1. initialize,从响应头取 mcp-session-id
curl -s -D - "${H[@]}" -X POST $URL \
-d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-06-18","capabilities":{},"clientInfo":{"name":"c","version":"0"}}}'
echo "Session: $SESSION"
# 2. 提交任务
curl -s "${H[@]}" -H 'mcp-session-id: <sid>' -X POST $URL \
-d '{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"video_task","arguments":{"op":"create","prompt":"一只猫在草地上跑"}}}'
# 2. notifications/initialized
curl -s -X POST http://localhost:8083/mcp \
-H "Content-Type: application/json" \
-H "Accept: application/json, text/event-stream" \
-H "Authorization: Bearer $TOKEN" \
-H "Mcp-Session-Id: $SESSION" \
-d '{"jsonrpc": "2.0", "method": "notifications/initialized"}'
# 3. 列出工具(可选验证)
curl -s -X POST http://localhost:8083/mcp \
-H "Content-Type: application/json" \
-H "Accept: application/json, text/event-stream" \
-H "Authorization: Bearer $TOKEN" \
-H "Mcp-Session-Id: $SESSION" \
-d '{"jsonrpc": "2.0", "id": 2, "method": "tools/list"}'
# 4. 提交文生视频任务(op=create)
curl -s -X POST http://localhost:8083/mcp \
-H "Content-Type: application/json" \
-H "Accept: application/json, text/event-stream" \
-H "Authorization: Bearer $TOKEN" \
-H "Mcp-Session-Id: $SESSION" \
-d '{
"jsonrpc": "2.0",
"id": 3,
"method": "tools/call",
"params": {
"name": "video_task",
"arguments": {
"op": "create",
"prompt": "A cat is playing with a ball.",
"with_audio": true
}
}
}'
# 5. 查结果(op=get,替换下面的 <task_id>)
curl -s -X POST http://localhost:8083/mcp \
-H "Content-Type: application/json" \
-H "Accept: application/json, text/event-stream" \
-H "Authorization: Bearer $TOKEN" \
-H "Mcp-Session-Id: $SESSION" \
-d '{
"jsonrpc": "2.0",
"id": 4,
"method": "tools/call",
"params": {
"name": "video_task",
"arguments": { "op": "get", "task_id": "<task_id>" }
}
}'
# 3. 查结果
curl -s "${H[@]}" -H 'mcp-session-id: <sid>' -X POST $URL \
-d '{"jsonrpc":"2.0","id":3,"method":"tools/call","params":{"name":"video_task","arguments":{"op":"get","task_id":"<id>"}}}'
```
响应是 SSE 格式(`event: message` + `data: {...}`),用 `grep '^data:'` 抽 JSON 即可。
响应是 SSE(`event: message` + `data: {...}`),取 `data:` 那行解析。
---
## 架构与文件
```
video_task/
├── Dockerfile # node:22-slim,安装依赖后启动 MCP HTTP server
├── .dockerignore # 排除 node_modules
package.json # @modelcontextprotocol/sdk + express
├── README.md # 本文件
└── src/
└── mcp-server.js # 单文件实现:HTTP server + MCP transport + 单工具(op 分发)
mcp/video_task/
├── Dockerfile
├── package.json
├── README.md
└── src/mcp-server.js # 全部逻辑:header 解析 / 上游调用 / MCP 服务
```
### 关键设计
- **单工具 + `op` 分发**:`video_task(op=create|get)` 替代原来的 `video_gen` + `query_video` 双工具,AI 面对的工具面更小,参数按 op 在 handler 侧校验
- **每 session 一个 transport + server**:通过 `Mcp-Session-Id` 复用,避免每请求重建
- **Token 闭包注入**:在 Express 入口处从 header 提取 token,闭包传给 tool 回调;不依赖 SDK 内部字段
- **AI 可见 vs AI 不可见**:
- AI 只看到 `op / prompt / image_url / with_audio / task_id`
- `model / quality / fps / watermark_enabled` 全部由 HTTP header 注入,避免 AI 误传或被诱导调高价档
- **异步语义暴露给 AI**:服务端不做轮询,`op=create` 只提交、`op=get` 只查一次。AI 自主决定节奏
- **服务端自动 `request_id`**:每次提交服务端生成一个 UUID 作为智谱 `request_id`,便于日志关联,但不暴露给 AI
- **不搬字节**:本地文件 -> 公网 URL 完全由 agent 侧集成的「公开临时 URL」工具完成,本服务不参与;所以本体不加任何写入口、不落盘、不需要额外端口
- **链接短命**:公开临时 URL 到期或 agent 重启后失效;智谱只需在提交任务那一刻拉一次图
### 默认模型
```js
// src/mcp-server.js
const DEFAULT_MODEL = "cogvideox-flash";
```
修改后 `docker compose up -d --build mcp_video_task` 即可生效。
---
## 常见问题
**Q: AI 拿到 task_id 后立刻 op=get 一直 PROCESSING,怎么办?**
A: AI 自己 sleep 几秒再调(建议 2~5 秒间隔)。这是设计取舍:把节奏控制权交给 AI 模型,而不是服务端硬编码超时。
**Q: 视频 URL 多久过期?**
A: 智谱签发 URL 默认 24h 左右。需要在收到后及时转存到自己的 OSS/S3。
**Q: 为什么 quality / fps 不让 AI 直接传?**
A: 这些是技术档位,与成本/单价挂钩。让 AI 自主挑 `quality=quality + fps=60` 会爆账号预算。改成 header 由部署方注入更可控。
**Q: 报错 `Missing valid Mcp-Session-Id`?**
A: 漏发了 `Mcp-Session-Id` header,或调 `tools/call` 前没先 `initialize`。
**Q: 同一 task_id 能并发查吗?**
A: 可以。`/async-result/{id}` 是幂等的读接口,并发无副作用。
**Q: 换模型需要重连 MCP session 吗?**
A: 不需要。Model header 在每次 `tools/call` 都从当前请求读取。
**Q: 上传的图片多久过期?**
A: 本服务不存图,不存在“上传的图片”:要用的图在 agent 的任务目录里,AI 用 agent 内置的公开临时 URL 工具现取一条短命链接给智谱拉。链接过期或 agent 重启后该 URL 失效,但智谱只在提交任务时拉一次,不受影响。
- **无状态**:不存密钥、不存任务,重启即忘。任务状态由上游持有,`task_id` 就是全部上下文。
- **不轮询**:`op=get` 只拉一次。轮询节奏由 AI 决定,避免服务端挂着长任务占资源。
- **配置错误不打上游**:缺 header 时同步返回 `isError`,省一次无意义的 400。
- **`wait=false` 提交**:立刻拿 `task_id`,不让工具调用被上游排队拖死。
+166 -248
View File
@@ -6,26 +6,16 @@ import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/
import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
import { z } from "zod";
const ZHIPU_SUBMIT_URL =
"https://open.bigmodel.cn/api/paas/v4/videos/generations";
const ZHIPU_QUERY_URL = (id) =>
`https://open.bigmodel.cn/api/paas/v4/async-result/${encodeURIComponent(id)}`;
// 上游必须是 OpenAI 兼容的视频端点:提交 POST /videos/generations,查询 GET /videos/{task_id}。
// Base-Url / 模型 / 凭据全部由调用方随每个请求用 header 带入(X-Video-Task-Base-Url /
// X-Video-Task-Model / Authorization),服务自己不存、也不预设任何厂商。
// 默认模型:cogvideox-flash
const DEFAULT_MODEL = "cogvideox-flash";
// AI 不可见的服务端默认(可被同名 header 覆盖)
const DEFAULT_QUALITY = "speed"; // speed | quality
const DEFAULT_FPS = 30; // 30 | 60
const DEFAULT_WATERMARK_ENABLED = true; // 平台政策默认 true
// submit/query 都是快接口,卡住基本等于上游挂了;限时避免工具调用被拖死
const UPSTREAM_TIMEOUT_MS = 30_000;
// 提交与查询都是快接口(wait=false 立刻回 task_id),卡住基本等于上游挂了。
const UPSTREAM_TIMEOUT_MS = 60_000;
// ── 优雅退出 ──────────────────────────────────────────────────────────────
// 容器里 node 以 PID 1 运行且未注册 SIGTERM 处理器时,内核不会对其执行默认
// 终止动作,docker stop/restart 会白等满 10s 宽限期才被 SIGKILL。
// 显式注册处理器,关闭 MCP session 与长连接后立即退出;3s 定时器为兜底。
let httpServer = null;
let closeAllSessions = () => {};
let shuttingDown = false;
@@ -43,11 +33,7 @@ process.on("SIGTERM", () => shutdown("SIGTERM"));
process.on("SIGINT", () => shutdown("SIGINT"));
function parseArgs(argv) {
const args = {
http: false,
port: 3000,
host: "0.0.0.0",
};
const args = { http: false, port: 3000, host: "0.0.0.0" };
for (let i = 0; i < argv.length; i++) {
const a = argv[i];
if (a === "--http") args.http = true;
@@ -57,74 +43,84 @@ function parseArgs(argv) {
return args;
}
function pickToken(headers) {
// 对外只有三个 header:Authorization / X-Video-Task-Base-Url / X-Video-Task-Model。
function pickAuthToken(headers) {
if (!headers) return null;
const candidates = [
headers["x-video-task-token"],
headers["x-mcp-token"],
headers["authorization"],
];
for (const v of candidates) {
if (!v) continue;
const s = String(v).trim();
if (!s) continue;
if (/^Bearer\s+/i.test(s)) {
const t = s.replace(/^Bearer\s+/i, "").trim();
if (t) return t;
} else {
return s;
}
const s = String(headers["authorization"] || "").trim();
if (!s) return null;
if (/^Bearer\s+/i.test(s)) {
const t = s.replace(/^Bearer\s+/i, "").trim();
return t || null;
}
return null;
return s;
}
function pickModel(headers) {
function pickHeaderString(headers, name) {
if (!headers) return null;
const v =
headers["x-video-task-model"] ||
headers["x-mcp-model"] ||
headers["x-model"];
if (!v) return null;
const v = headers[name];
if (v === undefined || v === null) return null;
const s = String(v).trim();
return s || null;
}
function pickHeaderString(headers, name, fallback) {
if (!headers) return fallback;
const v = headers[name];
if (v === undefined || v === null) return fallback;
const s = String(v).trim();
return s ? s : fallback;
function pickBaseUrl(headers) {
return pickHeaderString(headers, "x-video-task-base-url");
}
function pickHeaderInt(headers, name, fallback) {
if (!headers) return fallback;
const v = headers[name];
if (v === undefined || v === null) return fallback;
const n = parseInt(String(v).trim(), 10);
return Number.isFinite(n) ? n : fallback;
function pickModel(headers) {
return pickHeaderString(headers, "x-video-task-model");
}
function pickHeaderBool(headers, name, fallback) {
if (!headers) return fallback;
const v = headers[name];
if (v === undefined || v === null) return fallback;
const s = String(v).trim().toLowerCase();
if (s === "true" || s === "1" || s === "yes") return true;
if (s === "false" || s === "0" || s === "no") return false;
return fallback;
// 解析 Base-Url:必须是完整 http(s) URL。允许调用方直接填到 /videos/generations
// 或 /videos(照抄文档的写法),统一剥回 base——否则查询会被拼成两条路径。
function resolveBaseUrl(rawBase) {
const base = String(rawBase || "").trim().replace(/\/+$/, "");
if (!base) {
throw new Error(
"Missing X-Video-Task-Base-Url: pass the upstream base URL (e.g. https://<host>/v1)."
);
}
if (!/^https?:\/\//i.test(base)) {
throw new Error(
`Invalid X-Video-Task-Base-Url "${base}": must be a full http(s) URL.`
);
}
return base.replace(/\/videos(\/generations)?$/i, "");
}
async function callZhipu({ url, token, method = "POST", body }) {
// 模型只由 header 决定,AI 看不到也填不了。不猜缺省值:猜错只会换来含义不明的 400。
function resolveModel(headers) {
const model = pickModel(headers);
if (!model) {
throw new Error("Missing X-Video-Task-Model: pass the upstream model name.");
}
return model;
}
// 一次解析出本次请求的上游、凭据、模型。配置问题同步抛错,直接回给调用方。
function resolveTarget(headers) {
const token = pickAuthToken(headers);
if (!token) {
throw new Error('Missing Authorization: use "Authorization: Bearer <token>".');
}
return {
base: resolveBaseUrl(pickBaseUrl(headers)),
token,
model: resolveModel(headers),
};
}
// 统一的上游请求:超时、错误体解析都在这层,提交与查询共用。
async function callUpstream({ url, token, method = "POST", body }) {
const init = {
method,
headers: {
Authorization: `Bearer ${token}`,
"Content-Type": "application/json",
},
headers: { Authorization: `Bearer ${token}` },
signal: AbortSignal.timeout(UPSTREAM_TIMEOUT_MS),
};
if (body !== undefined) init.body = JSON.stringify(body);
if (body !== undefined) {
init.headers["Content-Type"] = "application/json";
init.body = JSON.stringify(body);
}
let resp;
try {
resp = await fetch(url, init);
@@ -143,9 +139,7 @@ async function callZhipu({ url, token, method = "POST", body }) {
data = { raw: text };
}
if (!resp.ok) {
const err = new Error(
`Zhipu API error: ${resp.status} ${resp.statusText} - ${text}`
);
const err = new Error(`Upstream error: ${resp.status} ${resp.statusText} - ${text}`);
err.status = resp.status;
err.detail = data;
throw err;
@@ -153,96 +147,74 @@ async function callZhipu({ url, token, method = "POST", body }) {
return data;
}
// ===== op=create:提交视频生成(同步只提交,立刻返回)=====
async function submitVideo({
token,
model,
prompt,
image_url,
quality,
with_audio,
fps,
watermark_enabled,
}) {
// 平台要求 image_url 和 prompt 至少传一个(handler 侧已校验)
const body = {
model,
quality,
with_audio: Boolean(with_audio),
watermark_enabled: Boolean(watermark_enabled),
fps,
// 由服务端生成唯一 request_id,便于日志关联;不暴露给 AI
request_id: randomUUID(),
};
// ===== op=create:提交视频生成(wait=false,立刻返回 task_id)=====
async function submitVideo({ base, token, model, prompt, image_url, seconds, aspect_ratio, resolution, negative_prompt, enable_audio }) {
const body = { model, wait: false };
if (prompt) body.prompt = prompt;
if (image_url) body.image_url = image_url;
if (image_url) body.image = image_url; // OpenAI Videos 口径的参考图字段
if (seconds !== undefined) body.seconds = seconds;
if (aspect_ratio) body.aspect_ratio = aspect_ratio;
if (resolution) body.resolution = resolution;
if (negative_prompt) body.negative_prompt = negative_prompt;
if (enable_audio !== undefined) body.enable_audio = Boolean(enable_audio);
return await callZhipu({ url: ZHIPU_SUBMIT_URL, token, body });
// { model, id, request_id, task_status }
return await callUpstream({ url: base + "/videos/generations", token, body });
}
// ===== op=get:查询异步结果(单次拉取,不内部轮询)=====
async function queryAsyncResult({ token, id }) {
return await callZhipu({
url: ZHIPU_QUERY_URL(id),
// ===== op=get:查询任务(单次拉取,不内部轮询)=====
async function queryVideo({ base, token, taskId }) {
return await callUpstream({
url: base + "/videos/" + encodeURIComponent(taskId),
token,
method: "GET",
});
// { id, request_id, model, task_status, video_result?, ... }
}
const DONE = new Set(["completed", "succeeded", "success"]);
const FAILED = new Set(["failed", "error", "cancelled", "canceled"]);
function normalizeStatus(s) {
return String(s || "").toLowerCase();
}
// ---------- op=create 的业务处理 ----------
async function handleCreate({ args, headers, token }) {
async function handleCreate({ args, headers }) {
// 纯空白 prompt 等同没给:schema 只校验类型/长度,不校验内容。
// 不 trim 的话,“ ”会被当成合法 prompt 提交(text-to-video 拿到空白提示词,
// image-to-video 则多传一个无意义字段)。
const prompt = typeof args.prompt === "string" ? args.prompt.trim() : "";
if (!prompt && !args.image_url) {
return {
isError: true,
content: [
{
type: "text",
text: 'op=create requires at least one of "prompt" or "image_url".',
},
],
content: [{ type: "text", text: 'op=create requires at least one of "prompt" or "image_url".' }],
};
}
// AI 不可见:全部走 header
const model = pickModel(headers) || DEFAULT_MODEL;
const quality = pickHeaderString(
headers,
"x-video-task-quality",
DEFAULT_QUALITY
);
const fps = pickHeaderInt(headers, "x-video-task-fps", DEFAULT_FPS);
const watermark_enabled = pickHeaderBool(
headers,
"x-video-task-watermark",
DEFAULT_WATERMARK_ENABLED
);
let target;
try {
target = resolveTarget(headers);
} catch (e) {
return { isError: true, content: [{ type: "text", text: e.message }] };
}
try {
const data = await submitVideo({
token,
model,
...target,
prompt,
image_url: args.image_url,
quality,
with_audio: args.with_audio ?? false,
fps,
watermark_enabled,
seconds: args.seconds,
aspect_ratio: args.aspect_ratio,
resolution: args.resolution,
negative_prompt: args.negative_prompt,
enable_audio: args.enable_audio ?? args.with_audio,
});
const taskId = data.task_id || data.id;
const summary =
`Model: ${model}\n` +
`task_id: ${data.id}\n` +
`request_id: ${data.request_id}\n` +
`task_status: ${data.task_status}\n` +
`task_id: ${taskId}\n` +
`model: ${target.model}\n` +
`status: ${data.status || "queued"}\n` +
`\n` +
`Video generation is asynchronous. ` +
`Call this tool again with op="get" and task_id="${data.id}" to fetch the result.`;
`Call this tool again with op="get" and task_id="${taskId}" to fetch the result.`;
return { content: [{ type: "text", text: summary }] };
} catch (e) {
@@ -251,9 +223,7 @@ async function handleCreate({ args, headers, token }) {
content: [
{
type: "text",
text: `Failed to submit video task: ${e.message}${
e.detail ? `\nDetails: ${JSON.stringify(e.detail)}` : ""
}`,
text: `提交视频任务失败:${e.message}${e.detail ? `\nDetails: ${JSON.stringify(e.detail)}` : ""}`,
},
],
};
@@ -261,59 +231,51 @@ async function handleCreate({ args, headers, token }) {
}
// ---------- op=get 的业务处理 ----------
async function handleGet({ args, token }) {
// 与 handleCreate 同理:纯空白 task_id 不能直接拼进上游路径,
// 否则会得到一条含编码后空白的上游报错,既无从归因也误导模型。
async function handleGet({ args, headers }) {
// 纯空白 task_id 不能直接拼进上游路径,否则得到一条含编码后空白的报错。
const taskId = typeof args.task_id === "string" ? args.task_id.trim() : "";
if (!taskId) {
return {
isError: true,
content: [{ type: "text", text: 'op=get requires "task_id".' }],
};
return { isError: true, content: [{ type: "text", text: 'op=get requires "task_id".' }] };
}
let target;
try {
target = resolveTarget(headers);
} catch (e) {
return { isError: true, content: [{ type: "text", text: e.message }] };
}
try {
const data = await queryAsyncResult({ token, id: taskId });
const status = data.task_status || "UNKNOWN";
const data = await queryVideo({ ...target, taskId });
const status = normalizeStatus(data.status);
if (status === "SUCCESS") {
const v = (data.video_result || [])[0];
if (!v || !v.url) {
if (DONE.has(status)) {
const url = (data.videos || [])[0]?.url || (data.data || [])[0]?.url;
if (!url) {
return {
isError: true,
content: [
{
type: "text",
text: `Task succeeded but no video URL returned. Raw: ${JSON.stringify(
data
)}`,
},
],
content: [{ type: "text", text: `任务已完成但没有视频地址。Raw: ${JSON.stringify(data).slice(0, 500)}` }],
};
}
const summary =
`task_id: ${data.id}\n` +
`model: ${data.model}\n` +
`task_status: SUCCESS\n` +
`Video URL: ${v.url}\n` +
(v.cover_image_url ? `Cover: ${v.cover_image_url}\n` : "");
// 单块输出:URL 已经写在摘要里,旧版额外回一个裸 URL 块会让模型
// (core 会把 text 块 join 成一段)看到同一个链接两遍。
return { content: [{ type: "text", text: summary }] };
const credit = data.usage?.credit;
const text =
`task_id: ${taskId}\n` +
`model: ${data.model || target.model}\n` +
`status: completed\n` +
`Video URL: ${url}\n` +
(credit !== undefined ? `credit: ${credit}\n` : "") +
(data.hint ? `note: ${data.hint}\n` : "");
return { content: [{ type: "text", text }] };
}
// PROCESSING / FAIL / 其他:原样返回关键字段
const errBlock = data.error ? `\nerror: ${JSON.stringify(data.error)}` : "";
const progress = data.progress !== undefined ? `\nprogress: ${data.progress}` : "";
return {
isError: status === "FAIL",
isError: FAILED.has(status),
content: [
{
type: "text",
text:
`task_id: ${data.id}\n` +
`model: ${data.model}\n` +
`task_status: ${status}` +
errBlock,
text: `task_id: ${taskId}\nmodel: ${data.model || target.model}\nstatus: ${data.status || "unknown"}${progress}${errBlock}`,
},
],
};
@@ -323,9 +285,7 @@ async function handleGet({ args, token }) {
content: [
{
type: "text",
text: `Failed to query video task: ${e.message}${
e.detail ? `\nDetails: ${JSON.stringify(e.detail)}` : ""
}`,
text: `查询视频任务失败:${e.message}${e.detail ? `\nDetails: ${JSON.stringify(e.detail)}` : ""}`,
},
],
};
@@ -333,81 +293,61 @@ async function handleGet({ args, token }) {
}
function buildServer() {
const server = new McpServer(
{ name: "video_task", version: "1.0.0" },
{ capabilities: { tools: {} } }
);
const server = new McpServer({ name: "video_task", version: "2.0.0" }, { capabilities: { tools: {} } });
server.tool(
"video_task",
`AI video generation task.
`AI video generation task (async).
Operations:
- \`create\`: Start a new video generation task. Requires at least one of \`prompt\` or \`image_url\`. Returns \`task_id\` immediately; generation runs in background.
- \`get\`: Check an existing task. Requires \`task_id\`. Returns status and, on SUCCESS, the video URL.
- \`create\`: Start a new task. Requires at least one of \`prompt\` or \`image_url\`. Returns \`task_id\` immediately.
- \`get\`: Check a task by \`task_id\`. Returns status and, when completed, the video URL.
Examples:
- Text-to-video → \`{"op":"create","prompt":"A cat running in a garden"}\`
- Image-to-video → \`{"op":"create","image_url":"https://example.com/cat.jpg","prompt":"The cat runs forward"}\`
- Check task → \`{"op":"get","task_id":"<task_id from create>"}\`
Workflow: call \`create\` once, then call \`get\` with the returned \`task_id\` until \`task_status\` is \`SUCCESS\` or \`FAIL\`. Never create duplicate tasks just to check status.`,
Workflow: call \`create\` once, then call \`get\` with the returned \`task_id\` until status is \`completed\` or \`failed\`. Never create duplicate tasks just to check status.`,
{
op: z
.enum(["create", "get"])
.describe(
"Use create to start video generation; use get to check a task by its task_id."
),
op: z.enum(["create", "get"]).describe("create 提交生成;get 按 task_id 查结果。"),
prompt: z
.string()
.max(512)
.max(2000)
.optional()
.describe(
"Video description, max 512 characters. Required for text-to-video; when combined with image_url it describes the motion."
),
.describe("视频描述,create 时 prompt 与 image_url 至少给一个。图生视频时描述画面如何运动。"),
image_url: z
.string()
.url()
.optional()
.describe(
"Reference image for image-to-video: publicly reachable png/jpeg/jpg URL <= 5 MB. For local files, first use the built-in mint_public_link tool to get a public temporary URL."
"参考图(图生视频):公开可访问的 png/jpeg URL。本地文件先用 agent 内置的公开临时 URL 工具换成短链。"
),
with_audio: z
.boolean()
.optional()
.describe(
"Whether to generate AI audio. Used with create; defaults to false."
),
task_id: z
.string()
seconds: z
.number()
.int()
.min(1)
.max(60)
.optional()
.describe("task_id returned by create. Required for get; omit for create."),
.describe("视频时长(秒)。留空用上游默认;越长越慢越贵。"),
aspect_ratio: z.string().optional().describe("画幅,如 16:9 / 9:16 / 1:1。"),
resolution: z.string().optional().describe("分辨率,如 768P / 1080P。留空用上游默认。"),
negative_prompt: z.string().optional().describe("不希望出现的画面描述。"),
enable_audio: z.boolean().optional().describe("是否生成音频,默认 false。"),
with_audio: z.boolean().optional().describe("旧字段名,等同 enable_audio。"),
task_id: z.string().min(1).optional().describe("create 返回的 task_id,get 时必填。"),
},
async (args, extra) => {
const headers = extra?.requestInfo?.headers;
const token = pickToken(headers);
if (!token) {
return {
isError: true,
content: [{ type: "text", text: "Missing authentication token." }],
};
}
switch (args.op) {
case "create":
return await handleCreate({ args, headers, token });
return await handleCreate({ args, headers });
case "get":
return await handleGet({ args, token });
return await handleGet({ args, headers });
default:
return {
isError: true,
content: [
{
type: "text",
text: `Unknown op "${args.op}" (available: create, get).`,
},
],
content: [{ type: "text", text: `Unknown op "${args.op}" (available: create, get).` }],
};
}
}
@@ -420,20 +360,14 @@ async function startHttp({ port, host }) {
const app = express();
app.use(express.json({ limit: "2mb" }));
// session -> { server, transport } 映射
const sessions = new Map();
closeAllSessions = () => {
for (const { server, transport } of sessions.values()) {
try {
transport.close();
} catch {}
try {
server.close();
} catch {}
try { transport.close(); } catch {}
try { server.close(); } catch {}
}
sessions.clear();
// 掰掉未关闭的 SSE / keep-alive 连接,否则 httpServer.close() 回调不会触发
httpServer?.closeAllConnections?.();
};
@@ -444,22 +378,16 @@ async function startHttp({ port, host }) {
async function handleSessionRequest(req, res) {
const sessionId = req.headers["mcp-session-id"];
// 已有 session:复用 transport
if (sessionId && sessions.has(sessionId)) {
const { transport } = sessions.get(sessionId);
await transport.handleRequest(req, res, req.body);
return;
}
// 新 session:必须是 initialize 请求
if (!isInitializeRequest(req.body)) {
res.status(400).json({
jsonrpc: "2.0",
error: {
code: -32000,
message:
"Bad Request: missing valid Mcp-Session-Id for non-initialize request",
},
error: { code: -32000, message: "Bad Request: missing valid Mcp-Session-Id for non-initialize request" },
id: req.body?.id ?? null,
});
return;
@@ -469,25 +397,19 @@ async function startHttp({ port, host }) {
const server = buildServer();
const transport = new StreamableHTTPServerTransport({
sessionIdGenerator: () => newId,
onsessioninitialized: (id) => {
sessions.set(id, { server, transport });
},
onsessioninitialized: (id) => { sessions.set(id, { server, transport }); },
});
transport.onclose = () => {
if (transport.sessionId) {
sessions.delete(transport.sessionId);
}
if (transport.sessionId) sessions.delete(transport.sessionId);
};
await server.connect(transport);
await transport.handleRequest(req, res, req.body);
}
// POST /mcp: 主入口
app.post("/mcp", handleSessionRequest);
// GET /mcp & DELETE /mcp: 用于 SSE 流 / 会话关闭
const handleOther = async (req, res) => {
const sessionId = req.headers["mcp-session-id"];
if (!sessionId || !sessions.has(sessionId)) {
@@ -501,17 +423,13 @@ async function startHttp({ port, host }) {
app.delete("/mcp", handleOther);
httpServer = app.listen(port, host, () => {
console.log(
`[video] MCP HTTP server listening on http://${host}:${port}/mcp`
);
console.log(`[video] MCP HTTP server listening on http://${host}:${port}/mcp`);
});
}
async function startStdio() {
const server = buildServer();
const { StdioServerTransport } = await import(
"@modelcontextprotocol/sdk/server/stdio.js"
);
const { StdioServerTransport } = await import("@modelcontextprotocol/sdk/server/stdio.js");
const transport = new StdioServerTransport();
await server.connect(transport);
console.error("[video] MCP stdio server started");
+1 -1
View File
@@ -141,7 +141,7 @@ services:
- `name`:固定端口路由用的服务标识(有域名时可省略)
- `host`:`域名` / `*.example.com` / `"*"`(兜底)
- `userAgent`:可选,握手时伪装浏览器 UA,降低被 DPI 盯上的概率
- 断线自动重连,启动时自检每个端口可达性(不可达只告警不退出)
- 断线自动重连(含半死链路:75 秒收不到任何帧即主动断开重连),启动时自检每个端口可达性(不可达只告警不退出)
## 隧道协议
+19 -3
View File
@@ -4,7 +4,8 @@
// 主动连服务器 → 收请求 → 按 Host 找本地端口 → 转发 → 流式回传
//
// 用法: node client.js [config.yml] 环境变量 TUNNEL_SERVER / TUNNEL_TOKEN 覆盖配置
// 断线自动重连(指数退避 1s → 30s),心跳由服务端 ping 驱动,本端 ws 库自动回 pong。
// 断线自动重连(指数退避 1s → 30s)。心跳由服务端 ping 驱动、本端 ws 库自动回 pong;
// 但半死链路(Mac 睡眠/切网后 TCP 还在、实际不通)不会触发 close,所以本端另设看门狗。
const fs = require('node:fs');
const path = require('node:path');
@@ -42,7 +43,9 @@ function loadConfig() {
}
const CFG = loadConfig();
function log(...a) { console.log(new Date().toISOString().slice(11, 19), '[client]', ...a); }
// 日志时间固定东八区:本机时区可能变,跨时区看日志不该换算
const CST_MS = 8 * 3600 * 1000;
function log(...a) { console.log(new Date(Date.now() + CST_MS).toISOString().slice(11, 19), '[client]', ...a); }
// ---------- 服务路由:Host → 本地端口 ----------
// 精确匹配优先;再退到「忽略端口」;最后允许 *.xxx 通配一项
@@ -72,6 +75,7 @@ const inflight = new Map();
let ws = null;
let backoff = 1000;
let stopping = false;
let lastSeen = 0; // 最近一次收到服务端任何帧的时刻
function send(obj) {
if (ws && ws.readyState === 1) {
@@ -192,10 +196,12 @@ function connect() {
ws.on('open', () => {
backoff = 1000;
linked = true;
lastSeen = Date.now();
log(everLinked ? '已重新连接' : '已连接 ' + CFG.server);
everLinked = true;
});
ws.on('message', onMessage);
ws.on('message', (data) => { lastSeen = Date.now(); onMessage(data); });
ws.on('ping', () => { lastSeen = Date.now(); });
ws.on('close', (code, reason) => {
if (stopping) return;
if (linked) { // 只在「连着 → 断开」这个跳变上说一次
@@ -208,6 +214,16 @@ function connect() {
ws.on('error', () => {}); // close 紧接着会来,不重复报
}
// 看门狗:服务端每 25s ping 一次,超过 75s(连丢 3 次)一个帧都没收到就认定链路半死。
// 这种连接 close 事件永远不来,只能本端主动 terminate,由 close 走既有重连。
setInterval(() => {
if (stopping || !ws || ws.readyState !== 1) return;
if (Date.now() - lastSeen > 75000) {
log('链路 ' + Math.round((Date.now() - lastSeen) / 1000) + 's 无响应,主动断开重连');
try { ws.terminate(); } catch (_) {}
}
}, 20000).unref();
process.on('SIGINT', () => { stopping = true; log('退出'); try { ws && ws.close(1000, 'client shutdown'); } catch (_) {} process.exit(0); });
process.on('SIGTERM', () => { stopping = true; process.exit(0); });
+6 -3
View File
@@ -123,9 +123,12 @@ function handleRequest(req, res, fixedService) {
client.send(JSON.stringify({ id, op: 'body', b64: chunk.toString('base64') }));
});
req.on('end', () => { if (!overflow) client.send(JSON.stringify({ id, op: 'end' })); });
// 手机/浏览器提前断开:让家里把上游请求也停掉,别白跑
req.on('aborted', () => {
if (!pending.has(id)) return;
// 客户端提前断开:让家里把上游请求也停掉,别白跑。
// 必须挂在 res 上:SSE 是 GET 无 body,req 的 'aborted' 只在传 body 时触发(且已废弃)。
// 漏掉这条时,前端关掉 SSE 后 client 会继续读流、继续往 WS 灌数据,切会话时
// 新旧两条流同时推,把单条 WS 占满,后发的 detail 请求只能排队。
res.on('close', () => {
if (!pending.has(id)) return; // 正常结束时 pending 已删
client.send(JSON.stringify({ id, op: 'abort' }));
pending.delete(id);
});