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
kicer 60d8278610 fix(local): 远程访问时 /api/local/* 一律 404,工作目录入口不再「点了没反应」
经隧道从手机访问时 core 跑在家里那台机器上、local 路由存在,前端会显示「工作目录」
入口;点下去调 /api/local/pick-dir 会在宿主机屏幕上弹原生对话框,用户看不到,
表现成点击无响应。

这些接口(弹目录对话框 / 开 Finder / 开终端)只有坐在这台机器前才有意义。加一个
中间件:非本机访问直接 404,行为和服务器形态完全一致(那边 server.js 根本不挂这个
路由),前端原有的 catch 就会把入口整条隐藏 —— 前端零改动。

判断看 X-Forwarded-* 头是否存在(反向代理的标准约定,不依赖具体 nginx 配置):
- 不能用 IP:stream 把 443 分流到 127.0.0.1:1443,nginx 看到的源地址永远是 127.0.0.1
- 不能用 Host:tunnel client 用 fetch 转发时 Host 是禁止头,被重写成 127.0.0.1:8090
2026-11-15 14:27:07 +08:00
kicer 772408fb6e perf(文件面板): 改成按目录懒加载,不再一次拉全量文件树
底部「任务文件」浮层原来是 GET /:id/files 全量递归:仓库级工作目录能扫出
10544 个文件、1.4MB(其中 81% 在 node_modules),移动端经隧道打开要好几秒。

改成和侧边栏同一个 /tree 接口,只拉当前这一层(单层 readdirSync,上限 500 条)。
根目录 1.4MB/144ms → 1.3KB/3.5ms,进任意子目录也是毫秒级。node_modules 这类
大目录由 TREE_IGNORE_DIRS 灰显沉底,但可以点进去,进哪层拉哪层。

配套:
- 目录行右侧显示修改时间(原来算递归文件数,懒加载拿不到)
- 新增 fmtFileTime,文件和目录统一成「年/月/日 时:分」(全局 fmtTime 对今天只给时分)
- /tree 给文件条目补 mtimeMs(原来只给目录,文件时间显示不出来)
- showFileTree 缓存还在就复用,反复开关面板不再重拉已展开的层
- refreshFileTree 提到 sessionId 变更处,切会话不再先闪一下上个会话的文件
2026-11-15 14:17:04 +08:00
kicer 111d6d6c90 perf: 会话详情去掉全量文件列表,隧道响应加 gzip
GET /api/sessions/:id 每次都递归扫一遍任务目录返回 files 字段,本地这个会话的目录
是整个仓库,10544 个文件 = 1.4MB,而前端从来没读过它(文件树走 /api/files 按目录
懒加载)。删掉后响应 1.4MB → 4.8KB,后端也省掉每次 10544 次 statSync。

client.js 对可压缩响应先缓冲再 gzip(SSE、超 8MB、压不动 10% 的除外),
跨境链路带宽是瓶颈,首屏 15 个资源 714KB → 234KB。

实测:会话详情经隧道 7s → 0.16s,首屏 3.5s → 1.2s。
2026-11-15 13:07:45 +08:00
kicer 9566cb8151 feat(local): 状态页停在「已启动」等用户点击,不再 2 秒自动跳转
启动完成后一律用 click 模式,页面留在状态页,启动摘要和日志尾巴都能看完再进应用。
「首次使用」那段提示改成 ui_done 的可选第三参数,只有首次运行才写进页面。

顺带去掉「(关掉这个页面不影响服务)」这句废话,以及给隧道加一行 ui_step,
和 MCP 子进程的提示方式保持一致。
2026-11-15 12:41:14 +08:00
kicer 0c9a92aabd feat(local): 启动器顺带拉起隧道 client,配了 tunnel/client.yml 才起
client 作为第 5 个子进程挂在启动器下,停止时由 do_cleanup 的 kill_tree 一并收掉,
所以不需要单独的 start/stop 脚本。它自带指数退避重连、进程不退出,也不需要有守护循环。

stop.sh 补一步兜底:启动器被 kill -9 时 EXIT trap 不跑,client 会漏成孤儿,
按它自己写的 tunnel.pid 收掉(正常路径读不到这个文件,do_cleanup 已删)。
2026-11-15 12:27:39 +08:00
kicer dab9d8f000 fix(tunnel): client 日志改成只在状态变化时输出,依赖锁死并改回官方源
client.js 原来每次重连都打「连接/连接错误/断开」,服务器不可达时会一直刷屏。
改成状态机:启动一条、连上一条、断开一条,重试全程静默,和 MCP 服务的风格一致。

client.example.yml 改成 IP 为主的示例(多数用户只有 IP,没有域名和证书)。
ws 从 ^8.18.0 锁到 8.23.0,与项目其余 package.json 的精确版本风格统一;
package-lock 的 resolved 改回 registry.npmjs.org,让 npm 的 --replace-registry-host
能按用户配置的镜像自动替换。
2026-11-15 12:22:59 +08:00
kicer d455c2d203 feat(tunnel): 通用反向隧道 server/client,按 Host/固定端口/通配路由,SSE 逐帧透传
服务端按 Host 头或固定端口把请求转给家里的 client,WS 长连接承载,
token 首次启动自动生成;响应流式逐帧回传,SSE 不受影响。
配置用 YAML(server.yml 自动生成,client.yml 手写),与项目其余配置一致。
2026-11-15 11:33:29 +08:00
kicer da8653e5e9 feat(ui): 文件树行内 @ 引用,相对路径插入输入框光标处 2026-11-15 10:00:35 +08:00
kicer d34b193033 feat(recall): 未收口会话的标题也参与检索与日期索引 2026-11-15 00:46:01 +08:00
kicer c3fdf8b6aa feat(ui): 桌面端语音输入改成点击开始 / 点击发送
手机按住说话是触屏习惯;桌面一直压着鼠标键说话手累,上滑取消在鼠标上也没
意义,说错了只能松手(等于发送)。

桌面(hover:hover + pointer:fine)改成点一下开始、再点一下发送。遮罩里自带
一行「取消 / 发送」,波形在上、按钮在下各占各位——之前那版把输入卡里的按钮
提到遮罩之上,正好压在波形中间。录音中 Esc 取消,两端都能用;键盘按住空格/
回车的旧绑定保留。

桌面休息态不再显示「说完点发送」那行(.vo-hint:empty 不占高度),识别中仍
显示分段进度。取消按钮用 #e8eaf0 实心底:原来的 --surface 在遮罩底部那层
淡蓝渐变上几乎看不出来。
2026-11-13 19:15:06 +08:00
kicer b018ba7864 feat(ui): Git 面板列表把 origin/master 标在它指向的提交上
列表只有本地历史,看不出哪条远端已经有了,也就判断不出本地领先几条。

ensureRepo 多返回 upstream(优先当前分支的 upstream,没配回退 origin/master),
列表渲染时给 id 相同的那条挂一枚 origin/master 徽章、行首加一条蓝竖线,
和 git log --decorate 一个意思。
2026-11-13 18:05:54 +08:00
kicer c07fc3be58 fix(ui): 手机端 HTML 预览底部那条白边
.fs-html-frame 是 <iframe>,默认 display:inline,作为行内元素参与行盒排版,底部会留出
4~5px 的基线间隙;#fs-body 又是 overflow:auto,这点溢出让容器能滚,手指上下滑就把底下
的背景露出来,看着像一条细白条。

display 改成 block 消掉间隙(根因),fs-bar 外层 overflow 从 auto 改成 hidden,不让它
再有滚动露底的机会——文本与源码的滚动仍由 #fs-body / #fs-src-pane 各自负责。
2026-11-13 18:03:45 +08:00
kicer a0195c710b feat(ui): Git 面板列表头显示 remote
列表只有仓库路径和分支,看不出这个仓库推到哪、也没法一眼确认有没有配远端。

ensureRepo 多读一条 git remote -v(取第一条 fetch,origin 惯例在最前),
URL 里的 user:pass 先脱敏再给前端;列表头渲染成「路径 · 分支 · origin」,
悬停看完整地址,没配 remote 时灰色标「无 remote」。
2026-11-13 18:00:56 +08:00
kicer 71f3cdb694 feat(ui): 主题切换挪到会话头部动作区,手机端进「更多」菜单
原来放在文件树头部,只有开着文件树才看得到;切到会话页/欢迎页就没有入口。

桌面放到头部动作区「新建会话」左边(.ha-icons),手机收进「更多」下拉菜单,
与切换模型/定时任务/压缩上下文同一套 data-act 分发,点完自动收起菜单。
files-tree.js 里那份按钮和主题逻辑一并删掉,统一到 sessions.js。

手机菜单项按现有写法拆成主文案「切换主题」+ 副标题「浅色/深色」,与其他
动作项一致(主文案是动作,副标题才是当前值)。
2026-11-13 17:59:08 +08:00
kicer 76297a8978 feat(ui): 加暗色主题,浅/深两态手动切换
style.css 里 204 处硬编码颜色(92 种)先收敛成 88 个语义变量,亮色值原样
保留——亮色主题视觉一点没变。暗色只写一块 :root[data-theme="dark"] 覆盖
这些变量,渲染规则一行没动,不会出现「调一处崩另一处」。

切换入口放文件树头部最右组(Finder 前面),太阳/月亮两态循环,存
localStorage,默认浅色;head 里一段内联脚本先落 data-theme,避免刷新时
先白一下。

配套:Prism token 一套 GitHub dark 配色、Git diff 的加减底色与行号分隔线、
color-scheme: dark(原生滚动条/输入框跟着转暗)、meta theme-color 同步。
.input-shell 原来写的是 rgba(0,0,0,0.1) 边框,黑底上等于没画,暗色下换成
#3d444d;工具卡的卡片底、命令区、文字原来是同一个黄褐色,分层为 #332713 /
#241c0a / #e3b341,结果文字改浅灰 #d7cfc0,一眼能分出层次。
2026-11-13 17:52:06 +08:00
kicer 0529991ba1 feat(ui): 会话正文里的围栏代码块也上色
md 渲染只做了 marked → HTML + 复制按钮,聊天里贴的 ```js 一直是无色纯文本;
代码预览和 Git diff 都上色了,唯独对话主体没有。

历史渲染在 appendMessagesDom 收口处、流式在 stream.js 两处(收尾整块重排与
分页追加)各补一次 pvHighlightMdCode;token 配色的选择器前缀加上 .md(聊天气泡
的 markdown 容器),与预览共用同一套 GitHub 配色。
2026-11-13 17:11:11 +08:00
kicer 87b8d5197b feat(ui): 手机端代码预览也带行号和语法高亮
移动端走的是另一条渲染路径 pvRenderLegacy,那里的 else 分支直接 esc(text)
成纯文本——同一个文件在电脑上有行号有色,在手机上什么都没有。

把桌面 pvTextNode 的代码分支抽成 pvCodeNode(text, name),两条路径共用:
pvTextNode 补上 __tb/__src,pvRenderLegacy 直接挂进 #fs-viewer。窄屏
(<960px)行号列收窄到 28px,不挤占正文宽度。
2026-11-13 17:05:57 +08:00
kicer 2be92e1106 perf(ui): 预览栏拖拽调宽改为每帧落值,拖动期间圈住重排
pointermove 每来一次就写 --pv-w:这个变量同时驱动 #pv-pane 宽度、#app 的 width 与
margin-left、#toast 的 left,等于每个鼠标事件都让整棵会话 DOM 重新布局、消息文字重新折行,
长会话下明显卡顿,鼠标 120Hz 时一帧还不止一次。

改成 pointermove 只记 lastX,rAF 里落一次值;pointerup 若还有挂起的帧先取消再补一次,
保证落点准确。拖动期间 body.pv-resizing 下:#app 关掉 pointer-events(图片/链接的 HTML5
拖拽不会再冒出来)、#chat-view 与 #pv-pane 各加 contain,把重排重绘圈在列内。

选中文字是同一处实现的两个缺口:pointerdown 没有 preventDefault,按下那一刻就可能开始
拖选;手柄只有 6px,点偏到会话区就完全没进 resizer 的 pointerdown。前者补上,后者把热区
放宽到 10px(hover 透明度同步从 .3 调到 .25)。
2026-11-13 16:16:03 +08:00
kicer f5099345d0 fix(ui): 代码预览的缩进空白被吃掉,Git diff 横向滚动时行背景露白
两个渲染层的坑:

1) 代码预览每行是 <div class="pv-cl"> 直接放文本节点,而 .pv-cl 是
display:flex,裸文本成了匿名 flex 项——浏览器会折叠它的前导空白,整行
只有缩进时该文本节点直接被当成「flex 项之间的空白」丢掉。现在代码包进
显式的 <span class="c">,.c 上 white-space: pre,缩进和 tab 都回来了。

2) Git diff 的行背景只到可视宽度:块级元素在 overflow-x 容器里宽度恒为
容器宽,内容溢出时背景不跟着延伸,横滑后短行右侧一片白。滚动区里包一层
.vcs-fb-in,行 width:100% 撑满它,宽度用 syncPatchWidth() 实测——
Math.max(clientWidth, scrollWidth),只量 clientWidth 会漏掉最长行的内容宽
(实测 699 vs 1129,13 行全部按 1129 铺开)。渲染详情与展开文件时各同步一次。
2026-11-13 16:12:40 +08:00
kicer 67dff34a89 fix(ui): 修好右下角运行中转圈的两段描边
上一轮把图标收进 sprite 后,转圈变成一个灰环:.scroll-bottom-btn .sb-spinner circle
和 ...path 是后代选择器,<use> 的内部元素在 shadow tree 里选不中,浅灰圆环与蓝色进度弧
的描边宽度、颜色全部回退成外层 svg 的 #556/2px。

改用 CSS 自定义属性穿透:--sb-ring / --sb-arc 定义在 .sb-spinner 上,symbol 里那两个元素
用 style 引用——presentation attribute 不解析 var(),必须写在 style 里。颜色仍归 CSS 管。

全量扫过一遍:CSS 里命中 svg 内部元素的后代选择器只有这一处,JS 里也没有 querySelector
直接改 path/circle 的写法。
2026-11-13 16:00:26 +08:00
kicer 8694061068 fix(ui): 空目录不再显示「(空目录)」,mtime 没变就不再请求
点开空文件夹只多一行「(空目录)」,本来就没有展开箭头(.tree-row.open 没有任何样式),
这行提示是唯一的视觉变化,去掉后点击就是看不出变化。根目录的空提示保留:整个文件树
空白时分不清是空还是没加载。

顺带省掉自动刷新时对空目录的重复请求:tree 接口给目录 entry 补 mtimeMs(readdir 的
Dirent 不带时间,statSync 一次即可),前端把确认空的目录记成 rel -> mtimeMs。目录内
增删子项会更新目录自身 mtime,父目录重拉时比对不上就重新请求——所以 AI 往空目录里写了
文件依然会自动出现,不会因为缓存看不见。invalidate(true) 保留这份记录,切会话/新建/
切隐藏文件(invalidate(false))清空。
2026-11-13 15:57:49 +08:00
kicer 95047678f3 feat(ui): 代码预览接入 Prism 语法高亮,md 代码块与 Git diff 共用一套配色
js/json/yml/sh/py 这类文件原来只有行号、没有颜色。vendor 里加 prism.min.js
(core + 20 种常用语言,52KB / gzip 18.7KB),UMD 直接 <script> 引入,与
marked 同一种加载方式,不需要构建。

代码预览是整块高亮后再按行拆:pvSplitHighlighted 维护一个打开的 span 栈,
行尾补 </span>、下一行行首重开同名标签。逐行调 Prism.highlight 会把多行注释、
三引号字符串、模板字符串切花;拆完行数与原文对不上时退回纯文本,保证行号不错位。

配色(GitHub 亮色系)用 :is(.pv-code, .pv-doc, .vcs-line) 覆盖三处:
- 代码预览 .pv-code
- md 里的围栏代码块:pvHighlightMdCode 用 highlightElement,只处理标了
  language-xx 且语言已打包的块,没有语言标记的保持纯文本
- Git 面板 diff:逐行着色(diff 是片段,跨行 token 本来也拼不完整),
  超过 2000 行的 patch 不上色,避免同步高亮把面板卡住
2026-11-13 15:53:46 +08:00
kicer baec30398a feat(ui): 代码预览加行号,放大时可铺满
js/json/yml/sh/py 这类文件原来只有一个 pre + textContent,纯等宽,看不出行,
放大预览也只是把 920px 的内容框居中摆着。

现在按行渲染 .pv-cl,行号用 CSS counter(.pv-cl::before)生成——伪元素不进
选区,拖选复制不会把行号带进剪贴板。行号列宽按最大行号位数(--nw)自适应,
不折行、横向滚动,视觉与 Git 面板的 .vcs-line 一致;超过 5000 行只渲染前段,
避免几万个逐行节点把面板拖死。

放大预览(body.pv-max)时代码区与源码面板都去掉 920px 上限铺满窗口。
2026-11-13 15:44:26 +08:00
kicer a03fc9b82b docs: 示例地址改占位符,去掉私有域名 2026-11-13 15:29:42 +08:00
kicer c21647c642 docs: AGENTS.md 补前端图标 sprite 约定
<use href> 指不到 symbol 时浏览器不报错,界面只是空白,这种静默失败必须写下来:
加图标先加 <symbol id="i-xxx">,形状只改 sprite 那一行,尺寸描边归各处 CSS。
2026-11-13 15:23:31 +08:00
kicer cf21c42b17 fix(ui): 新建或切换会话时收起预览与 Git 面板
预览分栏当初刻意设计成切会话不关的第三列,但里面放的是上一个会话的文件和仓库,
留在旁边容易被当成当前会话的;窄屏的全屏预览浮层更是直接盖住新会话。

新增 closePreviewAll() 一次收干净:桌面走 pvCloseDoc(内部会 vcsSetMode(false),
Git 面板一并落下),窄屏浮层补一次 closeFullscreen。openSession 与 newChat 都调。

新建会话还漏了 renderDrawerList:sessionId 置空后没重画侧栏,旧会话的选中态一直亮着。
2026-11-13 15:23:31 +08:00
kicer 2e2e47171f refactor(ui): 全站 svg 图标收进 index.html 的 symbol sprite
前端 99 处 svg、56 个唯一图形(× 号 11 次、+ 号 6 次、复制与文档各 5 次),
43 处是纯冗余路径:改一个图标得在两三个文件里同步,加个新图标又要复制一份 path。
现在几何图形统一定义在 index.html 里的一份 sprite,引用写成
<svg 原属性><use href="#i-xxx"/></svg>——外层 class、尺寸、fill/stroke 原样保留,
所以大小和描边仍归各处 CSS 管(.ic / .tree-act svg / .files-fab svg),形状逐像素照搬。

脚本按几何指纹建映射,99 处全部命中,零未匹配;校验结果 symbol 56 个、
引用 99 处、无缺失、无未被引用、sprite 外无残留几何标签,JS 全部 node --check 通过。
同形但历史写法不同的(folder/folder-b/folder-c、x-line/x-line-b/x-path、eye/eye-sm 等)
各留一份 symbol,保证替换前后完全一致,后续要收敛只改引用指向即可。

sprite 容器用 position:absolute + 零尺寸,不用 display:none:后者在部分旧浏览器上
会让被引用的 symbol 也一并不渲染。

体积:index.html +6KB(sprite 定义),js 合计 -5.3KB,总量基本持平。
2026-11-13 15:20:10 +08:00
kicer 0433e61941 chore(ui): 清掉操作成功的冗余提示,统一各处垃圾桶图标
这些 toast 说的东西界面已经摆在眼前:撤回后的文字就在输入框里、复制按钮自己变勾、
删除完列表自己少一行、深度思考按钮自己变色。弹出来反而挡住会话内容,统一去掉。
保留全部失败提示,以及带额外信息的(终止时清了几条队列、清空后文件仍保留)。

垃圾桶在前端有四份画法(盖沿 polyline、桶身一体、线条 path 三种混写),统一成
盖沿+提手+桶身+两道竖线这一套;尺寸与描边跟随各自上下文(20px/2、13px/1.8、14px/1.9),
只求形状一致,不改各处的视觉粗细。
2026-11-13 15:12:05 +08:00
kicer 7b1ef9a479 feat(ui): 排队消息可撤回输入框重新编辑
运行中发出的消息排在待发送条幅里,原来只有一个 ×:点掉就从服务端队列删了,正文跟着蒸发。
现在拆成两支:笔(撤回编辑)删队列项并把正文回填输入框、光标停在撤回段末尾;垃圾桶直接丢弃。
两者都走 DELETE /pending/:qid,区别只在要不要把正文带回来。撤回文本必须在请求前取,
DELETE 的响应里这条已经没了。

回填拼在已有草稿之前,与发送失败的兜底同序;之后 autosize / updateSendBtn 同步,
focus 带 preventScroll,免得浏览器为了露出输入框把页面滚一下。

条幅占位会改 chat-view 的 clientHeight,浏览器不会替你补滚动,最后一条消息因此被裁在视口外。
renderSendQueue 改成改动前先记 isNearBottom,贴底就在本帧与下一帧各补一次 scrollBottom;
条幅自己限高 100px、超出内部滚动,sq-item 加 flex:none 防止被压扁。

顺带清掉复制与删除消息两处成功提示(按钮变勾、消息已消失,都不需要再说一遍)。
2026-11-13 15:12:01 +08:00
kicer 793be29331 feat(ui): 上下文注入行改成折叠卡片,摘要卡片统一同一套视觉
画像快照、渠道说明、开场记忆这些「只发给模型看」的注入内容,之前要么完全
不可见(画像快照存在 sessions 表里,不在 messages),要么假装成用户发言——
channel_note / memory_note 会被 userMsgHtml 渲染成一条用户气泡,打开微信
会话时那两段 # [CTX] 大文本就挂在你名下。

现在统一成可折叠卡片:画像快照是每轮请求拼在最前的上下文,历史又是懒加载
的,所以等翻到最早(has_more=false)再补到流顶,不会插在首屏那几条前面被
后续分页顶到中间;渠道/记忆按 type 直接渲染成卡片。内容都走 markdown,和
摘要卡片一致。

压缩摘要卡片与它们共用一套:淡蓝底、蓝边蓝字、三角箭头、虚线分隔,折叠与
展开同底色,去掉渐变/阴影/数据库图标,默认全部收起(流式收尾也不再自动
展开),标题旁的「后续对话以此为起点」一并去掉。摘要卡片补 width:100%,
否则在 align-items:flex-start 的 .msg 里折叠后只剩标题那点宽。

顺带:errAck(工具参数非法被整轮移除)在气泡上方标一行,原来只显示模型
当时的内容,看不出这一轮其实没进上下文。
2026-11-13 14:52:24 +08:00
kicer b9fad470ee feat(engine): 重启后自动续跑被中断的回合
进程被 stop/重启打断时,回合状态只在内存 runs 里,重启即丢;init 又把
active 一律归位 held,用户得重新喊一声才动。

现在归位前先挑出「回合没走完」的:最后一条非 tool 消息是 user(模型还没答)
或带 tool_calls 的 assistant(这批工具之后没了下文)。已答完、只是没来得及
finalize 的会话不在此列,照常归位。归位后延迟 5 秒(等 listen 与 executor
就绪)再拉起:补中断点的回执,然后 ensureBinding + touch(active) +
恢复 deepThink + runLoop。

补回执不是伪造执行结果,文案写明「服务重启,本次调用被中断,执行结果未知」。
没有配对回执时 buildMessages 会把整行 tool_calls 丢掉,模型看不到自己发过
什么命令,「重启」这类任务就会无限重试(实测 stop/start 来回三轮)。
2026-11-13 14:30:30 +08:00
kicer 8168eae51e fix(ui): Git 面板的两句空状态提示改成现状措辞
服务器镜像现在装 git 了,「服务器镜像未装 git」这句注解已经不成立,
只说「这个环境没有 git 命令」,免得把人往镜像配置上引。

not_repo 统一改成「未找到 git 仓库:当前会话目录及其上级都不是仓库」:
后端这个 reason 也涵盖会话目录不存在、rev-parse 失败,原来只说「当前会话
目录不是 git 仓库」,用户会以为目录选错了,其实是没有仓库可读。
2026-11-13 11:41:42 +08:00
kicer a2bedbf0d7 feat(ui): 文件树头部操作钮分左右两组
五个图标钮原来全挤在右端(显示隐藏文件 / 刷新 / Git / Finder / 终端),
一排点下来容易点到隔壁,刷新和 Git 面板尤其挨得近。

现在左边一组是树内只读操作(显示隐藏文件、刷新、Git),右边一组是拉到外部
打开(Finder、终端,仅本地模式出现),两端由 space-between 拉开,组内间距仍按
侧栏收紧成 4px。没动机器行为,只多包一层 span 加两条覆盖规则。
2026-11-13 11:25:55 +08:00
kicer 3d5c8a80f1 feat(ui): 预览栏新增查看源码按钮
手机端 #fs-viewer 早有眼睛钮,桌面端预览栏只有下载和刷新:md / html / svg
这类渲染过的内容想看原文只能去终端开文件。

做法是渲染时把原文挂到节点的 __src,show() 带进 pvToolbar 的 o.source;
只有带 source 的类型才显示 #pv-src,点了在 #pv-body 里挂一个 pre 并隐藏预览
节点,再点移除。只做查看不做复制——桌面端选中即可复制,多一个按钮只是噪声。
超过 2MB 截断显示,避免大文件塞 pre 把面板卡住。

html/svg 顺手用同一份文本:r 只能读一次,svg 改为先取文本再自己包 blob。
代码类预览本身就是 .pv-pre,源码面板加 pv-src-pre 以便区分两套节点。
2026-11-13 11:25:52 +08:00
kicer 6eca2dd215 feat(ui): 会话流里的本机链接直接在预览窗打开
点 /app/task-x/daily.html 这类站内地址原来是浏览器默认的新标签,
预览窗只认 sessionId + 相对文件名,同一个地址没第二条进窗口的路。
现在 #chat-view 上加委托监听,命中本机 host 的链接就交给 pvOpenUrl:
桌面进右侧分栏,窄屏(含手机)进 #fs-viewer 全屏浮层,系统返回键可收起。

「本机」= 完全同源,或两端都是 localhost/127.0.0.1/[::1]/0.0.0.0 别名(端口不究),
部署在公网域名时同源自然命中。外链、//host、锚点、mailto、相对路径不拦;
Ctrl/Cmd 点击与中键放行,保留「我就是要开新标签」这个出口。

pvOpenUrl 走 iframe 直挂,不经过文件读取链路,sandbox 沿用现有 HTML 预览的
allow-same-origin allow-scripts——data-page 页面要靠脚本渲染表格。URL 模式下
隐藏下载钮(不是文件,按名下载会拼错路径),刷新钮重建 iframe,新窗口钮开原地址,
地址条回填完整 URL 方便复制。窄屏不传 source,源码/复制钮自动隐藏。

地址条回车顺带认站内绝对路径:/app/... 原来当相对文件名去 fetch,注定 404,
现在同样进预览窗。移动端 popstate 的判定从 [src^=/preview/] 放宽到 .fs-html-frame,
URL 预览也能被返回键收起。
2026-11-13 11:07:51 +08:00
kicer 43dec0ad0f feat(ui): 文件树新增 Git 面板(提交历史 / 提交详情 / 未提交改动)
原来想看仓库改了什么只能开终端敲 git,界面里没有入口。复用预览栏做二选一
(body.pv-mode-vcs):打开时占预览的位置,点文件自动切回预览,不再各占一块屏。

三个视图只用一个渲染器:列表 → 点提交进详情,顶部「未提交的改动」进工作区,
两者仅头部信息不同(有无 commit 元信息)。只读,不做 commit / checkout / pull。

不做任何自动刷新:只在打开面板、切视图、点刷新时请求,避免边干活边被打断。

后端 git.js 用 execFile 调 git,加 -c core.quotepath=false 保中文路径不被转义成
八进制;status 用 -z 输出,否则含空格的路径带引号、和 diff 里的裸路径对不上。
patch 按单文件 120KB / 合计 400KB 截断,未跟踪文件用 diff --no-index 现算。
不是仓库或没装 git 返回 HTTP 200 + reason,由界面给空状态。

镜像补装 git,apt 源照 executor/Dockerfile 换成腾讯云镜像(默认源在国内 update 会卡死)。
2026-11-13 11:00:50 +08:00
kicer ecf32c0388 fix(engine): 回合内自动压缩后接着跑完原任务
max_context 触发的压缩发生在任务中途,摘要落库后直接走到 !hasTools 收尾,整个回合就停在半路,得用户再喊一声才动。改为摘要落地后补一条 user 指令(上下文已压缩,请继续完成原任务。)并 continue 同一回合;手点「压缩」发起的独立压缩回合压完仍正常收尾。
2026-11-13 10:16:53 +08:00
kicer f2f8ba9b72 fix(config): 自动压缩提议阈值默认改为 0(关)
auto_compress_tokens 只管「回合结束后弹提议」,不必对所有人默认开启;默认关,需要的人自己填阈值。
2026-11-13 10:16:13 +08:00
kicer 728b213821 fix(ui): 会话列左右内边距 32px 收窄到 20px
桌面端 #chat-view 与 footer 的左右 32px 留白偏大,内容区两侧显得空;统一收到 20px,输入区与会话列仍然等宽。
2026-11-13 10:16:13 +08:00
kicer 14616e1606 feat(ui): 标签页标题直接用会话标题,不加后缀
无标题时仍回默认「Agent 任务台」。
2026-11-13 09:54:32 +08:00
kicer cf43206c98 feat(ui): 标签页标题跟随当前会话
renderHeader 是所有会话标题变化的出口(切会话/重命名/自动生成标题/首条消息临时标题),
在其中同步 document.title;回欢迎页或会话还没标题时恢复默认「Agent 任务台」。
2026-11-13 09:53:07 +08:00
kicer 0922045a38 refactor(ui): 去掉文件树多余的自动刷新触发(focus / visibilitychange)
切一下窗口就刷一次太吵;visibilitychange 那处也与 resyncSession 重复:
后台挂起回来会走 resumeStream→resyncSession 补拉并刷新,没挂起则 SSE 在线、done 已刷。
自动刷新收敛为三个:一轮跑完、断线重连补拉完、上传完成。
2026-11-13 09:51:19 +08:00
kicer 351662d18c feat(ui): 文件树在回合结束/回前台/重连后自动刷新
- 新增 reloadFileTree():保留展开与勾选,只重拉已展开的目录;250ms debounce + 1s 去重,多路触发合并
- 一轮跑完(engine 循环退出才发的 done)就地刷新;回前台 visibilitychange 与窗口重新聚焦也刷;断线重连补拉后补一次
- 修掉「切回文件树面板仍用旧缓存」:showFileTree 先失效再渲染
- 上传后改用 reloadFileTree,不再把用户已展开的目录收起来
2026-11-13 09:40:31 +08:00
kicer 4c4076ba13 feat(ui): 侧栏面板模式写进地址栏,刷新后保持文件树/会话列表
- syncUrl 改为无参,按 state.sessionId + #drawer 的 drawer-mode-files 拼 ?s=<id>[&files=1]
- setDrawerPane 切换成功后同步地址栏:点底部文件树图标、切回列表都会改写 URL
- 新窗口带 files=1 进来落地即文件树,F5 不再退回会话列表;窄屏 setDrawerPane 直接 return,地址栏不会写上 files=1
2026-11-13 09:27:47 +08:00
kicer 65d05d2656 feat(ui): 新窗口打开落地即进文件树,调换行内按钮顺序
- 行内按钮改为删除在最右、新窗口在它左边(误触删除的概率更低)
- 会话行新窗口链接带 files=1,打开会话后把侧栏切到文件树,省一次点击
- 手机端本来就不显示行内按钮(hover:hover + pointer:fine),窄屏 setDrawerPane 也会拒绝切文件树
2026-11-13 09:25:22 +08:00
kicer e50015cdc1 feat(ui): 侧栏会话支持在新窗口打开,地址栏常驻当前会话
- 会话行 hover 增加「在新窗口打开」按钮,走已有的 /?s=<id> 深链;触屏媒体查询下不显示
- 地址栏改为跟随当前会话:切会话写 ?s=,新建/删除回 /;原先深链消费一次就抹成 /,
  导致新窗口刷新或复制地址会丢会话
- 打开失败(会话已删/链接失效)时清回 / 并落回 welcome,不留「加载中…」和亮着的顶部按钮
2026-11-13 09:22:57 +08:00
kicer 6d4b41ebfe feat(ui): 文件树支持勾选批量下载 / 删除,去掉展开箭头
窄屏的旧文件面板一直有全选和批量操作,桌面端接管后的文件树没有。这次补上:

- 行内勾选框(hover 或已选中时淡入,占位常驻,不挤动文件名),目录行也能勾,
  勾目录表示整个目录;勾子项会把祖先目录降级,提交前再按目录折叠一次,避免
  zip 里重复。
- 树底部新增一条:全选(作用域=当前已展开可见的行,部分选中显示横杠)、已选
  计数、批量下载、批量删除。没选中时按钮禁用。
- 批量下载沿用旧面板两条链路:含目录交给 /files/zip-token 打包一次下载;纯文件
  先取完全部 download-token 再逐个触发,避免被浏览器当弹窗拦掉。
- 批量删除一次确认后逐项 DELETE,完成清空选中并刷新,预览里正开着的文件一起关。
- 行内动作保持原样:服务器端文件「下载/删除」、目录「删除」;本地端「在 Finder
  中显示/删除」。本地端底栏隐藏批量下载——文件就在本机,没意义。
- 去掉目录前的展开箭头:文件夹图标已说明可以点,点行任意位置都能展开。
2026-11-12 15:15:27 +08:00
kicer a4897c1ace docs: README 改成项目概览,加界面截图
483 行压到 77 行,只留定位、快速开始(服务器 / 本机)、组成、配置、升级、
安全、License。特性表、内置工具表、技能规范、目录树、环境变量、常见问题这些
细节删掉,各子目录的能力看 app/、mcp/、wxbot/、skills/、local/ 自己的 README。

界面截图从仓库根移到 docs/agent.jpg,README 开头直接引用。
2026-11-12 10:38:20 +08:00
kicer 25f9e157ad docs(skills): 排错清单统一成「报错 → 怎么办 → 命令」,office 改为建软链
技能目录的 AGENTS.md 只在报错时被读,所以只写「报错原文 → 怎么办 → 命令」,一节一个
现象,不写背景。命令块前统一声明「仅为示例,具体以本机平台实际情况为准」——路径分隔符、
可执行名、包管理器交给模型按本机情况自愈,不逐平台列出。

office:`command not found` 从按次拼 PATH 前缀改成建一次 $HOME/.local/bin/office 软链。
每条 terminal 命令都是新 shell,前缀不跨命令生效,按次拼的写法容易被反复踩。
image-process:PIL 缺包与「中文水印缺字体」拆成两节。
x2pdf:后端代价表压成三条列表,四个现象(ModuleNotFoundError / 没有可用排版能力 /
could not import some external libraries / 排版降级)各自成节。
document-photo-to-pdf:单节化,保留 fitz 是 pymupdf 的 import 名这条坑。
data-page 只用标准库,不需要 AGENTS.md。
2026-11-12 10:05:46 +08:00
kicer 8a92f2543d feat(engine): 会话目录改为首次调工具时才建,纯文本对话不再留空目录
建目录原来在 createSession 里,纯文本会话也照建,磁盘上越积越多(线上 119 个
会话目录里 39 个是空的)。改成在 executeTool 入口懒建:会话只算路径,第一次
真正用到工具(含技能递归调用)才 mkdir;上传/写文件本来就自带 mkdir,只读路径
(文件树、下载、公链、预览)维持「不存在即空/404」。
2026-11-12 09:46:52 +08:00
kicer 90158ab590 fix(local): 启动器改用 detached 方式起,关终端不再连带停服
nohup + & 起的后台副本仍在终端 shell 的作业表和进程组里:关窗口时 HUP 打到它,
脚本里的 trap HUP 又覆盖了 nohup 的忽略位,于是走 on_signal 把 core 和 MCP 一起
收掉(Terminal 上实测会挂,iTerm2 只是送信号方式不同)。同时 shell 因残留后台
作业,退出时还会卡一下。

改成 node 的 child_process.spawn({detached:true}),子进程 setsid 成独立会话、
无控制终端;pid 仍是本脚本,stop.sh 的 pid 文件逻辑不变。
2026-11-12 09:22:08 +08:00
kicer f587eb5b52 fix(llm): 深度思考状态随会话落库,压缩不再断前缀缓存
deepThink 只在发消息时写进 sessions.deep_think,重进会话按它回填按钮,压缩回合
沿用会话当前状态而不是强制关思考。

压缩回合照常发 tools、system prompt 不动,请求与上一发常规请求只差尾部那条压缩
指令,前缀缓存整段命中(原来压缩去 tools、关思考,前缀从最前面就断了)。

reasoning_content 只在开思考时回传:关思考不发历史思维链;开思考时带 tool_calls
却没有思维链的行用空串占位,避免上游 400。
2026-11-12 09:02:23 +08:00
kicer 57ff5073d8 feat(config): 模型可配 max_context,到线自动压缩上下文
max_context 是用户自定义的用量线,不是模型真实窗口:回合内 In 峰值到了,就在
下一发请求之前切成压缩回合,摘要落库后清零,支持连续压缩。

回合起点用上一发上游实报的 prompt_tokens 播种峰值,否则新回合第一发的判据永远是
0,历史早就超线也会整段再打一次(实测 123903 ≥ 120000 那发就是白打的)。
2026-11-12 08:42:07 +08:00
kicer b657a22fe2 fix(server): 下载响应接住 sendFile 异步错误,点文件不再 404 也不再吐堆栈
- sendDownload 加 dotfiles:'allow' 与图片分支对齐:.env / .gitignore 这类点文件
  本来存在,却被 send 的默认 ignore 策略当成不存在抛 NotFoundError
- sendDownload / sendInlineImage 都补上 sendFile 回调,失败统一走 sendFileError:
  4xx 折叠成 404、正文只留一行纯文本。此前错误没人接,落进 Express 默认处理器,
  非 production 环境下把 err.stack 拼成 HTML 吐给请求方(服务端绝对路径、源码
  文件名+行号、依赖版本),而 /p/<id> 是挂在 auth 之前的匿名可达端点
- 新增 error-handler.js 作统一错误出口,末尾挂在 server.js:任意路由漏出的异常
  同样只回一行纯文本,栈只进日志、不再进响应体
2026-11-12 07:45:06 +08:00
kicer ffca861dc1 fix(local): 预览网关按 executor/preview.js 对齐数据面,去掉白屏与冷启动卡顿
对照服务器实现(executor/preview.js)逐条补齐,这些不是优化而是缺功能:

- vendor 页把根绝对 `/` 当作「自身最新 HTML」比对,网关必须按 Referer 把它转给 watch。
  原来只转 `/events`、`/api/*`,`/` 回 404 → 页面判定自身过期 → location.reload(),
  用户看到的就是白屏后重新加载
- 就绪判定改为真发一次 `GET /`(首帧渲染在那次请求里完成);裸 TCP 连上只说明 Kestrel bind 好了
- HEAD 探针等槽位就绪(上限 15s)再回 200:冷启动渲染不再落到 iframe 的导航请求上
- 导航请求绝不为启动/自愈阻塞:未就绪或外部改动 → 立刻中转页 + 后台热槽;缺尾斜杠补 301
- 外部写盘靠 mtime 指纹 + 2s 轮询 POST /api/switch 触发重读;实现 __pv-touch(编辑命令的事后一脚)
- 转发看门狗、conns 计数、失败摘槽并原地复活重试一次、404 带 no-store

本地实测:冷 HEAD 3.3s 回 200、热导航 10ms、根绝对 / 与页面 HTML 逐字节相同、冷启动导航
2.7ms 回中转页、touch 后 SSE 收到 action:full、kill -9 watch 后自动换代重起。

顺带给 office 封装层注入 OFFICE_GATEWAY_PORT(它那段 __pv-touch 写死 3100)。
2026-11-11 22:34:47 +08:00
kicer f6665e904e fix(local): 预览槽位加活性校验,watch 退出后不再卡在 502
watch 进程被外部杀掉或 vendor 崩溃后,槽位仍留在网关里,于是所有转发都打到死端口,
面板上只有一句「预览服务不可达」(HEAD 探针只查文件存在性,还回 200,所以更像死链)。
- ensureWatch 拿槽位前先探活,死了就丢掉重起(HEAD 探针也会间接触发)
- forward 转发失败时立即丢槽位,下一次导航/刷新即可恢复,不必等 6h 闲置回收
- killSlot 对已退出的子进程不再按 pid 杀(pid 可能已被系统复用)
2026-11-11 22:20:42 +08:00
kicer 893fc92f6d fix(local): 变量名紧贴全角括号导致 unbound variable / 报错消息中断
bash 3.2 在 UTF-8 下把紧跟变量名的全角字符算进标识符,`"$PREVIEW_PORT(office 文档)"`
会被当成 $PREVIEW_PORT(office 这个变量 → set -u 下直接炸,启动器在 preview 那步退出。
四处一律改成 ${VAR} 形式;其中 `$SKILLS_DIR(python3 未安装…` 是原有问题(只在没 python3 时触发)。
2026-11-11 22:17:43 +08:00
kicer b3a0d5370c feat(local): 本地自建 office 预览网关,技能恢复服务器同源行为
- 新增 local/preview-gateway.js:零依赖复刻 executor :3100 的数据面(/preview 转发、SSE 与
  /api/* 按 Referer 认领槽位、4 槽 LRU + 闲置回收、缺二进制给安装页而不是无限转圈),
  不复刻 unshare/nsenter/mount 牢笼——本地没有沙箱,命令与 watch 本就同机同盘
- local/start.sh:选空闲端口起网关,经 PREVIEW_PROXIES 登记进 core 反代;端口写入
  .runtime/preview.port;local/stop.sh 兜底清理时一并收掉
- skills/office 回到 v2.5.0 行为:本地也发预览卡片、watch 族照旧隐藏,不再有 LOCAL 分支;
  binary missing 的报错改为指向技能自己的 AGENTS.md(平台中立)
- 网关按平台分支:进程回收(POSIX 进程组 / Windows taskkill /T)、二进制名(.exe、也认
  officecli-* 资产名)、POSIX 自动补 chmod +x;会话目录解析修正为读 {session:{work_dir}} 并限流
- 文档:docs/local-mode.md 补 4.15 与验证结果,local/README.md 补预览、日志与端口
2026-11-11 22:12:14 +08:00
kicer 8effba36dd feat(local): 工作目录拆成 data/skills/tasks,技能复制到用户目录
启动器不再把技能软链回仓库,改为首次启动把内置技能复制到 <工作目录>/skills,
之后每次启动只补缺不覆盖(用户/AI 改过的不会被冲掉)。deps 不复制,只建空目录,
pip 装进 <工作目录>/skills/deps,PYTHONPATH 与 AGENT_SKILLS_DEPS 都指过去。

工作目录据此变成三件套:tasks=会话工作区(AI 的文件根,与服务器 /workspace/tasks
同语义)、data=SQLite 与 prompt dump、skills=技能。仓库里不再有用户数据。

配置仍只由首次启动生成:workspace_root=<ws>/tasks、data_root=<ws>/data、
skills_root=<ws>/skills。新增 cfg_get/skills_dir 从配置读技能根,不自己发明路径。
2026-11-11 21:31:14 +08:00
kicer 77ef1ec11c feat(skills): office 本地放行 watch、x2pdf 加浏览器后端
office 封装层:本地直跑(AGENT_LOCAL_PICK)没有预览网关,不发 ui_card、
不 POST __pv-touch;watch/unwatch 与 mark/goto 族放行,watch 改后台拉起 +
等端口就绪后报地址退出(前台透传会卡到 terminal 超时)。

x2pdf:文本类分派改为 WeasyPrint → 无头浏览器 → LibreOffice,浏览器后端只需
装了 Chrome 系,不要求用户为转 PDF 现编 pango;CSS/base 注入到 head,无 @page 时
补 A4(浏览器默认 Letter)。吞掉 WeasyPrint 导入失败时裸 print 到 stdout 的告警。
对外文案只讲结果(排版降级/无可用排版能力),实现细节留在 AGENTS.md。
2026-11-11 20:50:18 +08:00
kicer 0234bc85e5 feat(local): 技能通用规则进提示词,移除 skills/AGENTS.md 中转
- env-local 加两条:长任务后台写日志+10 秒轮询;国内 pip/npm/GitHub/brew 换源
- 4 个技能 AGENTS.md 删掉指向根文档的指针行;pip 命令补 --upgrade
- document-photo-to-pdf:自检未能执行时单独给摘要,不再伪装成「建议确认」
- SKILL.md 示例去掉真实域名,改成 <站点地址>
- 删除 skills/AGENTS.md(根级中转文档,靠出错时翻文件拉不动)
2026-11-11 20:15:52 +08:00
94 changed files with 5849 additions and 1601 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
+14 -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` 的解析 |
@@ -180,6 +187,10 @@ curl -s http://127.0.0.1:8090/api/health
由 `server.js` 传函数进去。
- 前端是**无构建的经典脚本**:新增文件要同时改 `app/server/public/index.html` 的 `<script>`
顺序(共享全局作用域,顺序即依赖)。
- 前端图标统一走 `index.html` 顶部的 `<symbol>` sprite:引用写成
`<svg class="…" viewBox="0 0 24 24"><use href="#i-xxx"/></svg>`,形状只改 sprite 里那一行,
尺寸与描边归各处 CSS(`.ic` / `.tree-act svg` 等)。加图标先加 `<symbol id="i-xxx">`,
漏了不报错、界面只是空白。
## 常见任务去哪改
@@ -193,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` |
+33 -435
View File
@@ -1,483 +1,81 @@
# Agent 任务台
自托管的通用 Agent 系统。浏览器或微信发来任务,服务端调度模型、调用工具,在独立工作目录里生成文件并回传结果。
自托管的 Agent 系统。浏览器或微信下发任务,模型在独立工作目录里读写文件、执行命令、调用技能,产物直接回传。
它不是聊天壳子:每个会话对应一个真实的 Linux 工作目录,模型可以读写文件、执行命令、抓网页、操作 SQLite、调用技能和 MCP 服务;命令在隔离容器中运行,文件可以直接下载或生成公网临时链接。
- 面向个人或小团队自用,单实例部署。
- 模型层兼容任何 OpenAI `/chat/completions` 接口。
- 前端是免构建的移动优先 H5,HTTPS 下可安装为 PWA。
---
## 能力
| 能力 | 说明 |
|---|---|
| 任务会话 | 每个会话一个独立目录 `tasks/<会话 id>/`,历史、文件、模型绑定都随会话保存 |
| 模型池 | 多平台、每平台多 key、每平台多模型;key 共享并发,不独占、不排队 |
| 工具调用 | 文件读写编辑、目录列举、复制、命令执行、网页抓取、SQLite、定时任务、技能、长期记忆等 14 个内置工具 |
| 隔离执行 | `terminal` 和技能在 `agent-executor` 容器中运行,只看到当前会话目录,根文件系统只读 |
| 大文件交付 | 文件面板上传/下载/打包 zip;外部服务取图走带过期时间的公网短链 |
| 上下文管理 | 手动压缩、按 token 阈值提示压缩、历史重放自动裁剪、会话标题自动生成 |
| 回合中投递 | 运行中发的消息先进输入框上方的待发送条幅:默认等本轮结束自动发出;可「干预」(当前工具跑完就插话)或「立即发送」(终止本轮并立刻发)。队列在服务端,关页面不丢 |
| 定时任务 | 每会话最多一个 cron 任务;触发前清空模型可见历史,按计划执行并推送结果 |
| 微信接入 | 扫码绑定个人微信,文本/图片/视频/文件进入同一套会话与命令体系 |
| 语音输入 | 输入框为空时发送键变麦克风:点一下进入语音模式,输入框位置变成「按住 说话」,松开即转写并直接发送;发送键位置变键盘按钮可切回打字。套壳 App 走原生录音(http 页面也能用),浏览器走 MediaRecorder(需 HTTPS);识别在 `mcp_asr`,不经过模型、不消耗 token |
| 长期记忆 | 会话收口时生成第一人称工作日记;微信新会话注入最近几条,`recall` 可检索全部 |
| 用户画像 | 记录称谓、行业、偏好,会话创建时冻结注入,跨会话生效 |
| 技能 | 目录式技能(`SKILL.md` + `run.py`/`run.sh`),可在设置页管理 |
| MCP | 启动时发现 MCP 服务的工具;仓库内自带 `web_search` / `image_task` / `video_task` 三个 |
| 多用户 | 登录账号、管理员角色、按用户隔离的会话列表与画像 |
---
![Agent 任务台](docs/agent.jpg)
## 快速开始
### 前置条件
### 服务器
- Linux 服务器,Docker 与 Docker Compose v2。
- 至少一个 OpenAI 兼容模型平台的 API Key。
- 一个可用端口,默认 `8090`。
Debian 12 裸机可以先跑 `scripts/init_host.sh`(幂等,可重复执行,也可单独拷到服务器上跑):它会配好 Swap、Docker、国内镜像加速与基础 shell 环境;`REGION=oversea` 切海外源。跑完会打印后续的 `init.sh` 与部署步骤。
### 1. 初始化(只做部署接线)
在仓库根目录执行:
需要 Docker 与 Compose v2:
```bash
./scripts/init.sh
docker compose up -d --build
```
它只做三件事,**幂等**,随便重跑:
打开 `http://<服务器 IP>:8090`,用 `admin` / `admin` 登录,先改密码,再到「设置 → 模型」添加平台和 API Key,保存后点「重启服务」。
1. 生成 `.env` 里的 `EXECUTOR_TOKEN` / `WXBOT_TOKEN` / `AUTH_SECRET`(已有值原样复用,重跑不会掉登录态,也不会换掉 executor 的 token)。
2. 探测公网 IP 并写成 `PUBLIC_BASE_URL`(外部服务靠它回取会话文件,图生视频需要)。知道地址就直接给:
```bash
PUBLIC_IP=1.2.3.4 ./scripts/init.sh
```
3. 确保 `config.yml` 存在:**不存在时**才创建,内容只有初始管理员 `admin` / `admin`。已有文件**绝不改写**。
### 本机运行
脚本不再生成模型平台 / MCP / 语音这些配置——它们全部在前端「设置」里完成,写的就是同一个 `config.yml`。所以重跑脚本永远不会清掉你配好的东西(旧版脚本会覆盖,这是本次的行为变化)。
- 想换初始管理员:仅在**首次创建**时生效,`AUTH_USER=me AUTH_PASSWORD='强密码' ./scripts/init.sh`。
- `config.yml` 被 Docker 误建成了空目录(源文件缺失时才会这样):脚本会自动删掉并重建;目录非空则报错让你手工处理。
没有 `config.yml` 也能启动:`platforms` 为空、`auth` 为空即“无模型 + 不启用登录”,登录后从设置页补齐即可(保存后点「重启服务」生效)。
### 2. 启动
macOS / Linux,Node 20+,不需要 Docker:
```bash
# 迁移:把旧版根目录的 config.yml 原样留着即可,init.sh 不会动它
docker compose up -d --build
docker compose logs -f agent-core
./local/start.sh # 后台启动
./local/stop.sh
```
看到 `Agent server listening on 8090` 即启动完成。
首次运行会让你选一个工作目录(技能、会话、数据库都在里面)。命令直接在本机执行,没有沙箱隔离,只监听 `127.0.0.1`。
首次启动还会运行一次性的 `agent-executor-init`,把技能依赖安装到 `./skills/deps`,随后自动退出,属正常现象。
需要从外网访问时,配好 [`tunnel/client.yml`](tunnel/README.md) 后 `start.sh` 会一并拉起隧道 client;未配置则跳过。
### 3. 访问与首次配置
## 组成
浏览器打开:
```text
http://<服务器 IP>:<AGENT_PORT>
```
首次用 `admin` / `admin` 登录(**登录后立刻在「设置 → 账户」改密码**)。默认端口 `8090`,可用 `.env` 的 `AGENT_PORT` 修改。
登录后去「设置」补齐三块,保存后点页面顶部的「重启服务」:
| 设置页 | 配什么 |
| 目录 | 说明 |
|---|---|
| 模型 | 平台地址 + API Key + 模型 id(`extra_params` / `thinking_params` / profile 等在「高级」里) |
| MCP | `image_task` / `video_task` / `asr` 需上游 key;`web_search` 免费,地址 `http://mcp_web_search:3000/` |
| 用户 | 其余账号、角色、默认模型;改密码在「账户」 |
对外只需要放行 core 这一个端口。`agent-executor`、`wxbot` 和 MCP 服务都只在 Docker 内网,不映射到宿主机。
### 4. 同栈 MCP 服务
初始 `config.yml` 不包含任何 MCP 服务。设置页「MCP」会把四个同栈服务作为**内置服务卡片**列出来,
点卡片 → 填表 → 保存即可(url 与 header 名由 `app/server/presets.json` 提供,不用记)。
`web_search` 免费、无需 key;另外三个要填上游 key。手工写 YAML 的形状如下(容器不存密钥):
```yaml
mcp_servers:
- name: web_search
url: "http://mcp_web_search:3000/"
# - name: image_task
# url: "http://mcp_image_task:3000/mcp"
# headers:
# Authorization: Bearer <upstream-api-key>
# X-Image-Task-Base-Url: "https://open.bigmodel.cn/api/paas/v4" # 任意 OpenAI 兼容的 images 上游(生成 /images/generations、编辑 /images/edits)
# X-Image-Task-Model: "CogView-4"
# mode: skill
# - name: video_task
# url: "http://mcp_video_task:3000/mcp"
# headers:
# Authorization: Bearer <zhipu-api-key>
# mode: skill
# - name: asr
# url: "http://mcp_asr:3000/mcp"
# headers:
# Authorization: Bearer <key> # 免鉴权的自建服务可省
# X-ASR-Base-Url: "https://<host>/v1"
# X-ASR-Model: "whisper-1"
# mode: skill
```
`web_search` / `image_task` / `video_task` / `asr` 四个容器与 core 由同一个根 `docker-compose.yml` 启动(与是否写进配置无关),没有先后顺序,也不占宿主机端口。工具说明、header 覆盖项与调试方式见 [mcp/README.md](mcp/README.md)。
`ASR_URL`(`docker-compose.yml` 里固定为 `http://mcp_asr:3000`)是 core 调用语音转写的基地址;把 `mcp_asr` 放到另一台机器时改这一行即可(那台要能接受 `Authorization` / `X-ASR-Base-Url` / `X-ASR-Model` 三个 header)。
语音输入(H5 输入框里说话)走的是另一条路:客户端录音 → `POST /api/asr/transcribe` → `mcp_asr` 的 `/transcribe`,**不经过模型、不消耗 token**,结果插入输入框可编辑。客户端录音契约(Android 套壳原生桥 / 浏览器 MediaRecorder)见 [docs/voice-input.md](docs/voice-input.md);删掉 `config.yml` 里的 `asr` 段即整体关闭。
`mcp_asr` 自己**不存任何平台密钥**:上游 key / base_url / model 都由 core 从这里那段 `asr.headers` 随请求带进去,换平台只改 YAML(不用重建镜像、不用动 `.env`),也不预设任何厂商。
接入栈外的 MCP 服务:在设置页添加 `url` / `headers`,或在 `config.yml` 的 `mcp_servers` 追加一项。服务不可达时 core 只在启动日志里告警,不影响 Web 主流程,但对应工具不会下发给模型。
每个服务可用 `mode` 控制「工具是否下发给模型」:
| `mode` | 连接/发现 | 进 tools 数组 | 进技能清单 | 谁可以调用 |
|---|---|---|---|---|
| `advertise`(默认) | ✓ | ✓ | ✗ | 模型与技能 |
| `skill` | ✓ | ✗ | ✓ | `skill` 工具与 `lab` |
| `disable` | ✗ | ✗ | ✗ | 无人 |
`skill` 用于「能力包在技能后面」的场景:工具照常发现并注册,只是不进模型的 tools 数组,改为以技能形式暴露——`{"op":"list"}` 能看到它,`{"op":"get","name":"<名>"}` 直接返回 MCP 原始的 `description` + `input_schema`,`{"op":"run","name":"<名>","args":{…}}` 转发给服务。不用在 `skills/` 里建目录。旧字段 `enable` 已废弃,`mode: silent` 已移除(启动会报错并提示改用 `skill`)。
工具发现只在启动时做一次,因此发现失败后会自动按 **2s / 20s / 1min 重试 3 次**(覆盖 compose 并行拉起与宿主机重启后的容器乱序);成功后工具在下一轮请求即可用,三次都失败则需重启 core。四个 MCP 服务都配了 `/health` 健康检查,`docker ps` 可直接看状态。
---
## 使用
### 会话与模型
- 新建会话时自动绑定一个模型;不选则按平台轮转选择。
- 会话创建后模型绑定保持,重启、追问都不会丢。
- 模型被删除或禁用后,下一条消息会自动改选原平台的可用模型。
- 管理员可在「设置 → 用户」给某个用户锁定默认模型。
- 顶部「切换模型」只在该会话空闲时可用;正在输出时会拒绝换绑。
会话状态:
| 状态 | 含义 |
|---|---|
| 保持中 | 回合已结束,可以直接继续追问 |
| 活跃中 | 正在执行模型回合 |
| 已完成 | 已手动断开或空闲超时收口,仍可继续发消息 |
| 已终止 | 用户主动停止 |
### 文件
- 输入框附件、微信附件都落在 `tasks/<会话 id>/`。
- 右侧「任务文件」面板支持上传、下载、批量打包、删除、子目录浏览。
- 模型生成的文件与用户上传的文件在同一目录,AI 可直接继续处理。
- 超过 50 MB 的单文件上传会被拒绝;移动端大图上传前会在浏览器端压缩。
### 上下文压缩
- 顶部「压缩」可手动触发:模型基于完整历史生成摘要,摘要之前的消息标记为已存档,UI 仍可见,但不再发给模型。
- 当单回合输入 token 超过 `agent.auto_compress_tokens` 时,前端会弹一次确认框,询问是否压缩。
- 历史重放还会自动把较旧的 `write_file` 参数正文、`fetch` / `read_file` 回执替换为单行占位,数据库与 UI 不受影响。
### 定时任务
对 AI 说「每天早上九点汇总……」,它会在当前会话创建 cron 任务:
- 每会话最多一个任务,最小间隔 1 小时,时区固定 `Asia/Shanghai`。
- 每次触发前,会话历史整体标记为已存档,模型只看到任务提示词,等价一次全新会话。
- 执行结果留在会话里,同时可通过微信推送。
- 创建任务后,当前会话会收口为该任务的「专柜」,用户下一条消息自动进入新会话。
### 微信
在「设置 → 账户 → 微信绑定」生成二维码,扫码后即可单线对话:
- 微信消息复用同一套会话和命令层,支持 `/new`、`/list`、`/switch`、`/delete`、`/rename`、`/models`、`/think`、`/stop`、`/compact`、`/clear`、`/status`、`/help`。
- 回合进行中发消息=自动干预:当前工具调用跑完就插话(同批剩余调用标记为「因你介入未执行」),不会等本轮结束,也不会打断正在执行的命令。要立刻中止用 `/stop`。
- 图片、视频、文件会落到当前会话目录;单发媒体只留痕,不唤醒 AI。
- AI 最终回复会推回微信;较长回复自动分段,超长时落成 `.md` 文件卡片。
- 定时任务完成或失败也会通知微信。
### 长期记忆
- 会话空闲超过 `memory.wrap_idle_ms`(默认 4 小时)后,后台生成一条工作日记碎片,并归档、解绑通道。
- 微信新会话开场注入最近 `memory.inject_max` 条碎片。
- AI 可用 `recall` 工具按关键词、日期索引、具体某天检索全部日记。
- 删除会话会连带删除它的日记碎片;清空会话在普通情况下也会删除,但定时任务「专柜」例外。
- 日记调试页:`/memory.html`。
---
| [`app/`](app/README.md) | agent-core:Express + SQLite + 前端静态资源,唯一对外端口 |
| `executor/` | agent-executor:隔离的命令执行、Office 预览网关 |
| [`wxbot/`](wxbot/README.md) | 微信接入 |
| [`mcp/`](mcp/README.md) | 四个 MCP 服务:网页搜索、图片生成、视频生成、语音转写 |
| [`skills/`](skills/README.md) | 内置技能 |
| [`local/`](local/README.md) | 本机模式启动器 |
| [`tunnel/`](tunnel/README.md) | 反向隧道:把本机服务经服务器中转,供外网访问 |
## 配置
`config.yml` 只给 `agent-core` 读取,包含平台密钥和登录密钥。`agent-executor`、`wxbot` 不挂载、不读取它。
主要配置段:
| 段 | 作用 |
|---|---|
| `platforms` | 模型平台池:`name`、`url`、`type`、`models`、`keys` |
| `model_profiles` | prompt + 工具名单组合;模型用 `profile: <名>` 引用 |
| `tools_deny` | 全局工具黑名单,默认屏蔽元工具 `lab` |
| `auth` | 登录账号、`secret`、有效期;留空则不启用认证 |
| `mcp_servers` | 外部 MCP 服务:`url`、`headers`、`mode`(advertise / skill / disable)、`timeout_ms`、工具名单 |
| `public_link` | 公网临时链接前缀与有效期 |
| `agent` | 温度、最大工具迭代、重试、语言、压缩阈值、空闲收口、历史裁剪 |
| `memory` | 日记注入条数、保留期、空闲收口阈值 |
| `terminal` / `fetch` | 命令超时与输出上限、抓取超时、字节数、SSRF 开关 |
| `skills` | 技能目录与单次执行超时 |
| `upload` | 前端大图压缩阈值与参数 |
| `workspace_root` / `data_root` | 任务目录与 SQLite / 调试产物目录 |
平台结构示例:
`./scripts/init.sh` 首次生成 `config.yml`,只有 agent-core 读取。日常改动走设置页,保存后点「重启服务」。
```yaml
platforms:
- name: bigmodel
url: https://open.bigmodel.cn/api/paas/v4
type: bigmodel # 决定余额查询适配器
models:
- id: glm-5.3-flash
vision: true
extra_params: { reasoning_effort: "low", tool_stream: true }
thinking_params: { reasoning_effort: "max" }
keys:
- api_key: "sk-..."
```
通用模型字段:
端口与其余环境变量在 `docker-compose.yml` 里。
- `enable: false`:模型不进池,不参与分配。
- `vision: false`:读图时不回传像素,回执只给结构化说明(`reason: no_vision`)。
- `profile: <名>`:引用 `model_profiles`,不配则使用默认全量 prompt 与工具。
- `reasoning_ack_field`:需要把思考链回传给上游时填写,例如 DeepSeek 系的 `reasoning_content`。
日常修改配置建议使用设置页;改完需重启生效。设置页写入前会先校验,非法配置不会覆盖原文件。
### 环境变量
| 变量 | 作用 |
|---|---|
| `AGENT_CONFIG` | core 配置文件路径,容器内固定 `/app/config.yml` |
| `PORT` | core 监听端口,容器内 `8090` |
| `EXECUTOR_URL` | `agent-executor` 地址;空则命令在 core 进程内本地执行,仅适合开发 |
| `EXECUTOR_TOKEN` | core ↔ executor 的 Bearer token,两侧同值 |
| `ASR_URL` | core 拼接 `/transcribe` 的基地址,compose 里固定 `http://mcp_asr:3000`(把 `mcp_asr` 放别处时改那一行) |
| `ASR_LOG_LEVEL` | `mcp_asr` 日志等级 |
| `WXBOT_URL` | wxbot 地址;置空则微信功能整体关闭 |
| `WXBOT_TOKEN` | core ↔ wxbot 的共享 token |
| `PUBLIC_BASE_URL` | 对外的完整地址(如 `http://1.2.3.4:8090`),作为 `public_link` 的默认值;设置页填过则以设置页为准 |
| `PREVIEW_PROXIES` | 覆盖内置预览反代注册表(JSON 数组) |
| `EXECUTOR_LOG_LEVEL` / `WXBOT_LOG_LEVEL` | 两个附属服务的日志等级 |
`config.yml` 与 `.env` 都含密钥,已在 `.gitignore` 中。不要提交,也不要挂给不需要它的容器。
---
## 内置工具
模型实际收到的工具是内置工具加 MCP 工具,再经 `tools_deny` 与模型 `profile` 过滤。
| 工具 | 用途 |
|---|---|
| `read_file` | 读文本或图片;大文件返回符号大纲;支持 `@<会话 id>/<路径>` 只读查看历史会话文件 |
| `write_file` | 新建或覆盖文本文件 |
| `edit_file` | 按 `old_text` / `new_text` 做精确或容错编辑 |
| `list_directory` | 单层列目录;支持 `@<会话 id>/<路径>` |
| `copy_path` | 复制文件或目录;可从历史会话导入文件 |
| `terminal` | 执行 shell 命令;默认在会话目录,超时可终止 |
| `fetch` | 抓取 HTTP/HTTPS 并转 Markdown;带 SSRF 防护与分段续读 |
| `mint_public_link` | 为会话内文件签发短期公网链接 |
| `skill` | 技能:`op` = `list` / `get` / `run`;`name` 指技能,`args` 传参数 |
| `db` | 操作会话本地 `data.db`:`exec`、`query`、`insert`、`tables`、`schema` |
| `schedule` | 定时任务 `get` / `list` / `create` / `update` / `delete` |
| `profile` | 用户画像 `list` / `set` / `add` / `remove` |
| `recall` | 长期记忆 `search` / `days` / `day` |
| `lab` | 元工具:按名字调用任意工具,`help` 可列出全部工具;默认被全局黑名单屏蔽 |
跨会话路径只读:`@` 形式只用于 `read_file`、`list_directory` 和 `copy_path` 的源路径,且只能访问同一用户自己的会话。要真正处理旧文件,先用 `copy_path` 导入当前会话。
---
## 技能
技能是 `skills/<名字>/` 目录:
```text
skills/my-skill/
├── SKILL.md # 必需:描述、input_schema、可选 required / visit_url
├── run.py | run.sh # 入口,唯一命令行参数是 JSON 字符串
├── requirements.txt # 可选:Python 依赖
└── install.sh # 可选:系统层安装脚本,镜像构建期执行
```
- `SKILL.md` 的 `description` 会进入 system prompt,模型启动时就知道有哪些技能。
- `input_schema.required` 在 `op=run` 前校验。
- MCP 工具不用建目录:给该服务配 `mode: skill`,平台会自动把它暴露成技能(`get` 返回 MCP 原始的
`input_schema`,`run` 转发),见上文「同栈 MCP 服务」。
- 入口脚本以绝对路径启动;远端执行时 cwd 是会话目录,本地开发时是技能目录。相对路径参数会先按会话目录转成绝对路径。
- `requirements.txt` 的依赖由 `agent-executor-init` 安装到 `skills/deps`;技能容器通过 `PYTHONPATH` 可见。
- `install.sh` 在镜像构建期以 root 执行,用于必须落在系统层的依赖。改完需要重建 executor 镜像。
- 技能目录在 executor 中只读,运行期不能修改技能本身。
设置页支持创建、重命名、删除技能和在线编辑文本文件;技能列表变更后会实时刷新 system prompt 中的清单,无需重启。
---
## 安全模型
### 部署边界
- 对外只暴露 `agent-core` 端口。
- `agent-executor` 使用独立的 mount / PID / IPC namespace,只 bind 当前会话目录;根文件系统只读,丢弃全部 capability 后仅保留 `SYS_ADMIN`。
- 命令容器没有独立网络 namespace,所以 executor 会拒绝来自自身容器网卡的 `/exec` 请求,避免 token 泄漏后被借用。
- `wxbot` 只挂内网;微信登录凭证在 `./wxbot/data`,等同微信账号权限,不要外泄。
- 配置文件、`.env`、微信凭证、任务目录、SQLite 都属于敏感数据。
### 认证与授权
- 登录使用 HMAC 签名的 HttpOnly Cookie,支持 `Authorization: Basic` 作为脚本 / curl 的兜底。
- `auth.users` 留空则完全关闭认证,只适合本机或完全可信网络。
- 管理员接口:配置读写、用户管理、进程重启。
- 删除用户会连带清理其微信绑定(含 wxbot 实例与凭证)、会话(含任务目录)、画像、长期记忆与通道绑定;`model_usage` 的用量统计保留(与删会话一致,不清账)。
- **重要**:系统按单租户设计。除上述管理员接口外,会话、消息、文件、技能等 API 只校验「已登录」,不按用户做资源级授权;按用户的会话列表隔离发生在前端查询层。不要把实例开放给互不信任的用户。
### 公网临时链接
`mint_public_link` 生成 22 字符随机 ID,链接形如:
```text
http://<host>/p/<id>
```
- 只由 core 进程内的工具签发,签发前校验文件在任务目录内且 `realpath` 未越界。
- 默认 30 分钟过期,可配置 1 分钟到 24 小时。
- 链接可重复使用,直到过期;服务重启后全部失效。
- 响应头按类型分开:图片(`png/jpg/webp/gif/bmp/tif/avif/ico/svg`)返回 `inline` + 对应 `image/*`,点开链接直接看图;其余类型返回 `attachment`,交给浏览器/WebView 下载(SVG 额外带 `Content-Security-Policy: sandbox`,禁止内嵌脚本)。
- 任何人拿到链接即可匿名访问,不要对含密钥的文件签发。
### HTTPS
仓库不内置 TLS 反向代理。直接 `http://IP:端口` 使用时:
- PWA / Service Worker 不会注册。
- 复制按钮会回退到旧 API。
- 登录 Cookie 不带 `Secure` 标志,HTTP 下正常工作。
如果前面加 nginx 等反向代理,SSE 必须关闭缓冲:
```nginx
proxy_http_version 1.1;
proxy_buffering off;
proxy_read_timeout 3600s;
```
公网链接前缀取 `config.yml` 的 `public_link.base_url`(设置页「服务 → 公网地址」);没填时用 `.env` 的 `PUBLIC_BASE_URL`(`init.sh` 会自动探测写入)。前置了反向代理 + HTTPS 的部署,直接把它填成域名即可。
---
## 运维
### 数据位置
| 宿主机路径 | 容器内 | 内容 |
|---|---|---|
| `./tasks/` | `/workspace/tasks` | 每个会话的工作目录 |
| `./data/` | `/workspace/data` | SQLite `.agent.db`、`prompt.txt` 调试产物 |
| `./skills/` | `/workspace/skills` | 技能与共享依赖 |
| `./config.yml` | `/app/config.yml` | core 配置 |
| `./wxbot/data/` | `/data` | 微信登录凭证 |
备份至少覆盖 `data/`、`tasks/`、`config.yml`;需要保留微信登录态时再备份 `wxbot/data/`。
### 升级
## 升级
```bash
git pull
docker compose up -d --build
```
数据库与任务目录都在 bind mount 中,升级不丢数据。进程重启时,执行中的回合会被打断;`active` 会话会归位为保持中,用户再发消息即可继续。
数据在 `data/`、`tasks/` 和 `config.yml` 里,升级不受影响。
> 从旧的「agent + mcp 双仓库」部署升级:旧 mcp 容器占着 `agent-mcp-net` 和同名 `container_name`,需先停旧栈再 `up` 本栈,否则会报 `network agent-mcp-net has active endpoints` 或 `container name ... is already in use`。旧仓库的 `down` 只需执行一次:
>
> ```bash
> cd /root/workspace/tools/mcp && docker compose down
> cd /root/workspace/tools/agent && docker compose up -d --build
> ```
>
> 微信服务已改名为 `agent-wxbot`(原容器名 `wxbot`)。旧容器不受新 compose 管理,升级后需手动清理,否则两个实例会同时轮询同一个微信号:`docker rm -f wxbot`。
## 安全
### 日志与健康检查
- 对外只开 agent-core 一个端口,其余服务只在 Docker 内网
- 隧道只经服务器 nginx(TLS)对外,宿主机端口仅绑 `127.0.0.1`;`server.yml` 与 `client.yml` 的 token 必须一致
- 命令在 executor 容器里执行,只挂当前会话目录,根文件系统只读
- 单租户设计:除管理员接口外不做用户级资源隔离,不要开放给互不信任的人
- `config.yml`、`.env`、`wxbot/data/` 存密钥,已加入 `.gitignore`
```bash
docker compose logs -f agent-core
docker compose logs -f agent-executor
docker compose logs -f agent-wxbot
curl -s http://127.0.0.1:8090/api/health
# {"ok":true,"service":"agent-core","api":1,"time":...,"auth_required":true}
```
## License
- `GET /api/health` 是**唯一免登录接口**,供运维探活,也供套壳 App 校验用户手填的服务器地址。
客户端判定条件:HTTP 200 且 `ok === true` 且 `service === 'agent-core'`——**不要只看状态码**,
填错到别的站点或反代首页同样可能回 200。地址末尾的 `/` 可带可不带。
`auth_required` 用于区分「地址对了但没登录」与「地址错了」。
- core 日志等级由 `config.yml` 的 `log_level` 控制,改完重启生效。
- executor / wxbot 的日志等级由各自环境变量控制,`debug` 会打印完整交互。
- 启动时会在 `data/prompt.txt` 写入实际下发的 system prompt 与各 profile 的工具清单,便于核对。
### 常见问题
| 现象 | 原因 / 处理 |
|---|---|
| 启动时报 `network agent-mcp-net has active endpoints` | 旧的双仓库部署残留:先停旧的 mcp 仓库(`docker compose down`),再 `up` 本栈 |
| 套壳 App 填了服务器地址仍连不上 | 先 `curl <地址>/api/health` 看是否返回 `service:agent-core`;再查 Android 9+ 默认禁止明文 HTTP(需 `usesCleartextTraffic`)与 https 自签证书 |
| 麦克风按钮不显示 | `config.yml` 的 `mcp_servers` 里没有启用的 `asr` 段 / 该段缺 `X-ASR-Base-Url`(`GET /api/asr/status` 会返回 `reason`);或浏览器以 `http://<IP>` 访问且没有原生录音桥(非安全上下文开不了麦,见 `docs/voice-input.md`) |
| 点麦克风提示「语音识别服务不可用」 | `mcp_asr` 未起来(`docker compose logs --tail=50 mcp_asr`);或 `config.yml` 的 `asr.headers` 缺 `X-ASR-Base-Url` / `X-ASR-Model` |
| `config.yml` 变成目录 | 启动前文件不存在,Docker 自动建了同名目录;重跑 `./scripts/init.sh` 会自动删除空目录并重建(非空目录需先备份再手工删除) |
| 没有可用模型 | `platforms` 为空或模型全部禁用;在设置页添加后重启 |
| 创建会话报「无可用模型」 | 模型池为空,或指定模型所在平台没有 key |
| 技能依赖缺失 | 重新 `docker compose up -d --build agent-executor`;或检查 `skills/deps` |
| 微信设置页显示未连接 | wxbot 未启动,或 `WXBOT_TOKEN` 两侧不一致 |
| 图生视频拉不到参考图 | `public_link.base_url` 未配置,或公网不可达 |
| 启动日志出现 `xxx 工具发现失败` | 当时服务未就绪,core 会按 2s/20s/1min 重试 3 次;仍失败则重启 `agent-core` |
---
## 目录
```text
agent/
├── app/ agent-core:Express + SQLite + 前端静态资源
├── executor/ agent-executor:隔离命令执行与 Office 预览网关
├── wxbot/ 微信 iLink 协议调制解调器
├── mcp/ 同栈 MCP 服务:web_search / image_task / video_task
├── skills/ 技能目录
├── tasks/ 会话工作目录(运行时生成)
├── data/ SQLite 与调试产物(运行时生成)
├── docs/ 专题文档
├── docker-compose.yml
└── scripts/init.sh
```
进一步阅读:
- [mcp/README.md](mcp/README.md):同栈 MCP 服务(搜索 / 生图 / 生视频)。
- [docs/OFFICE.md](docs/OFFICE.md):Office 文档技能与预览链路。
- [docs/tool-design.md](docs/tool-design.md):工具接口设计规范。
## 开发
```bash
cd app
npm install
node server/server.js
```
AGPL-3.0,见 [LICENSE](LICENSE)。
+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` 回执必须从父
+16
View File
@@ -2,6 +2,22 @@ FROM node:20-slim
ENV TZ=Asia/Shanghai
# git:Git 面板(提交历史 / 未提交改动)要读仓库,本机与容器共用同一条代码路径。
# 国内构建慢:apt 默认源在国外,apt-get update 能卡十几分钟。默认换成腾讯云镜像(与 executor 同源)。
# 境外构建或想换源:docker compose build --build-arg DEBIAN_MIRROR=deb.debian.org
ARG DEBIAN_MIRROR=mirrors.cloud.tencent.com
# 换 apt 源:bookworm 可能是 /etc/apt/sources.list,也可能是 deb822 的 /etc/apt/sources.list.d/*.sources,
# 直接 grep 扫一遍、只替换域名,两种格式都盖住(路径 /debian、/debian-security 保持不变)。
RUN set -eux; \
files="$(grep -rl 'deb.debian.org' /etc/apt/ 2>/dev/null || true)"; \
if [ -n "$files" ]; then sed -i "s|deb.debian.org|${DEBIAN_MIRROR}|g" $files; fi
# 装完清 apt 列表,不给镜像多留几十 MB。
RUN apt-get update \
&& apt-get install -y --no-install-recommends git \
&& rm -rf /var/lib/apt/lists/*
WORKDIR /app
# 国内构建慢:npm 默认源在国外。默认换成腾讯云 npm 镜像(与宿主机 ~/.npmrc 一致)。
+4 -1
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 读完
@@ -46,7 +49,7 @@ agent:
max_tool_iterations: 100 # 单轮最大迭代数(含工具调用)
max_retries: 2 # 上游失败重试次数
language: "Simplified Chinese" # 强制回复语言;留空不限
auto_compress_tokens: 60000 # In token 超此值弹「自动压缩」提议;0=关
auto_compress_tokens: 0 # In token 超此值弹「自动压缩」提议;0=关(默认关)
# 历史重放占位裁剪(省 token):把「可再生的重负载」换成单行占位再发给上游
#(DB/UI 不动,盘上可重读/重抓)。两个距离条件**同时满足**才裁:
# rounds = 这一行之后又出现了几条 AI 回复 (「后面 AI 又说了几句话」)
+17 -3
View File
@@ -76,14 +76,16 @@ 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 上的回合缓存不重抓。
// allow_private=false 开 SSRF 防护:目标主机名解析到回环/私有/链路本地地址即拒绝(重定向逐跳复查);
// 确需抓内网服务再显式开 true(注意 DNS 重绑定属残余风险)。
fetch: { timeout_ms: 30000, max_bytes: 1048576, max_chars: 12000, max_chars_hard: 64000, allow_private: false },
// auto_compress_tokens:本轮 In token 峰值 ≥ 此值时推送「自动压缩」提议(0=关)。
// auto_compress_tokens:本轮 In token 峰值 ≥ 此值时推送「自动压缩」提议(0=关,默认关)。
// auto_complete_ms:held(保持中)超过此时长自动收口为 completed(0=关)。key 非独占后 held 不占任何资源,
// 收口是纯视觉动作:历史/绑定不动,再发言照常由 completed 分支续跑(见 engine.sweepHeldTimeouts)。
// 历史重放占位裁剪(llm.buildMessages):trim.rules 逐条声明「哪个工具、参数侧还是回执侧、
@@ -93,7 +95,7 @@ const DEFAULTS = {
// turns = 这一行之后又来了几条真人消息(role=user 且 type 为空,「后面又来了几条真人消息」)
// 所以 turns:1 = 回合内绝不裁、跨过用户回合边界才裁(避免长回合里模型反复重读同一个文件)。
// 这里是默认策略的唯一来源:config.yml 写了 trim.rules 就整体替换(写 [] = 全关)。
agent: { temperature: 1.0, max_tool_iterations: 100, max_retries: 2, language: 'Simplified Chinese', auto_compress_tokens: 60000, auto_complete_ms: 1800000, trim: {
agent: { temperature: 1.0, max_tool_iterations: 100, max_retries: 2, language: 'Simplified Chinese', auto_compress_tokens: 0, auto_complete_ms: 1800000, trim: {
min_chars: 600,
rules: [
// 参数正文只是写盘时的快照:不带 turns,回合内也照裁(省的是每轮重发整个文件)
@@ -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,12 @@ 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),
profile,
});
}
@@ -359,6 +371,8 @@ function parseAndValidate(rawText, configPath) {
display_name: m.display_name, vision: m.vision, enable: m.enable,
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,
+3
View File
@@ -20,6 +20,7 @@ function initDb(dbPath) {
assistant_type TEXT DEFAULT 'secretary',
user TEXT DEFAULT '',
profile TEXT DEFAULT '',
deep_think INTEGER NOT NULL DEFAULT 0,
created_at INTEGER NOT NULL,
updated_at INTEGER NOT NULL,
completed_at INTEGER,
@@ -234,6 +235,8 @@ function initDb(dbPath) {
// 迁移:会话级工作目录(本地桌面端新建会话时手选一个真实目录)。空串 = 沿用
// workspace_root/<会话id>;服务器形态永远为空,行为与旧版完全一致(见 engine.taskDirOf)。
if (!cols.some(c => c.name === 'work_dir')) db.exec("ALTER TABLE sessions ADD COLUMN work_dir TEXT NOT NULL DEFAULT ''");
// 迁移:会话级深度思考开关(发消息时按请求体落库;重进会话回填按钮,压缩回合也以它为准)。
if (!cols.some(c => c.name === 'deep_think')) db.exec('ALTER TABLE sessions ADD COLUMN deep_think INTEGER NOT NULL DEFAULT 0');
// 迁移:wechat_bindings 补 deep_think 列——微信端全局深度思考开关(routes/channel.js /think 读写,
// 投递时作为既有 deepThink 参数的取值来源);默认 0=关(与 H5 按钮初始态一致,/think on 手动开)。
// 旧库若曾按 DEFAULT 1 补过列(当时默认开,存量行都是默认值回填而非用户显式选择),
+32 -2
View File
@@ -3,6 +3,7 @@
'use strict';
const path = require('path');
const log = require('./log');
// Content-Disposition 手工构造,绕开 content-disposition 包的 ASCII 兜底:
// 该包会把中文名逐字替换成 ?(???.pdf),且 filename= 后紧跟 filename*= 会让
@@ -53,10 +54,36 @@ function noStore(res) {
res.setHeader('Expires', '0');
}
// sendFile 失败的统一出口(所有调用方共用,不再各自 try/catch——sendFile 的失败是
// **异步**回调,调用方外层的 try/catch 根本抓不到)。
//
// 为什么必须有人接:没人接就落进 Express 默认错误处理器,而它在 NODE_ENV != production 时
// 会把 err.stack 拼成 HTML 页面吐给请求方——服务端绝对路径、源码文件名+行号、依赖版本全在
// 里面。/p/<id> 是匿名可达端点(public-files.js 挂在 auth 之前),一次失败就等于把内部结构
// 公开。所以正文只留一行固定文案,细节进日志。
//
// 4xx 一律折叠成 404:不向匿名取用方区分「不存在」与「无权限」(原来的 403/416 会变成
// 探针,能区分路径是否存在)。
function sendFileError(res, err, abs) {
const code = Number(err && err.status);
const notFound = !!err && (err.code === 'ENOENT' || (code >= 400 && code < 500));
const status = notFound ? 404 : 500;
log.warn('download', (notFound ? '取不到文件:' : '发送失败:') + abs +
'(' + ((err && (err.code || err.message)) || err) + ')');
if (res.headersSent) { if (res.destroy) res.destroy(); return; } // 已吐了半截,只能断开
res.removeHeader('Content-Disposition'); // 进来前已按附件设过,错误响应不该带文件名
res.status(status).type('text').send(notFound ? 'not found' : 'internal error');
}
function sendDownload(res, abs) {
noStore(res);
res.setHeader('Content-Disposition', downloadDisposition(path.basename(abs)));
res.sendFile(abs, { lastModified: false, etag: false, maxAge: 0 });
// dotfiles:'allow' 与下面的图片分支对齐。send 默认 'ignore' 会把 .env / .gitignore 这类
// 文件当成"不存在"抛 NotFoundError——文件明明在,取用方却拿到 404,且历史版本还会连带
// 把堆栈页吐出去(见 sendFileError)。点文件本来就是我们自己签发的,没有理由拒绝。
res.sendFile(abs, { dotfiles: 'allow', lastModified: false, etag: false, maxAge: 0 }, function (err) {
if (err) sendFileError(res, err, abs);
});
}
// 内联图片响应(公网链 GET /p/<id> 的图片分支):点开链接直接显示,不再被当成附件下载。
@@ -72,7 +99,10 @@ function sendInlineImage(res, abs, type) {
// sandbox 不给 allow-scripts,退化成不可执行、无同源权限的文档;<img> 引用本就不执行脚本,不受影响。
if (type === 'image/svg+xml') res.setHeader('Content-Security-Policy', 'sandbox');
// dotfiles 显式放行:read_file 的压缩产物在 .imgcache/(点目录),默认策略对其他调用方不保证。
res.sendFile(abs, { dotfiles: 'allow', lastModified: false, etag: false, maxAge: 0 });
// 回调同 sendDownload:图片也可能在读盘中途失败(被删/EACCES),不能漏给默认错误处理器。
res.sendFile(abs, { dotfiles: 'allow', lastModified: false, etag: false, maxAge: 0 }, function (err) {
if (err) sendFileError(res, err, abs);
});
}
module.exports = { contentDisposition, downloadDisposition, sendDownload, sendInlineImage, inlineImageType };
+167 -14
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 (?,?,?,?,?,?,?,?,?,?,?)'
@@ -205,9 +222,44 @@ function syncModelPool() {
// 进程重启后:key 非独占,所有会话的绑定保持不动(顶部展示的模型持续可见,直到用户手动断开/换绑)。
// active(重启后必无回合进程)与遗留 queued 会话统一归位 held;指向已被删除/禁用模型的绑定,
// 下次发消息时由 ensureBinding 自动改选(优先留原平台),用户无感。
// 归位前先把「回合没走完」的 active 挑出来:stop/重启打断时它们停在半路,最后一条非 tool 消息
// 必是 user(模型还没答)或带 tool_calls 的 assistant(这批工具之后没了下文)。
// 已答完、只是没来得及 finalize 的会话(最后是纯文本 assistant)不在此列,照常归位 held。
const resumeIds = [];
for (const r of db.prepare("SELECT id FROM sessions WHERE status='active'").all()) {
const last = db.prepare(
"SELECT role, tool_calls FROM messages WHERE session_id = ? AND role != 'tool' ORDER BY id DESC LIMIT 1"
).get(r.id);
if (last && (last.role === 'user'
|| (last.role === 'assistant' && last.tool_calls && last.tool_calls !== '[]'))) resumeIds.push(r.id);
}
db.prepare('UPDATE model_pool SET is_busy = 0, current_session_id = NULL').run(); // 旧版独占列清残留(调度已不读)
db.prepare("UPDATE sessions SET status='held', held_at=COALESCE(held_at, updated_at), updated_at=? WHERE status IN ('active','queued')").run(now());
startHeldSweeper();
// 续跑:不伪造工具执行结果,但给中断点那批调用补一条「服务重启、结果未知」的回执,
// 否则 buildMessages 会把整行 tool_calls 丢掉,模型看不到自己发过什么命令,重启类任务就会无限重试。
// 等 5s 是因为 init 早于 server.listen,executor 也可能还在起,太早开跑首轮工具只会拿到连接错误。
const RESUME_DELAY_MS = 5000;
for (const id of resumeIds) {
setTimeout(() => {
const s = getSession(id);
// 5s 内用户可能已经自己发消息(已开跑)或点了停止:只接管仍停在 held/active 的会话
if (!s || (s.status !== 'held' && s.status !== 'active')) return;
try {
ensureBinding(s);
touch(id, { status: 'active', held_at: null, completed_at: null, cancelled_at: null });
getRun(id, true).deepThink = !!s.deep_think; // 恢复中断前的深度思考开关(会话行里持久化的值)
const n = markInterruptedBatch(id); // 先补中断点的回执,模型才能看到自己发过什么命令
if (n) log.info('tool', id + ' 重启续跑前补齐 ' + n + ' 条中断回执');
emitStatus(id);
runLoop(id);
log.info('engine', id + ' 重启后续跑未完成的回合');
} catch (e) {
log.warn('engine', id + ' 重启续跑失败:' + (e && e.message || e));
}
}, RESUME_DELAY_MS);
}
if (resumeIds.length) log.info('engine', '检测到 ' + resumeIds.length + ' 个被中断的回合,就绪后自动续跑');
}
// ---------- 会话闲置处理(30min held 归档 + 4h 记忆收口) ----------
@@ -352,6 +404,32 @@ function modelVision(session) {
return !!(m && m.vision);
}
// 会话绑定模型的自动压缩阈值(models[].max_context,0=未配→不自动压缩)。
// 它不是模型真实上下文窗口,而是用户自己设的「用量线」——到线就压,与真实窗口多大无关。
function modelMaxContext(session) {
const m = session.model_id && (cfg.models || []).find(x => x.id === session.model_id);
return (m && Number(m.max_context)) || 0;
}
// 回合起点播种回合一开局的 In token:取「上一回合最后一次上游实报的 prompt_tokens」。
// 不播种的话新回合第一个判据永远是 0(run.turnMaxPt 在 runLoop 里清零),
// 历史早就超线也照样把整段再发一遍,只有等到本回合内出现工具迭代才补判——
// 实测 123903 ≥ 120000 的那一发就是白打的(无 tool_calls 的回合到头来一发都不压)。
// 摘要行的 usage 是「压缩请求自身」的用量(含被截断的旧转写),不代表压缩后的上下文,
// 拿它播种会让刚压完立刻再压,故只认最新摘要之后的行。
function seedTurnMaxPt(sessionId) {
const last = db.prepare("SELECT MAX(id) AS id FROM messages WHERE session_id = ? AND type = 'summary'").get(sessionId);
const row = db.prepare(
"SELECT usage FROM messages WHERE session_id = ? AND role = 'assistant' AND usage IS NOT NULL" +
" AND id > ? ORDER BY id DESC LIMIT 1"
).get(sessionId, (last && last.id) || 0);
if (!row || !row.usage) return 0;
try {
const u = JSON.parse(row.usage);
return Math.max(0, Number(u && u.pt) || 0);
} catch (_) { return 0; }
}
// ---------- 模型 profile(prompt+tools 组合) ----------
// 把 cfg 里预加载的自定义 prompt 文本注册给 llm(配置加载时已读入,见 config.js);
// engine.init 调一次,运行期只按名选取,零 IO。
@@ -491,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();
}
@@ -546,7 +623,7 @@ async function runLoop(sessionId) {
if (run.looping) return; // 已有循环在跑(下一轮迭代会自动带上最新消息)
run.looping = true;
// 回合级 In token 峰值(整轮结束后供自动压缩检查);记录本回合是否为压缩回合,压缩回合不再自启压缩防递归
run.turnMaxPt = 0;
run.turnMaxPt = seedTurnMaxPt(sessionId);
const wasCompressTurn = !!run.summarizing;
try {
await runLoopInner(sessionId, run);
@@ -561,6 +638,34 @@ async function runLoop(sessionId) {
}
}
// 重启续跑前给中断点那批调用补回执:不伪造执行结果,只告知「服务重启、结果未知」。
// 有了配对回执,buildMessages 才会保留整行 tool_calls——否则它会把无回执的调用剔掉,
// 模型看不到自己发过什么命令,「重启」类任务就靠猜,猜错就无限重试。
function markInterruptedBatch(sessionId) {
const last = db.prepare(
"SELECT id, role, tool_calls FROM messages WHERE session_id = ? AND role != 'tool' ORDER BY id DESC LIMIT 1"
).get(sessionId);
if (!last || last.role !== 'assistant' || !last.tool_calls) return 0; // 收尾回复或用户才发完话
let calls = [];
try { calls = JSON.parse(last.tool_calls) || []; } catch (_) { return 0; }
const got = new Set(
db.prepare(
"SELECT tool_call_id FROM messages WHERE session_id = ? AND role = 'tool' AND id > ? AND tool_call_id IS NOT NULL AND tool_call_id != ''"
).all(sessionId, last.id).map(r => r.tool_call_id)
);
let n = 0;
for (const c of calls) {
if (!c || !c.id || got.has(c.id)) continue;
const name = (c.function && c.function.name) || '未知工具';
saveMessage(sessionId, {
role: 'tool', tool_call_id: c.id, name,
content: '[系统] 服务重启,本次调用被中断,执行结果未知:先核实实际状态再决定,不要直接重试。',
});
n++;
}
return n;
}
function finalize(sessionId, run) {
const s = getSession(sessionId);
if (!s || s.status !== 'active') { runs.delete(sessionId); return; }
@@ -698,9 +803,22 @@ async function runLoopInner(sessionId, run) {
if (!session || session.status !== 'active' || !session.model_id) break;
session.history = loadHistory(sessionId);
for (const m of session.history) if (m.id > lastIncludedId) lastIncludedId = m.id;
// 自动压缩:本回合已用到的 In token 峰值(上一轮上游实报值)达到模型配的 max_context,
// 就地把握回合切成压缩回合——不新开 run、不发 auto_compress 提议,前端无感(产物就是摘要卡片,
// 与手点「压缩」完全同一条路径:下一圈的 compressing 分支换 prompt、摘要落库归档)。
// 检查点必须在请求发出之前:这个数字是上一轮的真实值,下一轮只会更大。
// 压缩回合自身不再判(run.summarizing 已真),否则会把自己再压一遍。
const maxCtx = modelMaxContext(session);
if (maxCtx > 0 && !run.summarizing && (run.turnMaxPt || 0) >= maxCtx) {
log.info('msg', sessionId + ' 自动压缩:回合 In ' + run.turnMaxPt + ' ≥ max_context ' + maxCtx);
run.summarizing = true;
// 标记「这是回合内自动压缩」:摘要落地后要接着跑完原任务(见 isSummary 分支),
// 与用户手点「压缩」发起的独立压缩回合区分开(那种压完就该停)。
run.compactAuto = true;
}
// 压缩回合(run.summarizing = 由「压缩」按钮发起、尚未产出摘要):
// 沿用默认 system prompt + 正常历史,末尾追加一条压缩指令 user(见 llm.compressMessages);
// 且不传 tools,模型只能输出摘要文本。
// 沿用默认 system prompt + 正常历史 + 同一套 tools,末尾追加一条压缩指令 user(见 llm.compressMessages),
// 请求与上一发常规请求只差尾部这一段,前缀缓存整段命中。
// 发送前为历史里的 image_ref 块现签公网外链(GET /p/<id>,同 mint_public_link):
// 每次请求重签,回合内多轮迭代/重试永不过期;DB 只存几十字符的 rel,base64 不进库不进请求体。
// base_url 未配/校验不过/mint 异常时返回 null,buildMessages 降级为文字占位;本地形态
@@ -743,8 +861,9 @@ async function runLoopInner(sessionId, run) {
+ (txt.includes('"already_delivered"') ? '[图重复读挡回]' : '');
}).join(' '));
}
// 内置工具 + 启动时发现的 MCP 工具(按 profile 白名单过滤),一起随 system prompt 发给模型(压缩回合不发)
const tools = compressing ? [] : effectiveTools(profileName);
// 内置工具 + 启动时发现的 MCP 工具(按 profile 白名单过滤),一起随 system prompt 发给模型。
// 压缩回合也照发:tools 段在最前,删掉等于断整段前缀缓存(尾部指令已写明不要调用工具)。
const tools = effectiveTools(profileName);
let result = null;
let lastErr = null;
@@ -756,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));
}
}
@@ -849,6 +972,9 @@ async function runLoopInner(sessionId, run) {
// 后续对话从这条摘要开始,旧历史不再烧 token。
// 旧摘要行(多轮压缩)一并存档:被新摘要覆盖替代,不再进上下文。
run.summarizing = null;
// 摘要已落地:清掉本回合的 In 峰值,后续轮次按压缩后的新上下文重新计量。
// 不清就会拿旧值立刻再触发一次(死循环);清了则压完仍超还能再压(支持连续压缩)。
run.turnMaxPt = 0;
if ((msgRow.content || '').trim()) {
db.prepare("UPDATE messages SET type = 'summary' WHERE id = ?").run(assistantId);
const n = db.prepare(
@@ -857,6 +983,16 @@ async function runLoopInner(sessionId, run) {
).run(sessionId, assistantId).changes;
log.info('msg', sessionId + ' 压缩摘要 ' + assistantId + ' 落库,存档之前 ' + n + ' 条消息(不再发给模型)');
}
// 回合内自动压缩把正在跑的任务切成了摘要,摘要一落地就地续跑:
// 补一条 user 指令接回原任务,否则会直接走到下面的 !hasTools 收尾,
// 任务停在半路,要用户再喊一声才动。
if (run.compactAuto) {
run.compactAuto = false;
const resumeText = '上下文已压缩,请继续完成原任务。';
const resumeId = saveMessage(sessionId, { role: 'user', content: resumeText });
bus.emit(sessionId, 'user_message', { id: resumeId, content: resumeText, created_at: now() });
continue;
}
}
if (!hasTools) {
@@ -1043,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 }),
@@ -1198,11 +1339,10 @@ function createSession(title, preferModelId, assistantType, user, workDir) {
if (!modelId) throw Object.assign(new Error('无可用模型:请检查配置并重启服务'), { status_code: 503 });
}
const id = genTaskId();
// 手选目录:直接当作会话工作目录(不建 task-* 子目录);未选 = 老行为,在 workspace_root 下按 id 建档。
// 手选目录:直接当作会话工作目录(不建 task-* 子目录);未选 = 沿用 workspace_root/<会话id>。
// 选中的目录必须已存在(normalizeWorkDir 已校验),绝不在用户目录里替它 mkdir。
// 两种情况下目录都由工具执行时懒建(见 tools/executor.js 的 executeTool),纯文本对话不留空目录。
const wd = normalizeWorkDir(workDir);
const dir = wd || path.join(cfg.workspace_root, id);
if (!wd) fs.mkdirSync(dir, { recursive: true });
db.prepare(
"INSERT INTO sessions (id, title, status, model_id, model_slot, last_model_id, held_at, assistant_type, user, work_dir, created_at, updated_at) VALUES (?,?,'held',?,?,?,?,?,?,?,?,?)"
).run(id, title || '', modelId, key.id, modelId, now(), assistantType || 'secretary', user || '', wd, now(), now());
@@ -1362,6 +1502,8 @@ function postUserMessage(sessionId, content, opts) {
// 预建/更新 run 记录,记下本轮的 deepThink(被 runLoop / callModel 读取)
const run = getRun(sessionId, true);
run.deepThink = !!(opts && opts.deepThink);
// 随消息落库:重进会话按它回填按钮,压缩回合也读它
db.prepare('UPDATE sessions SET deep_think = ? WHERE id = ?').run(run.deepThink ? 1 : 0, sessionId);
// 真实用户消息到达:若还有个「尚未开跑」的压缩回合(见 summarizeContext),
// 让它作废,避免新消息被误当成压缩回合处理;已在跑(looping)的不动,
// 由其收尾时自行清空 summarizing。
@@ -1465,10 +1607,10 @@ function summarizeContext(sessionId) {
}
const prompt = '正在压缩上下文:AI 将基于完整对话记录生成摘要…';
// 与 postUserMessage 同样的唤醒语义(不再排队、不落消息行);run.summarizing 标记本回合为压缩回合,摘要产出后由 runLoopInner 清空。
// 状态流转时顺带重置 deepThink:压缩回合不需要思考参数,避免沿用上一轮的残留值。
// 思考参数跟会话当前状态(由发消息时落库),换开关就换请求体,历史字节不受影响。
const r = getRun(sessionId, true);
r.summarizing = true;
r.deepThink = false;
r.deepThink = !!session.deep_think;
ensureBinding(session);
touch(sessionId, { status: 'active', held_at: null, completed_at: null, cancelled_at: null });
emitStatus(sessionId);
@@ -1718,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); // 历史清零,恢复自动压缩提议额度
// 标题随历史一并清零:旧标题描述的是已删除的对话,留着会让新对话文不对题;
@@ -1754,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 = [];
@@ -1765,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 };
}
@@ -1782,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);
@@ -1812,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 };
}
+32
View File
@@ -0,0 +1,32 @@
// 统一 HTTP 错误出口(Express 的四参数错误中间件,必须在所有路由之后注册)。
//
// 存在理由:Express 默认错误处理器只有 NODE_ENV=production 时才回一句干净的 500,
// 其余环境把 err.stack 拼成 HTML 吐给请求方——里面是服务端绝对路径、源码文件名+行号、
// 依赖版本。本地形态 NODE_ENV 通常未设置,等于默认开启。而 /p/<id> 这类端点匿名可达
// (见 routes/public-files.js),一次 sendFile 失败就能把整份栈打到公网。
//
// 策略:状态码照旧透出(body-parser 的 400/413、send 的 404 都靠它,客户端要能区分),
// 正文永远固定一句,栈只进日志。
'use strict';
const log = require('./log');
// 只认 err.status / err.statusCode 里的合法 4xx-5xx;其余(含没状态码的普通 Error)一律 500。
function statusOf(err) {
const s = Number(err && (err.status || err.statusCode));
return s >= 400 && s <= 599 ? s : 500;
}
function errorHandler(err, req, res, next) { // eslint-disable-line no-unused-vars
const status = statusOf(err);
const where = (req && req.method ? req.method + ' ' + (req.originalUrl || req.url || '') : '(unknown)');
// 5xx = 未预期异常,栈进日志;4xx 是调用方问题,一行 message 足够。
if (status >= 500) log.error('http', where + ' → ' + status + ':' + ((err && err.stack) || err));
else log.warn('http', where + ' → ' + status + ':' + ((err && err.message) || err));
if (res.headersSent) { if (res.destroy) res.destroy(); return; } // 响应已开始,只能断开
res.removeHeader('Content-Disposition'); // 可能已被 download-send 设过,错误体不该带文件名
res.status(status).type('text').send(status >= 500 ? 'internal error' : 'request failed');
}
module.exports = { errorHandler, statusOf };
+280
View File
@@ -0,0 +1,280 @@
// 只读 git 数据层:仓库探测 / 提交列表 / 提交详情 / 未提交改动详情。
// 一律 execFile + 参数数组(不经 shell),只跑 rev-parse / status / log / show / diff,不碰任何写操作。
// -c core.quotepath=false:中文路径原样返回,不转义成 \346\226\207 那种八进制。
const { execFile } = require('child_process');
const fs = require('fs');
const TIMEOUT = 8000;
const MAX_BUFFER = 8 * 1024 * 1024;
const PATCH_FILE_MAX = 120 * 1024; // 单文件 diff 字符上限
const PATCH_TOTAL_MAX = 400 * 1024; // 整页 diff 字符上限
const UNTRACKED_MAX_BYTES = 512 * 1024; // 未跟踪文件超过此大小不生成 diff
const MAX_FILES = 300; // 一次最多返回的文件数
const BASE = ['-c', 'core.quotepath=false'];
function run(dir, args) {
return new Promise((resolve, reject) => {
// cwd 不存在时 execFile 也报 ENOENT,会和「没装 git」混为一谈,先自己挡掉
let isDir = false;
try { isDir = fs.statSync(dir).isDirectory(); } catch (_) { isDir = false; }
if (!isDir) return reject(Object.assign(new Error('会话目录不存在'), { reason: 'not_repo' }));
execFile('git', BASE.concat(args), { cwd: dir, timeout: TIMEOUT, maxBuffer: MAX_BUFFER }, (err, stdout, stderr) => {
if (!err) return resolve(stdout);
err.stdout = String(stdout || '');
err.stderr = String(stderr || '').trim();
reject(err);
});
});
}
function reasonOf(err) {
if (err && err.code === 'ENOENT') return 'no_git';
if (err && err.code === 'ETIMEDOUT') return 'timeout';
return 'not_repo';
}
// 仓库信息:root 用 --show-toplevel(会话目录可能是仓库子目录);空仓库没有 HEAD,不算错。
async function ensureRepo(dir) {
let root;
try {
root = (await run(dir, ['rev-parse', '--show-toplevel'])).trim();
} catch (err) {
throw Object.assign(new Error(err.code === 'ENOENT' ? '未安装 git' : '当前目录不是 git 仓库'), { reason: reasonOf(err) });
}
if (!root) throw Object.assign(new Error('当前目录不是 git 仓库'), { reason: 'not_repo' });
let branch = '';
let head = '';
try { branch = (await run(root, ['symbolic-ref', '--short', '-q', 'HEAD'])).trim(); } catch (_) { /* detached */ }
try { head = (await run(root, ['rev-parse', '--short', 'HEAD'])).trim(); } catch (_) { /* 空仓库 */ }
// remote:列表里要能看出这个仓库推到哪。只取第一条 fetch(origin 惯例在最前);
// URL 里的 user:pass 脱敏,免得面板上直接暴露凭据。
let remote = null;
try {
const first = (await run(root, ['remote', '-v'])).split('\n').filter(Boolean)[0] || '';
const m = /^(\S+)\s+(\S+)\s+\(fetch\)/.exec(first);
if (m) remote = { name: m[1], url: m[2].replace(/\/\/[^/@]+@/, '//***@') };
} catch (_) { /* 没配 remote */ }
// upstream:列表要把 origin/master 标在它指向的那条提交上,一眼看出本地领先几条。
// 优先当前分支的 upstream,没配就回退 origin/master。
let upstream = null;
try {
const ref = (await run(root, ['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{u}'])).trim();
if (ref) upstream = { ref, id: (await run(root, ['rev-parse', ref])).trim() };
} catch (_) {
try { upstream = { ref: 'origin/master', id: (await run(root, ['rev-parse', 'origin/master'])).trim() }; } catch (__) { upstream = null; }
}
return { root, branch: branch || (head ? 'detached' : ''), head, remote, upstream };
}
// 把一个整段 diff 按 `diff --git` 切开,键是文件路径。
// 路径优先取 `+++ b/...`(改后),删除文件取 `--- a/...`;都没有就等于没有内容变化(仅 mode 变更)。
function patchPath(body) {
const plus = body.match(/^\+\+\+ b\/(.+)$/m);
if (plus) return plus[1].replace(/\t$/, '');
const minus = body.match(/^--- a\/(.+)$/m);
if (minus) return minus[1].replace(/\t$/, '');
const head = body.match(/^diff --git a\/(.+) b\/(.+)$/m);
return head ? head[2] : null;
}
function splitPatch(text) {
const out = new Map();
if (!text) return out;
const parts = String(text).split(/^diff --git /m);
for (let i = 1; i < parts.length; i++) {
const body = 'diff --git ' + parts[i];
const p = patchPath(body);
if (p) out.set(p, body);
}
return out;
}
function countLines(patch) {
let adds = 0;
let dels = 0;
for (const line of String(patch).split('\n')) {
if (line.charAt(0) === '+' && line.charAt(1) !== '+') adds++;
else if (line.charAt(0) === '-' && line.charAt(1) !== '-') dels++;
}
return { adds, dels };
}
function statusOf(patch, fallback) {
if (/^new file mode /m.test(patch)) return 'A';
if (/^deleted file mode /m.test(patch)) return 'D';
if (/^rename from /m.test(patch) || /^copy from /m.test(patch)) return 'R';
if (/^Binary files .* differ$/m.test(patch) || /^GIT binary patch$/m.test(patch)) return fallback || 'M';
return fallback || 'M';
}
function isBinary(patch) {
return /^Binary files .* differ$/m.test(patch) || /^GIT binary patch$/m.test(patch);
}
// 裁剪 + 汇总。逐文件先裁,再按总量裁(超出的文件保留路径与统计,patch 置空并标 truncated)。
function buildFiles(map, order, extra) {
const files = [];
const byPath = new Map();
let budget = PATCH_TOTAL_MAX;
for (const p of order) {
if (files.length >= MAX_FILES) break;
const raw = map.get(p) || '';
const binary = isBinary(raw);
let patch = raw;
let truncated = false;
if (patch.length > PATCH_FILE_MAX) { patch = patch.slice(0, PATCH_FILE_MAX); truncated = true; }
if (patch.length > budget) { patch = ''; truncated = true; }
budget -= patch.length;
const counts = binary ? { adds: 0, dels: 0 } : countLines(patch);
const item = {
path: p,
status: extra && extra[p] ? extra[p].status : statusOf(raw, extra && extra[p] && extra[p].status),
adds: counts.adds,
dels: counts.dels,
binary: binary,
truncated: truncated,
patch: binary ? '' : patch,
};
if (extra && extra[p] && extra[p].old_path) item.old_path = extra[p].old_path;
files.push(item);
byPath.set(p, item);
}
return files;
}
function summarize(files) {
let adds = 0;
let dels = 0;
for (const f of files) { adds += f.adds; dels += f.dels; }
return { stats: { files: files.length, adds, dels } };
}
// git status --porcelain -z:拿未跟踪文件和状态字母(已跟踪文件的 patch 统一从 `diff HEAD` 拆)
// -z 必须加:不加引号规则下含空格的路径会被写成 "a b.txt",和 diff 里的裸路径对不上,会多出幽灵条目。
// -z 里改名的旧路径是紧随其后的一条 NUL 分隔记录。
function worktreeEntries(out) {
const entries = [];
const parts = String(out || '').split('\0');
for (let i = 0; i < parts.length; i++) {
const line = parts[i];
if (!line || line.length < 4) continue;
const xy = line.slice(0, 2);
const p = line.slice(3);
let oldPath = '';
if (/[RC]/.test(xy)) {
oldPath = parts[i + 1] || '';
i++;
}
let status = 'M';
if (xy === '??') status = 'U';
else if (xy.indexOf('A') >= 0) status = 'A';
else if (xy.indexOf('D') >= 0) status = 'D';
else if (xy.indexOf('R') >= 0) status = 'R';
entries.push({ path: p, old_path: oldPath || undefined, status });
}
return entries;
}
// 未跟踪文件没有 diff:用 --no-index 对 /dev/null 造一个(退出码 1 = 有差异,属正常)
async function untrackedPatch(root, rel) {
const abs = root + '/' + rel;
try {
const st = fs.statSync(abs);
if (!st.isFile() || st.size > UNTRACKED_MAX_BYTES) return { patch: '', binary: st.size > UNTRACKED_MAX_BYTES };
} catch (_) { return { patch: '', binary: false }; }
try {
return { patch: await run(root, ['diff', '--no-index', '--', '/dev/null', rel]), binary: false };
} catch (err) {
if (err.code === 1) return { patch: err.stdout, binary: false };
return { patch: '', binary: false };
}
}
async function worktreeDetail(root) {
let entries = [];
try { entries = worktreeEntries(await run(root, ['status', '--porcelain', '-z'])); }
catch (_) { entries = []; }
let all = '';
try { all = await run(root, ['diff', 'HEAD']); } catch (_) { all = ''; } // 空仓库没有 HEAD
const map = splitPatch(all);
const extra = {};
for (const e of entries) extra[e.path] = e;
const order = [];
for (const e of entries) order.push(e.path);
for (const p of map.keys()) if (!extra[p]) { extra[p] = { status: 'M' }; order.push(p); }
for (const e of entries) {
if (e.status !== 'U' || map.has(e.path)) continue;
const r = await untrackedPatch(root, e.path);
if (r.patch) map.set(e.path, r.patch);
else if (r.binary) extra[e.path].binary = true;
}
const files = buildFiles(map, order, extra);
return { kind: 'worktree', commit: null, files: files, ...summarize(files) };
}
// git log:before 是上一页最后一条的 commit id,用 `<id>^` 翻页(git 天然不含自身)。
async function listCommits(dir, before, limit) {
const repo = await ensureRepo(dir);
const n = Math.max(1, Math.min(100, limit || 30));
const args = ['log', '--max-count=' + (n + 1), '--pretty=format:%H%x1f%h%x1f%an%x1f%aI%x1f%s'];
if (before) args.push(before + '^', '--');
let out = '';
try { out = await run(repo.root, args); } catch (err) {
if (before) return { ok: true, repo, worktree: null, commits: [], next: null }; // 已经翻到底
if (reasonOf(err) === 'no_git') throw err;
return { ok: true, repo, worktree: null, commits: [], next: null }; // 空仓库
}
const rows = out.split('\n').filter(Boolean).map((line) => {
const f = line.split('\x1f');
return { id: f[0], short: f[1], author: f[2], time: f[3], subject: f[4] || '' };
});
const hasMore = rows.length > n;
const commits = hasMore ? rows.slice(0, n) : rows;
const next = hasMore && commits.length ? commits[commits.length - 1].id : null;
let worktree = null;
try {
const st = await run(repo.root, ['status', '--porcelain']);
worktree = { files: st.split('\n').filter(Boolean).length };
} catch (_) { worktree = null; }
return { ok: true, repo, worktree, commits, next };
}
async function commitDetail(dir, rev) {
const repo = await ensureRepo(dir);
if (rev === 'worktree') {
const d = await worktreeDetail(repo.root);
return { ok: true, repo, ...d };
}
let meta;
try {
meta = await run(repo.root, ['show', '-s', '--first-parent', '--format=%H%x1f%h%x1f%an%x1f%ae%x1f%aI%x1f%P%x1f%s%x1f%b', rev]);
} catch (err) {
throw Object.assign(new Error('提交不存在或读取失败'), { reason: 'bad_rev' });
}
const f = meta.split('\x1f');
const commit = {
id: f[0], short: f[1], author: f[2], email: f[3], time: f[4],
parents: String(f[5] || '').split(' ').filter(Boolean),
subject: f[6] || '', body: (f[7] || '').replace(/\s+$/, ''),
};
// --first-parent:合并提交默认不出 patch,跟第一个父提交比才是"这次合并带进来什么"
let all = '';
try { all = await run(repo.root, ['show', '--first-parent', '--format=', '--patch', rev]); } catch (_) { all = ''; }
const map = splitPatch(all);
const order = [...map.keys()];
const files = buildFiles(map, order, null);
return { ok: true, repo, kind: 'commit', commit, files, ...summarize(files) };
}
// 统一入口:ok:false 只用于「不是仓库 / 没装 git / 会话不存在」,前端按 reason 出空状态
async function query(dir, kind, opts) {
try {
if (kind === 'commits') return await listCommits(dir, opts && opts.before, opts && opts.limit);
return await commitDetail(dir, (opts && opts.rev) || '');
} catch (err) {
return { ok: false, reason: (err && err.reason) || 'not_repo', error: String((err && err.message) || err) };
}
}
module.exports = { query };
+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 };
+103 -16
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 时触发一次;
@@ -683,20 +696,26 @@ async function callModel(cfg, modelId, messages, tools, options) {
if (opts.deepThink && modelCfg.thinking_params && Object.keys(modelCfg.thinking_params).length) {
deepMergeInto(body, modelCfg.thinking_params);
}
// 思维链回传(逐模型 opt-in,纯配置闸门不看 tools):reasoning_ack_field 非空时,把
// buildMessages 挂的内部键 __reasoning 按该字段名写回 assistant 行(对话/压缩/标题回合同规则;
// 没配/无思考的行零变化)。无论配与否都剥一遍 __reasoning,内部键不出仓库。
// 思维链回传(逐模型 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;
// 思考模式下带 tool_calls 的 assistant 行必须回传 reasoning_content:中途开启思考时,
// 本轮早先的调用没有思维链,用空串占位(缺失会被上游 400,空串实测通过)。
const send = !!(ack && opts.deepThink);
body.messages = body.messages.map(mm => {
if (!mm || mm.role !== 'assistant') return mm;
const fill = !!(opts.deepThink && ack && mm.tool_calls && !mm.__reasoning);
if (!mm.__reasoning && !fill) return mm;
if (!mm || mm.role !== 'assistant') return stripRowId(mm);
if (!mm.__reasoning) {
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 (ack) c[ack] = c.__reasoning || '';
if (send) c[ack] = mm.__reasoning;
delete c.__reasoning;
delete c.__rowId;
return c;
});
}
@@ -711,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 = '';
@@ -812,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 };
+46 -7
View File
@@ -118,7 +118,7 @@ function tokenScore(fl, t) {
const frac = hit / (t.length - 1);
return frac >= 0.5 ? frac * 0.9 : 0;
}
function searchFragments(db, user, query, count) {
function searchFragments(db, user, query, count, excludeSid) {
const toks = String(query || '').toLowerCase().split(/[\s,,、;;。.!!??]+/).filter(Boolean).slice(0, 8);
if (!toks.length) return '';
const lim = Math.max(1, Math.min(30, Number(count) || 10));
@@ -132,6 +132,23 @@ function searchFragments(db, user, query, count) {
for (const t of toks) sum += tokenScore(fl, t);
if (sum > 0) hits.push({ r: r, score: sum / toks.length, i: i });
});
// 未收口的会话没有碎片,标题是它唯一可检索的记忆:同样打分、同样渲染、同样排序,
// 不另起段落(否则模型会把「标题命中」当另一类东西,反而不信)。
const pend = db.prepare(
"SELECT id, title, updated_at FROM sessions WHERE user = ? AND journaled_at IS NULL AND TRIM(title) != ''"
).all(String(user || ''));
pend.forEach((s, i) => {
if (excludeSid && s.id === excludeSid) return;
const fl = String(s.title).toLowerCase();
let sum = 0;
for (const t of toks) sum += tokenScore(fl, t);
if (sum > 0) {
hits.push({
r: { session_id: s.id, day: dayString(s.updated_at), text: s.title, last_active_at: s.updated_at },
score: sum / toks.length, i: rows.length + i
});
}
});
if (!hits.length) return '';
hits.sort((a, b) => b.score - a.score || a.i - b.i);
const shown = hits.slice(0, lim);
@@ -143,14 +160,36 @@ function searchFragments(db, user, query, count) {
// ---------- 读:日期索引 / 某天整天(只记得「大概哪天」时的翻页) ----------
function daysIndex(db, user) {
return db.prepare(
'SELECT day, COUNT(*) n FROM memory_fragments WHERE user = ? GROUP BY day ORDER BY day DESC'
).all(String(user || '')).map(r => '- ' + r.day + '(' + r.n + ' 条)');
const u = String(user || '');
const map = new Map();
for (const r of db.prepare('SELECT day, COUNT(*) n FROM memory_fragments WHERE user = ? GROUP BY day').all(u)) {
map.set(r.day, (map.get(r.day) || 0) + r.n);
}
// 未收口会话的日期也要进索引:那天干过活,只是还没落碎片,索引里不该整天消失。
// 日期一律走 dayString(业务时区 Asia/Shanghai),不交给 SQLite 的 localtime,避免容器 TZ 漂移。
for (const s of db.prepare(
"SELECT updated_at FROM sessions WHERE user = ? AND journaled_at IS NULL AND TRIM(title) != ''"
).all(u)) {
const d = dayString(s.updated_at);
map.set(d, (map.get(d) || 0) + 1);
}
return [...map.entries()].sort((a, b) => (a[0] < b[0] ? 1 : a[0] > b[0] ? -1 : 0))
.map(e => '- ' + e[0] + '(' + e[1] + ' 条)');
}
function dayEntry(db, user, date) {
return db.prepare(
'SELECT ' + FRAG_COLS + FRAG_FROM + ' WHERE f.user = ? AND f.day = ? ORDER BY COALESCE(f.last_active_at, f.created_at)'
).all(String(user || ''), String(date || '').trim()).map(renderFrag).join('\n\n');
const u = String(user || '');
const d = String(date || '').trim();
const rows = db.prepare(
'SELECT ' + FRAG_COLS + FRAG_FROM + ' WHERE f.user = ? AND f.day = ?'
).all(u, d);
for (const s of db.prepare(
"SELECT id, title, updated_at FROM sessions WHERE user = ? AND journaled_at IS NULL AND TRIM(title) != ''"
).all(u)) {
if (dayString(s.updated_at) !== d) continue;
rows.push({ session_id: s.id, day: d, text: s.title, last_active_at: s.updated_at });
}
rows.sort((a, b) => (Number(a.last_active_at) || 0) - (Number(b.last_active_at) || 0));
return rows.map(renderFrag).join('\n\n');
}
// ---------- 裁剪:day 为 ISO 串,字典序即日期序;默认永久存储为 no-op ----------
+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"
}
]
},
File diff suppressed because it is too large Load Diff
+157 -56
View File
@@ -8,22 +8,38 @@
<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 -->
<script>
(function () {
try {
var m = localStorage.getItem('agent-theme') === 'dark' ? 'dark' : 'light';
document.documentElement.setAttribute('data-theme', m);
document.documentElement.setAttribute('data-theme-mode', m);
} catch (_) {
document.documentElement.setAttribute('data-theme', 'light');
document.documentElement.setAttribute('data-theme-mode', 'light');
}
})();
</script>
<meta name="apple-mobile-web-app-capable" content="yes">
<meta name="apple-mobile-web-app-status-bar-style" content="black-translucent">
<meta name="apple-mobile-web-app-title" content="Agent">
<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-think 同族的折叠交互,但做成更醒目的蓝色调卡片;
流式收尾(live)和历史重渲染(type='summary' 消息)共用同一套样式。
live 阶段 open=true 展开阅读;历史重渲染默认收起。 */
/* 「压缩」摘要卡片:与 .msg-ctx(画像快照/渠道/记忆)同一套视觉——淡蓝底、蓝边蓝字、
三角箭头、虚线分隔。纯色不用渐变/阴影,折叠与展开同一底色。默认收起 */
.msg-summary {
margin: 0 0 8px; border: 1px solid #dbe4fb; border-radius: 12px; overflow: hidden;
background: linear-gradient(180deg, #f7f9ff 0%, #ffffff 56%);
box-shadow: 0 1px 3px rgba(57, 100, 254, 0.08);
width: 100%; /* .msg.other 是 align-items:flex-start 的列 flex,不写就只撑标题那点宽 */
margin: 0 0 8px; border: 1px solid var(--bd-dbe4fb); border-radius: 12px; overflow: hidden;
background: var(--bg-f7f9ff);
}
.msg-summary > summary {
list-style: none; cursor: pointer; user-select: none;
@@ -37,13 +53,12 @@
transition: transform .15s ease;
}
.msg-summary[open] > summary::before { transform: rotate(90deg); }
.msg-summary .sum-ic { flex: none; width: 15px; height: 15px; }
.msg-summary .sum-hint { margin-left: auto; font-size: 11px; font-weight: 400; color: var(--gray); }
.msg-summary-body {
border-top: 1px dashed #dbe4fb; background: var(--page);
/* 比标题区深一档(用变量,暗色自动跟随) */
border-top: 1px dashed var(--bd-dbe4fb); background: var(--bg-fbfcff);
padding: 10px 13px 12px;
}
.msg-summary-body .bubble-ai { margin: 0; font-size: 14px; line-height: 1.7; }
.msg-summary-body .bubble-ai { margin: 0; background: transparent; font-size: 14px; line-height: 1.7; }
/* 「仅摘要」后摘要之前的旧历史:UI 保留但变淡,尾部附存档说明(不再发给 AI) */
.msg-archived { opacity: .55; }
.archived-note {
@@ -57,7 +72,7 @@
#schedule-modal .sched-row select,
#schedule-modal .sched-row input {
width: auto; margin: 0; padding: 7px 8px; font-size: 14px;
border: 1px solid #dde1ea; border-radius: 8px; background: #fff; color: var(--ink);
border: 1px solid var(--bd-dde1ea); border-radius: 8px; background: var(--bg-fff); color: var(--ink);
}
#schedule-modal .sched-row select { appearance: none; -webkit-appearance: none; }
#schedule-modal .sched-row .sched-num { width: 52px; text-align: center; }
@@ -66,9 +81,9 @@
/* schedule 弹窗内的提示词编辑区(.modal input 不覆盖 textarea,单独给样式) */
#schedule-modal textarea {
width: 100%; box-sizing: border-box; display: block;
border: 1px solid #dde1ea; border-radius: 10px;
border: 1px solid var(--bd-dde1ea); border-radius: 10px;
padding: 10px 12px; font-size: 14px; line-height: 1.5;
margin-bottom: 10px; background: #fff; color: var(--ink); resize: vertical;
margin-bottom: 10px; background: var(--bg-fff); color: var(--ink); resize: vertical;
}
#schedule-modal textarea:focus { border-color: var(--active); }
/* welcome 头像兼做「选择模型」入口(与聊天态的「选择模型」同一弹窗) */
@@ -86,12 +101,79 @@
</script>
</head>
<body>
<!-- 图标 sprite:全站 99 处 svg 的几何图形都收在这里,引用方式
<svg class="ic" viewBox="0 0 24 24"><use href="#i-xxx"/></svg>
尺寸/描边仍由各处 CSS 控制(.ic、.tree-act svg 等),本文件只存形状。
同形但历史写法不同的(folder/folder-b/folder-c、x-line/x-line-b/x-path、eye/eye-sm 等)
各留一份,保证替换前后逐像素一致;后续要收敛,改引用指向同一个 id 即可。 -->
<svg id="icon-sprite" style="position:absolute;width:0;height:0;overflow:hidden" aria-hidden="true">
<symbol id="i-history" viewBox="0 0 24 24"><path stroke-width="2" stroke-linecap="round" d="M4 5h16M4 15h10"/></symbol>
<symbol id="i-clock" viewBox="0 0 24 24"><circle cx="12" cy="12" r="8.5"></circle><polyline points="12 7.5 12 12 15.5 14"></polyline></symbol>
<symbol id="i-database" viewBox="0 0 24 24"><ellipse cx="12" cy="5" rx="8" ry="2.5" fill="none" stroke="currentColor" stroke-width="1.6"></ellipse><path fill="none" stroke="currentColor" stroke-width="1.6" stroke-linecap="round" d="M4 5v6c0 1.4 3.6 2.5 8 2.5s8-1.1 8-2.5V5"></path><path fill="none" stroke="currentColor" stroke-width="1.6" stroke-linecap="round" d="M4 11v6c0 1.4 3.6 2.5 8 2.5s8-1.1 8-2.5v-6"></path></symbol>
<symbol id="i-plus" viewBox="0 0 24 24"><line x1="12" y1="5" x2="12" y2="19"></line><line x1="5" y1="12" x2="19" y2="12"></line></symbol>
<symbol id="i-more" viewBox="0 0 24 24"><circle cx="5" cy="12" r="1.4" fill="currentColor" stroke="none"></circle><circle cx="12" cy="12" r="1.4" fill="currentColor" stroke="none"></circle><circle cx="19" cy="12" r="1.4" fill="currentColor" stroke="none"></circle></symbol>
<symbol id="i-sliders" viewBox="0 0 24 24"><line x1="3" y1="7" x2="21" y2="7"></line><circle cx="9" cy="7" r="2.6"></circle><line x1="3" y1="17" x2="21" y2="17"></line><circle cx="15" cy="17" r="2.6"></circle></symbol>
<symbol id="i-robot" viewBox="0 0 24 24"><rect x="4" y="8" width="16" height="12" rx="3"></rect><line x1="12" y1="4" x2="12" y2="8"></line><circle cx="12" cy="3" r="1.4"></circle><circle cx="9" cy="13.5" r="1" fill="currentColor" stroke="none"></circle><circle cx="15" cy="13.5" r="1" fill="currentColor" stroke="none"></circle><line x1="9.5" y1="17" x2="14.5" y2="17"></line></symbol>
<symbol id="i-folder" viewBox="0 0 24 24"><path d="M3 7a2 2 0 0 1 2-2h4l2 2h8a2 2 0 0 1 2 2v8a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2z"></path></symbol>
<symbol id="i-x-line" viewBox="0 0 24 24"><line x1="6" y1="6" x2="18" y2="18"></line><line x1="18" y1="6" x2="6" y2="18"></line></symbol>
<symbol id="i-bulb" viewBox="0 0 24 24"><path d="M12 10.2a1.8 1.8 0 1 0 0.001 3.6A1.8 1.8 0 0 0 12 10.2z"></path><path stroke-width="1.5" d="M15.76 15.76 C10.955 20.565 5.373 22.779 3.297 20.703 C1.22 18.627 3.434 13.045 8.24 8.24 C13.045 3.435 18.627 1.22 20.703 3.297 C22.779 5.374 20.565 10.955 15.76 15.76z"></path><path stroke-width="1.5" d="M16.096 7.904 C20.905 12.713 22.965 18.298 20.703 20.703 C18.44 23.108 13.003 20.755 8.24 15.76 C3.477 10.76 1.22 5.373 3.297 3.297 C5.374 1.22 10.955 3.434 16.096 7.904z"></path></symbol>
<symbol id="i-folder-b" viewBox="0 0 24 24"><path fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" d="M22 19a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h5l2 3h9a2 2 0 0 1 2 2z"></path></symbol>
<symbol id="i-paperclip" viewBox="0 0 24 24"><path fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" d="M21.44 11.05l-9.19 9.19a6 6 0 0 1-8.49-8.49l9.19-9.19a4 4 0 0 1 5.66 5.66l-9.2 9.19a2 2 0 0 1-2.83-2.83l8.49-8.48"></path></symbol>
<symbol id="i-send" viewBox="0 0 24 24"><line x1="12" y1="19" x2="12" y2="5"></line><polyline points="5 12 12 5 19 12"></polyline></symbol>
<symbol id="i-mic" viewBox="0 0 24 24"><rect x="9" y="2" width="6" height="12" rx="3"></rect><path d="M5 10a7 7 0 0 0 14 0"></path><line x1="12" y1="19" x2="12" y2="22"></line></symbol>
<symbol id="i-keyboard" viewBox="0 0 24 24"><rect x="3" y="5" width="18" height="14" rx="2.5"></rect><circle cx="7" cy="9" r="1.1" fill="currentColor" stroke="none"></circle><circle cx="12" cy="9" r="1.1" fill="currentColor" stroke="none"></circle><circle cx="17" cy="9" r="1.1" fill="currentColor" stroke="none"></circle><circle cx="7" cy="12.5" r="1.1" fill="currentColor" stroke="none"></circle><circle cx="12" cy="12.5" r="1.1" fill="currentColor" stroke="none"></circle><circle cx="17" cy="12.5" r="1.1" fill="currentColor" stroke="none"></circle><line x1="8" y1="16" x2="16" y2="16"></line></symbol>
<symbol id="i-chevron-down" viewBox="0 0 24 24"><polyline points="6 9 12 15 18 9"></polyline></symbol>
<symbol id="i-spinner" viewBox="0 0 24 24"><circle cx="12" cy="12" r="10" style="fill:none;stroke:var(--sb-ring,#dde);stroke-width:2.5"></circle><path d="M22 12a10 10 0 0 1-10 10" style="fill:none;stroke:var(--sb-arc,#3964FE);stroke-width:2.5;stroke-linecap:round"></path></symbol>
<symbol id="i-search" viewBox="0 0 24 24"><circle cx="11" cy="11" r="8"></circle><line x1="21" y1="21" x2="16.65" y2="16.65"></line></symbol>
<symbol id="i-gear" viewBox="0 0 24 24"><circle cx="12" cy="12" r="3"></circle><path d="M12.22 2h-.44a2 2 0 0 0-2 2v.18a2 2 0 0 1-1 1.73l-.43.25a2 2 0 0 1-2 0l-.15-.08a2 2 0 0 0-2.73.73l-.22.38a2 2 0 0 0 .73 2.73l.15.1a2 2 0 0 1 1 1.72v.51a2 2 0 0 1-1 1.74l-.15.09a2 2 0 0 0-.73 2.73l.22.38a2 2 0 0 0 2.73.73l.15-.08a2 2 0 0 1 2 0l.43.25a2 2 0 0 1 1 1.73V20a2 2 0 0 0 2 2h.44a2 2 0 0 0 2-2v-.18a2 2 0 0 1 1-1.73l.43-.25a2 2 0 0 1 2 0l.15.08a2 2 0 0 0 2.73-.73l.22-.39a2 2 0 0 0-.73-2.73l-.15-.08a2 2 0 0 1-1-1.74v-.5a2 2 0 0 1 1-1.74l.15-.09a2 2 0 0 0 .73-2.73l-.22-.38a2 2 0 0 0-2.73-.73l-.15.08a2 2 0 0 1-2 0l-.43-.25a2 2 0 0 1-1-1.73V4a2 2 0 0 0-2-2z"></path></symbol>
<symbol id="i-upload-cloud" viewBox="0 0 24 24"><path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4"></path><polyline points="17 8 12 3 7 8"></polyline><line x1="12" y1="3" x2="12" y2="15"></line></symbol>
<symbol id="i-download" viewBox="0 0 24 24"><path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4"></path><polyline points="7 10 12 15 17 10"></polyline><line x1="12" y1="15" x2="12" y2="3"></line></symbol>
<symbol id="i-trash" viewBox="0 0 24 24"><path d="M3 6h18"/><path d="M8 6V4a1 1 0 0 1 1-1h6a1 1 0 0 1 1 1v2"/><path d="M19 6l-1 14a2 2 0 0 1-2 2H8a2 2 0 0 1-2-2L5 6"/><path d="M10 11v6"/><path d="M14 11v6"/></symbol>
<symbol id="i-chevron-left" viewBox="0 0 24 24"><polyline points="15 18 9 12 15 6"></polyline></symbol>
<symbol id="i-x-line-b" viewBox="0 0 24 24"><line x1="18" y1="6" x2="6" y2="18"></line><line x1="6" y1="6" x2="18" y2="18"></line></symbol>
<symbol id="i-refresh" viewBox="0 0 24 24"><polyline points="23 4 23 10 17 10"></polyline><path d="M20.49 15a9 9 0 1 1-2.12-9.36L23 10"></path></symbol>
<symbol id="i-external" viewBox="0 0 24 24"><path d="M18 13v6a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h6"></path><polyline points="15 3 21 3 21 9"></polyline><line x1="10" y1="14" x2="21" y2="3"></line></symbol>
<symbol id="i-eye" viewBox="0 0 24 24"><path d="M1 12s4-8 11-8 11 8 11 8-4 8-11 8-11-8-11-8z"></path><circle cx="12" cy="12" r="3"></circle></symbol>
<symbol id="i-maximize" viewBox="0 0 24 24"><path d="M8 3H5a2 2 0 0 0-2 2v3"></path><path d="M21 8V5a2 2 0 0 0-2-2h-3"></path><path d="M16 21h3a2 2 0 0 0 2-2v-3"></path><path d="M3 16v3a2 2 0 0 0 2 2h3"></path></symbol>
<symbol id="i-minimize" viewBox="0 0 24 24"><path d="M8 3v3a2 2 0 0 1-2 2H3"></path><path d="M21 8h-3a2 2 0 0 1-2-2V3"></path><path d="M3 16h3a2 2 0 0 1 2 2v3"></path><path d="M16 21v-3a2 2 0 0 1 2-2h3"></path></symbol>
<symbol id="i-copy" viewBox="0 0 24 24"><rect x="9" y="9" width="13" height="13" rx="2"></rect><path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1"></path></symbol>
<symbol id="i-x-path" viewBox="0 0 24 24"><path d="M18 6 6 18"></path><path d="m6 6 12 12"></path></symbol>
<symbol id="i-pencil" viewBox="0 0 24 24"><path d="M12 20h9"></path><path d="M16.5 3.5a2.1 2.1 0 0 1 3 3L7 19l-4 1 1-4z"></path></symbol>
<symbol id="i-gem" viewBox="0 0 24 24"><path d="M6 3h12l4 6-10 13L2 9z"></path><polyline points="2 9 22 9"></polyline><polyline points="10 3 8 9 12 22"></polyline><polyline points="14 3 16 9 12 22"></polyline></symbol>
<symbol id="i-image" viewBox="0 0 24 24"><rect x="3" y="3" width="18" height="18" rx="2"></rect><circle cx="8.5" cy="8.5" r="1.5"></circle><polyline points="21 15 16 10 5 21"></polyline></symbol>
<symbol id="i-file" viewBox="0 0 24 24"><path d="M6 3h8l4 4v14H6z"/><path d="M14 3v4h4"/></symbol>
<symbol id="i-link" viewBox="0 0 24 24"><path d="M10 13a5 5 0 0 0 7 0l2-2a5 5 0 0 0-7-7l-1 1"/><path d="M14 11a5 5 0 0 0-7 0l-2 2a5 5 0 0 0 7 7l1-1"/></symbol>
<symbol id="i-external-b" viewBox="0 0 24 24"><path d="M14 4h6v6"/><path d="M20 4l-9 9"/><path d="M19 14v5a1 1 0 0 1-1 1H5a1 1 0 0 1-1-1V6a1 1 0 0 1 1-1h5"/></symbol>
<symbol id="i-reload" viewBox="0 0 24 24"><path d="M20 12a8 8 0 1 1-2.3-5.7"/><path d="M20 4v5h-5"/></symbol>
<symbol id="i-terminal" viewBox="0 0 24 24"><rect x="3" y="4" width="18" height="16" rx="2"/><path d="M7 9l3 3-3 3"/><path d="M13 15h4"/></symbol>
<symbol id="i-git" viewBox="0 0 24 24"><circle cx="6" cy="5" r="2"/><circle cx="6" cy="19" r="2"/><circle cx="18" cy="7" r="2"/><path d="M6 7v10"/><path d="M18 9v1a4 4 0 0 1-4 4H9"/></symbol>
<symbol id="i-eye-sm" viewBox="0 0 24 24"><path d="M2 12s3.5-7 10-7 10 7 10 7-3.5 7-10 7S2 12 2 12z"/><circle cx="12" cy="12" r="2.6"/></symbol>
<symbol id="i-theme-auto" viewBox="0 0 24 24"><rect x="2" y="3" width="20" height="14" rx="2"/><path d="M8 21h8"/><path d="M12 17v4"/></symbol>
<symbol id="i-theme-light" viewBox="0 0 24 24"><circle cx="12" cy="12" r="4.5"/><path d="M12 1.5v2M12 20.5v2M3.4 3.4l1.4 1.4M19.2 19.2l1.4 1.4M1.5 12h2M20.5 12h2M3.4 20.6l1.4-1.4M19.2 4.8l1.4-1.4"/></symbol>
<symbol id="i-theme-dark" viewBox="0 0 24 24"><path d="M21 13.2A9 9 0 1 1 10.8 3a7.2 7.2 0 0 0 10.2 10.2z"/></symbol>
<symbol id="i-file-doc" viewBox="0 0 24 24"><path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z"></path><polyline points="14 2 14 8 20 8"></polyline></symbol>
<symbol id="i-folder-c" viewBox="0 0 24 24"><path d="M22 19a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h5l2 3h9a2 2 0 0 1 2 2z"></path></symbol>
<symbol id="i-chevron-right" viewBox="0 0 24 24"><polyline points="9 18 15 12 9 6"></polyline></symbol>
<symbol id="i-home" viewBox="0 0 24 24"><path d="M3 9l9-7 9 7v11a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2z"></path><polyline points="9 22 9 12 15 12 15 22"></polyline></symbol>
<symbol id="i-image-b" viewBox="0 0 24 24"><rect x="3" y="3" width="18" height="18" rx="2" ry="2"></rect><circle cx="8.5" cy="8.5" r="1.5"></circle><polyline points="21 15 16 10 5 21"></polyline></symbol>
<symbol id="i-user" viewBox="0 0 24 24"><circle cx="12" cy="8" r="4"></circle><path d="M4 21c0-4 4-6 8-6s8 2 8 6"></path></symbol>
<symbol id="i-users" viewBox="0 0 24 24"><circle cx="9" cy="8" r="3.5"></circle><path d="M2 21c0-3.6 3.1-5.5 7-5.5s7 1.9 7 5.5"></path><path d="M16 8.5a3 3 0 0 1 0 6"></path><path d="M18 21c0-2.8-1.4-4.5-4-5.2"></path></symbol>
<symbol id="i-sliders-v" viewBox="0 0 24 24"><line x1="4" y1="21" x2="4" y2="14"></line><line x1="4" y1="10" x2="4" y2="3"></line><line x1="12" y1="21" x2="12" y2="12"></line><line x1="12" y1="8" x2="12" y2="3"></line><line x1="20" y1="21" x2="20" y2="16"></line><line x1="20" y1="12" x2="20" y2="3"></line><line x1="1" y1="14" x2="7" y2="14"></line><line x1="9" y1="8" x2="15" y2="8"></line><line x1="17" y1="16" x2="23" y2="16"></line></symbol>
<symbol id="i-zap" viewBox="0 0 24 24"><polygon points="13 2 3 14 12 14 11 22 21 10 12 10 13 2"></polygon></symbol>
<symbol id="i-cpu" viewBox="0 0 24 24"><rect x="4" y="4" width="16" height="16" rx="2"></rect><rect x="9" y="9" width="6" height="6"></rect><line x1="9" y1="1" x2="9" y2="4"></line><line x1="15" y1="1" x2="15" y2="4"></line><line x1="9" y1="20" x2="9" y2="23"></line><line x1="15" y1="20" x2="15" y2="23"></line><line x1="20" y1="9" x2="23" y2="9"></line><line x1="20" y1="14" x2="23" y2="14"></line><line x1="1" y1="9" x2="4" y2="9"></line><line x1="1" y1="14" x2="4" y2="14"></line></symbol>
<symbol id="i-layout" viewBox="0 0 24 24"><rect x="3" y="4" width="18" height="16" rx="2"></rect><line x1="3" y1="10" x2="21" y2="10"></line><circle cx="7" cy="15" r="1.2" fill="currentColor" stroke="none"></circle><circle cx="12" cy="15" r="1.2" fill="currentColor" stroke="none"></circle><circle cx="17" cy="15" r="1.2" fill="currentColor" stroke="none"></circle></symbol>
<symbol id="i-chevron-right-b" viewBox="0 0 24 24"><polyline points="9 6 15 12 9 18"></polyline></symbol>
<symbol id="i-edit" viewBox="0 0 24 24"><path d="M11 4H4a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-7"></path><path d="M18.5 2.5a2.12 2.12 0 0 1 3 3L12 15l-4 1 1-4z"></path></symbol>
<symbol id="i-check" viewBox="0 0 24 24"><polyline points="20 6 9 17 4 12"></polyline></symbol>
<symbol id="i-pencil-b" viewBox="0 0 24 24"><path d="M12 20h9"/><path d="M16.5 3.5a2.12 2.12 0 0 1 3 3L7 19l-4 1 1-4Z"/></symbol>
</svg>
<div id="app">
<!-- ================= 顶部导航栏 ================= -->
<header class="header" id="chat-header">
<button class="icon-btn" id="menu-btn" title="历史记录" aria-label="打开历史记录">
<svg viewBox="0 0 24 24" class="ic sm"><path stroke-width="2" stroke-linecap="round" d="M4 5h16M4 15h10"/></svg>
<svg viewBox="0 0 24 24" class="ic sm"><use href="#i-history"/></svg>
</button>
<div class="header-center" id="header-center"><!-- 未对话状态为空白,JS 注入对话信息 --></div>
@@ -102,11 +184,11 @@
<span class="hdr-label" id="hdr-model-text">选择模型</span>
</button>
<button class="hdr-chip hdr-sched hidden" id="hdr-sched" data-act="schedule" data-tip="定时任务" aria-label="定时任务">
<svg class="ic" viewBox="0 0 24 24"><circle cx="12" cy="12" r="8.5"></circle><polyline points="12 7.5 12 12 15.5 14"></polyline></svg>
<svg class="ic" viewBox="0 0 24 24"><use href="#i-clock"/></svg>
<span class="hdr-label" id="hdr-sched-text">定时任务</span>
</button>
<button class="icon-btn ha-btn hdr-compact hidden" id="hdr-compact" data-act="compact" data-tip="压缩上下文" aria-label="压缩上下文">
<svg class="ic" viewBox="0 0 24 24"><ellipse cx="12" cy="5" rx="8" ry="2.5" fill="none" stroke="currentColor" stroke-width="1.6"></ellipse><path fill="none" stroke="currentColor" stroke-width="1.6" stroke-linecap="round" d="M4 5v6c0 1.4 3.6 2.5 8 2.5s8-1.1 8-2.5V5"></path><path fill="none" stroke="currentColor" stroke-width="1.6" stroke-linecap="round" d="M4 11v6c0 1.4 3.6 2.5 8 2.5s8-1.1 8-2.5v-6"></path></svg>
<svg class="ic" viewBox="0 0 24 24"><use href="#i-database"/></svg>
</button>
</div>
@@ -114,28 +196,37 @@
桌面属性区与菜单项共用 data-act,事件统一在 sessions.js 分发。 -->
<div class="header-actions" id="header-actions">
<div class="ha-icons">
<button class="icon-btn ha-btn" data-act="theme" id="theme-toggle" data-tip="主题:浅色" aria-label="切换主题">
<svg class="ic sm" viewBox="0 0 24 24"><use href="#i-theme-light"/></svg>
<svg class="ic sm hidden" viewBox="0 0 24 24"><use href="#i-theme-dark"/></svg>
</button>
<button class="icon-btn ha-btn" data-act="new" data-tip="新建会话" aria-label="新建会话">
<svg class="ic sm" viewBox="0 0 24 24"><line x1="12" y1="5" x2="12" y2="19"></line><line x1="5" y1="12" x2="19" y2="12"></line></svg>
<svg class="ic sm" viewBox="0 0 24 24"><use href="#i-plus"/></svg>
</button>
</div>
<button class="icon-btn ha-more" id="ha-more" title="更多" aria-label="更多操作" aria-haspopup="menu" aria-expanded="false" aria-controls="ha-menu">
<svg class="ic sm" viewBox="0 0 24 24"><circle cx="5" cy="12" r="1.4" fill="currentColor" stroke="none"></circle><circle cx="12" cy="12" r="1.4" fill="currentColor" stroke="none"></circle><circle cx="19" cy="12" r="1.4" fill="currentColor" stroke="none"></circle></svg>
<svg class="ic sm" viewBox="0 0 24 24"><use href="#i-more"/></svg>
</button>
<div class="ha-menu hidden" id="ha-menu" role="menu">
<button class="ha-item" role="menuitem" data-act="model">
<svg class="ic sm" viewBox="0 0 24 24"><line x1="3" y1="7" x2="21" y2="7"></line><circle cx="9" cy="7" r="2.6"></circle><line x1="3" y1="17" x2="21" y2="17"></line><circle cx="15" cy="17" r="2.6"></circle></svg>
<svg class="ic sm" viewBox="0 0 24 24"><use href="#i-sliders"/></svg>
<span class="ha-item-main">切换模型</span><span class="ha-item-sub hidden" id="ha-model-sub"></span>
</button>
<button class="ha-item" role="menuitem" data-act="schedule">
<svg class="ic sm" viewBox="0 0 24 24"><circle cx="12" cy="12" r="8.5"></circle><polyline points="12 7.5 12 12 15.5 14"></polyline></svg>
<svg class="ic sm" viewBox="0 0 24 24"><use href="#i-clock"/></svg>
<span class="ha-item-main">定时任务</span><span class="ha-item-sub hidden" id="ha-sched-sub"></span>
</button>
<button class="ha-item" role="menuitem" data-act="compact">
<svg class="ic sm" viewBox="0 0 24 24"><ellipse cx="12" cy="5" rx="8" ry="2.5" fill="none" stroke="currentColor" stroke-width="1.6"></ellipse><path fill="none" stroke="currentColor" stroke-width="1.6" stroke-linecap="round" d="M4 5v6c0 1.4 3.6 2.5 8 2.5s8-1.1 8-2.5V5"></path><path fill="none" stroke="currentColor" stroke-width="1.6" stroke-linecap="round" d="M4 11v6c0 1.4 3.6 2.5 8 2.5s8-1.1 8-2.5v-6"></path></svg>
<svg class="ic sm" viewBox="0 0 24 24"><use href="#i-database"/></svg>
<span class="ha-item-main">压缩上下文</span>
</button>
<button class="ha-item" role="menuitem" data-act="theme" id="theme-toggle-mobile">
<svg class="ic sm" viewBox="0 0 24 24"><use href="#i-theme-light"/></svg>
<svg class="ic sm hidden" viewBox="0 0 24 24"><use href="#i-theme-dark"/></svg>
<span class="ha-item-main">切换主题</span><span class="ha-item-sub" id="theme-label-mobile">浅色</span>
</button>
<button class="ha-item" role="menuitem" data-act="new">
<svg class="ic sm" viewBox="0 0 24 24"><line x1="12" y1="5" x2="12" y2="19"></line><line x1="5" y1="12" x2="19" y2="12"></line></svg>
<svg class="ic sm" viewBox="0 0 24 24"><use href="#i-plus"/></svg>
<span class="ha-item-main">新建会话</span>
</button>
</div>
@@ -147,7 +238,7 @@
<section id="welcome-view">
<div class="welcome-head">
<div class="logo-badge" onclick="openModelSwitch()" title="选择模型" role="button" aria-label="选择模型">
<svg class="ic" viewBox="0 0 24 24"><rect x="4" y="8" width="16" height="12" rx="3"></rect><line x1="12" y1="4" x2="12" y2="8"></line><circle cx="12" cy="3" r="1.4"></circle><circle cx="9" cy="13.5" r="1" fill="currentColor" stroke="none"></circle><circle cx="15" cy="13.5" r="1" fill="currentColor" stroke="none"></circle><line x1="9.5" y1="17" x2="14.5" y2="17"></line></svg>
<svg class="ic" viewBox="0 0 24 24"><use href="#i-robot"/></svg>
</div>
<div class="welcome-slogan">随时开始吧</div>
</div>
@@ -156,11 +247,11 @@
<div class="welcome-dir hidden" id="welcome-dir">
<span class="welcome-dir-cap">工作目录</span>
<button type="button" class="welcome-dir-pick" id="welcome-dir-pick" title="选择本会话的工作目录">
<svg class="ic sm" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M3 7a2 2 0 0 1 2-2h4l2 2h8a2 2 0 0 1 2 2v8a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2z"></path></svg>
<svg class="ic sm" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><use href="#i-folder"/></svg>
<span class="welcome-dir-path" id="welcome-dir-path">默认</span>
</button>
<button type="button" class="welcome-dir-clear hidden" id="welcome-dir-clear" title="恢复默认目录" aria-label="恢复默认目录">
<svg class="ic sm" viewBox="0 0 24 24"><line x1="6" y1="6" x2="18" y2="18"></line><line x1="18" y1="6" x2="6" y2="18"></line></svg>
<svg class="ic sm" viewBox="0 0 24 24"><use href="#i-x-line"/></svg>
</button>
</div>
</section>
@@ -188,23 +279,23 @@
<div class="input-actions">
<div class="ia-side ia-left">
<button class="think-toggle" id="deep-think-btn" title="深度思考">
<svg viewBox="0 0 24 24" class="ic sm"><path d="M12 10.2a1.8 1.8 0 1 0 0.001 3.6A1.8 1.8 0 0 0 12 10.2z"></path><path stroke-width="1.5" d="M15.76 15.76 C10.955 20.565 5.373 22.779 3.297 20.703 C1.22 18.627 3.434 13.045 8.24 8.24 C13.045 3.435 18.627 1.22 20.703 3.297 C22.779 5.374 20.565 10.955 15.76 15.76z"></path><path stroke-width="1.5" d="M16.096 7.904 C20.905 12.713 22.965 18.298 20.703 20.703 C18.44 23.108 13.003 20.755 8.24 15.76 C3.477 10.76 1.22 5.373 3.297 3.297 C5.374 1.22 10.955 3.434 16.096 7.904z"></path></svg>
<svg viewBox="0 0 24 24" class="ic sm"><use href="#i-bulb"/></svg>
深度思考
</button>
</div>
<div class="ia-side ia-right">
<button class="plus-btn" id="files-btn" title="任务文件" aria-label="任务文件">
<svg viewBox="0 0 24 24" class="ic sm"><path fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" d="M22 19a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h5l2 3h9a2 2 0 0 1 2 2z"></path></svg>
<svg viewBox="0 0 24 24" class="ic sm"><use href="#i-folder-b"/></svg>
</button>
<button class="plus-btn" id="attach-btn" title="上传文件" aria-label="上传文件">
<svg viewBox="0 0 24 24" class="ic sm"><path fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" d="M21.44 11.05l-9.19 9.19a6 6 0 0 1-8.49-8.49l9.19-9.19a4 4 0 0 1 5.66 5.66l-9.2 9.19a2 2 0 0 1-2.83-2.83l8.49-8.48"></path></svg>
<svg viewBox="0 0 24 24" class="ic sm"><use href="#i-paperclip"/></svg>
</button>
<!-- 同一按钮四态:发送(↑)/ 停止(方块)/ 语音(麦克风)/ 键盘。
data-state 由 JS 切换,尺寸不变避免输入区跳动 -->
<button class="send-btn" id="send-btn" data-state="send" title="发送" aria-label="发送">
<svg class="ic sm ic-send" viewBox="0 0 24 24"><line x1="12" y1="19" x2="12" y2="5"></line><polyline points="5 12 12 5 19 12"></polyline></svg>
<svg class="ic sm ic-voice" viewBox="0 0 24 24"><rect x="9" y="2" width="6" height="12" rx="3"></rect><path d="M5 10a7 7 0 0 0 14 0"></path><line x1="12" y1="19" x2="12" y2="22"></line></svg>
<svg class="ic sm ic-kb" viewBox="0 0 24 24"><rect x="3" y="5" width="18" height="14" rx="2.5"></rect><circle cx="7" cy="9" r="1.1" fill="currentColor" stroke="none"></circle><circle cx="12" cy="9" r="1.1" fill="currentColor" stroke="none"></circle><circle cx="17" cy="9" r="1.1" fill="currentColor" stroke="none"></circle><circle cx="7" cy="12.5" r="1.1" fill="currentColor" stroke="none"></circle><circle cx="12" cy="12.5" r="1.1" fill="currentColor" stroke="none"></circle><circle cx="17" cy="12.5" r="1.1" fill="currentColor" stroke="none"></circle><line x1="8" y1="16" x2="16" y2="16"></line></svg>
<svg class="ic sm ic-send" viewBox="0 0 24 24"><use href="#i-send"/></svg>
<svg class="ic sm ic-voice" viewBox="0 0 24 24"><use href="#i-mic"/></svg>
<svg class="ic sm ic-kb" viewBox="0 0 24 24"><use href="#i-keyboard"/></svg>
<span class="stop-sq" aria-hidden="true"></span>
</button>
</div>
@@ -214,13 +305,18 @@
<div id="voice-overlay" class="hidden" aria-hidden="true">
<div class="vo-hint" id="voice-hint">松手传送,上滑取消</div>
<div class="vo-wave" id="voice-wave"></div>
<!-- 桌面点击模式的操作行:手机端按住说话用不到,CSS 里默认隐藏 -->
<div class="vo-actions" id="voice-actions">
<button type="button" class="vo-btn ghost" id="voice-cancel">取消</button>
<button type="button" class="vo-btn primary" id="voice-send">发送</button>
</div>
</div>
</div>
<!-- 回到底部浮动按钮(搬自 index;上翻历史时出现、AI 输出中常驻转圈)。
放在 footer 内、相对 footer 顶边停靠:输入框长高/编辑条出现时不会被盖住 -->
<button class="scroll-bottom-btn hidden" id="scroll-bottom-btn" onclick="clickScrollBottom()" title="回到底部" aria-label="回到底部">
<svg class="sb-arrow" viewBox="0 0 24 24"><polyline points="6 9 12 15 18 9"></polyline></svg>
<svg class="sb-spinner hidden" viewBox="0 0 24 24"><circle cx="12" cy="12" r="10"></circle><path d="M22 12a10 10 0 0 1-10 10"></path></svg>
<svg class="sb-arrow" viewBox="0 0 24 24"><use href="#i-chevron-down"/></svg>
<svg class="sb-spinner hidden" viewBox="0 0 24 24"><use href="#i-spinner"/></svg>
</button>
</footer>
@@ -229,7 +325,7 @@
<aside id="drawer" aria-label="对话历史">
<div class="drawer-search">
<div class="search-box">
<svg class="ic sm" viewBox="0 0 24 24"><circle cx="11" cy="11" r="8"></circle><line x1="21" y1="21" x2="16.65" y2="16.65"></line></svg>
<svg class="ic sm" viewBox="0 0 24 24"><use href="#i-search"/></svg>
<input type="search" id="search-input" placeholder="搜寻对话内容..." enterkeyhint="search">
</div>
</div>
@@ -240,10 +336,10 @@
窄屏两个都隐藏:文件只保留输入行右侧的旧面板(不做两套)。选中项高亮。 -->
<div class="drawer-actions" id="drawer-actions">
<button class="drawer-act" id="da-files" type="button" title="文件树" aria-label="文件树">
<svg viewBox="0 0 24 24"><path d="M3 7a2 2 0 0 1 2-2h4l2 2h8a2 2 0 0 1 2 2v8a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2z"></path></svg>
<svg viewBox="0 0 24 24"><use href="#i-folder"/></svg>
</button>
<button class="drawer-act" id="da-settings" type="button" title="设置" aria-label="设置">
<svg viewBox="0 0 24 24"><circle cx="12" cy="12" r="3"></circle><path d="M12.22 2h-.44a2 2 0 0 0-2 2v.18a2 2 0 0 1-1 1.73l-.43.25a2 2 0 0 1-2 0l-.15-.08a2 2 0 0 0-2.73.73l-.22.38a2 2 0 0 0 .73 2.73l.15.1a2 2 0 0 1 1 1.72v.51a2 2 0 0 1-1 1.74l-.15.09a2 2 0 0 0-.73 2.73l.22.38a2 2 0 0 0 2.73.73l.15-.08a2 2 0 0 1 2 0l.43.25a2 2 0 0 1 1 1.73V20a2 2 0 0 0 2 2h.44a2 2 0 0 0 2-2v-.18a2 2 0 0 1 1-1.73l.43-.25a2 2 0 0 1 2 0l.15.08a2 2 0 0 0 2.73-.73l.22-.39a2 2 0 0 0-.73-2.73l-.15-.08a2 2 0 0 1-1-1.74v-.5a2 2 0 0 1 1-1.74l.15-.09a2 2 0 0 0 .73-2.73l-.22-.38a2 2 0 0 0-2.73-.73l-.15.08a2 2 0 0 1-2 0l-.43-.25a2 2 0 0 1-1-1.73V4a2 2 0 0 0-2-2z"></path></svg>
<svg viewBox="0 0 24 24"><use href="#i-gear"/></svg>
</button>
</div>
</aside>
@@ -256,7 +352,7 @@
<span class="files-panel-title">任务文件<span class="files-panel-size" id="files-panel-size" title="当前目录下全部文件总大小"></span></span>
<label class="file-upload" title="上传文件" aria-label="上传文件">
<input type="file" id="file-input" multiple hidden>
<svg viewBox="0 0 24 24"><path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4"></path><polyline points="17 8 12 3 7 8"></polyline><line x1="12" y1="3" x2="12" y2="15"></line></svg>
<svg viewBox="0 0 24 24"><use href="#i-upload-cloud"/></svg>
</label>
</div>
<div class="files-crumbs hidden" id="files-crumbs" aria-label="目录路径"></div>
@@ -272,10 +368,10 @@
</div>
<div class="files-panel-actions">
<button class="files-fab" id="files-bulk-download" title="批量下载" aria-label="批量下载" disabled>
<svg viewBox="0 0 24 24"><path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4"></path><polyline points="7 10 12 15 17 10"></polyline><line x1="12" y1="15" x2="12" y2="3"></line></svg>
<svg viewBox="0 0 24 24"><use href="#i-download"/></svg>
</button>
<button class="files-fab del" id="files-bulk-delete" title="批量删除" aria-label="批量删除" disabled>
<svg viewBox="0 0 24 24"><polyline points="3 6 5 6 21 6"></polyline><path d="M19 6l-1 14a2 2 0 0 1-2 2H8a2 2 0 0 1-2-2L5 6"></path><line x1="10" y1="11" x2="10" y2="17"></line><line x1="14" y1="11" x2="14" y2="17"></line></svg>
<svg viewBox="0 0 24 24"><use href="#i-trash"/></svg>
</button>
</div>
</div>
@@ -290,7 +386,7 @@
<!-- 顶栏:左侧返回 + 中间标题 + 右侧操作按钮,风格与对话页 header 一致 -->
<header class="header">
<button class="icon-btn" id="set-back-btn" title="返回" aria-label="返回">
<svg class="ic" viewBox="0 0 24 24"><polyline points="15 18 9 12 15 6"></polyline></svg>
<svg class="ic" viewBox="0 0 24 24"><use href="#i-chevron-left"/></svg>
</button>
<div class="header-center"><div class="header-title" id="set-title">设置</div></div>
<div class="header-right" id="set-actions"><!-- JS 按页注入操作按钮 --></div>
@@ -303,7 +399,7 @@
<div id="skill-create-modal" class="modal-overlay hidden" onclick="if(event.target===this)sUI.closeCreate()">
<div class="modal">
<button class="modal-close-btn" onclick="sUI.closeCreate()">
<svg viewBox="0 0 24 24"><line x1="18" y1="6" x2="6" y2="18"></line><line x1="6" y1="6" x2="18" y2="18"></line></svg>
<svg viewBox="0 0 24 24"><use href="#i-x-line-b"/></svg>
</button>
<h3>新建技能</h3>
<input type="text" id="skill-new-name" placeholder="技能名(字母/数字/-/_)">
@@ -316,7 +412,7 @@
<div id="model-edit-modal" class="modal-overlay hidden" onclick="if(event.target===this)sUI.mClose()">
<div class="modal modal-wide">
<button class="modal-close-btn" onclick="sUI.mClose()">
<svg viewBox="0 0 24 24"><line x1="18" y1="6" x2="6" y2="18"></line><line x1="6" y1="6" x2="18" y2="18"></line></svg>
<svg viewBox="0 0 24 24"><use href="#i-x-line-b"/></svg>
</button>
<h3 id="mpe-title">编辑平台</h3>
<!-- 平台预设:仅新增平台时展示,点选即填好 url/类型并给模型卡带上该平台的参数缺省 -->
@@ -342,7 +438,7 @@
<div id="user-edit-modal" class="modal-overlay hidden" onclick="if(event.target===this)sUI.closeUserModal()">
<div class="modal">
<button class="modal-close-btn" onclick="sUI.closeUserModal()">
<svg viewBox="0 0 24 24"><line x1="18" y1="6" x2="6" y2="18"></line><line x1="6" y1="6" x2="18" y2="18"></line></svg>
<svg viewBox="0 0 24 24"><use href="#i-x-line-b"/></svg>
</button>
<h3 id="ue-title">添加用户</h3>
<input type="text" id="ue-user" placeholder="用户名(字母/数字/下划线)" autocomplete="off">
@@ -364,7 +460,7 @@
<div id="mcp-edit-modal" class="modal-overlay hidden" onclick="if(event.target===this)mcpUI.close()">
<div class="modal modal-wide">
<button class="modal-close-btn" onclick="mcpUI.close()">
<svg viewBox="0 0 24 24"><line x1="18" y1="6" x2="6" y2="18"></line><line x1="6" y1="6" x2="18" y2="18"></line></svg>
<svg viewBox="0 0 24 24"><use href="#i-x-line-b"/></svg>
</button>
<h3 id="mce-title">编辑 MCP 服务</h3>
<input type="text" id="mce-name" placeholder="服务名">
@@ -402,7 +498,7 @@
<div id="schedule-modal" class="modal-overlay hidden" onclick="if(event.target===this)closeScheduleModal()">
<div class="modal">
<button class="modal-close-btn" onclick="closeScheduleModal()">
<svg viewBox="0 0 24 24"><line x1="18" y1="6" x2="6" y2="18"></line><line x1="6" y1="6" x2="18" y2="18"></line></svg>
<svg viewBox="0 0 24 24"><use href="#i-x-line-b"/></svg>
</button>
<h3 id="schedule-modal-title">定时任务</h3>
<div class="sched-row">
@@ -435,7 +531,7 @@
<div id="confirm-modal" class="modal-overlay hidden" onclick="if(event.target===this)confirmClose(null)">
<div class="modal">
<button class="modal-close-btn" onclick="confirmClose(null)" aria-label="关闭">
<svg viewBox="0 0 24 24"><line x1="18" y1="6" x2="6" y2="18"></line><line x1="6" y1="6" x2="18" y2="18"></line></svg>
<svg viewBox="0 0 24 24"><use href="#i-x-line-b"/></svg>
</button>
<h3 id="confirm-title">请确认</h3>
<div class="modal-text" id="confirm-text"></div>
@@ -451,7 +547,7 @@
<div id="prompt-modal" class="modal-overlay hidden" onclick="if(event.target===this)promptCancel()">
<div class="modal">
<button class="modal-close-btn" onclick="promptCancel()">
<svg viewBox="0 0 24 24"><line x1="18" y1="6" x2="6" y2="18"></line><line x1="6" y1="6" x2="18" y2="18"></line></svg>
<svg viewBox="0 0 24 24"><use href="#i-x-line-b"/></svg>
</button>
<h3 id="prompt-title">请输入</h3>
<input type="text" id="prompt-input">
@@ -471,7 +567,7 @@
<p class="msw-sub" id="bind-model-sub">选择一个模型继续当前会话</p>
</div>
<button class="modal-close-btn" onclick="closeModelSwitch()">
<svg viewBox="0 0 24 24"><line x1="18" y1="6" x2="6" y2="18"></line><line x1="6" y1="6" x2="18" y2="18"></line></svg>
<svg viewBox="0 0 24 24"><use href="#i-x-line-b"/></svg>
</button>
</div>
<div class="msw-list" id="bind-model-list"></div>
@@ -496,19 +592,23 @@
<span class="pv-addr">
<input class="pv-title" id="pv-title" aria-label="文件路径或网址">
<button class="icon-btn hidden" id="pv-refresh" title="重新载入" aria-label="重新载入">
<svg class="ic sm" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><polyline points="23 4 23 10 17 10"></polyline><path d="M20.49 15a9 9 0 1 1-2.12-9.36L23 10"></path></svg>
<svg class="ic sm" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><use href="#i-refresh"/></svg>
</button>
<button class="icon-btn hidden" id="pv-popup" title="新窗口打开" aria-label="新窗口打开">
<svg class="ic sm" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M18 13v6a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h6"></path><polyline points="15 3 21 3 21 9"></polyline><line x1="10" y1="14" x2="21" y2="3"></line></svg>
<svg class="ic sm" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><use href="#i-external"/></svg>
</button>
</span>
<span class="pv-actions">
<!-- 源码钮:只在当前内容有源文本时出现(md/文本/代码/html/svg),点了在预览与原文间切换 -->
<button class="icon-btn hidden" id="pv-src" title="查看源码" aria-label="查看源码">
<svg class="ic sm" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><use href="#i-eye"/></svg>
</button>
<button class="icon-btn hidden" id="pv-download" title="下载文件" aria-label="下载文件">
<svg class="ic sm" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4"></path><polyline points="7 10 12 15 17 10"></polyline><line x1="12" y1="15" x2="12" y2="3"></line></svg>
<svg class="ic sm" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><use href="#i-download"/></svg>
</button>
<button class="icon-btn" id="pv-max" title="放大" aria-label="放大">
<svg class="ic sm" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M8 3H5a2 2 0 0 0-2 2v3"></path><path d="M21 8V5a2 2 0 0 0-2-2h-3"></path><path d="M16 21h3a2 2 0 0 0 2-2v-3"></path><path d="M3 16v3a2 2 0 0 0 2 2h3"></path></svg>
<svg class="ic sm hidden" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M8 3v3a2 2 0 0 1-2 2H3"></path><path d="M21 8h-3a2 2 0 0 1-2-2V3"></path><path d="M3 16h3a2 2 0 0 1 2 2v3"></path><path d="M16 21v-3a2 2 0 0 1 2-2h3"></path></svg>
<svg class="ic sm" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><use href="#i-maximize"/></svg>
<svg class="ic sm hidden" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><use href="#i-minimize"/></svg>
</button>
<button class="icon-btn" id="pv-close" title="关闭预览" aria-label="关闭预览">✕</button>
</span>
@@ -525,11 +625,11 @@
<span class="fs-name" id="fs-file-name"></span>
<!-- 源码切换钮:仅当当前内容有源文本时显隐(toggleFsSrc 在渲染视图/源码面板间互切) -->
<button class="fs-btn hidden" id="fs-src-btn" title="显示源码" aria-label="显示源码">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M1 12s4-8 11-8 11 8 11 8-4 8-11 8-11-8-11-8z"></path><circle cx="12" cy="12" r="3"></circle></svg>
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><use href="#i-eye"/></svg>
</button>
<!-- 复制源码:显隐与 eye 一致(有源文本才出现);HTML/SVG/MD/代码通用 -->
<button class="fs-btn hidden" id="fs-copy-btn" title="复制源码" aria-label="复制源码">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><rect x="9" y="9" width="13" height="13" rx="2"></rect><path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1"></path></svg>
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><use href="#i-copy"/></svg>
</button>
<button class="fs-btn" onclick="closeFullscreen()" title="关闭" aria-label="关闭">✕</button>
</div>
@@ -540,7 +640,7 @@
<!-- 拖拽上传提示层:window 级 dragenter 时显示;pointer-events:none,不参与命中测试(逻辑见 js/files.js) -->
<div id="drop-overlay" class="hidden" aria-hidden="true">
<div class="drop-hint">
<svg viewBox="0 0 24 24" class="ic"><path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4"></path><polyline points="17 8 12 3 7 8"></polyline><line x1="12" y1="3" x2="12" y2="15"></line></svg>
<svg viewBox="0 0 24 24" class="ic"><use href="#i-upload-cloud"/></svg>
<span>松开即可上传</span>
</div>
</div>
@@ -553,6 +653,7 @@
<script src="/js/files.js"></script>
<script src="/js/voice.js"></script>
<script src="/js/preview.js"></script>
<script src="/js/vcs.js"></script>
<script src="/js/files-tree.js"></script>
<script src="/js/settings.js"></script>
<script>
+40 -20
View File
@@ -32,13 +32,13 @@
// 删除本条:仅已落库消息可删(传 m.id);流式未落库时无 id,不渲染
const del = msgId
? '<button class="act act-del" title="删除本条" data-msg-id="' + msgId + '">' +
'<svg class="ic sm" viewBox="0 0 24 24"><path d="M18 6 6 18"></path><path d="m6 6 12 12"></path></svg>' +
'<svg class="ic sm" viewBox="0 0 24 24"><use href="#i-x-path"/></svg>' +
'</button>'
: '';
// 编辑并重发:只给未压缩的用户消息(调用方传 canEdit);带 b64 回填输入框,避免从 DOM 反推
const edit = canEdit && msgId
? '<button class="act act-edit" title="编辑并重发" data-msg-id="' + msgId + '" data-b64="' + b64 + '">' +
'<svg class="ic sm" viewBox="0 0 24 24"><path d="M12 20h9"></path><path d="M16.5 3.5a2.1 2.1 0 0 1 3 3L7 19l-4 1 1-4z"></path></svg>' +
'<svg class="ic sm" viewBox="0 0 24 24"><use href="#i-pencil"/></svg>' +
'</button>'
: '';
const u = normUsage(usage);
@@ -49,13 +49,28 @@
'<span>' + fmtTime(ts) + '</span>' +
usageHtml +
'<button class="act act-copy" title="复制" data-b64="' + b64 + '">' +
'<svg class="ic sm" viewBox="0 0 24 24"><rect x="9" y="9" width="13" height="13" rx="2"></rect><path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1"></path></svg>' +
'<svg class="ic sm" viewBox="0 0 24 24"><use href="#i-copy"/></svg>' +
'</button>' +
edit +
del +
'</div>';
}
// 上下文卡片:画像快照 / 渠道说明 / 开场记忆这类「只发给模型看的注入行」,
// 统一渲染成可折叠的系统卡片,而不是伪装成用户发言。
function ctxCardHtml(title, text, id) {
const r = mdHtml(text || ''); // 与摘要卡片同样走 markdown,保持四张卡片观感一致
return '<details class="msg-ctx"' + (id ? ' id="' + id + '"' : '') + '><summary>' + esc(title) + '</summary>'
+ '<div class="msg-ctx-body"><div class="bubble-ai' + (r.fmt ? ' md' : '') + '">' + r.html + '</div></div></details>';
}
// 画像快照是每轮请求拼在最前的上下文(不在 messages 表里)。历史是懒加载的,首屏只拉最近几条,
// 所以不能一打开就插,得等翻到最早、确认没有更早的消息了再放到最顶。
function ensureProfileCard(box) {
if (!state.profileSnapshot || !box || box.querySelector('#ctx-profile')) return;
box.insertAdjacentHTML('afterbegin', ctxCardHtml('画像快照', state.profileSnapshot, 'ctx-profile'));
}
function userMsgHtml(m) {
const p = parseUploadNotice(m.content);
const attach = p.files && p.files.length
@@ -72,16 +87,20 @@
function aiMsgHtml(m) {
const text = (m.content || '').trim();
const reason = (m.reasoning || '').trim();
if (!text && !reason) return null; // 纯工具调用的应答:不渲染气泡,工具卡由 appendToolCardsFromAssistant 铺
const errAck = m.type === 'errAck';
// 纯工具调用的应答不渲染气泡(工具卡由 appendToolCardsFromAssistant 铺),但 errAck 要留个标记
if (!text && !reason && !errAck) return null;
const note = errAck
? '<div class="msg-note">工具调用参数无效,本轮已从上下文移除,模型会重新发起</div>' : '';
const think = reason ? thinkPanelHtml(m.reasoning) : '';
const bubble = text ? (() => { const r = mdHtml(m.content); return '<div class="bubble-ai' + (r.fmt ? ' md' : '') + '">' + r.html + '</div>'; })() : '';
return '<div class="msg other">' + think + bubble + actionsHtml(m.created_at, m.content || '', m.id, m.usage) + '</div>';
return '<div class="msg other">' + note + think + bubble + actionsHtml(m.created_at, m.content || '', m.id, m.usage) + '</div>';
}
// 思考过程折叠面板:summary 固定名「思考过程」+ 右侧复制按钮,body 展示推理全文。
// 历史重渲染默认收起(与原设计一致),流式阶段的展开行为由 ensureStreamThinkPanel 显式控制。
// 复制按钮走 onCopyClick 统一代理:点击时从 DOM 取思考全文(不依赖 b64,流式增量也能复制)
const THINK_COPY_BTN = '<button class="act act-copy" title="复制思考内容">' +
'<svg class="ic sm" viewBox="0 0 24 24"><rect x="9" y="9" width="13" height="13" rx="2"></rect><path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1"></path></svg>' +
'<svg class="ic sm" viewBox="0 0 24 24"><use href="#i-copy"/></svg>' +
'</button>';
function thinkPanelHtml(text) {
return '<details class="msg-think"><summary>思考过程' + THINK_COPY_BTN + '</summary><div class="msg-think-body">' + esc(text) + '</div></details>';
@@ -93,7 +112,7 @@
// 复制文本在点击时从 pre.textContent 现取(onCopyClick 的 .code-wrap 分支),不嵌 b64、不怕内容后续变化。
// 只碰 .md 里的 pre:工具卡 / 思考区已有自己的复制按钮,行内 code 不加。
const CODE_COPY_BTN = '<button class="act act-copy" type="button" title="复制代码">' +
'<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><rect x="9" y="9" width="13" height="13" rx="2"></rect><path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1"></path></svg>' +
'<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><use href="#i-copy"/></svg>' +
'</button>';
function decorateCodePre(root) {
if (!root || !root.querySelectorAll) return;
@@ -118,15 +137,7 @@
// 「压缩」摘要卡片:流式收尾与历史重渲染共用的头部(图标 + 标题 + 右侧说明)。
function summaryHeaderHtml() {
return '<summary>' +
'<svg class="sum-ic" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.6" stroke-linecap="round">' +
'<ellipse cx="12" cy="5" rx="8" ry="2.5"></ellipse>' +
'<path d="M4 5v6c0 1.4 3.6 2.5 8 2.5s8-1.1 8-2.5V5"></path>' +
'<path d="M4 11v6c0 1.4 3.6 2.5 8 2.5s8-1.1 8-2.5v-6"></path>' +
'</svg>' +
'<span>上下文总结</span>' +
'<span class="sum-hint">后续对话以此为起点</span>' +
'</summary>';
return '<summary><span>上下文总结</span></summary>';
}
// 历史重渲染:被标记 type='summary' 的摘要消息渲染成摘要卡片(默认收起,点开可重现)。
@@ -161,14 +172,14 @@
if (!text) return '';
const b64 = btoa(unescape(encodeURIComponent(text)));
return '<button class="act act-copy" title="复制参数与结果" data-b64="' + b64 + '">' +
'<svg class="ic sm" viewBox="0 0 24 24"><rect x="9" y="9" width="13" height="13" rx="2"></rect><path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1"></path></svg></button>';
'<svg class="ic sm" viewBox="0 0 24 24"><use href="#i-copy"/></svg></button>';
}
// 工具卡「删除本条」:删的是 tool 消息行;后端会把它在父 assistant 里的调用同步摘除。
// msgId = tool 消息的库行 id(历史渲染传 m.id;实时由 tool_result 事件的 msg_id 携带)
function toolDelBtnHtml(msgId) {
if (!msgId) return '';
return '<button class="act act-del" title="删除本条" data-msg-id="' + msgId + '">' +
'<svg class="ic sm" viewBox="0 0 24 24"><path d="M18 6 6 18"></path><path d="m6 6 12 12"></path></svg></button>';
'<svg class="ic sm" viewBox="0 0 24 24"><use href="#i-x-path"/></svg></button>';
}
function renderToolCard(id, name, argsStr, createdAt, opts) {
const div = document.createElement('div');
@@ -322,7 +333,11 @@
}
function msgNode(m) {
if (m.role === 'user') return userMsgHtml(m);
if (m.role === 'user') {
if (m.type === 'channel_note') return ctxCardHtml('渠道上下文', m.content);
if (m.type === 'memory_note') return ctxCardHtml('开场记忆', m.content);
return userMsgHtml(m);
}
// 被「压缩总结」标记的摘要消息:重渲染成摘要卡片,而不是普通 AI 气泡
if (m.role === 'assistant') return m.type === 'summary' ? summaryMsgHtml(m) : aiMsgHtml(m);
return null; // tool 结果不单独展示
@@ -365,6 +380,7 @@
}
// 历史渲染收口:给本轮新渲染出的代码块补复制按钮(目标可能是分页离屏容器,装饰后再随节点搬迁)
decorateCodePre(target);
pvHighlightMdCode(target); // 对话正文里的围栏代码块也上色(与预览同一套)
return { closeArc };
}
@@ -431,9 +447,12 @@
const prevTop = keepView ? box.scrollTop : 0;
const followBottom = !keepView || !box.firstElementChild || isNearBottom();
box.innerHTML = '';
state.profileSnapshot = (s && s.profile_snapshot) || '';
appendMessagesDom(detail.messages || [], box).closeArc();
// 首屏就把历史拉完了(条数少):直接上画像卡片;否则等上滑翻到最早再插
if (!detail.has_more) ensureProfileCard(box);
if (!(detail.messages || []).length) {
box.innerHTML = '<div class="drawer-empty">描述你的需求,AI 会和你讨论并直接干活。</div>';
box.insertAdjacentHTML('beforeend', '<div class="drawer-empty">描述你的需求,AI 会和你讨论并直接干活。</div>');
}
state.chatHasMore = !!detail.has_more;
state.chatOldestId = detail.oldest_id || null;
@@ -501,6 +520,7 @@
while (frag.firstChild) box.insertBefore(frag.firstChild, anchor);
box.scrollTop = box.scrollHeight - prevH + prevTop;
state.chatHasMore = !!detail.has_more;
if (!detail.has_more) ensureProfileCard(box); // 翻到最早了:画像卡片补到流最顶
if (detail.oldest_id) state.chatOldestId = detail.oldest_id;
state.chatLoadedCount += (detail.messages || []).length;
// 旧页太短导致补完后仍贴在触发区:继续拉下一页,避免卡在顶部要再动一下才加载
+17 -5
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) {
@@ -148,11 +154,11 @@
const MODES = {
secretary: {
label: '文秘助理', hint: '支持文字输入,可起草、润色、整理文书',
icon: '<svg class="header-mode-icon" viewBox="0 0 24 24"><path d="M6 3h12l4 6-10 13L2 9z"></path><polyline points="2 9 22 9"></polyline><polyline points="10 3 8 9 12 22"></polyline><polyline points="14 3 16 9 12 22"></polyline></svg>',
icon: '<svg class="header-mode-icon" viewBox="0 0 24 24"><use href="#i-gem"/></svg>',
},
vision: {
label: '识图专家', hint: '支持图片识别输入',
icon: '<svg class="header-mode-icon" viewBox="0 0 24 24"><rect x="3" y="3" width="18" height="18" rx="2"></rect><circle cx="8.5" cy="8.5" r="1.5"></circle><polyline points="21 15 16 10 5 21"></polyline></svg>',
icon: '<svg class="header-mode-icon" viewBox="0 0 24 24"><use href="#i-image"/></svg>',
},
};
@@ -161,7 +167,7 @@
view: 'welcome', // welcome | chat
mode: 'secretary', // 新建会话默认助手类型(欢迎页已去掉模式切换,不再可变)
sessionType: 'secretary', // 当前会话的助手类型(建档时锁定,后续不随模式切换变更)
deepThink: false, // 深度思考开关(仅本地视觉状态,无后端参数)
deepThink: false, // 深度思考开关(发消息时落库到 sessions.deep_think,重进会话回填)
pendingModel: '', // welcome 预选模型(ensureSession 建档时透传 model_id)
sessionId: null, // 当前会话
sessionTitle: '', // 当前会话标题
@@ -208,7 +214,11 @@
function renderHeader() {
const c = $('header-center');
// welcome(含刚 newChat)一律清空:newChat 会停在 welcome,不重刷会残留旧会话标题
if (state.view !== 'chat' || !state.sessionId) { c.innerHTML = ''; return; }
if (state.view !== 'chat' || !state.sessionId) {
c.innerHTML = '';
document.title = 'Agent 任务台'; // 回欢迎页/新建会话时标签页恢复默认
return;
}
// 顶部只显标题;助手类型 icon 早已退位(会话阶段徽标随 advising 一并移除)
const title = document.createElement('div');
title.className = 'header-title';
@@ -218,6 +228,8 @@
title.addEventListener('click', renameSession); // 点标题重命名(同步 index)
c.innerHTML = '';
c.appendChild(title);
// 标签页标题跟着会话走:切会话/重命名/自动生成标题都会走到这里
document.title = state.sessionTitle || 'Agent 任务台';
}
// ---------- 模式切换已移除:新建会话固定用 state.mode(secretary),助手类型不再占顶部 icon
+285 -30
View File
@@ -8,30 +8,36 @@
// 依赖(全局):state $ req toast downloadFile confirmModal openFilePreview
'use strict';
(function () {
const SVG_FOLDER = '<svg class="ic sm" viewBox="0 0 24 24"><path d="M3 7a2 2 0 0 1 2-2h4l2 2h8a2 2 0 0 1 2 2v8a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2z"/></svg>';
const SVG_FILE = '<svg class="ic sm" viewBox="0 0 24 24"><path d="M6 3h8l4 4v14H6z"/><path d="M14 3v4h4"/></svg>';
const SVG_LINK = '<svg class="ic sm" viewBox="0 0 24 24"><path d="M10 13a5 5 0 0 0 7 0l2-2a5 5 0 0 0-7-7l-1 1"/><path d="M14 11a5 5 0 0 0-7 0l-2 2a5 5 0 0 0 7 7l1-1"/></svg>';
const SVG_REVEAL = '<svg class="ic sm" viewBox="0 0 24 24"><path d="M14 4h6v6"/><path d="M20 4l-9 9"/><path d="M19 14v5a1 1 0 0 1-1 1H5a1 1 0 0 1-1-1V6a1 1 0 0 1 1-1h5"/></svg>';
const SVG_REFRESH = '<svg class="ic sm" viewBox="0 0 24 24"><path d="M20 12a8 8 0 1 1-2.3-5.7"/><path d="M20 4v5h-5"/></svg>';
const SVG_TERM = '<svg class="ic sm" viewBox="0 0 24 24"><rect x="3" y="4" width="18" height="16" rx="2"/><path d="M7 9l3 3-3 3"/><path d="M13 15h4"/></svg>';
const SVG_EYE = '<svg class="ic sm" viewBox="0 0 24 24"><path d="M2 12s3.5-7 10-7 10 7 10 7-3.5 7-10 7S2 12 2 12z"/><circle cx="12" cy="12" r="2.6"/></svg>';
const SVG_DL = '<svg viewBox="0 0 24 24"><path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4"/><polyline points="7 10 12 15 17 10"/><line x1="12" y1="15" x2="12" y2="3"/></svg>';
const SVG_DEL = '<svg viewBox="0 0 24 24"><polyline points="3 6 5 6 21 6"/><path d="M19 6l-1 14a2 2 0 0 1-2 2H8a2 2 0 0 1-2-2L5 6"/><line x1="10" y1="11" x2="10" y2="17"/><line x1="14" y1="11" x2="14" y2="17"/></svg>';
const SVG_REVEAL_SM = '<svg viewBox="0 0 24 24"><path d="M14 4h6v6"/><path d="M20 4l-9 9"/><path d="M19 14v5a1 1 0 0 1-1 1H5a1 1 0 0 1-1-1V6a1 1 0 0 1 1-1h5"/></svg>';
const SVG_FOLDER = '<svg class="ic sm" viewBox="0 0 24 24"><use href="#i-folder"/></svg>';
const SVG_FILE = '<svg class="ic sm" viewBox="0 0 24 24"><use href="#i-file"/></svg>';
const SVG_LINK = '<svg class="ic sm" viewBox="0 0 24 24"><use href="#i-link"/></svg>';
const SVG_REVEAL = '<svg class="ic sm" viewBox="0 0 24 24"><use href="#i-external-b"/></svg>';
const SVG_REFRESH = '<svg class="ic sm" viewBox="0 0 24 24"><use href="#i-reload"/></svg>';
const SVG_TERM = '<svg class="ic sm" viewBox="0 0 24 24"><use href="#i-terminal"/></svg>';
const SVG_VCS = '<svg class="ic sm" viewBox="0 0 24 24"><use href="#i-git"/></svg>';
const SVG_EYE = '<svg class="ic sm" viewBox="0 0 24 24"><use href="#i-eye-sm"/></svg>';
const SVG_DL = '<svg viewBox="0 0 24 24"><use href="#i-download"/></svg>';
const SVG_DEL = '<svg viewBox="0 0 24 24"><use href="#i-trash"/></svg>';
const SVG_REVEAL_SM = '<svg viewBox="0 0 24 24"><use href="#i-external-b"/></svg>';
const SVG_AT = '<span class="at-glyph">@</span>';
let localCapable = false; // local 启动器:才显示「在 Finder/终端中打开」
let showHidden = false;
let expanded = new Set(['']); // 已展开的相对目录('' = 根)
let cache = new Map(); // rel -> /tree 响应
let loading = new Map(); // rel -> Promise(并发去重)
let emptyDirs = new Map(); // rel -> 目录 mtimeMs:确认空着的目录,mtime 没变就不必再请求
let gen = 0; // 会话切换/刷新时自增,防止旧请求回填到新树的缓存
// 多选:rel -> 'dir' | 'file'。勾目录表示整个目录(下载打成一个 zip、删除递归),
// 所以勾目录会吃掉子项,勾子项会把祖先目录降级掉,见 toggleSel。
let sel = new Map();
// 失效缓存。gen 自增让在飞的旧请求回来时不再写缓存(否则切会话会闪旧目录)。
function invalidate(keepExpanded) {
gen++;
cache = new Map();
loading = new Map();
if (!keepExpanded) expanded = new Set(['']);
if (!keepExpanded) { expanded = new Set(['']); sel.clear(); emptyDirs = new Map(); }
}
function sid() { return (state && state.sessionId) || ''; }
@@ -43,15 +49,24 @@
parent.appendChild(el);
}
function openDir(rel) {
function openDir(rel, dirMtime) {
if (cache.has(rel)) return Promise.resolve(cache.get(rel));
if (loading.has(rel)) return loading.get(rel);
if (!sid()) return Promise.resolve(null);
// 已知空目录且目录自身 mtime 未变(增删子项才会变):跳过请求,直接给空结果
if (dirMtime != null && emptyDirs.get(rel) === dirMtime) {
return Promise.resolve({ dir: rel, total: 0, capped: false, entries: [] });
}
const url = '/api/sessions/' + encodeURIComponent(sid()) + '/tree?dir=' +
encodeURIComponent(rel) + (showHidden ? '&hidden=1' : '');
const myGen = gen;
const p = req('GET', url).then(function (data) {
if (myGen === gen) { cache.set(rel, data); loading.delete(rel); }
if (myGen === gen) {
cache.set(rel, data); loading.delete(rel);
const n = (data && data.entries) ? data.entries.length : 0;
if (!n && dirMtime != null) emptyDirs.set(rel, dirMtime);
else if (n) emptyDirs.delete(rel);
}
return data;
}, function (e) {
if (myGen === gen) loading.delete(rel);
@@ -83,11 +98,21 @@
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');
const caret = document.createElement('span');
caret.className = 'tree-caret';
row.appendChild(caret);
// 不画展开箭头:文件夹图标已经说明可以点,点行任意位置都能展开/收起。
// 勾选框:hover 或已选中时淡入,但占位始终在,避免 hover 时文件名左右跳。
// 软链不参与批量操作(后端也不让删),所以不给勾选框。
if (ent.type !== 'link') {
const chk = document.createElement('span');
chk.className = 'tree-check';
chk.setAttribute('role', 'checkbox');
chk.setAttribute('aria-label', '选择');
const on = sel.has(ent.rel);
chk.setAttribute('aria-checked', on ? 'true' : 'false');
if (on) row.classList.add('selected');
row.appendChild(chk);
}
const ico = document.createElement('span');
ico.className = 'tree-ico';
@@ -99,32 +124,31 @@
name.textContent = ent.name;
row.appendChild(name);
if (ent.ignored) {
row.title = ent.rel + '(已忽略的大目录/构建产物)';
return row;
}
// 行内动作:服务器形态给「下载 / 删除」;local 本就跑在同一台机器上,
// 「下载」到本地是多余的(用 Finder 直接看原文件更顺),所以换成「在 Finder 中显示」。
// @ 引用排最前:它是「往输入框送东西」的动作,和后面的下载 / Finder / 删除(对文件本身动手)分开
row.appendChild(actBtn('at', ent.type === 'dir' ? '引用此目录' : '引用到输入框', SVG_AT, false));
if (ent.type === 'file' && !localCapable) row.appendChild(actBtn('download', '下载', SVG_DL, false));
if (localCapable) row.appendChild(actBtn('reveal', '在 Finder 中显示', SVG_REVEAL_SM, false));
row.appendChild(actBtn('delete', '删除', SVG_DEL, true));
return row;
}
async function renderDirInto(container, rel, depth) {
async function renderDirInto(container, rel, depth, dirMtime) {
container.innerHTML = '';
const data = await openDir(rel);
const data = await openDir(rel, dirMtime);
if (!data) return;
const frag = document.createDocumentFragment();
const list = data.entries || [];
if (!list.length) tip(frag, '(空目录)');
// 只在根目录给空提示:子目录展开后本来就该「看不出变化」,根节点全空白则分不清是空还是没加载
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);
renderDirInto(kids, ent.rel, depth + 1).catch(function () {}); // 异步填充子层
renderDirInto(kids, ent.rel, depth + 1, ent.mtimeMs).catch(function () {}); // 异步填充子层
}
}
if (data.capped) tip(frag, '仅显示前 ' + list.length + ' 项(共 ' + data.total + ' 项)', 'tree-more');
@@ -152,6 +176,7 @@
tip(root, '加载失败:' + e.message);
}
body.scrollTop = sc;
syncSelUI();
}
async function localAction(kind, rel) {
@@ -176,17 +201,176 @@
await req('DELETE', '/api/sessions/' + sid() + '/files?path=' + encodeURIComponent(rel));
// 预览里正开着被删的文件 → 一起关掉,别留一份已不存在的内容
if (typeof pvState === 'object' && pvState && pvState.name === rel && typeof pvCloseDoc === 'function') pvCloseDoc();
sel.delete(rel);
invalidate(true);
renderBody();
toast('已删除');
} catch (e) { toast('删除失败:' + e.message); }
}
// ---- 多选与批量操作 ----
// 有效选中:自身被勾,或某个祖先目录被勾(勾目录=整目录)。
// 注意 UI 上只给 sel 里显式存在的行打勾:目录打勾就代表整目录,子行不再重复显示勾。
function isSel(rel) {
if (sel.has(rel)) return true;
let p = rel;
while (p.lastIndexOf('/') > 0) {
p = p.slice(0, p.lastIndexOf('/'));
if (sel.has(p)) return true;
}
return false;
}
function toggleSel(rel, type) {
if (sel.has(rel)) {
sel.delete(rel);
} else {
// 选子项时祖先目录降级为部分选择,否则一个目录会既「全选」又「只选一部分」
let p = rel;
while (p.lastIndexOf('/') > 0) {
p = p.slice(0, p.lastIndexOf('/'));
sel.delete(p);
}
sel.set(rel, type);
}
syncSelUI();
}
// 当前可见(已展开)的可选行
function visibleRows() {
const body = $('tree-body');
if (!body) return [];
return Array.from(body.querySelectorAll('.tree-row')).filter(function (r) {
return r.dataset.type !== 'link';
});
}
// 提交给后端前折叠:目录已选时,它下面的路径不再单独出现(否则 zip 里会重复)
function effectiveSel() {
const keys = Array.from(sel.keys()).sort(function (a, b) {
return a.split('/').length - b.split('/').length;
});
const out = [];
for (const k of keys) {
if (!out.some(function (p) { return k.startsWith(p + '/'); })) out.push(k);
}
return out;
}
function syncSelUI() {
const body = $('tree-body');
if (body) {
body.querySelectorAll('.tree-row').forEach(function (row) {
const chk = row.querySelector('.tree-check');
if (!chk) return;
const on = sel.has(row.dataset.rel);
chk.setAttribute('aria-checked', on ? 'true' : 'false');
row.classList.toggle('selected', on);
});
}
const n = sel.size;
const cnt = $('tree-sel-count'), dl = $('tree-bulk-download'), del = $('tree-bulk-delete');
if (cnt) cnt.textContent = n ? '已选 ' + n + ' 项' : '未选择';
if (dl) dl.disabled = !n;
if (del) del.disabled = !n;
const all = $('tree-check-all');
if (all) {
const rows = visibleRows();
const every = rows.length > 0 && rows.every(function (r) { return isSel(r.dataset.rel); });
all.setAttribute('aria-checked', every ? 'true' : (n ? 'mixed' : 'false'));
}
}
function toggleSelAll() {
const rows = visibleRows();
const every = rows.length > 0 && rows.every(function (r) { return isSel(r.dataset.rel); });
sel.clear();
if (!every) {
// 浅的先加:父目录已经覆盖的子项不再重复记
rows.map(function (r) { return [r.dataset.rel, r.dataset.type]; })
.sort(function (a, b) { return a[0].split('/').length - b[0].split('/').length; })
.forEach(function (it) { if (!isSel(it[0])) sel.set(it[0], it[1]); });
}
syncSelUI();
}
async function bulkDownload() {
if (!sid() || !sel.size) return;
const paths = effectiveSel();
const hasDir = paths.some(function (p) { return sel.get(p) === 'dir'; });
// 含目录 → 后端打成一个 zip;纯文件 → 逐个签名直链。
// 先把 token 全取完再逐个触发,边取边点会让浏览器把后面的当弹窗拦掉。
if (hasDir) {
try {
const r = await req('GET', '/api/sessions/' + sid() + '/files/zip-token?paths=' +
encodeURIComponent(JSON.stringify(paths)));
if (!r || !r.url) throw new Error('未拿到打包链接');
const a = document.createElement('a');
a.href = r.url;
if (r.name) a.download = r.name;
document.body.appendChild(a);
a.click();
a.remove();
} catch (e) { toast('打包下载失败:' + e.message); }
return;
}
const items = [];
for (const p of paths) {
try {
const r = await req('GET', '/api/sessions/' + sid() + '/files/download-token?path=' +
encodeURIComponent(p));
if (r && r.url) items.push({ name: p.split('/').pop(), url: r.url });
} catch (e) { /* 单个取票失败不拖累其余 */ }
}
if (!items.length) { toast('下载失败'); return; }
items.forEach(function (it, i) {
setTimeout(function () {
const a = document.createElement('a');
a.href = it.url;
a.download = it.name;
document.body.appendChild(a);
a.click();
a.remove();
}, i * 250);
});
}
async function bulkDelete() {
if (!sid() || !sel.size) return;
const paths = effectiveSel();
const ok = typeof confirmModal === 'function'
? await confirmModal('批量删除', '删除选中的 ' + paths.length + ' 项?文件夹会连同内容一起删除。', '删除', true)
: true;
if (!ok) return;
let done = 0, fail = 0;
for (const p of paths) {
try {
await req('DELETE', '/api/sessions/' + sid() + '/files?path=' + encodeURIComponent(p));
done++;
} catch (e) { fail++; }
}
// 预览里正开着被删的文件就一起关掉,别留一份已不存在的内容
if (typeof pvState === 'object' && pvState && pvState.name && typeof pvCloseDoc === 'function') {
const cur = pvState.name;
if (paths.some(function (p) { return cur === p || cur.startsWith(p + '/'); })) pvCloseDoc();
}
sel.clear();
invalidate(true);
renderBody();
if (fail) toast('已删除 ' + done + ' 项,' + fail + ' 项失败'); // 全成功时列表自己就空了,不弹
}
function onTreeClick(e) {
const row = e.target.closest('.tree-row');
if (!row) return;
const rel = row.dataset.rel;
const isDir = row.dataset.type === 'dir';
// 勾选框只切换选中,不展开、不预览(树里点错行代价大,整行不承担选中)
if (e.target.closest('.tree-check')) {
e.stopPropagation();
toggleSel(rel, row.dataset.type);
return;
}
const act = e.target.closest('.tree-act');
if (act) {
e.stopPropagation();
@@ -194,9 +378,10 @@
if (a === 'download') { if (typeof downloadFile === 'function') downloadFile(rel); }
else if (a === 'delete') deleteNode(rel, isDir);
else if (a === 'reveal') localAction('reveal', rel);
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();
@@ -207,11 +392,39 @@
}
}
// @ 引用:把相对路径插到对话框光标处。插的是纯相对路径,不带 @ 前缀——
// @<会话id>/<rel> 是跨会话只读路径的语法(resolvePastPath),带上会被当成会话 id 而报错。
// 相对路径正是 read_file / list_directory 直接认的形态。
function insertPathRef(rel, isDir) {
const ta = $('msg-input');
if (!ta || !rel) return;
const txt = isDir ? rel + '/' : rel;
const s = ta.selectionStart == null ? ta.value.length : ta.selectionStart;
const e = ta.selectionEnd == null ? s : ta.selectionEnd;
const before = ta.value.slice(0, s);
const after = ta.value.slice(e);
// 前后补空格:粘在已有文字上会让路径和句子糊成一串,AI 切不开。
// 末尾(光标后无内容)也补一个,光标落在空格之后,接着打字不会和路径粘连。
const lead = before && !/\s$/.test(before) ? ' ' : '';
const tail = after ? (/^\s/.test(after) ? '' : ' ') : ' ';
ta.value = before + lead + txt + tail + after;
// 光标落在「路径 + 尾部空格」之后:末尾插入时继续打字不会和路径粘连(空格真起作用),
// 开头/中间插入时也停在插入块之后,与原文自然隔开。
const pos = (before + lead + txt + tail).length;
ta.focus();
try { ta.setSelectionRange(pos, pos); } catch (_) { /* 部分环境不支持,光标位置不强求 */ }
ta.dispatchEvent(new Event('input', { bubbles: true })); // 发送按钮状态 / 自动高度靠它跟上
}
// local 能力探测结果回来后才把「在 Finder/终端中打开」露出来(服务器形态永远隐藏)
function syncLocalButtons() {
const rv = $('tree-reveal'), tm = $('tree-terminal');
if (rv) rv.classList.toggle('hidden', !localCapable);
if (tm) tm.classList.toggle('hidden', !localCapable);
// 本地端文件就在本机,批量下载是多余的,底栏只留删除;服务器端才需要
const bulkDl = $('tree-bulk-download');
if (bulkDl) bulkDl.classList.toggle('hidden', localCapable);
if (localCapable && $('tree-body')) renderBody(); // 行内 reveal 按钮也要重新生成
}
@@ -223,13 +436,18 @@
// 头部直接复用预览栏的 .pv-head / .pv-actions / .icon-btn:
// 两者在桌面上左右并排,尺寸/描边/内边距必须一模一样,否则一眼就看出错位。
// 不放地址条(路径在 280px 里必然截断,没有信息量),所以只剩右侧操作钮。
// 不放地址条(路径在 280px 里必然截断,没有信息量)。
// 操作钮按用途分两组:左边是树内的只读操作(显示隐藏文件 / 刷新 / Git 面板),
// 右边是拉到外部打开(Finder / 终端,仅本地模式出现)。两组分居两端,连点不易误触。
const head = document.createElement('header');
head.className = 'pv-head tree-head';
head.innerHTML =
'<span class="pv-actions">' +
'<span class="pv-actions tree-actions-main">' +
'<button class="icon-btn" type="button" id="tree-hidden" title="显示隐藏文件" aria-label="显示隐藏文件">' + SVG_EYE + '</button>' +
'<button class="icon-btn" type="button" id="tree-refresh" title="刷新" aria-label="刷新">' + SVG_REFRESH + '</button>' +
'<button class="icon-btn" type="button" id="tree-vcs" title="Git 改动与历史" aria-label="Git 改动与历史">' + SVG_VCS + '</button>' +
'</span>' +
'<span class="pv-actions tree-actions-ext">' +
'<button class="icon-btn hidden" type="button" id="tree-reveal" title="在 Finder 中打开" aria-label="在 Finder 中打开">' + SVG_REVEAL + '</button>' +
'<button class="icon-btn hidden" type="button" id="tree-terminal" title="在终端中打开" aria-label="在终端中打开">' + SVG_TERM + '</button>' +
'</span>';
@@ -238,8 +456,18 @@
body.className = 'tree-body';
body.id = 'tree-body';
// 底部批量条:全选框、计数、下载/删除。未选时两个按钮禁用。
const foot = document.createElement('div');
foot.className = 'tree-foot';
foot.innerHTML =
'<span class="tree-check-all" id="tree-check-all" role="checkbox" aria-checked="false" title="全选当前可见" aria-label="全选"></span>' +
'<span class="tree-sel-count" id="tree-sel-count">未选择</span>' +
'<button class="tree-foot-btn" type="button" id="tree-bulk-download" title="下载所选" aria-label="下载所选" disabled>' + SVG_DL + '</button>' +
'<button class="tree-foot-btn danger" type="button" id="tree-bulk-delete" title="删除所选" aria-label="删除所选" disabled>' + SVG_DEL + '</button>';
box.appendChild(head);
box.appendChild(body);
box.appendChild(foot);
head.querySelector('#tree-hidden').addEventListener('click', function () {
showHidden = !showHidden;
@@ -253,6 +481,12 @@
});
head.querySelector('#tree-reveal').addEventListener('click', function () { localAction('reveal', ''); });
head.querySelector('#tree-terminal').addEventListener('click', function () { localAction('terminal', ''); });
head.querySelector('#tree-vcs').addEventListener('click', function () {
if (typeof window.openVcsPane === 'function') window.openVcsPane();
});
foot.querySelector('#tree-check-all').addEventListener('click', toggleSelAll);
foot.querySelector('#tree-bulk-download').addEventListener('click', bulkDownload);
foot.querySelector('#tree-bulk-delete').addEventListener('click', bulkDelete);
body.addEventListener('click', onTreeClick);
syncLocalButtons();
@@ -261,6 +495,10 @@
// 侧栏底部「文件树」图标 → 切到这个面板(由 files.js 的 setDrawerPane 调用)。
window.showFileTree = function () {
ensureShell();
// 缓存还在就直接用:同一会话里反复开关面板,不该把已展开的目录全部重拉一遍
// (展开 N 层就是 N 轮请求,移动网络下能到 1-2 秒)。文件真变了有 reloadFileTree 兜底,
// 它在一轮跑完 / 回前台 / 断线重连时会把已展开的层重新拉一遍。
if (!cache.size) invalidate(true);
renderBody();
};
@@ -271,6 +509,23 @@
if (drawer && drawer.classList.contains('drawer-mode-files')) renderBody();
};
// 按需刷新(一轮跑完 / 回前台 / 断线重连):保留展开与勾选,只重拉已展开的目录。
// 不在文件树面板时只标脏不渲染,等切回来由 showFileTree 重新拉。
let reloadTimer = 0, reloadAt = 0, reloading = false;
window.reloadFileTree = function () {
clearTimeout(reloadTimer);
reloadTimer = setTimeout(async function () {
if (Date.now() - reloadAt < 1000) return; // 刚刷过:多路触发(done/visibility/focus/resync)合并掉
if (reloading) return; // 上一轮还在渲,跳过(它读到的就是刚清过的缓存)
reloadAt = Date.now();
invalidate(true);
const drawer = $('drawer');
if (!drawer || !drawer.classList.contains('drawer-mode-files')) return;
reloading = true;
try { await renderBody(); } finally { reloading = false; }
}, 250);
};
(function init() {
if (!$('drawer-actions') || !$('files-tree')) return;
req('GET', '/api/local/info').then(function (info) {
+68 -80
View File
@@ -49,8 +49,7 @@
// 深度思考开关:每次发消息随 body 传给后端,后端会合并该模型的 thinking_params
$('deep-think-btn').addEventListener('click', () => {
state.deepThink = !state.deepThink;
$('deep-think-btn').classList.toggle('on', state.deepThink);
toast(state.deepThink ? '深度思考已开启' : '深度思考已关闭');
$('deep-think-btn').classList.toggle('on', state.deepThink); // 按钮态即反馈,不再弹 toast
});
// ---------- 任务文件面板(底部浮层:点输入行右侧文件夹按钮展开,遮罩盖住输入区) ----------
@@ -159,10 +158,10 @@
return fileSelected.has(p) || isPathInDirSel(p);
}
// 目录节点内所有文件的相对路径(递归)
// 当前层能拿到的文件(懒加载只拉这一层,子目录内容没有;
// 目录整体勾选走 dirSelKey,zip 打包由后端 collectZipEntries 递归)
function filesUnderDir(node) {
let out = node.files.map(f => f.filename);
for (const d of node.dirs.values()) out = out.concat(filesUnderDir(d));
return out;
return node ? node.files.map(f => f.filename) : [];
}
// 全选的作用域 = 当前浏览目录下的全部文件(递归含其子文件夹,等价于逐个勾选这些文件夹行)。
// 不能再用全任务树的扁平列表:在子文件夹里点全选会把根下其它文件也选上,批量删除会清空整个任务目录。
@@ -298,31 +297,28 @@
// 扁平文件列表 → 树节点 { name, path, dirs: Map, files: [] }
// 目录标记行(?dirs=1:filename 以 '/' 结尾 + dir:true)只沿途铺设路径节点、不入任何 files[],
// 不含文件的空夹子因此也能渲染;与同名文件路径铺出的节点经 dirs Map 天然去重。
function buildFilesTree(files) {
const root = { name: '', path: '', dirs: new Map(), files: [] };
for (const f of files) {
const isDir = f.dir === true || /\/$/.test(String(f.filename));
const name = isDir ? String(f.filename).replace(/\/+$/, '') : String(f.filename);
if (!name) continue;
const segs = name.split('/');
let node = root, rel = '';
const dirDepth = isDir ? segs.length : segs.length - 1; // 文件:末段是文件名;目录:全是路径段
for (let i = 0; i < dirDepth; i++) {
const seg = segs[i];
rel = rel ? rel + '/' + seg : seg;
if (!node.dirs.has(seg)) node.dirs.set(seg, { name: seg, path: rel, dirs: new Map(), files: [] });
node = node.dirs.get(seg);
// 把 /tree 返回的单层 entries 变成渲染用节点(子目录只留空 Map,进入时才拉)
function buildNodeFromEntries(dir, entries) {
const node = { name: dir.split('/').pop() || '', path: dir, dirs: new Map(), files: [] };
for (const e of entries) {
if (e.type === 'dir') {
node.dirs.set(e.name, { name: e.name, path: e.rel, dirs: new Map(), files: [], mtime: e.mtimeMs });
} else if (e.type === 'file') {
node.files.push({ filename: e.rel, size: e.size, mtime: e.mtimeMs, ctime: e.mtimeMs });
}
if (!isDir) node.files.push(f);
}
return root;
return node;
}
// 目录(含子目录)内文件总数,用于目录头计数
function countDirFiles(node) {
let n = node.files.length;
for (const d of node.dirs.values()) n += countDirFiles(d);
return n;
// 文件/目录时间:统一「年/月/日 时:分」。全局 fmtTime 对今天只给时分(聊天消息那种场景),
// 文件列表要能一眼看出新旧,所以固定带日期。
function fmtFileTime(ts) {
if (!ts) return '';
const d = new Date(ts);
if (isNaN(d.getTime())) return '';
const p = n => String(n).padStart(2, '0');
return d.getFullYear() + '/' + p(d.getMonth() + 1) + '/' + p(d.getDate())
+ ' ' + p(d.getHours()) + ':' + p(d.getMinutes());
}
function fileRowHtml(f) {
@@ -330,10 +326,10 @@
const low = f.filename.toLowerCase();
const fsPv = /\.(md|txt|html?|pdf|png|jpe?g|gif|webp|svg|docx|xlsx|pptx|csv|tsv|json|jsonl|xml|yml|yaml|toml|ini|conf|cfg|properties|env|log|py|pyw|js|mjs|cjs|ts|tsx|jsx|java|kt|c|h|cpp|hpp|cc|cs|go|rs|rb|php|swift|sh|bash|zsh|bat|ps1|sql|lua|r|dart|vue|css|less|scss|srt|vtt)$/.test(low);
const ico = fsPv
? '<svg class="file-ico eye" viewBox="0 0 24 24" aria-label="可预览"><path d="M1 12s4-8 11-8 11 8 11 8-4 8-11 8-11-8-11-8z"></path><circle cx="12" cy="12" r="3"></circle></svg>'
: '<svg class="file-ico doc" viewBox="0 0 24 24" aria-label="可下载"><path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z"></path><polyline points="14 2 14 8 20 8"></polyline></svg>';
? '<svg class="file-ico eye" viewBox="0 0 24 24" aria-label="可预览"><use href="#i-eye"/></svg>'
: '<svg class="file-ico doc" viewBox="0 0 24 24" aria-label="可下载"><use href="#i-file-doc"/></svg>';
const name = esc(String(f.filename).split('/').pop() || f.filename);
const ftime = fmtTime(f.mtime || f.ctime);
const ftime = fmtFileTime(f.mtime || f.ctime);
const sel = isFileEffectivelySelected(f.filename);
return '<div class="file-row clickable' + (sel ? ' selected' : '') + '" data-path="' + esc(f.filename) + '" data-preview="' + (fsPv ? '1' : '0') + '" data-size="' + esc(fmtSize(f.size)) + '">' +
'<span class="file-check" role="checkbox" aria-checked="' + (sel ? 'true' : 'false') + '" aria-label="选择"></span>' +
@@ -347,29 +343,23 @@
// 目录行(带勾选框):整个文件夹作为一个选中项(下载时后端打包成 zip);
// 点行其余区域进入该目录(单层列表,不再有折叠/展开)。
// 懒加载下不知道子目录内容,勾选态只看这一行自己是否被整体勾选;右侧显示修改时间,和文件行一致。
function dirRowHtml(node) {
const under = filesUnderDir(node);
const checked = fileSelected.has(dirSelKey(node.path)) ||
(under.length > 0 && under.every(isFileEffectivelySelected));
const checked = fileSelected.has(dirSelKey(node.path));
const dtime = fmtFileTime(node.mtime);
return '<div class="file-dir-head' + (checked ? ' selected' : '') + '" data-dir="' + esc(node.path) + '" role="button">' +
'<span class="file-check" role="checkbox" aria-checked="' + (checked ? 'true' : 'false') + '" aria-label="选择文件夹"></span>' +
'<svg class="file-dir-ico" viewBox="0 0 24 24"><path d="M22 19a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h5l2 3h9a2 2 0 0 1 2 2z"></path></svg>' +
'<svg class="file-dir-ico" viewBox="0 0 24 24"><use href="#i-folder-c"/></svg>' +
'<span class="file-dir-name">' + esc(node.name) + '</span>' +
'<span class="file-dir-count">' + countDirFiles(node) + ' 个文件</span>' +
'<svg class="file-dir-go" viewBox="0 0 24 24"><polyline points="9 18 15 12 9 6"></polyline></svg>' +
(dtime ? '<span class="file-dir-time">' + dtime + '</span>' : '') +
'<svg class="file-dir-go" viewBox="0 0 24 24"><use href="#i-chevron-right"/></svg>' +
'</div>';
}
// 按相对路径取树节点('' = 根);路径不存在(如删除后重拉)返回 null
// 懒加载下只有当前浏览目录的节点('' = 根);其它路径没有数据
function filesNodeAt(path) {
let node = filesTreeRoot;
if (!node) return null;
if (!path) return node;
for (const seg of String(path).split('/')) {
node = node.dirs.get(seg);
if (!node) return null;
}
return node;
if (!filesTreeRoot) return null;
return (path || '') === filesCurDir ? filesTreeRoot : null;
}
// 渲染当前目录:顶部面包屑(根目录(home) › a › b,点任意节点回跳)+ 单层列表(目录在前、文件在后)。
@@ -381,13 +371,13 @@
if (!node) { filesCurDir = ''; node = filesNodeAt(''); } // 当前目录已被删除 → 退回根
const sizeEl = $('files-panel-size');
if (!node) { el.innerHTML = ''; if (sizeEl) sizeEl.textContent = ''; return; }
// 标题旁总大小:按未过滤的聚合表取当前目录递归总量(关彩蛋时服务端不返回 dot 项;开彩蛋时含 .imgcache/.tmp/.venv 全计)
// 标题旁总大小:只算当前层文件(子目录的递归大小要额外扫全树,懒加载拿不到)
if (sizeEl) {
const total = filesDirSizes.get(filesCurDir) || 0;
sizeEl.textContent = total > 0 ? fmtSize(total) : '';
}
// 根节点:home 图标 + 「根目录」,比一个孤悬的「/」醒目得多;在根时它是当前层,纯文本不可点
const homeIc = '<svg class="crumb-ic" viewBox="0 0 24 24"><path d="M3 9l9-7 9 7v11a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2z"></path><polyline points="9 22 9 12 15 12 15 22"></polyline></svg>';
const homeIc = '<svg class="crumb-ic" viewBox="0 0 24 24"><use href="#i-home"/></svg>';
let html = filesCurDir
? '<span class="crumb" data-path="">' + homeIc + '根目录</span>'
: '<span class="crumb cur">' + homeIc + '根目录</span>';
@@ -420,28 +410,18 @@
filesTreeRoot = null;
updateFilesFooter();
try {
// 彩蛋开启时后端连 dot 项一起列,且不再滤 .tmp/.venv(全量放出)
// 按目录懒加载:只拉当前这一层(/tree),不再全量递归。
// 之前一次拉全树,仓库级工作目录能到 1.4MB(10544 个文件,81% 在 node_modules)。
const hiddenQ = filesShowHidden ? '&hidden=1' : '';
const files = await req('GET', '/api/sessions/' + state.sessionId + '/files?dirs=1' + hiddenQ);
// 会话级 .tmp(executor 的共享 /tmp 落盘处)与 .venv(Python 虚拟环境)不属于任务产物:默认隐藏(老后端兼容兑底;新版关彩蛋时服务端已不返回 dot 项)
const shown = filesShowHidden ? files : files.filter(f => !/^(\.tmp|\.venv)(\/|$)/.test(String(f.filename)));
// 重建目录树后只渲染当前目录这一层(后端已按时间倒序,组内再排一次防旧排序缓存)
filesTreeRoot = buildFilesTree(shown);
// 总大小按原始列表(含 .tmp/.venv)聚合:目录标记行无字节量跳过;文件把 size 记到每一级祖先目录(根 = '')
filesDirSizes = new Map([['', 0]]);
for (const f of files) {
if (f.dir === true || /\/$/.test(String(f.filename))) continue;
const sz = Number(f.size) || 0;
if (!sz) continue;
filesDirSizes.set('', (filesDirSizes.get('') || 0) + sz);
const segs = String(f.filename).split('/');
segs.pop(); // 末段是文件名,其余是祖先目录
let acc = '';
for (const seg of segs) {
acc = acc ? acc + '/' + seg : seg;
filesDirSizes.set(acc, (filesDirSizes.get(acc) || 0) + sz);
}
}
const data = await req('GET', '/api/sessions/' + state.sessionId + '/tree?dir='
+ encodeURIComponent(filesCurDir) + hiddenQ);
const entries = (data && data.entries) || [];
filesTreeRoot = buildNodeFromEntries(filesCurDir, entries);
// 标题旁总大小:只统计当前层文件(子目录的递归大小要额外扫全树,懒加载拿不到)
let total = 0;
for (const f of filesTreeRoot.files) total += Number(f.size) || 0;
filesDirSizes = new Map([[filesCurDir, total]]);
if (data && data.capped) toast('目录条目过多,仅显示前 ' + entries.length + ' 项');
renderFilesDir(); // filesCurDir 失效时自动退回根目录
// 重新渲染后刷新底部计数与按钮状态
updateFilesFooter();
@@ -544,8 +524,7 @@
if (!dp || !state.sessionId) return;
if (e.target.closest('.file-check')) { toggleDirSelect(dp); return; }
filesCurDir = dp;
renderFilesDir();
updateFilesFooter(); // 全选作用域随浏览目录变化,刷新底部勾选态
loadFiles(); // 懒加载:进哪层拉哪层(renderFilesDir / updateFilesFooter 在它内部调)
return;
}
const row = e.target.closest('.file-row');
@@ -595,8 +574,7 @@
const c = e.target.closest('.crumb[data-path]');
if (!c) return;
filesCurDir = c.dataset.path;
renderFilesDir();
updateFilesFooter(); // 同上:面包屑回跳也重算全选态
loadFiles(); // 同上:面包屑回跳也按目录重拉
});
// 彩蛋:点面板标题旁的总大小文本 = 切换隐藏文件(dot 项含 .tmp/.venv)显隐。
@@ -666,8 +644,7 @@
ok++;
} catch (e) { fail++; toast('删除失败:' + name + ' ' + e.message); }
}
if (ok) toast('已删除 ' + ok + ' 项');
loadFiles(); // 重新拉取并重置选中
loadFiles(); // 重新拉取并重置选中;失败已逐条提示,全成功时不弹汇总
}
$('files-bulk-download').addEventListener('click', bulkDownload);
$('files-bulk-delete').addEventListener('click', bulkDelete);
@@ -775,8 +752,8 @@
function uploadIconSvg(name) {
// 与文件面板同款图标语言:图片用图、其余用文档
return /\.(png|jpe?g|gif|webp|bmp|svg)$/i.test(name || '')
? '<svg class="ic" viewBox="0 0 24 24"><rect x="3" y="3" width="18" height="18" rx="2" ry="2"></rect><circle cx="8.5" cy="8.5" r="1.5"></circle><polyline points="21 15 16 10 5 21"></polyline></svg>'
: '<svg class="ic" viewBox="0 0 24 24"><path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z"></path><polyline points="14 2 14 8 20 8"></polyline></svg>';
? '<svg class="ic" viewBox="0 0 24 24"><use href="#i-image-b"/></svg>'
: '<svg class="ic" viewBox="0 0 24 24"><use href="#i-file-doc"/></svg>';
}
function addUploadCard(file) {
const row = $('up-cards');
@@ -791,7 +768,7 @@
'<div class="up-meta">' + uploadTypeLabel(file.name) + ' · ' + fmtSize(file.size) + '</div>' +
'</div>' +
'<button class="up-x hidden" title="不再随消息告知该文件" aria-label="移除卡片">' +
'<svg class="ic" viewBox="0 0 24 24"><line x1="18" y1="6" x2="6" y2="18"></line><line x1="6" y1="6" x2="18" y2="18"></line></svg>' +
'<svg class="ic" viewBox="0 0 24 24"><use href="#i-x-line-b"/></svg>' +
'</button>' +
'<div class="up-mask"><span class="up-pct">0%</span></div>';
const mask = card.querySelector('.up-mask');
@@ -910,8 +887,9 @@
// 全部成功不再弹提示(卡片已完成态即反馈);有失败才提醒
if (errCount) toast('已上传 ' + done + ' 个,失败 ' + errCount + ' 个');
loadFiles();
// 桌面端左栏文件树是新的浏览入口,上传后要同步(旧面板只在手机端用)
if (typeof window.refreshFileTree === 'function') window.refreshFileTree();
// 桌面端左栏文件树是新的浏览入口,上传后要同步(旧面板只在手机端用);
// 用 reloadFileTree 保留展开与勾选,refreshFileTree 会把用户展开的目录全收起来
if (typeof window.reloadFileTree === 'function') window.reloadFileTree();
// 1.2s 后收起进度条(还有别的批次在传就不收)
setTimeout(() => {
if (uploadBatches.size) return;
@@ -1059,7 +1037,7 @@
row.innerHTML = state.attachments.map((f, i) =>
'<span class="attach-chip"><span class="name">' + esc(f.name) + '</span>' +
'<button class="rm" data-i="' + i + '" aria-label="移除附件">' +
'<svg class="ic sm" viewBox="0 0 24 24"><line x1="18" y1="6" x2="6" y2="18"></line><line x1="6" y1="6" x2="18" y2="18"></line></svg>' +
'<svg class="ic sm" viewBox="0 0 24 24"><use href="#i-x-line-b"/></svg>' +
'</button></span>').join('');
}
$('attach-chips').addEventListener('click', e => {
@@ -1093,7 +1071,15 @@
searchTimer = setTimeout(loadSessionList, 250);
});
$('drawer-list').addEventListener('click', e => {
// 桌面端 hover 删除按钮:先于打开会话处理,点击弹删除确认 modal
// 桌面端 hover 行内按钮:先于打开会话处理
const popBtn = e.target.closest('.conv-pop');
if (popBtn) {
e.stopPropagation();
// files=1 让新窗口开局直接把侧栏切到文件树(打开后即被 syncUrl 抹掉)
window.open('/?s=' + encodeURIComponent(popBtn.dataset.pop) + '&files=1', '_blank', 'noopener');
return;
}
// 删除按钮:点击弹删除确认 modal
const delBtn = e.target.closest('.conv-del');
if (delBtn) { e.stopPropagation(); deleteSession(delBtn.dataset.del); return; }
const item = e.target.closest('.conv-item');
@@ -1251,6 +1237,8 @@
if (!changed) return;
if (files) window.showFileTree();
else loadSessionList();
// 地址栏跟着侧栏模式走(?s=<id>&files=1):刷新后还停在同一面板
if (typeof syncUrl === 'function') syncUrl();
}
$('da-files').addEventListener('click', () => {
setDrawerPane(!$('drawer').classList.contains('drawer-mode-files'));
+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);
}
+259 -41
View File
@@ -15,9 +15,64 @@ const PV_PLAIN = /\.(txt|log)$/i;
// 常见代码/配置/数据文本扩展名;无扩展名的文件(Dockerfile/LICENSE 等)也按文本尝试,二进制嗅探兜底
const PV_TEXT = /\.(md|markdown|txt|log|csv|tsv|json|jsonl|xml|yml|yaml|toml|ini|conf|cfg|properties|env|py|pyw|js|mjs|cjs|ts|tsx|jsx|java|kt|c|h|cpp|hpp|cc|cs|go|rs|rb|php|swift|sh|bash|zsh|bat|ps1|sql|lua|r|dart|vue|css|less|scss|srt|vtt)$/i;
const PV_TEXT_MAX = 512 * 1024; // 文本预览截断阈值(字符),超出提示下载看全文
const PV_CODE_MAX = 5000; // 代码预览最多逐行渲染的行数:行号要逐行建节点,几万行会把面板拖死
// 扩展名 → Prism 语言 id。只映射打包进来的语言(见 vendor/prism.min.js),命中不了就当纯文本
const PV_LANG = {
js: 'javascript', mjs: 'javascript', cjs: 'javascript', jsx: 'jsx',
ts: 'typescript', mts: 'typescript', cts: 'typescript', tsx: 'tsx',
json: 'json', jsonl: 'json', json5: 'json',
yml: 'yaml', yaml: 'yaml',
sh: 'bash', bash: 'bash', zsh: 'bash', ksh: 'bash', env: 'bash',
py: 'python', pyw: 'python',
go: 'go', rs: 'rust', java: 'java',
c: 'c', h: 'c', cpp: 'cpp', hpp: 'cpp', cc: 'cpp', cxx: 'cpp', hh: 'cpp',
sql: 'sql', css: 'css', wxss: 'css',
html: 'markup', htm: 'markup', xml: 'markup', svg: 'markup', vue: 'markup',
md: 'markdown', markdown: 'markdown',
toml: 'toml', ini: 'ini', conf: 'ini', cfg: 'ini', properties: 'ini',
diff: 'diff', patch: 'diff',
};
// 整块高亮;Prism 没加载、语言没打包、或抛异常都返回 null,调用方退回纯文本
function pvHighlightCode(text, name) {
if (typeof Prism === 'undefined' || !Prism.languages) return null;
const ext = (String(name).match(/\.([^.\\/]+)$/) || [])[1];
const lang = PV_LANG[String(ext || '').toLowerCase()];
const grammar = lang && Prism.languages[lang];
if (!grammar) return null;
try { return Prism.highlight(text, grammar, lang); } catch (_) { return null; }
}
// 把整块高亮 HTML 按行拆开:跨行的 <span> 在行尾补 </span>、下一行行首重开。
// 逐行调用 Prism.highlight 会把多行注释/三引号字符串切花,所以必须先整块高亮再拆。
// Prism 输出的文本已转义(&lt; 等),不存在裸 '<',因此只匹配标签与换行就够了。
function pvSplitHighlighted(html) {
const out = [];
const stack = [];
let cur = '';
let last = 0;
const re = /(\n|<span\b[^>]*>|<\/span>)/g;
let m;
while ((m = re.exec(html))) {
cur += html.slice(last, m.index);
last = m.index + m[0].length;
if (m[0] === '\n') {
out.push(cur + '</span>'.repeat(stack.length));
cur = stack.join('');
} else if (m[0] === '</span>') {
stack.pop();
cur += '</span>';
} else {
stack.push(m[0]);
cur += m[0];
}
}
out.push(cur + html.slice(last)); // 末尾无条件留一行:文本以 \n 结尾时最后是空行
return out;
}
const PV_SRC_MAX = 2 * 1024 * 1024; // 源码面板的显示上限,超过就只给前 2MB(大文件塞 pre 会卡)
let pvSeq = 0; // 预览序号:快速连点时旧请求不许再动 DOM
// reload: 当前内容的"重新载入"动作(文本类无 iframe,按名重开);为 null 时回退到 reload iframe
const pvState = { name: null, url: null, blobUrl: null, reload: null, mobilePush: false };
const pvState = { name: null, url: null, blobUrl: null, reload: null, mobilePush: false,
source: null, srcOn: false, bodyNode: null, srcPre: null };
function pvDesktop() { return window.matchMedia('(min-width: 960px)').matches; }
@@ -75,6 +130,54 @@ function pvToolbar(o) {
document.getElementById('pv-popup').classList.toggle('hidden', !o.popup);
pvState.reload = typeof o.reload === 'function' ? o.reload : null;
pvState.url = o.url === undefined ? null : o.url;
// 源码钮:o.source 是原文(已渲染过的内容才有),没传就藏起来并回到预览态
pvState.source = o.source == null || o.source === '' ? null : String(o.source);
pvState.srcOn = false;
pvState.srcPre = null;
const sb = document.getElementById('pv-src');
sb.classList.toggle('hidden', pvState.source == null);
sb.classList.remove('active');
sb.title = '查看源码';
sb.setAttribute('aria-label', '查看源码');
}
// 预览 ↔ 源码互切:不重建预览节点,只把它 display:none 再挂一个等宽 pre,来回切代价很低
function pvToggleSrc() {
const btn = document.getElementById('pv-src');
if (!btn || pvState.source == null || !pvState.bodyNode) return;
pvState.srcOn = !pvState.srcOn;
if (pvState.srcOn) {
let text = pvState.source;
if (text.length > PV_SRC_MAX) text = text.slice(0, PV_SRC_MAX) + '\n\n…(源码较大,仅显示前 ' + Math.round(PV_SRC_MAX / 1024) + ' KB)';
const pre = document.createElement('pre');
pre.className = 'pv-pre pv-src-pre'; // 源码面板:不加行号的原文(代码预览本身走 .pv-code)
pre.textContent = text; // 不用 innerHTML:源码里的标签必须当文本
pvState.srcPre = pre;
document.getElementById('pv-body').appendChild(pre);
pvState.bodyNode.style.display = 'none';
} else {
if (pvState.srcPre && pvState.srcPre.parentNode) pvState.srcPre.parentNode.removeChild(pvState.srcPre);
pvState.srcPre = null;
pvState.bodyNode.style.display = '';
}
btn.classList.toggle('active', pvState.srcOn);
const lbl = pvState.srcOn ? '返回预览' : '查看源码';
btn.title = lbl;
btn.setAttribute('aria-label', lbl);
}
// md 里的围栏代码块上色:marked 输出 <pre><code class="language-xx">,命中 PV_LANG 才处理。
// highlightElement 会重写 code 的 innerHTML,复制按钮挂在父级 .code-wrap 上,不受影响。
function pvHighlightMdCode(root) {
if (typeof Prism === 'undefined' || !Prism.languages) return;
root.querySelectorAll('pre code').forEach((el) => {
if (el.dataset.hl) return; // 幂等:同一节点被重复装饰时不再处理
const m = /language-([\w-]+)/.exec(String(el.className || ''));
const lang = m && PV_LANG[m[1].toLowerCase()];
if (!lang || !Prism.languages[lang]) return;
el.dataset.hl = '1';
try { Prism.highlightElement(el); } catch (_) {}
});
}
// 每次展示内容都过一遍:标题显示相对路径(子目录可见),右上角下载钮随文件走
@@ -90,6 +193,11 @@ function pvClearBody() {
document.getElementById('pv-body').innerHTML = '';
pvState.reload = null; // 换内容/关窗后旧的刷新动作立即失效
pvState.url = null; // 新窗口地址同理:不清会残留上一份内容的 blob/网关 URL
pvState.source = null; // 源码同样跟内容走,不然会把上一个文件的原文留在按钮里
pvState.srcOn = false;
pvState.bodyNode = null;
pvState.srcPre = null;
document.getElementById('pv-src').classList.add('hidden');
if (pvState.blobUrl) { try { URL.revokeObjectURL(pvState.blobUrl); } catch (_) {} pvState.blobUrl = null; }
}
@@ -104,8 +212,7 @@ function pvInfoNode(name, sizeText, hint) {
const box = document.createElement('div');
box.className = 'pv-none';
box.innerHTML =
'<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.4" stroke-linecap="round" stroke-linejoin="round">' +
'<path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z"></path><polyline points="14 2 14 8 20 8"></polyline></svg>' +
'<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.4" stroke-linecap="round" stroke-linejoin="round"><use href="#i-file-doc"/></svg>' +
'<div class="nm"></div><div class="meta"></div><div class="hint"></div>';
box.querySelector('.nm').textContent = String(name || '');
box.querySelector('.meta').textContent = sizeText ? sizeText : '';
@@ -130,6 +237,7 @@ function pvOpenPane() {
function pvCloseDoc() {
if (!document.body.classList.contains('pv-open')) return;
document.body.classList.remove('pv-open', 'pv-max');
if (typeof vcsSetMode === 'function') vcsSetMode(false); // 关面板即离开 Git 模式
if (typeof pvSetMaxUI === 'function') pvSetMaxUI(false); // 收起时复位放大钮图标(函数声明提升,定义在后亦可)
pvClearBody();
pvState.name = null; pvState.url = null;
@@ -203,9 +311,56 @@ async function pvOpenOffice(name, sizeText) {
pvState.url = url;
}
// ---------- 站内地址预览:会话流里的链接 / 地址条回车 → 直接挂进预览窗 ----------
// 「本机」判定:完全同源,或两端都是本机别名(localhost/127.0.0.1/[::1]/0.0.0.0,端口不究)。
// 外链、锚点、mailto、相对路径都不算,调用方自行放行。
function pvLocalHost(h) { return h === 'localhost' || h === '127.0.0.1' || h === '::1' || h === '[::1]' || h === '0.0.0.0'; }
function pvSameHost(target) {
let u;
try { u = new URL(target, location.href); } catch (_) { return null; }
if (u.origin === location.origin) return u;
if (pvLocalHost(u.hostname) && pvLocalHost(location.hostname)) return u;
return null;
}
function pvUrlTitle(url) {
try {
const u = new URL(url, location.href);
return decodeURIComponent(u.pathname.split('/').filter(Boolean).pop() || '') || u.host;
} catch (_) { return String(url); }
}
// iframe 直挂,不走文件读取链路:桌面进右侧分栏,窄屏进全屏浮层。
// sandbox 与现有 HTML 预览一致——data-page 页面要靠脚本渲染表格。
function pvOpenUrl(url, title) {
const desk = pvDesktop();
const name = title || pvUrlTitle(url);
++pvSeq; // 在途的文件预览请求就此作废,别回来抢 DOM
const mkFrame = () => {
const fr = document.createElement('iframe');
fr.className = desk ? 'pv-frame' : 'fs-html-frame';
fr.title = name;
fr.setAttribute('sandbox', 'allow-same-origin allow-scripts');
fr.src = url;
return fr;
};
if (desk) {
pvOpenPane(); pvClearBody();
pvHeader(name, '');
pvState.name = null; // 不是文件:下载钮收起(按名下载会拼错路径)
document.getElementById('pv-download').classList.add('hidden');
pvToolbar({ refresh: true, popup: true, reload: () => pvOpenUrl(url, title), url });
const t = document.getElementById('pv-title'); // 地址条显示完整地址,可选中复制
t.value = url; t.title = url;
document.getElementById('pv-body').appendChild(mkFrame());
} else {
pvOverlayShow(mkFrame(), { bar: true, name });
if (!pvState.mobilePush) { try { history.pushState({ pvOffice: 1 }, ''); pvState.mobilePush = true; } catch (_) {} }
}
}
// ---------- 统一入口:所有文件点击都走这 ----------
async function openFilePreview(name, sizeText) {
if (!state.sessionId) return;
if (typeof vcsSetMode === 'function') vcsSetMode(false); // 点文件即离开 Git 面板(预览/Git 二选一)
if (PV_OFFICE.test(name)) { try { await pvOpenOffice(name, sizeText); } catch (e) { toast('预览失败:' + e.message); } return; }
let kind = pvKind(name);
if (kind === 'pdf' && !navigator.pdfViewerEnabled) kind = 'none'; // WebView 内嵌不了 PDF:给占位卡,不再自动下载
@@ -224,9 +379,12 @@ async function openFilePreview(name, sizeText) {
}
const show = (node, tb) => {
if (my !== pvSeq) return;
// 节点上挂了 __src(原文)就带进工具条:预览栏据此显示源码钮。手机端的源码钮走 fs-viewer,不掺和。
if (node && node.__src != null) { tb = Object.assign({}, tb || tbAll, { source: node.__src }); delete node.__src; }
if (desk) {
pvClearBody(); pvHeader(name, sizeText);
document.getElementById('pv-body').appendChild(node);
pvState.bodyNode = node;
pvToolbar(tb || tbAll);
} else pvOverlayShow(node, { bar: true, name: name });
};
@@ -289,11 +447,13 @@ async function openFilePreview(name, sizeText) {
// 统一等 show() 之后登记,陈旧序号则立即撤销防泄漏。
let newBlobUrl = null;
if (kind === 'html') {
const src = rewriteHtmlDocSrcs(await r.text(), name); // 相对资源改写,否则 about:srcdoc/blob 基准下全 404
const raw = await r.text(); // 原文留着做源码面板,改写只用于内嵌显示
const src = rewriteHtmlDocSrcs(raw, name); // 相对资源改写,否则 about:srcdoc/blob 基准下全 404
const fr = document.createElement('iframe');
fr.className = 'pv-frame';
fr.setAttribute('sandbox', 'allow-same-origin allow-scripts');
fr.srcdoc = src;
fr.__src = raw;
newBlobUrl = URL.createObjectURL(new Blob([src], { type: 'text/html;charset=utf-8' }));
tb = Object.assign({}, tbAll, { url: newBlobUrl }); // 新窗口=改写后的页面(与面板里同一份)
node = fr;
@@ -304,10 +464,14 @@ async function openFilePreview(name, sizeText) {
fr.className = 'pv-frame'; fr.title = String(name); fr.src = u; // 不加 sandbox:内建查看器插件需要 unrestricted 帧
node = fr; tb = Object.assign({}, tbAll, { url: u });
} else if (kind === 'img') {
const u = URL.createObjectURL(await r.blob());
// r 只能读一次:svg 先取文本再自己包 blob(也顺便拿到源码面板要的原文)
const isSvg = /\.svg$/i.test(name);
const svgText = isSvg ? await r.text() : null;
const u = URL.createObjectURL(isSvg ? new Blob([svgText], { type: 'image/svg+xml;charset=utf-8' }) : await r.blob());
newBlobUrl = u;
const im = document.createElement('img');
im.className = 'pv-img'; im.src = u; im.alt = String(name);
if (isSvg) im.__src = svgText;
const g = pvImgGroup(name);
im.addEventListener('click', () => openImageViewer(u, String(name).split('/').pop(), g && g.list, g && g.at));
node = im; tb = Object.assign({}, tbAll, { url: u });
@@ -333,21 +497,69 @@ 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' })); }
// 代码/配置/数据渲染:行号 + Prism 着色。桌面(pvTextNode)与移动端(pvRenderLegacy)共用——
// 移动端原来只 esc 成纯文本,同一个文件在手机上没行号也没颜色。
function pvCodeNode(text, name) {
const frag = document.createDocumentFragment();
let bodyText = text;
if (text.length > PV_TEXT_MAX) {
bodyText = text.slice(0, PV_TEXT_MAX);
const tip = document.createElement('div');
tip.className = 'pv-trunc';
tip.textContent = '文件较大,仅预览前 ' + Math.round(PV_TEXT_MAX / 1024) + ' KB,完整内容请下载查看。';
frag.appendChild(tip);
}
// 逐行渲染以便左侧打行号(视觉同 Git 面板的 .vcs-line)。
// 超过 PV_CODE_MAX 行只渲染前段,剩下的交代一句——几万个逐行节点会让面板卡到没法滚。
const lines = bodyText.split('\n');
const total = lines.length;
const shown = total > PV_CODE_MAX ? lines.slice(0, PV_CODE_MAX) : lines;
const code = document.createElement('div');
code.className = 'pv-code';
code.style.setProperty('--nw', Math.max(2, String(shown.length).length) + 'ch'); // 行号列宽按最大行号位数
const rows = [];
const hl = pvHighlightCode(shown.join('\n'), name); // 整块高亮再按行拆,跨行 token 才不会花
const parts = hl ? pvSplitHighlighted(hl) : null;
const useHl = parts && parts.length === shown.length; // 行数对不上就退回纯文本,不让行号错位
for (let i = 0; i < shown.length; i++) {
// 行号交给 CSS counter(.pv-cl::before)生成:伪元素不进选区,复制不会把行号带走。
// 代码必须包在 .c 里:裸文本在 flex 容器里是匿名 flex 项,浏览器会折叠它的前导空白。
rows.push('<div class="pv-cl"><span class="c">' + (useHl ? parts[i] : esc(shown[i])) + '</span></div>');
}
code.innerHTML = rows.join('');
frag.appendChild(code);
if (total > PV_CODE_MAX) {
const tip2 = document.createElement('div');
tip2.className = 'pv-trunc';
tip2.textContent = '文件较大,仅显示前 ' + PV_CODE_MAX + ' 行(共 ' + total + ' 行),完整内容请下载查看。';
frag.appendChild(tip2);
}
const holder = document.createElement('div');
holder.className = 'pv-plain';
holder.appendChild(frag);
return holder;
}
// 桌面文本渲染:md 走气泡 markdown;txt/log 原文排版;代码/配置/数据等宽 pre;二进制嗅探回退占位卡
async function pvTextNode(name, sizeText, r) {
const text = await r.text();
@@ -362,37 +574,25 @@ async function pvTextNode(name, sizeText, r) {
wrap.className = 'msg other';
wrap.innerHTML = '<div class="' + cls + ' pv-doc">' + html + '</div>';
decorateCodePre(wrap);
pvHighlightMdCode(wrap); // 围栏代码块上色(与代码预览同一套配色)
const n = wrap.firstChild;
// q.fmt=false 表示 marked 不可用、面板就是原文排版:新窗口也按纯文本开,避免空白被折叠
n.__tb = q.fmt
? { popup: true, url: URL.createObjectURL(new Blob([pvMdDoc(html, name)], { type: 'text/html;charset=utf-8' })) }
: { popup: true, url: pvTextUrl(text) };
n.__src = text;
return n;
}
if (PV_PLAIN.test(low)) {
const wrap = document.createElement('div');
wrap.className = 'msg other';
wrap.innerHTML = '<div class="bubble-ai pv-doc">' + esc(text) + '</div>';
const n = wrap.firstChild; n.__tb = { popup: true, url: pvTextUrl(text) };
const n = wrap.firstChild; n.__tb = { popup: true, url: pvTextUrl(text) }; n.__src = text;
return n;
}
const frag = document.createDocumentFragment();
let bodyText = text;
if (text.length > PV_TEXT_MAX) {
bodyText = text.slice(0, PV_TEXT_MAX);
const tip = document.createElement('div');
tip.className = 'pv-trunc';
tip.textContent = '文件较大,仅预览前 ' + Math.round(PV_TEXT_MAX / 1024) + ' KB,完整内容请下载查看。';
frag.appendChild(tip);
}
const pre = document.createElement('pre');
pre.className = 'pv-pre';
pre.textContent = bodyText;
frag.appendChild(pre);
const holder = document.createElement('div');
holder.className = 'pv-plain';
holder.appendChild(frag);
const holder = pvCodeNode(text, name);
holder.__tb = { popup: true, url: pvTextUrl(text) }; // 新窗口用全文,不受面板截断影响
holder.__src = text; // 源码面板同样给全文
return holder;
}
@@ -434,19 +634,21 @@ async function pvRenderLegacy(name, r, my) {
openImageViewer(u, name, g && g.list, g && g.at);
} else {
const text = await r.text();
let cls = 'bubble-ai', html;
if (PV_MD.test(name)) {
const q = mdHtml(text);
html = q.html;
if (q.fmt) cls += ' md';
html = rewriteMdImageSrcs(html, name);
} else {
html = esc(text);
if (!PV_MD.test(name)) {
// 代码/配置/数据:与桌面同一套行号 + Prism 着色(原来在手机上只是纯文本)
pvOverlayShow(pvCodeNode(text, name), { bar: true, name: name, source: text });
return;
}
const q = mdHtml(text);
let cls = 'bubble-ai';
let html = q.html;
if (q.fmt) cls += ' md';
html = rewriteMdImageSrcs(html, name);
const wrap = document.createElement('div');
wrap.className = 'msg other';
wrap.innerHTML = '<div class="' + cls + '">' + html + '</div>';
decorateCodePre(wrap);
pvHighlightMdCode(wrap);
pvOverlayShow(wrap.firstChild, { bar: true, name: name, source: text }); // 全宽沉浸,eye/复制看原文
}
}
@@ -468,6 +670,7 @@ document.getElementById('pv-max').addEventListener('click', () => {
const max = document.body.classList.toggle('pv-max');
pvSetMaxUI(max);
});
document.getElementById('pv-src').addEventListener('click', pvToggleSrc);
document.getElementById('pv-refresh').addEventListener('click', () => {
if (typeof pvState.reload === 'function') { pvState.reload(); return; }
const f = document.getElementById('pv-body').querySelector('iframe');
@@ -479,11 +682,16 @@ document.getElementById('pv-popup').addEventListener('click', () => {
});
// 地址条:点击/聚焦全选——长路径被截断时可选中看全文、直接 Ctrl+C 复制
document.getElementById('pv-title').addEventListener('focus', (e) => e.target.select());
// 地址条回车跳转:http(s) 网址新标签打开,其余按任务目录相对路径进预览
// 地址条回车跳转:本机地址(含 /app/... 这类站内绝对路径)进预览窗,外部网址新开标签,
// 其余按任务目录相对路径当文件预览。
function pvClean(s) { return String(s || '').trim().replace(/^["']+|["']+$/g, ''); }
function pvAddrGo(v) {
if (/^https?:\/\//i.test(v)) { window.open(v, '_blank', 'noopener'); return; }
if (/^https?:\/\//i.test(v)) {
if (pvSameHost(v)) { document.getElementById('pv-title').blur(); pvOpenUrl(v); return; }
window.open(v, '_blank', 'noopener'); return;
}
document.getElementById('pv-title').blur();
if (v.charAt(0) === '/' && v.charAt(1) !== '/') { pvOpenUrl(v); return; }
openFilePreview(v);
}
// ---------- 地址条文件名补全:候选取自 files.js 缓存的目录树(filesNodeAt),零请求 ----------
@@ -568,11 +776,11 @@ document.getElementById('pv-pane').addEventListener('click', (e) => {
const b = e.target.closest('.act-copy');
if (b && typeof onCopyClick === 'function') onCopyClick(e);
});
// 移动端系统返回键:先收起 office 全屏预览
// 移动端系统返回键:先收起 iframe 类全屏预览(office 网关 / 站内地址)
window.addEventListener('popstate', () => {
pvState.mobilePush = false;
const fs = document.getElementById('fs-viewer');
if (!fs.classList.contains('hidden') && fs.querySelector('.fs-html-frame[src^="/preview/"]')) closeFullscreen();
if (!fs.classList.contains('hidden') && fs.querySelector('.fs-html-frame')) closeFullscreen();
});
// Esc 关闭预览分栏(未开全屏查看器时)
window.addEventListener('keydown', (e) => {
@@ -594,21 +802,31 @@ window.matchMedia('(min-width: 960px)').addEventListener('change', () => { if (!
const h = document.createElement('div');
h.className = 'pv-resizer';
pane.appendChild(h);
let st = null;
let st = null; // { x: 起始 clientX, w: 起始宽度, lastX: 最新 clientX }
let rafId = 0;
// 改 --pv-w 会带着 #app 的 width/margin 一起重排(会话里的文字跟着重新折行),
// 一帧可能来十几个 pointermove,所以只在 rAF 里落一次值。
function commit() {
if (!st) return;
document.documentElement.style.setProperty('--pv-w', clamp(st.w + (st.lastX - st.x)) + 'px');
}
h.addEventListener('pointerdown', (e) => {
st = { x: e.clientX, w: pane.offsetWidth || clamp(window.innerWidth * 0.5) };
e.preventDefault(); // 从按下这一刻就掐掉拖选,否则会顺手选中一大片消息文字
st = { x: e.clientX, w: pane.offsetWidth || clamp(window.innerWidth * 0.5), lastX: e.clientX };
try { h.setPointerCapture(e.pointerId); } catch (_) {}
document.body.classList.add('pv-resizing');
});
h.addEventListener('pointermove', (e) => {
if (!st) return;
document.documentElement.style.setProperty('--pv-w', clamp(st.w + (e.clientX - st.x)) + 'px');
st.lastX = e.clientX;
if (!rafId) rafId = requestAnimationFrame(() => { rafId = 0; commit(); });
});
function end() {
if (!st) return;
if (rafId) { cancelAnimationFrame(rafId); rafId = 0; commit(); } // 把最后一帧补上
const w = pane.offsetWidth;
st = null;
document.body.classList.remove('pv-resizing');
const w = pane.offsetWidth;
if (w) localStorage.setItem('pv-w', String(w));
}
h.addEventListener('pointerup', end);
@@ -622,7 +840,7 @@ window.matchMedia('(min-width: 960px)').addEventListener('change', () => { if (!
// —— 通用 UI 卡片(stream.js 转发 SSE ui_card;任何 MCP 服务/工具回包附 type:"ui_card" 块即可产出)——
// 产生方契约 {action, arg, title?, note?};新交互在动作注册表加一条即可,未知 action 忽略(向前兼容)。
// 图标由前端统一持有(与 pv-none 同一枚文档 SVG),产生方不提供图形,只给数据。
const UI_CARD_ICON_DOC = '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.4" stroke-linecap="round" stroke-linejoin="round"><path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z"></path><polyline points="14 2 14 8 20 8"></polyline></svg>';
const UI_CARD_ICON_DOC = '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.4" stroke-linecap="round" stroke-linejoin="round"><use href="#i-file-doc"/></svg>';
const UI_CARD_ACTIONS = {
// arg = 相对会话目录的文件路径,点击 = openFilePreview(office 走预览网关,其余类型走文本/图片渲染)
open_preview: { go: '预览 ›', hint: '点击打开预览', icon: UI_CARD_ICON_DOC, run: (d) => openFilePreview(d.arg) },
+78 -8
View File
@@ -31,8 +31,11 @@
'<button class="conv-item' + (s.id === state.sessionId ? ' active' : '') + '" data-id="' + esc(s.id) + '">' +
'<span class="conv-title">' + esc(s.title || s.id) + '</span>' + drawerStatusDot(s) +
'</button>' +
'<button class="conv-pop" data-pop="' + esc(s.id) + '" title="在新窗口打开" aria-label="在新窗口打开">' +
'<svg viewBox="0 0 24 24" width="14" height="14" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><use href="#i-external"/></svg>' +
'</button>' +
'<button class="conv-del" data-del="' + esc(s.id) + '" title="删除会话" aria-label="删除会话">' +
'<svg viewBox="0 0 24 24" width="14" height="14" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><polyline points="3 6 5 6 21 6"/><path d="M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6m3 0V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2"/></svg>' +
'<svg viewBox="0 0 24 24" width="14" height="14" fill="none" stroke="currentColor" stroke-width="1.9" stroke-linecap="round" stroke-linejoin="round"><use href="#i-trash"/></svg>' +
'</button>' +
'</div>';
}
@@ -90,9 +93,9 @@
state.renderedSigs = {};
state.streaming = false;
if (typeof clearEditState === 'function') clearEditState();
syncUrl();
setView('welcome'); // 复用 newChat 同样的视图切换路径
}
toast('已删除会话');
loadSessionList();
} catch (e) { toast('删除失败:' + e.message); }
}
@@ -120,6 +123,8 @@
}).catch(() => {}).then(() => {
sseResyncing = false;
if (state.sessionId === id && state.view === 'chat' && !state.es) connectStream();
// 断点期间的文件变动看不到任何 SSE,补拉完顺手重刷一次文件树
if (typeof window.reloadFileTree === 'function') window.reloadFileTree();
});
}
setInterval(() => {
@@ -184,12 +189,32 @@
if (Date.now() - state.lastSseAt > 45000) probeSseAlive();
});
// 地址栏跟随当前会话与侧栏模式:?s=<id>[&files=1],刷新/收藏/分享都能回到同一屏
function syncUrl() {
const id = state.sessionId;
let url = '/';
if (id) {
url = '/?s=' + encodeURIComponent(id);
// 侧栏停在文件树时带上 files=1:刷新后还是文件树,不会莫名退回会话列表
if ($('drawer').classList.contains('drawer-mode-files')) url += '&files=1';
}
try { history.replaceState(null, '', url); } catch (_) {}
}
// 收起预览:桌面分栏(#pv-pane,含 Git 面板)与窄屏全屏浮层都要收。
// pvCloseDoc 内部会 vcsSetMode(false),Git 面板跟着一起落下。
function closePreviewAll() {
if (typeof pvCloseDoc === 'function') pvCloseDoc();
const fs = document.getElementById('fs-viewer');
if (fs && !fs.classList.contains('hidden') && typeof closeFullscreen === 'function') closeFullscreen();
}
async function openSession(id) {
closeStream();
removeTyping();
setFilesPanel(false); // 会话切换,收起文件面板防旧列表残留
// 预览分栏故意不关:它现在是「随手看参考」的第三列,切会话时关掉会让用户反复重开。
// 保留已渲染的内容(静态文件,不存在跨会话越权),点新会话的文件会自然覆盖。
// 切会话也要收起预览与 Git:里面是上一个会话的文件/仓库,留在旁边容易被当成新会话的
closePreviewAll();
state.sessionId = id;
state.status = '';
state.modelId = '';
@@ -217,16 +242,28 @@
renderAttachChips();
clearUploadCards(); // 切会话清掉旧会话的上传卡片
renderDrawerList(); // 会话切换后立刻重画抽屉高亮,避免下次打开才看到更新
// 文件树同理,而且更早:它的缓存按路径存、不含会话,晚一步清就会在抽屉里
// 先看到上个会话的文件。紧跟 sessionId 变更就清,不等 detail 回来。
if (window.refreshFileTree) window.refreshFileTree();
setView('chat');
$('chat-view').innerHTML = '<div class="drawer-empty">加载中…</div>';
try {
const detail = await req('GET', '/api/sessions/' + id + '?limit=' + CHAT_INIT_PAGE_SIZE);
if (state.sessionId !== id) return; // 期间已切到别的会话
renderDetail(detail);
// 深度思考跟随会话(发消息时落库):只在这里回填,软刷新不动用户未发出的切换
state.deepThink = !!(detail.session && detail.session.deep_think);
$('deep-think-btn').classList.toggle('on', state.deepThink);
connectStream();
if (window.refreshFileTree) window.refreshFileTree();
syncUrl(); // 详情拿到才写地址栏:坏链接不会把刷新后的页面也钉死在坏会话上
} catch (e) {
if (state.sessionId === id) toast('打开会话失败:' + e.message);
if (state.sessionId === id) {
toast('打开会话失败:' + e.message);
state.sessionId = null;
state.sessionTitle = '';
syncUrl();
setView('welcome'); // 会话已被删/链接失效:别把「加载中…」留在屏幕上(同时把顶部按钮置灰)
}
}
}
@@ -244,6 +281,7 @@
renderHeader();
updateHeaderActions();
connectStream();
syncUrl();
return s.id;
}
@@ -294,6 +332,7 @@
closeStream();
removeTyping();
setFilesPanel(false); // 新建会话,文件面板随之收起
closePreviewAll(); // 预览/Git 都属于上一个会话,新建时一并收起
state.sessionId = null;
state.sessionTitle = '';
state.sessionType = 'secretary';
@@ -318,6 +357,8 @@
userPaused = false;
renderAttachChips();
clearUploadCards();
renderDrawerList(); // sessionId 已置空,重画抽屉把旧会话的选中态清掉
syncUrl();
setView('welcome');
$('chat-view').innerHTML = '';
$('msg-input').value = '';
@@ -335,7 +376,6 @@
const title = String(t).trim();
try {
await req('PATCH', '/api/sessions/' + state.sessionId, { title: title });
toast('已重命名');
state.sessionTitle = title;
renderHeader();
loadSessionList();
@@ -453,8 +493,37 @@
if (act === 'model') openModelSwitch();
else if (act === 'schedule') openScheduleModal();
else if (act === 'compact') summarizeChat();
else if (act === 'theme') cycleTheme();
else if (act === 'new') newChat();
}
// ---------- 主题(浅/深两态,默认浅色;色板全在 style.css 变量里)----------
function themeMode() { return document.documentElement.getAttribute('data-theme-mode') === 'dark' ? 'dark' : 'light'; }
function applyTheme(mode) {
const m = mode === 'dark' ? 'dark' : 'light';
document.documentElement.setAttribute('data-theme', m);
document.documentElement.setAttribute('data-theme-mode', m);
try { localStorage.setItem('agent-theme', m); } catch (_) {}
const meta = document.querySelector('meta[name="theme-color"]');
if (meta) meta.setAttribute('content', m === 'dark' ? '#0d1117' : '#3964FE');
syncThemeBtns();
}
function cycleTheme() { applyTheme(themeMode() === 'dark' ? 'light' : 'dark'); }
function syncThemeBtns() {
const dark = themeMode() === 'dark';
const lbl = dark ? '主题:深色' : '主题:浅色';
['theme-toggle', 'theme-toggle-mobile'].forEach(function (id) {
const b = $(id);
if (!b) return;
b.querySelectorAll('svg').forEach(function (s, k) { s.classList.toggle('hidden', k !== (dark ? 1 : 0)); });
});
const t = $('theme-toggle');
if (t) { t.title = lbl; t.dataset.tip = lbl; }
const lab = $('theme-label-mobile');
if (lab) lab.textContent = dark ? '深色' : '浅色'; // 副标题只写当前值,主文案是动作
}
window.applyTheme = applyTheme;
window.cycleTheme = cycleTheme;
// 桌面属性区(模型/定时任务/压缩)与移动菜单项共用同一批 data-act,事件只在这里绑一次。
(function bindHeaderActions() {
document.querySelectorAll('#header-meta [data-act], #header-actions [data-act]').forEach(el => {
@@ -467,6 +536,7 @@
if (!e.target.closest('#header-actions')) closeHeaderMenu();
});
document.addEventListener('keydown', e => { if (e.key === 'Escape') closeHeaderMenu(); });
syncThemeBtns(); // 按钮图标/文字跟着当前主题落一次
})();
// ---------- 定时任务(弹窗改频次/提示词;无任务时同一弹窗即新建) ----------
@@ -786,7 +856,7 @@
wrap.innerHTML =
'<div class="modal">' +
'<button class="modal-close-btn" data-act="cancel" aria-label="关闭">' +
'<svg viewBox="0 0 24 24"><line x1="18" y1="6" x2="6" y2="18"></line><line x1="6" y1="6" x2="18" y2="18"></line></svg>' +
'<svg viewBox="0 0 24 24"><use href="#i-x-line-b"/></svg>' +
'</button>' +
'<h3 id="compress-modal-title">压缩上下文</h3>' +
'<div class="modal-body" style="font-size:14px;line-height:1.55;color:#555;padding:4px 0 12px;">' +
+48 -25
View File
@@ -146,7 +146,7 @@
// 快照里的 id 全部剥除,防止重复 id 干扰 $('…') 查找;仅作动画背景,滑完由 renderSetPage 重渲染真页。
function snapSetPage() {
const box = document.createElement('div');
box.innerHTML = '<header class="header"><button class="icon-btn" tabindex="-1"><svg class="ic" viewBox="0 0 24 24"><polyline points="15 18 9 12 15 6"></polyline></svg></button>' +
box.innerHTML = '<header class="header"><button class="icon-btn" tabindex="-1"><svg class="ic" viewBox="0 0 24 24"><use href="#i-chevron-left"/></svg></button>' +
'<div class="header-center"><div class="header-title">' + esc($('set-title').textContent) + '</div></div>' +
'<div class="header-right">' + $('set-actions').innerHTML + '</div></header>' +
'<div class="set-under-body">' + $('set-body').innerHTML + '</div>';
@@ -281,17 +281,17 @@
// ---------- 页:设置主页(卡片入口) ----------
const SET_CARDS = [
{ go: 'account', name: '账户', desc: '修改密码 · 用户画像 · 退出登录',
icon: '<svg class="ic" viewBox="0 0 24 24"><circle cx="12" cy="8" r="4"></circle><path d="M4 21c0-4 4-6 8-6s8 2 8 6"></path></svg>' },
icon: '<svg class="ic" viewBox="0 0 24 24"><use href="#i-user"/></svg>' },
{ go: 'users', name: '用户', desc: '账号 · 角色 · 默认模型', adminOnly: true, needAuth: true,
icon: '<svg class="ic" viewBox="0 0 24 24"><circle cx="9" cy="8" r="3.5"></circle><path d="M2 21c0-3.6 3.1-5.5 7-5.5s7 1.9 7 5.5"></path><path d="M16 8.5a3 3 0 0 1 0 6"></path><path d="M18 21c0-2.8-1.4-4.5-4-5.2"></path></svg>' },
icon: '<svg class="ic" viewBox="0 0 24 24"><use href="#i-users"/></svg>' },
{ go: 'service', name: '服务', desc: '服务状态 · 系统配置', adminOnly: true,
icon: '<svg class="ic" viewBox="0 0 24 24"><line x1="4" y1="21" x2="4" y2="14"></line><line x1="4" y1="10" x2="4" y2="3"></line><line x1="12" y1="21" x2="12" y2="12"></line><line x1="12" y1="8" x2="12" y2="3"></line><line x1="20" y1="21" x2="20" y2="16"></line><line x1="20" y1="12" x2="20" y2="3"></line><line x1="1" y1="14" x2="7" y2="14"></line><line x1="9" y1="8" x2="15" y2="8"></line><line x1="17" y1="16" x2="23" y2="16"></line></svg>' },
icon: '<svg class="ic" viewBox="0 0 24 24"><use href="#i-sliders-v"/></svg>' },
{ go: 'skills', name: '技能', desc: '技能管理 · 技能文件编辑', adminOnly: true,
icon: '<svg class="ic" viewBox="0 0 24 24"><polygon points="13 2 3 14 12 14 11 22 21 10 12 10 13 2"></polygon></svg>' },
icon: '<svg class="ic" viewBox="0 0 24 24"><use href="#i-zap"/></svg>' },
{ go: 'models', name: '模型', desc: '模型池状态 · 增删改', adminOnly: true,
icon: '<svg class="ic" viewBox="0 0 24 24"><rect x="4" y="4" width="16" height="16" rx="2"></rect><rect x="9" y="9" width="6" height="6"></rect><line x1="9" y1="1" x2="9" y2="4"></line><line x1="15" y1="1" x2="15" y2="4"></line><line x1="9" y1="20" x2="9" y2="23"></line><line x1="15" y1="20" x2="15" y2="23"></line><line x1="20" y1="9" x2="23" y2="9"></line><line x1="20" y1="14" x2="23" y2="14"></line><line x1="1" y1="9" x2="4" y2="9"></line><line x1="1" y1="14" x2="4" y2="14"></line></svg>' },
icon: '<svg class="ic" viewBox="0 0 24 24"><use href="#i-cpu"/></svg>' },
{ go: 'mcp', name: 'MCP', desc: 'MCP 服务 · 增删改', adminOnly: true,
icon: '<svg class="ic" viewBox="0 0 24 24"><rect x="3" y="4" width="18" height="16" rx="2"></rect><line x1="3" y1="10" x2="21" y2="10"></line><circle cx="7" cy="15" r="1.2" fill="currentColor" stroke="none"></circle><circle cx="12" cy="15" r="1.2" fill="currentColor" stroke="none"></circle><circle cx="17" cy="15" r="1.2" fill="currentColor" stroke="none"></circle></svg>' },
icon: '<svg class="ic" viewBox="0 0 24 24"><use href="#i-layout"/></svg>' },
];
function setPageHome(ctx) {
setTitle('设置');
@@ -303,7 +303,7 @@
'<span class="set-ico">' + c.icon + '</span>' +
'<span class="set-tt"><span class="set-name">' + c.name + '</span>' +
'<span class="set-desc">' + c.desc + '</span></span>' +
'<svg class="ic sm set-arrow" viewBox="0 0 24 24"><polyline points="9 6 15 12 9 18"></polyline></svg>' +
'<svg class="ic sm set-arrow" viewBox="0 0 24 24"><use href="#i-chevron-right-b"/></svg>' +
'</button>').join('') + '</div>');
}
@@ -395,7 +395,7 @@
async function setPageUsers(ctx) {
setTitle('用户');
setActions('<button class="icon-btn" title="添加用户" onclick="sUI.openUserAdd()">' +
'<svg class="ic" viewBox="0 0 24 24"><line x1="12" y1="5" x2="12" y2="19"></line><line x1="5" y1="12" x2="19" y2="12"></line></svg></button>');
'<svg class="ic" viewBox="0 0 24 24"><use href="#i-plus"/></svg></button>');
setBody('<div class="set-scroll" id="user-list"><div class="empty-tip">加载中…</div></div>');
try {
const r = await req('GET', '/api/users');
@@ -689,7 +689,7 @@
async function setPageService(ctx) {
setTitle('服务');
setActions('<button class="icon-btn" title="编辑配置文件" onclick="sUI.openCfg()">' +
'<svg class="ic" viewBox="0 0 24 24"><path d="M11 4H4a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-7"></path><path d="M18.5 2.5a2.12 2.12 0 0 1 3 3L12 15l-4 1 1-4z"></path></svg></button>');
'<svg class="ic" viewBox="0 0 24 24"><use href="#i-edit"/></svg></button>');
setBody('<div class="set-scroll" id="svc-body"><div class="empty-tip">加载中…</div></div>');
try {
const [st, cg] = await Promise.all([
@@ -769,7 +769,7 @@
async function setPageCfgEditor(ctx) {
setTitle('config.yml 原文');
setActions('<button class="icon-btn" title="校验并保存" onclick="sUI.saveCfg()">' +
'<svg class="ic" viewBox="0 0 24 24"><polyline points="20 6 9 17 4 12"></polyline></svg></button>');
'<svg class="ic" viewBox="0 0 24 24"><use href="#i-check"/></svg></button>');
setBody('<div class="set-editor"><div class="cfg-err hidden" id="cfg-editor-err"></div>' +
'<textarea id="set-editor-area" spellcheck="false" autocomplete="off" autocapitalize="off"></textarea></div>');
try {
@@ -812,7 +812,7 @@
SET.curSkill = null;
setTitle('技能管理');
setActions('<button class="icon-btn" title="新建技能" onclick="sUI.openCreate()">' +
'<svg class="ic" viewBox="0 0 24 24"><line x1="12" y1="5" x2="12" y2="19"></line><line x1="5" y1="12" x2="19" y2="12"></line></svg></button>');
'<svg class="ic" viewBox="0 0 24 24"><use href="#i-plus"/></svg></button>');
setBody('<div class="set-scroll" id="skills-list"><div class="empty-tip">加载中…</div></div>');
try {
const rows = await req('GET', '/api/skills');
@@ -855,7 +855,7 @@
setTitle(SET.curSkill);
setActions('<label class="icon-btn" title="上传文件">' +
'<input type="file" style="display:none;" onchange="sUI.onUpload(event)">' +
'<svg class="ic" viewBox="0 0 24 24"><path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4"></path><polyline points="17 8 12 3 7 8"></polyline><line x1="12" y1="3" x2="12" y2="15"></line></svg></label>');
'<svg class="ic" viewBox="0 0 24 24"><use href="#i-upload-cloud"/></svg></label>');
setBody('<div class="set-scroll" id="skill-detail"><div class="empty-tip">加载中…</div></div>');
try {
const d = await req('GET', '/api/skills/' + encodeURIComponent(SET.curSkill));
@@ -871,7 +871,7 @@
el.innerHTML = '<div class="skill-files">' + d.files.map(f => {
const a = encodeURIComponent(f.filename);
return '<div class="file-row" onclick="sUI.editFile(\'' + a + '\')">' +
'<svg class="file-ico" viewBox="0 0 24 24"><path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z"></path><polyline points="14 2 14 8 20 8"></polyline></svg>' +
'<svg class="file-ico" viewBox="0 0 24 24"><use href="#i-file-doc"/></svg>' +
'<span class="file-name">' + esc(f.filename) + '</span>' +
'<span class="file-size">' + fmtSize(f.size) + '</span>' +
'<button class="file-act" onclick="event.stopPropagation();sUI.editFile(\'' + a + '\')">编辑</button>' +
@@ -885,7 +885,7 @@
function setPageSkillEditor(ctx) {
setTitle(SET.editorLabel || '编辑文件');
setActions('<button class="icon-btn" title="保存" onclick="sUI.saveFile()">' +
'<svg class="ic" viewBox="0 0 24 24"><polyline points="20 6 9 17 4 12"></polyline></svg></button>');
'<svg class="ic" viewBox="0 0 24 24"><use href="#i-check"/></svg></button>');
setBody('<div class="set-editor"><textarea id="set-editor-area" spellcheck="false" autocomplete="off" autocapitalize="off"></textarea></div>');
$('set-editor-area').value = SET.editorText;
}
@@ -1066,7 +1066,7 @@
if (ev) ev.stopPropagation(); // 冒泡到分组头会误触折叠/展开
fetchBalance(pi + '-' + ki, pi, ki, true);
}
const BAL_REFRESH_SVG = '<svg viewBox="0 0 24 24"><polyline points="23 4 23 10 17 10"></polyline><path d="M20.49 15a9 9 0 1 1-2.12-9.36L23 10"></path></svg>';
const BAL_REFRESH_SVG = '<svg viewBox="0 0 24 24"><use href="#i-refresh"/></svg>';
// 平台卡折叠/展开(gk = 'p'+pi)。首次展开:给该平台每个 Key 行自动查一次余额(每页会话一次;手动刷新不受限)。
function toggleModelGroup(gk) {
const on = !SET.expandedGroups[gk];
@@ -1159,7 +1159,7 @@
}).join('') : '';
return '<div class="model-group' + (open ? ' open' : '') + '" id="mgrp-' + gk + '">' +
'<div class="model-group-head" onclick="sUI.toggleGroup(\'' + gk + '\')">' +
'<svg class="model-group-caret" viewBox="0 0 24 24"><polyline points="9 6 15 12 9 18"></polyline></svg>' +
'<svg class="model-group-caret" viewBox="0 0 24 24"><use href="#i-chevron-right-b"/></svg>' +
'<span class="model-group-name">' + esc(p.name || ('平台' + pi)) + '</span>' +
'<span class="model-group-badge">' + keys.length + ' keys</span>' +
'<span class="model-group-meta">' + models.filter(m => m.enable !== false).length + ' / ' + models.length + ' 模型</span>' +
@@ -1212,7 +1212,7 @@
function setPageModels(ctx) {
setTitle('模型池');
setActions('<button class="icon-btn" title="添加模型" onclick="sUI.openAdd()">' +
'<svg class="ic" viewBox="0 0 24 24"><line x1="12" y1="5" x2="12" y2="19"></line><line x1="5" y1="12" x2="19" y2="12"></line></svg></button>');
'<svg class="ic" viewBox="0 0 24 24"><use href="#i-plus"/></svg></button>');
setBody('<div class="set-scroll" id="model-cards"><div class="empty-tip">加载中…</div></div>');
// 余额与展开态跨设置内导航保持(仅 closeSettings 回会话页时重置),重进本页不重复查余额
loadModelCards(ctx);
@@ -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: '', adv: false };
extra_params: '', thinking_params: '', reasoning_ack_field: '', max_context: 0, store: false, adv: false };
if (pfEdit) applyModelDefaults(r, pfEdit.preset);
return r;
}
@@ -1283,6 +1283,8 @@
extra_params: pfJsonText(m.extra_params),
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,
})),
};
@@ -1363,6 +1365,7 @@
'<label class="mpe-line"><span>请求参数</span><textarea rows="2" spellcheck="false" placeholder=\'{"key":"value"}\' oninput="sUI.mModField(' + i + ',\'extra_params\',this.value)">' + esc(r.extra_params) + '</textarea></label>' +
'<label class="mpe-line"><span>思考参数</span><textarea rows="2" spellcheck="false" placeholder=\'{"reasoning_effort":"max"}\' oninput="sUI.mModField(' + i + ',\'thinking_params\',this.value)">' + esc(r.thinking_params) + '</textarea></label>' +
'<label class="mpe-line"><span>思考链回传</span><input type="text" placeholder="回传字段名" value="' + att(r.reasoning_ack_field) + '" oninput="sUI.mModField(' + i + ',\'reasoning_ack_field\',this.value)"></label>' +
'<label class="mpe-line"><span>压缩阈值</span><input type="number" min="0" step="1000" placeholder="0=不自动压缩" value="' + att(r.max_context || 0) + '" oninput="sUI.mModField(' + i + ',\'max_context\',this.value)"></label>' +
'</div>' : '';
return '<div class="mpe-mcard">' +
'<div class="mpe-row">' +
@@ -1372,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>';
@@ -1426,6 +1430,9 @@
if (Object.keys(tp).length) nv.thinking_params = tp;
const ra = String(r.reasoning_ack_field || '').trim();
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)。
@@ -1502,6 +1509,18 @@
} else if (ra !== curRa) {
edits.push({ path: mp.concat('reasoning_ack_field'), value: ra });
}
// 压缩阈值:0 = 删键(缺省不写),避免无意义重写文件
const curMc = Number(om.max_context) || 0;
const mc = Math.max(0, parseInt(r.max_context, 10) || 0);
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) });
}
@@ -1612,7 +1631,7 @@
async function setPageMcp(ctx) {
setTitle('MCP 服务');
setActions('<button class="icon-btn" title="添加 MCP 服务" onclick="mcpUI.add()">' +
'<svg class="ic" viewBox="0 0 24 24"><line x1="12" y1="5" x2="12" y2="19"></line><line x1="5" y1="12" x2="19" y2="12"></line></svg></button>');
'<svg class="ic" viewBox="0 0 24 24"><use href="#i-plus"/></svg></button>');
setBody('<div class="set-scroll" id="mcp-list"><div class="empty-tip">加载中…</div></div>');
await loadMcpList(ctx);
}
@@ -2075,11 +2094,15 @@
loadSessionList();
// 侧栏底部已是纯图标操作栏(不展示用户信息),不再需要 loadDrawerUser
// 会话深链 /?s=<session_id>:数据页面(/app/{task_id}/...)的「返回会话」FAB 用——
// task_id 即会话 id(engine 里 1:1),启动时消费一次即 replaceState 抹掉参数,
// 避免刷新/分享时被钉回该会话;会话已删则 openSession 自行报错,落在 welcome。
const deep = new URLSearchParams(location.search).get('s');
// task_id 即会话 id(engine 里 1:1)。地址栏常驻 ?s= 不抹掉,刷新/收藏/分享都能回到同一会话;
// 会话已删时 openSession 会自己回落到 welcome 并把 URL 清回 /。
const params = new URLSearchParams(location.search);
const deep = params.get('s');
if (deep) {
history.replaceState(null, '', '/');
openSession(deep);
openSession(deep).then(() => {
// 从侧栏「在新窗口打开」进来(带 files=1):开局直接把侧栏切到文件树;
// 窄屏/无会话/文件树未加载时 setDrawerPane 内部会自行忽略
if (params.get('files') === '1' && typeof setDrawerPane === 'function') setDrawerPane(true);
});
}
})();
+54 -13
View File
@@ -98,13 +98,19 @@
// ---------- 待发送条幅 ----------
// 队列本身在服务端(engine.pendings),关页面/换设备/重连都不丢;这里只负责画。
// 每条一行;只有队首有「干预 / 立即发送」,其余显示排队中(不能越过前一条先发)。
// 两条操作各配一枚图标:笔=撤回编辑(正文退回输入框),垃圾桶=直接丢弃这条
const SQ_EDIT_ICON = '<svg viewBox="0 0 24 24" width="14" height="14" fill="none" stroke="currentColor" stroke-width="1.9" stroke-linecap="round" stroke-linejoin="round"><use href="#i-pencil-b"/></svg>';
const SQ_TRASH_ICON = '<svg viewBox="0 0 24 24" width="14" height="14" fill="none" stroke="currentColor" stroke-width="1.9" stroke-linecap="round" stroke-linejoin="round"><use href="#i-trash"/></svg>';
function renderSendQueue() {
const box = $('send-queue');
if (!box) return;
const list = state.pending || [];
// 条幅增减会改 chat-view 的 clientHeight,浏览器不会替你补滚动:
// 改动前先记住是不是贴底,贴底就强制滚回去,否则最后一条消息被裁在视口外。
const keepBottom = typeof isNearBottom === 'function' ? isNearBottom() : false;
box.classList.toggle('hidden', !list.length);
if (!list.length) { box.innerHTML = ''; return; }
box.innerHTML = list.map((it, i) => {
box.innerHTML = list.length ? list.map((it, i) => {
const busy = it.mode === 'interject' || it.mode === 'now';
const tag = it.mode === 'now' ? '<span class="sq-tag">正在中断…</span>'
: it.mode === 'interject' ? '<span class="sq-tag">等待当前步骤…</span>'
@@ -116,11 +122,14 @@
return '<div class="sq-item' + (busy ? ' sq-busy' : '') + '" data-qid="' + esc(it.id) + '">' +
'<span class="sq-text" title="' + esc(it.content) + '">' + esc(it.content) + '</span>' +
tag + acts +
'<button class="sq-x" data-act="cancel" title="取消这条">×</button></div>';
}).join('');
'<button class="sq-act" data-act="recall" title="撤回到输入框,重新编辑" aria-label="撤回编辑">' + SQ_EDIT_ICON + '</button>' +
'<button class="sq-act" data-act="cancel" title="删除这条" aria-label="删除这条">' + SQ_TRASH_ICON + '</button></div>';
}).join('') : '';
// 双帧补滚:hidden 类与 textarea 高度都是本帧生效,rAF 后再跟一次才稳
if (keepBottom && typeof scrollBottom === 'function') { scrollBottom(); requestAnimationFrame(scrollBottom); }
}
// 条幅按钮:× 取消;干预/立即发送升级队首(服务端只在安全边界真正投递)。
// 条幅按钮:笔=撤回编辑(正文退回输入框),垃圾桶=直接丢弃;干预/立即发送升级队首。
async function onSendQueueClick(e) {
const btn = e.target.closest('#send-queue button[data-act]');
if (!btn || !state.sessionId) return;
@@ -128,20 +137,34 @@
const qid = item && item.dataset.qid;
if (!qid) return;
const act = btn.dataset.act;
const isDel = act === 'recall' || act === 'cancel'; // 两者都是删队列项,区别只在要不要回填
// 撤回文本必须在请求前取:DELETE 的响应里这条已经没了
const draft = act === 'recall' ? ((state.pending || []).find(x => x.id === qid) || {}).content || '' : '';
btn.disabled = true;
try {
const base = '/api/sessions/' + state.sessionId + '/pending/' + encodeURIComponent(qid);
const r = act === 'cancel' ? await req('DELETE', base) : await req('POST', base, { action: act });
const r = isDel ? await req('DELETE', base) : await req('POST', base, { action: act });
if (r && Array.isArray(r.pending)) { state.pending = r.pending; renderSendQueue(); }
if (act === 'cancel') return;
if (r && r.delivered) return; // 回合已结束:服务端直接投递,等 user_message 画气泡
toast(act === 'now' ? '已请求中断,随后立即发送' : '已请求干预:当前步骤结束后插话');
if (isDel) { if (draft) recallToInput(draft); return; }
// 干预/立即发送:条幅自己会变成「等待当前步骤…」/「正在中断…」,不再弹 toast
} catch (err) {
toast('操作失败:' + err.message);
renderSendQueue();
}
}
// 撤回:塞回输入框(撤回段在前、已有草稿在后,与发送失败的兜底同序),光标停在撤回段末尾
function recallToInput(text) {
const ta = $('msg-input');
if (!ta) return;
ta.value = text + (ta.value ? '\n' + ta.value : '');
autosize();
updateSendBtn();
ta.focus({ preventScroll: true }); // 别让浏览器为露出输入框去滚页面,聊天区的位置由下面统一管
try { ta.setSelectionRange(text.length, text.length); } catch (_) {}
if (typeof scrollBottom === 'function') { scrollBottom(); requestAnimationFrame(scrollBottom); }
}
const sendQueueBox = $('send-queue');
if (sendQueueBox) sendQueueBox.addEventListener('click', onSendQueueClick);
@@ -290,6 +313,7 @@
state.streamEl.className = 'bubble-ai' + (r.fmt ? ' md' : ''); // 增量期间是纯文本,收尾统一换 md 排版
state.streamEl.innerHTML = r.html;
decorateCodePre(state.streamEl); // 流式期间不插按钮(每帧整块换 innerHTML),收尾统一装饰一次
pvHighlightMdCode(state.streamEl); // 围栏代码块上色
} else {
// 无文本时去掉气泡(纯工具调用/纯思考也要保留思考面板)
state.streamEl.remove();
@@ -303,18 +327,18 @@
bubble.className = 'bubble-ai' + (r.fmt ? ' md' : '');
bubble.innerHTML = r.html;
decorateCodePre(bubble);
pvHighlightMdCode(bubble);
state.streamWrap.appendChild(bubble);
}
// 「压缩」总结回合的最终答复(后端已保证只有压缩回合里首条无工具调用的收尾回复才带 is_summary,
// 中间 AI 回复已按普通消息渲染):把已流式输出的气泡装进摘要卡片(与历史重渲染同款样式),
// 并标记 wrap 为 msg-summary-live:archiveDomBeforeSummary 据此定位摘要卡片,之前的旧消息收进存档容器。
// open=true 让用户立刻读到;后续轮次不自动折起(卡片可手动点 summary 收起)。
// 摘要卡片默认收起(与画像快照/渠道/记忆同一种交互),用户想读时点开。
// 防重:同一 streamWrap 已有卡片则不再重复插入(保护 SSE 重连重发等场景)。
if (d.is_summary && hasText && state.streamWrap && !state.streamWrap.querySelector('.msg-summary')) {
const wrap0 = state.streamWrap;
const det = document.createElement('details');
det.className = 'msg-summary';
det.open = true;
det.innerHTML = summaryHeaderHtml() + '<div class="msg-summary-body"></div>';
const body = det.querySelector('.msg-summary-body');
const bubble = wrap0.querySelector('.bubble-ai');
@@ -473,6 +497,9 @@
state.toolCallStreaming = {}; // 流式参数早卡映射随会话/回合重置
updateScrollBottomBtn();
loadSessionList();
// 一轮完整跑完(agent 循环退出才发 done):工具/技能产物可能新增或改名,文件树就地刷新;
// 不在文件树面板时 reloadFileTree 只标脏,等切回去再重拉
if (typeof window.reloadFileTree === 'function') window.reloadFileTree();
});
// 服务端首次交互后自动生成的标题(finalize 后约 1s 到达):即时刷新顶栏 + 重拉会话列表(PC 常驻侧边栏/移动抽屉)
es.addEventListener('title', ev => {
@@ -517,7 +544,7 @@
try { text = decodeURIComponent(escape(atob(copyBtn.dataset.b64 || ''))); } catch (_) {}
}
const ok = await copyText(text);
toast(ok ? '已复制' : '复制失败');
if (!ok) toast('复制失败');
if (ok) {
copyBtn.classList.add('copied');
setTimeout(() => copyBtn.classList.remove('copied'), 1200);
@@ -538,7 +565,6 @@
btn.disabled = true;
try {
await req('DELETE', '/api/sessions/' + state.sessionId + '/messages/' + msgId);
toast('已删除');
// 按已加载量分页重拉(长会话删一条不该退回全量重建)
const detail = await req('GET', '/api/sessions/' + state.sessionId + '?limit=' + Math.max(CHAT_PAGE_SIZE, state.chatLoadedCount));
if (state.view === 'chat') renderDetail(detail);
@@ -702,6 +728,21 @@
$('chat-view').addEventListener('click', imgViewerDelegate);
$('fs-viewer').addEventListener('click', imgViewerDelegate);
// ---------- 会话流里的本机链接:进预览窗 ----------
// 只拦本机 host(同源 / localhost 别名);外链、锚点、mailto、相对路径维持浏览器默认。
// 修饰键与中键放行,留着「我就是要新开一个标签页」这个出口。
function linkPreviewDelegate(e) {
if (e.button !== 0 || e.ctrlKey || e.metaKey || e.shiftKey || e.altKey) return;
const a = e.target.closest('a[href]');
if (!a) return;
const href = a.getAttribute('href') || '';
if (!/^(https?:\/\/|\/(?!\/))/i.test(href) || !pvSameHost(href)) return;
e.preventDefault();
const txt = (a.textContent || '').trim();
pvOpenUrl(href, txt && txt.length <= 40 ? txt : null);
}
$('chat-view').addEventListener('click', linkPreviewDelegate);
// 图片全屏查看器:transform 缩放+平移。双指捻合缩放(1~6x)、放大后单指/鼠标拖动、双击切 2.5x。
// 第 3 参 list([{src,alt}] 或 [src]) 传入「同组图片」时开启左右滑动切换;第 4 参 at 指定起始下标。
// 切图用双层 img 做真正的分页位移(旧图跟手滑出、新图同步滑入),并在开图时预取相邻图,
+275
View File
@@ -0,0 +1,275 @@
// Git 面板(复用 #pv-pane:预览 / Git 二选一,由 body.pv-mode-vcs 切换)。
// 三个视图:list(提交历史 + 未提交入口)/ detail(提交详情)/ worktree(未提交改动)。
// 后两者共用一个渲染器,区别只在头部有没有 commit 信息。
// 不做自动刷新:打开、切视图、点刷新时才请求。
// 依赖(全局):state esc toast req pvOpenPane pvHeader pvToolbar pvClearBody pvState pvDesktop openFilePreview
'use strict';
(function () {
const PAGE = 30;
// view: list | detail | worktree;cur: 当前详情响应;lastPreview: 进 Git 前预览的文件(切回用)
const st = { view: 'list', sid: '', repo: null, commits: [], next: null, cur: null, lastPreview: null, seq: 0 };
function bodyEl() { return document.getElementById('pv-body'); }
function sid() { return (state && state.sessionId) || ''; }
function api(p) {
return req('GET', '/api/sessions/' + encodeURIComponent(sid()) + p);
}
// 仓库路径显示在地址条上(地址条是现成的路径位,不另开头部)
function setAddr(repo) {
const t = document.getElementById('pv-title');
if (!t || !repo) return;
t.value = repo.root || '';
t.title = (repo.root || '') + (repo.branch ? ' · ' + repo.branch : '');
}
function fmtTime(iso) {
const d = new Date(iso);
if (isNaN(d.getTime())) return String(iso || '');
const p = (n) => (n < 10 ? '0' + n : '' + n);
return d.getFullYear() + '-' + p(d.getMonth() + 1) + '-' + p(d.getDate()) + ' ' + p(d.getHours()) + ':' + p(d.getMinutes());
}
const BADGE = { A: '新增', D: '删除', R: '改名', M: '修改', U: '未跟踪' };
function errBox(text, retry) {
bodyEl().innerHTML =
'<div class="pv-err"><div class="vcs-err-t"></div>' + (retry ? '<button type="button" class="vcs-retry">重试</button>' : '') + '</div>';
bodyEl().querySelector('.vcs-err-t').textContent = text;
const b = bodyEl().querySelector('.vcs-retry');
if (b) b.addEventListener('click', retry);
}
function reasonText(reason) {
if (reason === 'no_git') return '这个环境没有 git 命令。';
if (reason === 'bad_rev') return '提交不存在,可能已被改写或清理。';
if (reason === 'timeout') return 'git 执行超时,仓库可能过大。';
if (reason === 'not_repo') return '未找到 git 仓库:当前会话目录及其上级都不是仓库。';
return '读取失败:' + (reason || '未知错误');
}
// ---------- 列表 ----------
function renderList() {
const parts = [];
parts.push('<div class="vcs-list">');
if (st.repo) {
const rm = st.repo.remote;
parts.push('<div class="vcs-repo">' + esc(st.repo.root) + (st.repo.branch ? ' · ' + esc(st.repo.branch) : '') +
' · <span class="vcs-remote' + (rm ? '' : ' none') + '" title="' + esc(rm ? rm.url : '未配置 remote') + '">' +
esc(rm ? rm.name : '无 remote') + '</span></div>');
}
if (st.worktree && st.worktree.files) {
parts.push('<div class="vcs-item wt" data-act="worktree">' +
'<div class="t">未提交的改动</div>' +
'<div class="m">' + st.worktree.files + ' 个文件有变动</div></div>');
}
const up = st.repo && st.repo.upstream;
for (const c of st.commits) {
const atUp = up && c.id === up.id;
parts.push('<div class="vcs-item' + (atUp ? ' at-up' : '') + '" data-act="commit" data-id="' + esc(c.id) + '">' +
'<div class="t">' + esc(c.subject) +
(atUp ? ' <span class="vcs-up" title="远端 ' + esc(up.ref) + ' 指向这里">' + esc(up.ref) + '</span>' : '') + '</div>' +
'<div class="m">' + esc(c.author) + ' · ' + esc(fmtTime(c.time)) + ' · ' + esc(c.short) + '</div></div>');
}
if (!st.commits.length && !(st.worktree && st.worktree.files)) {
parts.push('<div class="vcs-empty">还没有提交记录</div>');
}
if (st.next) parts.push('<button type="button" class="vcs-more" data-act="more">加载更多</button>');
parts.push('</div>');
bodyEl().innerHTML = parts.join('');
}
// ---------- 详情(提交 / 未提交共用)----------
// 语法高亮:与预览共用 PV_LANG(preview.js)。只能逐行高亮:diff 是片段,多行注释/三引号串
// 本来就拼不完整;逐行反而不会把行号与红绿底色搞乱。
function prismLang(path) {
if (typeof PV_LANG === 'undefined' || typeof Prism === 'undefined' || !Prism.languages) return null;
const m = /\.([^.\\/]+)$/.exec(String(path || ''));
const lang = m && PV_LANG[m[1].toLowerCase()];
return lang && Prism.languages[lang] ? lang : null;
}
function codeEsc(text, lang) {
if (!lang) return esc(text);
try { return Prism.highlight(text, Prism.languages[lang], lang); } catch (_) { return esc(text); }
}
function lineHtml(cls, oldNo, newNo, text, lang) {
return '<div class="vcs-line' + (cls ? ' ' + cls : '') + '"><span class="n">' + (oldNo == null ? '' : oldNo) +
'</span><span class="n">' + (newNo == null ? '' : newNo) + '</span><span class="c">' + codeEsc(text, lang) + '</span></div>';
}
// 行号自己推:@@ -a,b +c,d @@ 之后的上下文/+/- 分别推进两个计数器
function patchHtml(f) {
if (f.binary) return '<div class="vcs-nodiff">二进制文件,不显示差异</div>';
if (!f.patch) return '<div class="vcs-nodiff">没有可显示的差异</div>';
const out = [];
const lines = String(f.patch).split('\n');
// 大 patch 不上色:逐行跑 Prism 是同步的,几千行会把面板卡一下
const lang = lines.length <= 2000 ? prismLang(f.path) : null;
let oldNo = 0, newNo = 0, inHunk = false, rows = 0;
for (let i = 0; i < lines.length; i++) {
const line = lines[i];
if (i === lines.length - 1 && line === '') break; // 末尾换行不算内容行
if (line.slice(0, 2) === '@@') {
const m = /^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@/.exec(line);
if (m) { oldNo = Number(m[1]); newNo = Number(m[2]); inHunk = true; }
out.push('<div class="vcs-line h"><span class="n"></span><span class="n"></span><span class="c">' + esc(line) + '</span></div>');
continue;
}
if (!inHunk) continue; // 文件头(diff --git / index / --- / +++)由文件行本身表达,不重复渲染
if (line.charAt(0) === '\\') { out.push('<div class="vcs-line meta"><span class="n"></span><span class="n"></span><span class="c">' + esc(line) + '</span></div>'); continue; }
const c = line.charAt(0);
if (c === '+') out.push(lineHtml('a', null, newNo++, line.slice(1), lang));
else if (c === '-') out.push(lineHtml('d', oldNo++, null, line.slice(1), lang));
else out.push(lineHtml('', oldNo++, newNo++, line.slice(1), lang));
if (++rows > 3000) { out.push('<div class="vcs-nodiff">行数过多,剩余部分已隐藏</div>'); break; }
}
return out.join('') || '<div class="vcs-nodiff">仅改名或模式变更,没有内容差异</div>';
}
function fileHtml(f, idx, openAll) {
const open = openAll ? ' open' : '';
return '<div class="vcs-file' + open + '" data-i="' + idx + '">' +
'<div class="vcs-fh">' +
'<span class="vcs-caret"></span>' +
'<span class="vcs-path">' + esc(f.path) + '</span>' +
'<span class="vcs-badge ' + esc(String(f.status || '').toLowerCase()) + '">' + esc(BADGE[f.status] || f.status) + '</span>' +
'<span class="vcs-stat"><b class="a">+' + f.adds + '</b><b class="d">-' + f.dels + '</b></span>' +
'</div>' +
'<div class="vcs-fb"><div class="vcs-fb-in">' + patchHtml(f) + (f.truncated ? '<div class="vcs-nodiff">差异过大,已截断</div>' : '') + '</div></div>' +
'</div>';
}
// 行背景要盖满「可视宽度 ∩ 内容宽度」:只量 clientWidth 不够,长行溢出到 1129 时行背景仍只有 699,
// 横滑右边就露白。scrollWidth 正好是最长行的内容宽,取两者较大值写成 px 给内层。
function syncPatchWidth(scope) {
(scope || document).querySelectorAll('.vcs-fb').forEach(function (fb) {
const inner = fb.firstElementChild;
if (!inner) return;
const w = Math.max(fb.clientWidth, fb.scrollWidth);
if (w > 0) inner.style.minWidth = w + 'px';
});
}
function renderDetail(d) {
st.cur = d;
const openAll = d.files.length <= 3; // 少量文件默认展开,多文件默认折叠
const parts = [];
parts.push('<div class="vcs-detail">');
parts.push('<button type="button" class="vcs-back" data-act="back">返回提交列表</button>');
if (d.commit) {
parts.push('<div class="vcs-commit">' +
'<div class="vcs-subject">' + esc(d.commit.subject) + '</div>' +
'<div class="vcs-meta"><span>' + esc(d.commit.author) + '</span><span>' + esc(fmtTime(d.commit.time)) + '</span>' +
'<span class="vcs-hash">' + esc(d.commit.short) + '</span>' +
(d.commit.parents && d.commit.parents.length > 1 ? '<span>合并提交</span>' : '') + '</div>' +
(d.commit.body ? '<pre class="vcs-msg">' + esc(d.commit.body) + '</pre>' : '') +
'</div>');
} else {
parts.push('<div class="vcs-commit"><div class="vcs-subject">未提交的改动</div>' +
'<div class="vcs-meta"><span>' + esc(d.repo.branch || 'HEAD') + '</span><span>' + esc(d.repo.root) + '</span></div></div>');
}
parts.push('<div class="vcs-sum">' + d.stats.files + ' 个文件 · <b class="a">+' + d.stats.adds + '</b> <b class="d">-' + d.stats.dels + '</b></div>');
d.files.forEach(function (f, i) { parts.push(fileHtml(f, i, openAll)); });
if (!d.files.length) parts.push('<div class="vcs-empty">没有文件变动</div>');
parts.push('</div>');
bodyEl().innerHTML = parts.join('');
syncPatchWidth(bodyEl());
}
// ---------- 数据加载 ----------
async function loadList(more) {
const seq = ++st.seq;
const keepTop = more ? bodyEl().scrollTop : 0; // 加载更多是整体重绘,得自己把滚动位置补回去
st.view = 'list';
st.sid = sid();
if (!more) { st.commits = []; st.next = null; bodyEl().innerHTML = '<div class="pv-loading"></div>'; }
const q = '?limit=' + PAGE + (more && st.next ? '&before=' + encodeURIComponent(st.next) : '');
let d;
try { d = await api('/git/commits' + q); }
catch (e) { if (seq === st.seq) errBox('请求失败:' + (e.message || e), function () { loadList(false); }); return; }
if (seq !== st.seq) return;
if (!d || !d.ok) { errBox(reasonText(d && d.reason), function () { loadList(false); }); return; }
st.repo = d.repo;
st.worktree = d.worktree;
st.commits = more ? st.commits.concat(d.commits) : d.commits;
st.next = d.next;
setAddr(d.repo);
renderList();
if (more) bodyEl().scrollTop = keepTop;
}
async function loadDetail(rev) {
const seq = ++st.seq;
st.view = rev === 'worktree' ? 'worktree' : 'detail';
st.sid = sid();
bodyEl().innerHTML = '<div class="pv-loading"></div>';
let d;
try { d = await api('/git/commit/' + encodeURIComponent(rev)); }
catch (e) {
if (seq === st.seq) errBox('请求失败:' + (e.message || e), function () { loadDetail(rev); });
return;
}
if (seq !== st.seq) return;
if (!d || !d.ok) { errBox(reasonText(d && d.reason), function () { loadDetail(rev); }); return; }
renderDetail(d);
}
function refresh() {
if (st.view === 'list') return loadList(false);
if (st.view === 'worktree') return loadDetail('worktree');
if (st.cur && st.cur.commit) return loadDetail(st.cur.commit.id);
return loadList(false);
}
// ---------- 面板开关 ----------
function syncBtn() {
const b = document.getElementById('tree-vcs');
if (b) b.classList.toggle('active', document.body.classList.contains('pv-mode-vcs'));
}
function setMode(on) {
document.body.classList.toggle('pv-mode-vcs', !!on);
syncBtn();
}
function openPane() {
if (!sid()) { toast('请先打开一个会话'); return; }
if (typeof pvDesktop === 'function' && !pvDesktop()) { toast('Git 面板仅在桌面端可用'); return; }
const on = document.body.classList.contains('pv-mode-vcs');
if (on && st.sid === sid()) { // 再点一次:有上次预览就切回预览,否则关面板
setMode(false);
if (st.lastPreview) { openFilePreview(st.lastPreview); return; }
document.getElementById('pv-close').click();
return;
}
if (!on) st.lastPreview = (typeof pvState === 'object' && pvState && pvState.name) || null;
if (typeof pvOpenPane === 'function') pvOpenPane();
setMode(true);
pvClearBody();
pvHeader(null); // 清掉预览的文件名与下载钮;地址条下面再写仓库路径
pvToolbar({ refresh: true, popup: false, reload: refresh });
loadList(false);
}
// 事件委托:pv-body 的内容每次整体重建,逐元素绑定没必要
document.getElementById('pv-body').addEventListener('click', function (e) {
if (!document.body.classList.contains('pv-mode-vcs')) return;
const it = e.target.closest('.vcs-item');
if (it) {
if (it.dataset.act === 'worktree') loadDetail('worktree');
else if (it.dataset.act === 'commit') loadDetail(it.dataset.id);
return;
}
const more = e.target.closest('.vcs-more');
if (more) { loadList(true); return; }
const back = e.target.closest('.vcs-back');
if (back) { loadList(false); return; }
const fh = e.target.closest('.vcs-fh');
if (fh) { fh.parentNode.classList.toggle('open'); syncPatchWidth(fh.parentNode); return; }
});
window.openVcsPane = openPane;
window.vcsSetMode = setMode;
window.vcsRefresh = refresh;
})();
+51 -16
View File
@@ -36,6 +36,11 @@
const MAX_MS = 180000; // 单次录音上限(流式上传后不再受 60s 限制)
const MIN_MS = 500; // 短于这个时长按误触处理,不上传
const FLUSH_MS = 60000; // 松手后等尾段识别完的上限(超过就当失败)
// 桌面用鼠标就用「点一下开始、再点一下发送」;手机(触屏)继续按住说话。
// 桌面一直压着鼠标键说话手累,上滑取消也没意义;两个平台各自按自己的习惯来。
const POINT_FINE = !!(window.matchMedia && window.matchMedia('(hover: hover) and (pointer: fine)').matches);
const HOLD_IDLE = POINT_FINE ? '点击 说话' : '按住 说话';
const HOLD_REC = POINT_FINE ? '说完 点击发送' : '松开 结束';
// 转写请求的并发上限:段一碎(6s 软切)并发就会很多,全放出去会把上游压垮、
// 也可能被限流。超过就排到后面,等前面的落定再发。改完刷新页面即生效。
const ASR_MAX_CONCURRENCY = 3;
@@ -125,10 +130,14 @@
// ---------- 遮罩 / 声波 ----------
function setOverlayMode(m) { // 'send' | 'cancel' | 'busy'
cancelArmed = m === 'cancel';
if (overlay) overlay.classList.toggle('cancel', m === 'cancel');
if (overlay) {
overlay.classList.toggle('cancel', m === 'cancel');
overlay.classList.toggle('busy', m === 'busy'); // 识别中把操作行藏起来,避免空点
}
if (hintEl) {
hintEl.textContent = m === 'cancel' ? '松开取消'
: m === 'busy' ? busyHintText() : '松手传送,上滑取消';
hintEl.textContent = m === 'cancel' ? '松手取消'
: m === 'busy' ? busyHintText()
: (POINT_FINE ? '' : '松手传送,上滑取消');
}
}
@@ -302,7 +311,7 @@
abortStream();
if (stopTimer) { clearTimeout(stopTimer); stopTimer = null; }
hold.classList.remove('recording');
setHoldText('按住 说话');
setHoldText(HOLD_IDLE);
hideOverlay();
updateSendBtn();
}
@@ -344,7 +353,7 @@
segSent = 0;
segDone = 0;
hold.classList.add('recording');
setHoldText('松开 结束');
setHoldText(HOLD_REC);
showOverlay();
if (native) {
@@ -413,7 +422,7 @@
if (held < MIN_MS) discard = true;
phase = 'busy';
hold.classList.remove('recording');
setHoldText(discard ? '按住 说话' : '正在识别…');
setHoldText(discard ? HOLD_IDLE : '正在识别…');
// 遮罩留着,文案换成动态识别进度;柱子停在低位,等结果回来再收
setOverlayMode(discard ? 'send' : 'busy');
stopMeter();
@@ -464,15 +473,15 @@
resetUI();
}
// ---------- 按住 / 滑动 / 松开 ----------
hold.addEventListener('pointerdown', function (e) {
// ---------- 按住 / 滑动 / 松开(手机)或点击切换(桌面)----------
function onPointerDown(e) {
if (e && e.button != null && e.button !== 0) return; // 只响应左键/触摸
e.preventDefault();
if (phase !== 'idle') return;
pressY = e.clientY || 0;
try { hold.setPointerCapture(e.pointerId); } catch (_) { /* 忽略 */ }
startHold();
});
}
function onMove(e) {
if (!pressing) return;
@@ -503,13 +512,39 @@
else if (phase === 'arming') cancelHold(); // 还没真正开录:当误触
}
hold.addEventListener('pointerup', onRelease);
hold.addEventListener('pointercancel', onRelease);
hold.addEventListener('pointermove', onMove);
// 兜底:个别环境下 setPointerCapture 不生效,手指移出按钮后也要跟手
window.addEventListener('pointerup', onRelease);
window.addEventListener('pointercancel', onRelease);
window.addEventListener('pointermove', onMove);
if (POINT_FINE) {
// 桌面:点一下开始,再点一下发送(pressing 由 startHold 置 true 后一直保持,不会自己松)
hold.addEventListener('click', function (e) {
e.preventDefault();
if (phase === 'idle') startHold();
else if (phase === 'recording') finishHold();
else if (phase === 'arming') cancelHold(); // 等麦克风授权时再点一下 = 取消
});
} else {
hold.addEventListener('pointerdown', onPointerDown);
hold.addEventListener('pointerup', onRelease);
hold.addEventListener('pointercancel', onRelease);
hold.addEventListener('pointermove', onMove);
// 兜底:个别环境下 setPointerCapture 不生效,手指移出按钮后也要跟手
window.addEventListener('pointerup', onRelease);
window.addEventListener('pointercancel', onRelease);
window.addEventListener('pointermove', onMove);
}
// 桌面点击模式:遮罩底部那行「取消 / 发送」的点击绑定
if (POINT_FINE) {
const sendBtn = $('voice-send');
const cancelBtn = $('voice-cancel');
if (sendBtn) sendBtn.addEventListener('click', function (e) { e.stopPropagation(); if (phase === 'recording') finishHold(); });
if (cancelBtn) cancelBtn.addEventListener('click', function (e) { e.stopPropagation(); cancelHold(); });
}
// 录音中 Esc 取消(两端都可用,桌面端尤其需要一个键盘出口)
document.addEventListener('keydown', function (e) {
if (e.key !== 'Escape' || phase === 'idle') return;
e.preventDefault();
cancelHold();
});
// 长按不弹系统菜单(移动端)
hold.addEventListener('contextmenu', function (e) { e.preventDefault(); });
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
File diff suppressed because one or more lines are too long
+35 -10
View File
@@ -9,6 +9,7 @@ const { listTaskFiles } = require('./sessions');
const { resolveInTask } = require('../tools/executor');
const downloadToken = require('../download-token');
const log = require('../log');
const git = require('../git');
const router = express.Router();
@@ -80,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 双重校验,防符号链接跳出会话目录。
@@ -118,19 +115,21 @@ router.get('/:id/tree', function (req, res) {
const childRel = rel ? rel + '/' + e.name : e.name;
if (e.isSymbolicLink()) { entries.push({ name: e.name, rel: childRel, type: 'link' }); continue; }
if (e.isDirectory()) {
entries.push({ name: e.name, rel: childRel, type: 'dir', ignored: TREE_IGNORE_DIRS.has(e.name) });
// mtimeMs 给前端判断空目录是否还是空的:目录内增删子项会更新它
let mtimeMs = null;
try { mtimeMs = fs.statSync(path.join(abs, e.name)).mtimeMs; } catch (_) {}
entries.push({ name: e.name, rel: childRel, type: 'dir', mtimeMs: mtimeMs });
} else if (e.isFile()) {
let size = null;
try { size = fs.statSync(path.join(abs, e.name)).size; } catch (_) {}
entries.push({ name: e.name, rel: childRel, type: 'file', size: size });
let size = null, mtimeMs = null;
try { const st = fs.statSync(path.join(abs, e.name)); size = st.size; mtimeMs = st.mtimeMs; } catch (_) {}
entries.push({ name: e.name, rel: childRel, type: 'file', size: size, mtimeMs: mtimeMs });
}
}
} 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({
@@ -142,6 +141,32 @@ router.get('/:id/tree', function (req, res) {
});
});
// ---------- Git 面板(只读):提交列表 / 提交详情 ----------
// rev=worktree 是「未提交的改动」,与提交详情返回同一副骨架(commit=null),前端共用一个渲染器。
// 不是仓库 / 没装 git 不算错误:HTTP 200 + { ok:false, reason },由界面显示空状态。
function gitDir(req) { return engine.taskDirOf(req.params.id); }
router.get('/:id/git/commits', async function (req, res) {
const session = engine.getSession(req.params.id);
if (!session) return res.status(404).json({ error: '会话不存在' });
const limit = Math.min(Math.max(parseInt(req.query.limit, 10) || 30, 1), 100);
const before = String(req.query.before || '');
// before 只接受完整/短 hash:它会拼进 git 参数,绝不能是任意表达式
const out = await git.query(gitDir(req), 'commits', {
before: /^[0-9a-f]{7,40}$/i.test(before) ? before : '',
limit,
});
res.json(out);
});
router.get('/:id/git/commit/:rev', async function (req, res) {
const session = engine.getSession(req.params.id);
if (!session) return res.status(404).json({ error: '会话不存在' });
const rev = String(req.params.rev || '');
if (rev !== 'worktree' && !/^[0-9a-f]{4,40}$/i.test(rev)) return res.status(400).json({ error: '非法的提交编号' });
res.json(await git.query(gitDir(req), 'commit', { rev }));
});
router.get('/:id/files', function (req, res) {
try {
const session = engine.getSession(req.params.id);
+19
View File
@@ -14,6 +14,25 @@ const engine = require('../engine');
const router = express.Router();
// 这些接口都是弹宿主机的原生对话框 / 开 Finder / 开终端,只有坐在这台机器前才有意义。
// 远程访问(经隧道 / 反代 / 局域网)一律当作不存在,返回 404 —— 行为和服务器形态完全一致
// (那边 server.js 根本不挂这个路由),前端原有的 catch 就会把入口整条隐藏。
// 判断依据:反向代理一定会加 X-Forwarded-* 头(nginx 设的,tunnel client 原样转发),
// 本机直连 127.0.0.1:8090 不会有。
// 不能看 Host:tunnel client 用 fetch 转发时 Host 是禁止头、会被重写成 127.0.0.1:8090。
// 也不能看 X-Forwarded-For 的 IP 值:stream 分流后源地址永远是 127.0.0.1。
function isLocalHost(req) {
if (req.headers['x-forwarded-for'] || req.headers['x-forwarded-host']
|| req.headers['x-real-ip'] || req.headers['x-forwarded-proto']) return false;
const host = String(req.headers.host || '').replace(/:\d+$/, '').toLowerCase().replace(/^\[|\]$/g, '');
return host === '127.0.0.1' || host === 'localhost' || host === '::1';
}
router.use(function (req, res, next) {
if (isLocalHost(req)) return next();
res.status(404).json({ error: 'Not Found' });
});
function sendErr(res, err) {
const code = (err && err.status_code) || 500;
res.status(code).json({ error: String((err && err.message) || err) });
+2 -2
View File
@@ -198,16 +198,16 @@ router.get('/:id', wrap((req, res) => {
}
}
const taskDir = engine.taskDirOf(session.id);
// 定时任务状态(scheduler.js / schedule 工具;每会话至多一行,无则 null)。
// 列表接口故意不带此字段,避免 N+1;前端进会话详情时才拉。
const schedule = db.prepare(
'SELECT cron_expr, prompt, next_run_at, last_run_at, last_status, last_note FROM scheduled_tasks WHERE session_id = ?'
).get(session.id) || null;
// 不再返回 files:文件树由 /api/files 按目录懒加载(routes/files.js),
// 这里全量递归扫一遍纯属浪费——曾让每次切会话多传 1.4MB(10544 个文件)。
res.json({
session,
messages,
files: listTaskFiles(taskDir),
schedule,
running: !!(engine.getRun(session.id) || {}).looping,
// 待投递队列(刷新/换设备后条幅能原样恢复):只在服务端内存里,重启即空
+11
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);
@@ -179,6 +180,12 @@ app.get('/api/health', (req, res) => {
});
});
// 统一错误出口:**必须最后挂**(Express 按注册顺序挑错误中间件,挂在路由前等于没挂)。
// 没有它,任何路由漏出的异常(最典型:res.sendFile 的异步失败)都会落到 Express 默认
// 处理器,在非 production 环境下把 err.stack 拼成 HTML 吐给请求方,泄露服务端绝对路径、
// 源码行号与依赖版本——/p/<id> 是匿名可达端点,这份栈等于公开。详见 error-handler.js。
app.use(require('./error-handler').errorHandler);
const PORT = process.env.PORT || cfg.port;
// 监听地址:不设 = 0.0.0.0(容器/服务器形态,宿主机端口映射靠它)。
// 本机 local 模式由 local/start.sh 注入 HOST=127.0.0.1:单机自用不该让同一局域网的人直接访问。
@@ -237,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)) {
+6 -1
View File
@@ -2,5 +2,10 @@
conversations share it and `/tmp` is the system temp dir. Work inside the
working directory; treat everything outside it as the user's.
- `python3` may be missing. Install what a task needs; Python packages go into
`$AGENT_SKILLS_DEPS`. If a skill fails, read its own `AGENTS.md`
`$AGENT_SKILLS_DEPS`. If a skill fails, cat its own `AGENTS.md`
(`"$(dirname "$AGENT_SKILLS_DEPS")/<skill>/AGENTS.md"`) and follow it.
- Installs and big downloads stay silent until they end. Run them in the background
with output to a log file and poll that file every ~10s, instead of one long timeout.
- Slow or failing installs and downloads: switch mirrors instead of retrying — pip
`-i https://pypi.tuna.tsinghua.edu.cn/simple`, npm `--registry=https://registry.npmmirror.com`,
GitHub URLs prefixed with `https://gh-proxy.com/`, Homebrew mirrors or let the user install.
+8 -8
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 读取完成(非仅响应头);
@@ -1757,7 +1755,7 @@ function toolRecall(ctx, args) {
case 'search': {
const q = String(args.query || '').trim();
if (!q) throw new Error('op=search 需要 query(关键词;空格分隔多个词更好,如「身份证 水印」)');
const txt = memory.searchFragments(db, user, q, args.count);
const txt = memory.searchFragments(db, user, q, args.count, ctx.sessionId);
return txt || '日记中无「' + q + '」相关记录。';
}
case 'days': {
@@ -1798,6 +1796,8 @@ const HANDLERS = {
// (见 imageReceipt),image_rel 缺省表示本次不投递像素。
// 内置工具优先;未命中时交给 MCP 注册表(启动时发现的服务工具)。
async function executeTool(baseCtx, name, args) {
// 会话目录懒建:会话创建时不再占坑,第一次真用到工具才建(纯文本对话不留空目录)。
try { if (baseCtx && baseCtx.taskDir) fs.mkdirSync(baseCtx.taskDir, { recursive: true }); } catch (_) {}
const handler = HANDLERS[name];
if (handler) return handler(baseCtx, args || {});
if (mcp.hasTool(name)) return mcp.callTool(name, args || {}, baseCtx); // baseCtx.taskDir → X-Session-Dir 头下发给 MCP 服务
+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);
BIN
View File
Binary file not shown.

After

Width:  |  Height:  |  Size: 257 KiB

+90 -36
View File
@@ -8,7 +8,8 @@
## 1. 目标
把同一个 `agent-core` 直接跑在本机(macOS / Linux),**不装 Docker、不起 executor**,形态类似
桌面 agent:给它一个工作目录,它在这个目录里放开手脚干活。
桌面 agent:给它一个工作目录,它在这个目录下的 `tasks/` 里放开手脚干活(`data/`、`skills/` 是兄弟目录,
归启动器和技能自己管)。
明确的设计约束(都来自讨论):
@@ -20,17 +21,18 @@
基线版本:`v2.5.0`(服务器端最后一个纯容器部署版本)。
## 2. 与服务器形态的差异(只有五处)
## 2. 与服务器形态的差异(只有六处)
| 差异 | 服务器 | 本地 | 由谁注入 |
|---|---|---|---|
| 命令在哪跑 | `agent-executor` 容器(mount/pid namespace 隔离) | 本机 `spawn`(**无沙箱**) | `EXECUTOR_URL` 留空 → 现成分支,未改代码 |
| 文件工具的根 | 会话目录 `tasks/<会话id>/` | 指定的工作目录 | `AGENT_FILE_SCOPE=workspace` |
| 文件工具的根 | 会话目录 `tasks/<会话id>/` | 工作目录下的 `tasks/`(`data/`、`skills/` 是兄弟目录,越界) | `AGENT_FILE_SCOPE=workspace` |
| 监听地址 | `0.0.0.0` | `127.0.0.1` | `HOST=127.0.0.1` |
| 对外链接(`mint_public_link` / `visit_url`) | `public_link.base_url` 拼公网短链 | 没有公网前缀时改拼 `http://127.0.0.1:<PORT>/p/<id>` | 复用 `localOrigin()`,靠 `HOST` 判断形态,不写配置 |
| 读图回传给模型 | 签公网短链,上游服务器来拉 | 上游拉不到回环地址,改为内联 base64 `data:` URL | `AGENT_IMAGE_INLINE=1` |
| office 预览的后端 | executor 的 `:3100` 网关(mount/pid 牢笼) | `local/preview-gateway.js`(同机、无牢笼) | `PREVIEW_PROXIES` 注入 core 的反代注册表 |
后四项是本次新增的开关。**四个都不设置时,行为与 v2.5.0 完全一致**(容器部署不受影响)。
后五项都由本地启动器注入。**都不注入时,行为与 v2.5.0 完全一致**(容器部署不受影响)。
## 3. 本次改动清单
@@ -67,6 +69,7 @@
| `start.sh` | 主入口:探测 → 首次生成配置 → 装依赖 → 起 core + MCP → 守护重启。**后台化**:拉起真正的启动器就返回 |
| `stop.sh` | 停止启动器(按 `supervisor.pid` → core 的父进程 → 占端口的进程,三级兜底),幂等 |
| `config.example.yml` | **仅作参考,不被读取**;实际配置由 `start.sh` 生成到 `config.local.yml` |
| `preview-gateway.js` | 本地 office 预览网关(对位 executor 的 `:3100`,见 §4.15) |
| `README.md` | 给使用者的说明(含安全边界、已知限制) |
`.gitignore` 增加 `local/.runtime/`、`local/config.local.yml`。
@@ -108,7 +111,7 @@
`config.local.yml` 里既有启动器生成的字段(`workspace_root` / `skills_root`),也有用户在网页里
配的东西(`platforms`、API Key、MCP headers)。每次启动重写会直接冲掉后者。
推论:**能力变化不能靠改配置实现**,只能靠 env / 起不起子进程 / 软链(见 4.3、4.4)。
推论:**能力变化不能靠改配置实现**,只能靠 env / 起不起子进程 / 首次复制(见 4.3、4.4)。
### 4.3 ffmpeg 是运行时能力,与配置解耦
@@ -120,21 +123,31 @@
装完 ffmpeg 后**重跑脚本**即生效,配置文件一个字不用改。
### 4.4 技能目录用软链固定指向仓库,不再按 python3 有无切换
### 4.4 技能是工作目录里的副本,不再软链仓库并随 python3 有无切换
配置里永远写 `skills_root: <仓库>/local/.runtime/skills`(首次生成后不覆盖),启动器每次都重建这个
软链,恒指向 `<仓库>/skills`。
用户选的工作目录被拆成三个兄弟目录:
早期版本在「没有 python3」时把它指向一个空目录,想的是“别让模型看到跑不了的工具”。两个问题:
```
<工作目录>/tasks/ 会话工作区(AI 的文件根)
<工作目录>/data/ SQLite、prompt dump
<工作目录>/skills/ 技能 + deps/
```
1. **技能不一定是 Python 的**。`office` 只有 `SKILL.md` + `scripts/office`,模型在 `terminal` 里调
`office <cmd>`,完全不需要 python3——一刀切会把这类技能一并藏掉。
2. **没必要防**。`skills.js` 的 `runEntry` 对 `spawn` 的 `error` 有处理,缺解释器时模型拿到的是
「技能入口启动失败:spawn python3 ENOENT」,干净可读、不崩不挂。模型据此自己装解释器或模块,
装完继续跑即可。
`skills_root` 写死 `<工作目录>/skills`(首次生成后不覆盖)。首次启动时把仓库 `skills/` 里的
**内置技能逐个复制**过去,之后每次启动**只补缺、不覆盖**:
所以现在只有一种行为:技能总是可见;python3 缺失只影响 `run.py` 类技能能否执行。装好 python3 后
(若在 core 启动时 `PATH` 已有的目录里,如 brew 的 `/opt/homebrew/bin`)无需重启即生效,否则重跑脚本。
- 只复制目录,`deps` 不复制(仓库那份是服务器构建期产物,平台/版本都不该跟着走)
- 目标已存在就跳过——用户改过的、AI 自己新建的技能都靠这条保住
- 要拿仓库里的新版:删掉对应子目录再跑一次脚本
这样三个东西同时在位:仓库永远干净(`git status` 无未跟踪用户数据);用户数据一目录备份、
一目录卸载;AI 真能“自己长技能”(新增目录即被发现,`skill list` 实时可见)。
早期版本把 `.runtime/skills` 软链到仓库,导致技能只能写回版本库(与仓库更新抢地盘)。
更早还按 python3 有无切到空目录,想“别让模型看到跑不了的工具”——但技能不一定是 Python 的
(`office` 只要 Node + 二进制),一刀切会把它们一并藏掉;而且 `skills.js` 的 `runEntry` 对
`spawn` 的 `error` 有处理,缺解释器时模型拿到的是「技能入口启动失败:spawn python3 ENOENT」,
干净可读,自己装完继续跑即可。
**没有改 `skills.js` 一行代码。**
@@ -171,11 +184,11 @@
「terminal 写真实 /tmp、file 工具读会话 .tmp」的错位——这正是 `AGENT_FILE_SCOPE=workspace`
要关掉重定向的原因。
### 4.8 `skills_root` 的默认值陷阱
### 4.8 `skills_root` 的默认值
`skills.skills_root` 留空时默认取 `workspace_root` 的**同级** `skills` 目录。本地把
`workspace_root` 指到用户选的目录后,默认值会变成不存在的 `<用户目录>/../skills`。
因此生成的配置必须显式写死 `skills_root`。
`skills.skills_root` 留空时默认取 `workspace_root` 的**同级** `skills` 目录。新的目录布局正好也是
`tasks/` 与 `skills/` 同级,所以留空也能算对;但生成的配置仍然显式写死它——一个字段就能看出
技能到底在哪,不依赖目录推导。
### 4.9 状态页:静态文件 + `meta refresh`,不起 HTTP 服务
@@ -260,8 +273,8 @@ health 只作为「端口上有服务但不是本启动器拉起的」兜底提
`PYTHONPATH`)。本地没有这套东西,`start.sh` 也不去跑 pip——安装时机、镜像源、半成品清理
是另一整套逻辑,收益不抵成本。做法改成「缺了再装」:
- `start.sh` 起 core 时注入 `PYTHONPATH=<仓库>/skills/deps`(**原本就有**)与
`AGENT_SKILLS_DEPS=<仓库>/skills/deps`(新增,只为把路径交给模型)。
- `start.sh` 起 core 时注入 `PYTHONPATH=<工作目录>/skills/deps` 与
`AGENT_SKILLS_DEPS=<工作目录>/skills/deps`(后者只为把路径交给模型)。
`terminal` 与技能子进程都继承 core 的 env,所以装进去的东西**下次运行就能 import**,不用重启。
- `templates/env-local.txt` 把原来的「永远不要自己装任何东西」改成「缺模块就装进
`$AGENT_SKILLS_DEPS` 再重试」——**只给路径,不给命令**,怎么装由模型自己决定。
@@ -289,9 +302,10 @@ health 只作为「端口上有服务但不是本启动器拉起的」兜底提
(报什么错、敲什么),不写背景、不提服务器。起点是 `env-local` 提示词的一句话:技能失败就读
`"$(dirname "$AGENT_SKILLS_DEPS")/<技能>/AGENTS.md"`。装完不需要重启,旧进程不影响。
分两层写,避免四份重复漂移:技能目录的 `AGENTS.md` 只写该技能特有的(缺哪个包、缺什么系统库);
网络类的(pip / npm / GitHub / brew 换源)全局只需要一份,放在技能根目录
`"$(dirname "$AGENT_SKILLS_DEPS")/AGENTS.md"`,各技能的清单末尾指过去。
分两层,各管各的:**技能目录的 `AGENTS.md` 只写该技能特有的**(缺哪个包、缺什么系统库);
**网络换源与长任务这类通用规则不进技能文档**,直接写在 `env-local.txt` 提示词里——
它们必须常驻上下文,靠「出错时去翻文件」是拉不动的(尤其长任务:AI 决定跑 `brew install` 的
那一刻没有任何报错信号触发它去查文档)。
代价明写:`office` 的命令入口在本地不在 PATH 上,按次 `PATH="$SK/scripts:$PATH" office ...` 即可
(这是它 `AGENTS.md` 的第一条)。
@@ -303,14 +317,44 @@ health 只作为「端口上有服务但不是本启动器拉起的」兜底提
| `office` 封装层 ENOENT | 本技能 `AGENTS.md` 绝对路径 |
| `x2pdf` 缺包 / 无渲染后端 | 同上 |
| `image-process` 缺中文字体 | 同上(并提示传 `font`) |
| 网络类(pip / npm / GitHub / brew) | 由技能清单指到技能根目录的 `AGENTS.md`(只有一份) |
| 网络类 / 长任务 | 不进技能文档:写在 `env-local.txt`,常驻上下文 |
唯一保留的环境相关代码是 `x2pdf` 的 `find_soffice()`:`brew install --cask libreoffice` 后
`soffice` 不在 PATH(在 app bundle 内),不探这几个默认位置,“装 LibreOffice 即可”就是假的。
另保留了 WeasyPrint 不可用时回落 LibreOffice,让本地只需一个后端而不是 pango + WeasyPrint 两套链。
没做的是预览:预览卡片要 executor 的 `:3100` 网关,本地没有。要补相当于把
`executor/preview.js` 的槽位管理搬进 core,不值得。
没做的是预览:预览卡片要 executor 的 `:3100` 网关,本地没有——这一项后来补了,见 §4.15。
### 4.15 office 文档预览:本地自建一个薄网关
服务器上「点开 docx」是 core → 反代 `/preview` → executor 的 `:3100` 网关 → 网关按需 spawn
`officecli watch`。本地没有 executor,链路断在中间。补法不是改 core,而是在 `local/` 里放一个
零依赖网关,用 `PREVIEW_PROXIES` 把它登记进 core 的反代注册表(`app/` 一行没改)。
**不复用 `executor/preview.js`**:那套 `unshare --mount --pid` + `nsenter` + `mount --bind` 是为
「让沙箱内的命令和 watch 看见同一个世界」造的(vendor 靠 `TMPDIR` 下的句柄文件 + 回环 TCP 相互
发现)。本地没有沙箱,命令和 watch 本来就同机同盘,那些系统调用不但用不上,有些平台根本没有。
于是本地网关只剩数据面:
- `/preview/<会话id>/<相对路径>` → 解析真实文件 → 确保有 watch → 剥前缀转发
- `/`、`/events`(SSE)与 `/api/*` → 按 `Referer` 认领槽位转发(`/` 尤其关键:vendor 把根绝对
`/` 当「自身最新 HTML」比对,回 404 它就 `location.reload()`,用户看到的是白屏后重载)
- 4 个槽位,LRU 挤占 + 闲置回收;watch 端口从 26315 起按代轮转,跳过已被占用的
- 就绪 = 真发一次 `GET /`(首帧渲染在那次请求里完成);裸 TCP 连上只说明 Kestrel bind 好了
- HEAD 探针等槽位就绪再回 200(有上限):冷启动渲染不落到 iframe 的导航请求上
- 导航请求绝不为启动/自愈阻塞:未就绪或外部改动 → 立刻中转页 + 后台热槽;缺尾斜杠补 301
- 外部写盘靠 mtime 指纹 + 2s 轮询 `POST /api/switch` 触发重读;`__pv-touch` 是编辑命令的事后一脚
- 槽位带活性校验:watch 自己退了就丢掉重起,转发出错也立即摘槽(GET/HEAD 再自愈重试一次)
- 缺 `officecli` 时给「安装说明页」,而不是无限转圈:服务器那份二进制是构建期必装的,
`preview.js` 从没为「没装」设计;本地全新 clone 一定没有,这是常态不是异常
于是本地 `office` 的体验与服务器一致:`create`/`open` 后聊天里出预览卡片,点开即右侧预览,
`get-pos` 能读到选区。技能侧因此不需要任何本地分支(`skills/office` 与服务器同源)。
平台差异都收在两处:进程回收(POSIX 杀进程组 / Windows `taskkill /T`)、二进制解析(`.exe`、
POSIX 补 `chmod +x`、`officecli-*` 资产名也认)。其余只用 Node 内置能力。
已知:watch 没有 `--host` 参数,只能绑 `0.0.0.0`(与 `mcp_asr` 同类);网关与 core 只在回环上。
## 5. 验证结果(macOS 12.7.6 / x86_64 / Node 22.21 / python3 3.10 / 本机无 ffmpeg)
@@ -319,10 +363,10 @@ health 只作为「端口上有服务但不是本启动器拉起的」兜底提
| 项 | 结果 |
|---|---|
| 首次启动:生成配置 → 装依赖(app 134 包,image_task / video_task 各 127 包)→ 起 MCP + core → 打开状态页(停在「已启动」,等点击) | 通过 |
| 配置内容:`workspace_root` 是选的目录、`data_root` 指仓库 `data/`、`skills_root` 指 `local/.runtime/skills`、`platforms: []`、MCP 端口 8091~8094 | 通过 |
| 配置内容:`workspace_root` = `<选定目录>/tasks`、`data_root` = `<选定目录>/data`、`skills_root` = `<选定目录>/skills`(内置技能已复制)、`platforms: []`、MCP 端口 8091~8094 | 通过 |
| 绑定地址:`lsof` 只有 `127.0.0.1:8090` | 通过 |
| 设置页「重启」→ 守护拉起:PID 变化,2 秒内 `/api/health` 恢复 | 通过 |
| 文件工具越出会话目录:工作目录根的 `probe.txt` 可读 | 通过 |
| 文件工具限定在 `<工作目录>/tasks/` 下:放进 `tasks/` 的 `probe.txt` 可读,`<工作目录>/data/` 报路径越界 | 待复测 |
| 越界保护:`read_file ~/.ssh/config`、`terminal cd /etc` 均报「路径越界」 | 通过 |
| `/tmp` 一致性:`write_file /tmp/x` → `terminal cat /tmp/x` 与 `read_file /tmp/x` 内容一致 | 通过 |
| 无 ffmpeg:`/api/asr/status` = `enabled:false`(麦克风隐藏),asr 子进程不启动,8094 不监听 | 通过 |
@@ -342,6 +386,17 @@ health 只作为「端口上有服务但不是本启动器拉起的」兜底提
| 无 node(PATH 里剥掉 node/npm):入口直接拦下,**不** 先让选目录、不生成配置;终端打出安装方式;状态页列出自检项(X Node.js / X npm) | 通过 |
| 失败时只开一个状态页标签(不再两个) | 通过 |
| 状态页:启动即弹出、每秒刷新、显示步骤/计时/日志尾巴;失败时保留错误与日志 | 通过 |
| 预览网关(直接打网关,临时 tasks 根):HEAD 探针 200、GET 200、自动起 watch @26315 | 通过 |
| 预览数据面:`/events` 是真 SSE、`/api/selection` 204、`/api/send` 200;无 `Referer` 404 | 通过 |
| 缺 `officecli`:给安装说明页,HEAD 仍 200(面板不闪死链) | 通过 |
| 网关退出:watch 端口释放,无残留进程 | 通过 |
| 冷 HEAD 等首帧(3.3s)回 200;随后热导航 10ms 拿到页面 | 通过 |
| vendor 的根绝对 `/`(带 Referer):200 且与页面 HTML 逐字节相同(不再触发 `location.reload()` 白屏) | 通过 |
| 冷启动导航:2.7ms 回中转页(不等启动),4 秒后刷新即真页面 | 通过 |
| 缺尾斜杠导航:301 到带斜杠的页面 | 通过 |
| `__pv-touch`:命中活槽位 → `{"touched":true}`;外部 `touch` 文件 → 2s 轮询 POST `/api/switch` → SSE 收到 `"action":"full"` | 通过 |
| 槽位自愈:`kill -9` 掉 watch 后再请求,自动在下一代端口重起(26315 → 26316),页面照常返回 | 通过 |
| 经 core 的 `/preview` 端到端(含手选工作目录、`work_dir` 在 `tasks/` 外的会话) | 待复验 |
| `osascript` 真实选目录弹窗 | 未验证(用桩跑的「没选→回落 `~/AgentWork`」分支) |
| 真浏览器打开(`open`) | 未验证(用桩记录了被打开的 URL) |
| 装 ffmpeg 之后:`ASR_URL` 注入、asr 子进程与麦克风一起出现 | 未验证(本机未装 ffmpeg) |
@@ -382,9 +437,9 @@ tail -f local/.runtime/core.log # 以及 npm-install.log / mcp-*.log
| `mcp_asr` 监听 `0.0.0.0` | 它只认 `PORT` 环境变量、`listen` 不带 host(已启动时才是问题)。不存密钥(上游参数随请求带入),暴露面有限;要收紧需给 `mcp/asr` 加 `--host` 支持 |
| Windows 不支持 | `spawn('/bin/sh')`、`process.kill(-pid)`、模型写的 bash 语法都是 POSIX 语义 |
| 链接只在本机可达 | 本地没有公网前缀:`mint_public_link` / 页面访问地址都签成 `http://127.0.0.1:<PORT>/...`,只能在这台机器上打开(这正是本地形态的预期)。要真正对外暴露才需在设置页填 `public_link.base_url` |
| 技能依赖 | 本地不预装:缺包时模型会把包装进 `skills/deps`(`$AGENT_SKILLS_DEPS`,已在该进程 `PYTHONPATH` 里,装完下次运行即生效);连 `python3` 都没有时也由它自己装。怎么装由模型自己决定。需要系统库的包(`weasyprint`→pango/cairo)pip 装不了,仍需手工 `brew install`。服务器上由 `agent-executor-init` 处理 |
| 技能依赖 | 本地不预装:缺包时模型会把包装进 `<工作目录>/skills/deps`(`$AGENT_SKILLS_DEPS`,已在该进程 `PYTHONPATH` 里,装完下次运行即生效);连 `python3` 都没有时也由它自己装。怎么装由模型自己决定。需要系统库的包(`weasyprint`→pango/cairo)pip 装不了,仍需手工 `brew install`。服务器上由 `agent-executor-init` 处理 |
| `office` 二进制 | 不入库、也不预装:首次用到时报 `binary missing` 并给出该技能 `AGENTS.md` 的绝对路径,模型按它自己下载(`releases/latest`,~34MB,GitHub 慢就用 gh-proxy)。不需要 root、不需重启。officecli 会自更新到 latest,版本比服务器 pin 的新属正常 |
| `office` 预览 | 预览卡片走 core → executor 的 `:3100` 网关,本地没有这个网关 → 点开打不开。文档创建/编辑/读取不受影响 |
| `office` 预览 | 本地网关按需起 `officecli watch`,体验与服务器一致;但 watch 没有 `--host`,只能绑 `0.0.0.0`,且预览进程闲置 6h 回收(槽位 4 个) |
| 首个 `npm install` 要联网 | 支持 `NPM_REGISTRY` 覆盖源;`app/package-lock.json` 的 `resolved` 已改指向公共 registry(原来钉在内网镜像,外部机器必失败) |
## 8. 回滚
@@ -400,10 +455,9 @@ rm -rf local/ # 或保留脚本、只是不用
## 9. 记录:测试残留(都不入库)
跑过启动器之后本机会多出:`local/.runtime/`(日志、状态页、技能软链)、
`local/config.local.yml`、`~/AgentWork/`、`app/node_modules/`、`mcp/image_task|video_task/node_modules/`。
全部在 gitignore 内,不影响仓库;想彻底重来就把它们删掉再跑脚本(会话产出在 `data/` 与
工作目录下的 `task-*` 里,不会被清)。
跑过启动器之后本机会多出:`local/.runtime/`(日志、状态页)、`local/config.local.yml`、
你选的工作目录(`data/` `skills/` `tasks/`)、`app/node_modules/`、`mcp/image_task|video_task/node_modules/`。
仓库里只有前两项,且都在 gitignore 内;用户数据全在工作目录里,删掉它等于彻底重置。
## 10. 新建会话手选工作目录(本地端)
+94 -16
View File
@@ -7,7 +7,7 @@
| 差异 | 服务器 | 本地 |
|---|---|---|
| 命令在哪跑 | `agent-executor` 容器(mount/pid namespace 隔离) | 直接在本机 `spawn`(无沙箱) |
| 文件工具的根 | 会话目录 `tasks/<会话id>/` | 你指定的工作目录 `workspace_root` |
| 文件工具的根 | 会话目录 `tasks/<会话id>/` | 你选的工作目录下的 `tasks/` |
| 监听地址 | `0.0.0.0`(靠宿主机端口映射对外) | `127.0.0.1`(只有本机能访问) |
后两项分别由环境变量 `AGENT_FILE_SCOPE=workspace` 和 `HOST=127.0.0.1` 控制,容器部署不设置,
@@ -24,16 +24,19 @@ cd agent
首次运行会:
1. 自检环境(Node 20+ 必需;ffmpeg / python3 可选),并打开一个**启动状态页**
2. 弹窗让你选一个**工作目录**(AI 会在这个目录里干活)
3. 生成 `local/config.local.yml`
4. 装一次 Node 依赖(`app/` 与带依赖的 MCP,需要联网)
5. 起 core + MCP 子进程(没 ffmpeg 时 asr 不启动)
6. 停在那儿守护:core 退出就自动拉起
2. 弹窗让你选一个**工作目录**,在里面建 `data/`、`skills/`、`tasks/` 三个子目录
3. 把仓库 `skills/` 里的内置技能复制到 `<工作目录>/skills/`
4. 生成 `local/config.local.yml`
5. 装一次 Node 依赖(`app/` 与带依赖的 MCP,需要联网)
6. 起 core + MCP 子进程(没 ffmpeg 时 asr 不启动)
7. 停在那儿守护:core 退出就自动拉起
工作目录是你的:数据库、会话、技能都在里面,仓库里不存任何运行数据。
浏览器里首次使用:**左下角「用户区」→ 设置 → 模型池**,添加平台和 API Key,然后点「重启」。
新建会话时,欢迎页「随时开始吧」下方可以**手选一个工作目录**:选了之后这个会话的 AI 一切操作
都在那个目录里(不再建 `task-*` 子目录);不选就沿用默认(系统工作目录下的独立会话目录)。
都在那个目录里(不再建 `task-*` 子目录);不选就沿用默认(`<工作目录>/tasks/<会话id>`)。
删会话不会删你选的目录。
没有 Node 20+ 时不会让你白选目录:脚本在入口就停下,终端打出安装方式,自检结果(哪项缺、怎么装)写到状态页。
@@ -60,15 +63,73 @@ 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%`。
模型最好用相对路径或会话目录。
## 可选能力
| 能力 | 需要 | 没有时的表现 |
|---|---|---|
| 语音输入 | `ffmpeg` + 设置页给 `asr` 填上游(`X-ASR-Base-Url` / `X-ASR-Model`) | 麦克风入口自动隐藏(`/api/asr/status` 返回 `enabled:false`),`mcp_asr` 子进程也不启动 |
| 技能 | `python3`(仅 Python 类技能需要) | 技能清单照常显示;调 `run.py` 类技能报「入口启动失败」,`office` 这类非 Python 技能不受影响 |
| Office 文档(docx/xlsx/pptx) | 首次用到时下载一次 officecli 二进制(约 34MB) | `office` 报 `binary missing` 并给出该技能 `AGENTS.md` 的路径,按它下载即可(不需 root、不需重启) |
| 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`)就无需重启;
@@ -76,11 +137,21 @@ cd agent
## 配置放哪
- 生成的配置:`local/config.local.yml`(**首次生成,之后永不覆盖**,避免冲掉你在网页里配的模型与密钥)
- 会话数据:`data/`(SQLite + prompt dump)与工作目录下的 `task-YYYYMMDD-NNN/`
- 运行期产物:`local/.runtime/`(`status.html` 状态页、`core.log`、`npm-install.log`、各 MCP 日志、技能软链)
你选的工作目录下:
想彻底重来:删掉 `local/config.local.yml`(以及可选的 `data/`)再启动。会话目录里的产出不会被删。
| 路径 | 内容 |
|---|---|
| `<工作目录>/data/` | SQLite(`.agent.db`)、启动时的 prompt dump |
| `<工作目录>/tasks/` | 会话工作区,一个会话一个 `task-YYYYMMDD-NNN/` |
| `<工作目录>/skills/` | 技能;内置技能首次启动时复制过来,以后只补缺不覆盖。依赖装在 `skills/deps/` |
仓库里只有:
- 生成的配置:`local/config.local.yml`(**首次生成,之后永不覆盖**,避免冲掉你在网页里配的模型与密钥)
- 运行期产物:`local/.runtime/`(`status.html` 状态页、`core.log`、`npm-install.log`、`mcp-*.log`、`preview.log` + `watch-<端口>.log`)
想彻底重来:删掉 `local/config.local.yml` 再启动(工作目录里的数据不会动,重选一个目录就换一套)。
技能要跟着仓库更新:删掉 `<工作目录>/skills/<技能名>` 再启动,脚本会把新版补回来(你自建的技能不受影响)。
## 常用环境变量
@@ -89,6 +160,7 @@ cd agent
| `PORT` | `8090` | core 端口(别撞下面的 MCP 端口) |
| `NPM_REGISTRY` | 空 | 手动指定 npm 源(默认自动探测;指定后不再自动换源) |
| `MCP_WEB_PORT` / `MCP_IMAGE_PORT` / `MCP_VIDEO_PORT` / `MCP_ASR_PORT` | 8091~8094 | 四个 MCP 的端口(同机跑必须各占一个;改这里还要同步改配置里的 url) |
| `PREVIEW_PORT` | `3100` | office 文档预览网关的端口(被占时自动往后找);watch 自己的端口从 26315 起 |
| `AGENT_LOCAL_UI` | `auto` | 是否自动打开状态页:`auto` = 仅 macOS,`1` 强制,`0` 关闭(页面无论如何都会生成) |
| `AGENT_LOCAL_DETACH` | `1` | `1` = 后台启动后立即返回(用 `stop.sh` 停);`0` = 前台阻塞(看实时日志、`Ctrl-C` 停) |
| `AGENT_LOCAL_CACHE` | `~/.cache/agent-local` | 依赖缓存的存放位置(多个 clone 共享) |
@@ -130,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` 不启动(它转码要靠
@@ -142,10 +217,11 @@ git pull
`http://127.0.0.1:<PORT>/...`,在这台机器上点得开,发给别人打不开。要对外暴露再填
`public_link.base_url`(设置页)。本地监听回环地址,模型厂商也拉不到,所以读图回传改走内联
base64(`AGENT_IMAGE_INLINE=1`,启动器已注入)。
- **`office` 文档没有预览**:预览卡片走 core → executor 的 `:3100` 网关,本地没有这个网关,
点开得不到可用页面;文档本身的创建/编辑/读取完全正常。
- **技能依赖不预装**:本地没有 `agent-executor-init`,`skills/*/requirements.txt` 不会在启动时
自动安装。技能缺包时会报 `ModuleNotFoundError`,模型会把缺的包装进 `skills/deps`
- **`office` 预览依赖 `officecli`**:网关按需起 `officecli watch`(最多 4 个,闲置 6 小时回收)。
没装二进制时预览面板会直接显示安装说明,不会无限转圈。watch 只能监听 `0.0.0.0`(它没有
`--host` 参数),同机其它用户理论上能访问那几个端口。
- **技能依赖不预装**:本地没有 `agent-executor-init`,技能自带的 `requirements.txt` 不会在启动时
自动安装。缺包时会报 `ModuleNotFoundError`,模型会把缺的包装进 `<工作目录>/skills/deps`
(`AGENT_SKILLS_DEPS` 指向它,且已在该进程的 `PYTHONPATH` 里,装完下次运行即生效)。
连 `python3` 都没有时技能清单依旧完整,模型会自己把它装上再继续。
需要系统库的包(如 `weasyprint` 依赖 pango/cairo)pip 装不了,得自己 `brew install`。
@@ -161,6 +237,7 @@ open local/.runtime/status.html # 启动状态页:步骤、失败原因
tail -f local/.runtime/core.log # core 日志(含 prompt dump 路径、MCP 发现结果)
tail -f local/.runtime/npm-install.log # 装依赖的输出
tail -f local/.runtime/mcp-asr.log # 单个 MCP 的日志
tail -f local/.runtime/preview.log # office 预览网关(watch 启动失败的原因也在这)
```
启动失败时状态页会自己弹出(带错误说明和日志尾部);它是个静态页,所以改完环境要自己重跑脚本
@@ -170,4 +247,5 @@ tail -f local/.runtime/mcp-asr.log # 单个 MCP 的日志
```bash
lsof -nP -iTCP:8090-8094 -sTCP:LISTEN # core + 四个 MCP 的监听情况
lsof -nP -iTCP:3100 -sTCP:LISTEN # 预览网关(没用 office 时不存在)
```
+9 -7
View File
@@ -8,16 +8,18 @@
port: 8090
# AI 的工作根。local 模式注入 AGENT_FILE_SCOPE=workspace 后,文件工具可读写这个目录下任何位置。
workspace_root: /Users/you/AgentWork
# 你选的工作目录下的三个子目录:tasks(会话工作区)、data(数据库等)、skills(技能)。
# SQLite(.agent.db)与启动 prompt dump。默认指到仓库里的 data/(已在 .gitignore)。
data_root: /path/to/agent/data
# AI 的工作根:文件工具的根就是它,AI 看不到同级的 data/ 与 skills/。
workspace_root: /Users/you/AgentWork/tasks
# SQLite(.agent.db)与启动 prompt dump。
data_root: /Users/you/AgentWork/data
skills:
# 指向 local/.runtime/skills —— 启动脚本按「python3 是否可用」把它软链到真技能目录或空目录,
# 因此装不装 python3 都不需要改这里,改完重跑启动脚本即生效。
skills_root: /path/to/agent/local/.runtime/skills
# 技能根。首次启动时从仓库 skills/ 复制内置技能过来,之后只补缺不覆盖;
# pip 装的依赖落在同级的 deps/。
skills_root: /Users/you/AgentWork/skills
# 留空:启动后到设置页添加平台与 API Key,再点「重启」(启动器负责把进程拉起来)。
platforms: []
+718
View File
@@ -0,0 +1,718 @@
#!/usr/bin/env node
// local/preview-gateway.js —— 本地 office 文档预览网关(对位服务器上 executor 的 :3100)。
//
// 为什么要有它:服务器上「点开 docx」这条链是 core → 反代 /preview → executor 预览网关 →
// 网关自己按需 spawn `officecli watch`。本地没有 executor,那条链路会断,面板里是个空 iframe。
// 这里用零依赖 Node 复刻 executor/preview.js 的**数据面**,但不复刻它的隔离层:
// 服务器给 watch 造 pid/mount ns 牢笼、bind 会话 .tmp 到 /tmp,是为了让**沙箱里的命令**
// 和 watch 看见同一个世界(vendor 用 TMPDIR 下的 .port 文件 + TCP 回环发现彼此)。
// 本地既没有沙箱,命令和 watch 本来就在同一个文件系统、同一个临时目录里,
// 那些 unshare/nsenter 不但用不上,有些平台上根本不存在。于是这里只剩数据面:
//
// 1. /preview/<会话id>/<相对路径>/ → 解析成真实文件 → 确保它有 watch → 转发
// 2. 页内数据面(/events、/api/*、以及 vendor 拿去比对自身的 /)→ 按 Referer 认领槽位转发
// 3. 槽位:最多 N 个并发 watch,挤占最久未用的,闲置回收
// 4. 缺 officecli 时给人能看懂的一页,而不是无限转圈(服务器那份二进制是构建期必装的,
// 所以 executor 那份没为「没装」设计过;本地全新 clone 一定没有,这是常态不是异常)
//
// 与服务器实现逐条对齐的几处(都踩过,别简化掉):
// - 探活 = 真发一次 `GET /`(首帧渲染就在这次请求里完成),裸 TCP 连上只说明 Kestrel bind 好了
// - HEAD 探针等槽位就绪(有上限)再回 200:否则冷启动的首次渲染全砸在 iframe 的导航请求上
// - 导航请求绝不为启动/自愈阻塞首字节:未就绪 → 立刻回中转页 + 后台热槽
// - vendor 页把 `/` 当作「自身最新 HTML」来比对,回 404 它就 location.reload() —— 用户看到白屏
// - 外部写盘(不走 officecli 的)靠 mtime 指纹 + 2s 轮询 POST /api/switch 触发重读
//
// 平台:只用 Node 内置能力,进程回收/二进制名/可执行位都按平台分支,不假设 POSIX。
// 监听回环(默认 127.0.0.1:3100),唯一入口仍是 core 的 /preview 反代(登录门禁在那边)。
'use strict';
const fs = require('node:fs');
const fsp = require('node:fs').promises;
const http = require('node:http');
const net = require('node:net');
const path = require('node:path');
const { spawn } = require('node:child_process');
const WIN = process.platform === 'win32';
const HOST = process.env.OFFICE_PREVIEW_HOST || '127.0.0.1';
const PORT = Number(process.env.OFFICE_PREVIEW_PORT || 3100);
const PREFIX = (process.env.OFFICE_PREVIEW_PREFIX || '/preview').replace(/\/+$/, '');
const SLOTS = Math.max(1, Number(process.env.OFFICE_SLOTS || 4));
const WATCH_BASE = Number(process.env.OFFICE_WATCH_BASE || 26315);
const WATCH_SPAN = Math.max(SLOTS, Number(process.env.OFFICE_WATCH_SPAN || 64));
const IDLE_MS = Number(process.env.OFFICE_IDLE_MS || 6 * 3600 * 1000);
const RESPOND_TIMEOUT_MS = Number(process.env.OFFICE_RESPOND_TIMEOUT_MS || 15000); // 数据请求等首响包
const NAV_TIMEOUT_MS = Number(process.env.OFFICE_NAV_TIMEOUT_MS || 5000); // 导航请求更短:失败转中转页
const COOLDOWN_MS = Number(process.env.OFFICE_COOLDOWN_MS || 8000); // 启动失败后短期不再重试
const HEAD_WAIT_MS = Number(process.env.OFFICE_HEAD_WAIT_MS || 15000); // 探针等首帧的上限
const NAV_TIMEOUT_RETRIES = 3; // 连续导航超时几次才判死
// 会话真实目录:默认 <tasks 根>/<会话id>;手选过工作目录的会话要问 core 拿 work_dir(本地免鉴权)。
const TASKS_ROOT = path.resolve(process.env.AGENT_TASKS_ROOT || process.cwd());
const SKILLS_ROOT = path.resolve(process.env.AGENT_SKILLS_ROOT || path.join(TASKS_ROOT, '..', 'skills'));
const REPO_ROOT = path.resolve(process.env.AGENT_REPO_ROOT || path.join(__dirname, '..'));
const RUNTIME = path.resolve(process.env.AGENT_RUNTIME || path.join(__dirname, '.runtime'));
const CORE_URL = process.env.AGENT_CORE_URL || '';
const EXTS = new Set(['.docx', '.xlsx', '.pptx']);
const SID_RE = /^task-[0-9A-Za-z_-]+$/;
const slots = new Map(); // 文件绝对路径 → { file, port, watch, pageDec, ready, readyP, lastUsed, conns, ... }
const starting = new Map(); // 文件绝对路径 → Promise:同文件并发请求合并成一次 spawn
const cooldown = new Map(); // 文件绝对路径 → 冷却截止时间戳
const dirCache = new Map(); // 会话id → 真实目录(只缓存命中,避免会话晚建时永久失效)
let watchGen = 0; // watch 端口按代轮转:残留孤儿占着旧口也不会被新槽撞上
const log = (msg) => process.stdout.write(new Date().toISOString() + ' ' + msg + '\n');
// ---------- 小工具 ----------
function escapeHtml(s) {
return String(s).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
}
// 二进制解析:每次 spawn 时才做——AI 按技能 AGENTS.md 装好之后,用户点一下刷新就该能用,不该要求重启网关。
// 名字不一定是 officecli:官方资产叫 officecli-<平台>-<架构>[.exe],AI 很可能原样下载,所以标准名之后
// 再认同目录里任何 officecli* 可执行文件。可执行位只在 POSIX 上有意义,且 curl 下来的资产常常是 0644,
// 这里顺手补一下(不能要求调用者先 chmod)。
function executable(p) {
if (WIN) {
try { return fs.statSync(p).isFile(); } catch (_) { return false; }
}
try { fs.accessSync(p, fs.constants.X_OK); return true; } catch (_) {}
try { fs.chmodSync(p, 0o755); fs.accessSync(p, fs.constants.X_OK); return true; } catch (_) { return false; }
}
function binDirs() {
return [path.join(SKILLS_ROOT, 'office', 'bin'), path.join(REPO_ROOT, 'skills', 'office', 'bin')];
}
function resolveBin() {
const env = String(process.env.OFFICECLI_BIN || '').trim();
if (env && executable(env)) return env;
const std = WIN ? ['officecli.exe', 'officecli'] : ['officecli'];
const dirs = binDirs();
for (const d of dirs) {
for (const n of std) {
const p = path.join(d, n);
if (executable(p)) return p;
}
}
for (const d of dirs) {
let list = [];
try { list = fs.readdirSync(d).sort(); } catch (_) { continue; }
for (const n of list) {
if (!/^officecli/i.test(n)) continue;
if (WIN ? !/\.exe$/i.test(n) : /\.(?:log|txt|md|zip|tar|gz|sha\d*)$/i.test(n)) continue;
const p = path.join(d, n);
if (executable(p)) return p;
}
}
return null;
}
// 端口能不能连上(判「有没有人在听」)。注意它**不能**当就绪判定:Kestrel bind 完成就能连,
// 首帧还没渲染;就绪一律用 portUp(真发一次 GET /)。
function portListening(port) {
return new Promise((resolve) => {
const s = net.connect({ host: '127.0.0.1', port, timeout: 800 });
let done = false;
const fin = (v) => { if (done) return; done = true; try { s.destroy(); } catch (_) {} resolve(v); };
s.once('connect', () => fin(true));
s.once('timeout', () => fin(false)); // 回环上不回 SYN 几乎不存在,按空闲处理
s.once('error', () => fin(false));
});
}
// 就绪探活:真发一次 `GET /`(首帧渲染在这次请求里完成,后续浏览器请求走 vendor 的页内缓存)。
// 任何状态码都算活着;拒连/超时继续重试,预算 40 次 x 250ms。
function portUp(port, tries = 40) {
return new Promise((resolve, reject) => {
let n = 0;
const probe = () => {
const rq = http.get({ host: '127.0.0.1', port, path: '/', timeout: 2000 }, (up) => {
up.resume();
resolve();
});
const retry = () => {
if (++n >= tries) return reject(new Error('watch 未在预期时间内就绪'));
setTimeout(probe, 250);
};
rq.on('error', retry);
rq.on('timeout', () => { try { rq.destroy(); } catch (_) {} retry(); });
};
probe();
});
}
// 端口代次轮转 + 领取前确认空闲:AI 手动起的 watch、以及被杀的旧 watch 残留,都占着固定口。
async function allocPort() {
for (let i = 0; i < WATCH_SPAN; i++) {
const p = WATCH_BASE + (watchGen++ % WATCH_SPAN);
let used = false;
for (const s of slots.values()) if (s.port === p) { used = true; break; }
if (used) continue;
if (!(await portListening(p))) return p;
}
throw new Error('没有空闲的 watch 端口(' + WATCH_BASE + '~' + (WATCH_BASE + WATCH_SPAN - 1) + ')');
}
// 回收 watch:POSIX 上它自成进程组(detached),按组杀才不会留下占端口的子进程;
// Windows 没有进程组信号,用 taskkill /T 连子树一起收。
function killTree(child) {
if (!child || !child.pid) return;
if (WIN) {
try { spawn('taskkill', ['/pid', String(child.pid), '/T', '/F'], { stdio: 'ignore', windowsHide: true }); return; } catch (_) {}
} else {
try { process.kill(-child.pid, 'SIGKILL'); return; } catch (_) {}
}
try { child.kill('SIGKILL'); } catch (_) {}
}
function killWatch(entry) {
// 已退出的进程不再按 pid 杀:pid 可能已被系统回给别的进程组(POSIX 上是 -pid)
if (entry.watch && entry.watch.exitCode === null && entry.watch.signalCode === null) killTree(entry.watch);
}
function stopEntry(entry, why) {
const key = entry.file;
if (slots.get(key) === entry) slots.delete(key);
killWatch(entry);
if (why) log('回收槽位 ' + path.basename(key) + '(' + why + ')');
}
// ---------- 页面 ----------
function htmlPage(res, title, body, autoRefresh, code) {
const html = '<!doctype html><html lang="zh-CN"><head><meta charset="utf-8">' +
'<title>' + escapeHtml(title) + '</title>' +
(autoRefresh ? '<meta http-equiv="refresh" content="' + autoRefresh + '">' : '') +
'<style>body{font-family:-apple-system,system-ui,sans-serif;margin:0;padding:40px;line-height:1.7;color:#222}' +
'h1{font-size:18px;margin:0 0 12px}code{background:#f2f2f2;padding:1px 5px;border-radius:3px;font-size:13px}' +
'p{margin:8px 0;max-width:46em;color:#444}</style></head><body>' +
'<h1>' + escapeHtml(title) + '</h1>' + body + '</body></html>';
res.writeHead(code || 200, { 'content-type': 'text/html; charset=utf-8', 'cache-control': 'no-store' });
res.end(html);
}
// 中转页:槽位在启动/刚死,先给浏览器一个纯 CSS 转圈 + 自动刷新,别白屏干等(与服务器同一张页)。
function loading(res) {
res.writeHead(200, { 'content-type': 'text/html; charset=utf-8', 'cache-control': 'no-store' });
res.end('<!doctype html><meta charset="utf-8"><meta http-equiv="refresh" content="2">' +
'<title>正在准备预览</title><style>' +
'html,body{height:100%;margin:0;font-family:system-ui,-apple-system,sans-serif;background:#fafafa;color:#666}' +
'.w{position:absolute;top:50%;left:50%;transform:translate(-50%,-50%);text-align:center}' +
'.s{width:36px;height:36px;margin:0 auto 14px;border:3px solid #ddd;border-top-color:#4a90d9;border-radius:50%;animation:r 1s linear infinite}' +
'@keyframes r{to{transform:rotate(360deg)}}p{font-size:14px}' +
'</style><div class="w"><div class="s"></div><p>正在准备预览,请稍候。</p></div>');
}
function installPage(res) {
const bin = path.join(SKILLS_ROOT, 'office', 'bin', WIN ? 'officecli.exe' : 'officecli');
htmlPage(res, 'office 预览组件未安装',
'<p>预览需要 <code>officecli</code> 二进制,这台机器上还没有。</p>' +
'<p>它应该放在 <code>' + escapeHtml(bin) + '</code>。</p>' +
'<p>让 AI 打开一次这个文档即可(说「用 office 打开这个文档」)——它会按技能目录里的 ' +
'<code>AGENTS.md</code> 自己下载好;装完点下面的按钮刷新,不用重启服务。</p>' +
'<p><button onclick="location.reload()">刷新</button></p>');
}
function notFound(res) {
// no-store:前端拿 HEAD 当探针,404 一旦被浏览器缓存,文件补上后还会继续显示「暂无文档」
res.writeHead(404, { 'content-type': 'text/plain; charset=utf-8', 'cache-control': 'no-store' })
.end('无匹配预览(文档不存在、不在会话目录下,或不是 .docx/.xlsx/.pptx)');
}
function fail502(res) {
if (!res.headersSent) {
res.writeHead(502, { 'content-type': 'text/plain; charset=utf-8' }).end('预览暂时不可用,请稍后重试');
}
}
// ---------- 会话目录与路径护栏 ----------
function coreGet(pathname) {
return new Promise((resolve, reject) => {
if (!CORE_URL) return reject(new Error('未配置 AGENT_CORE_URL'));
const u = new URL(CORE_URL);
const req = http.request({ host: u.hostname, port: u.port, path: pathname, method: 'GET', timeout: 3000 }, (res) => {
let body = '';
res.setEncoding('utf8');
res.on('data', (c) => { body += c; });
res.on('end', () => {
if (res.statusCode !== 200) return reject(new Error('core ' + res.statusCode));
try { resolve(JSON.parse(body)); } catch (e) { reject(e); }
});
});
req.on('error', reject);
req.on('timeout', () => { req.destroy(new Error('core 超时')); });
req.end();
});
}
async function sessionDir(sid) {
if (dirCache.has(sid)) return dirCache.get(sid);
const plain = path.join(TASKS_ROOT, sid);
let dir = fs.existsSync(plain) ? plain : '';
if (!dir) {
// 手选工作目录的会话:只有 core 知道真实路径(sessions.work_dir)。
// 接口回的是 { session, ... },limit=1 只为别把整段历史拉回来。
try {
const row = await coreGet('/api/sessions/' + encodeURIComponent(sid) + '?limit=1');
const wd = String((row && row.session && row.session.work_dir) || '');
if (wd && fs.existsSync(wd)) dir = wd;
} catch (_) { /* core 没起来 / 会话不存在:下面按缺失处理 */ }
}
if (dir) dirCache.set(sid, dir);
return dir;
}
// /preview/<会话id>/<相对路径> → { sid, dir, abs, rel };越界(..、绝对路径)与非办公文档一律 null。
async function guard(sid, rawRel) {
if (!SID_RE.test(sid)) return null;
const dir = await sessionDir(sid);
if (!dir) return null;
const rel = rawRel.replace(/^\/+/, '');
const abs = path.resolve(dir, rel);
if (abs !== dir && !abs.startsWith(dir + path.sep)) return null;
if (!EXTS.has(path.extname(abs).toLowerCase())) return null;
try { await fsp.access(abs); } catch (_) { return null; }
return { sid, dir, abs, rel: path.relative(dir, abs).split(path.sep).join('/') };
}
function pageOf(t) {
return '/' + t.sid + '/' + t.rel; // 页面前缀(已解码):槽位按它寻址
}
// 路由:rel = 已解码、剥掉 PREFIX 的请求路径(形如 /task-x/doc.docx/…);最长前缀优先。
// exact = 命中的就是页面本身(此时缺尾斜杠要 301,否则页面内相对资源会解析错)。
function matchPage(rel) {
if (!rel) return null;
const rr = rel.startsWith('/') ? rel : '/' + rel;
const cut = rr.replace(/\/+$/, '');
let best = null;
for (const s of slots.values()) {
if (cut === s.pageDec) return { entry: s, exact: true };
if (cut.startsWith(s.pageDec + '/')) {
if (!best || s.pageDec.length > best.entry.pageDec.length) best = { entry: s, exact: false };
}
}
return best;
}
// ---------- watch 生命周期 ----------
async function spawnWatch(t) {
const bin = resolveBin();
if (!bin) {
const e = new Error('缺少 officecli 二进制');
e.code = 'MISSING_BIN';
throw e;
}
// 槽满:优先踢「就绪且无活动连接」里最久未用的;正在启动的槽最后才动(踢掉它等于白费冷启动)
if (slots.size >= SLOTS) {
const list = [...slots.values()];
const pick = (list.filter((s) => !s.conns && s.ready).length ? list.filter((s) => !s.conns && s.ready)
: list.filter((s) => !s.conns).length ? list.filter((s) => !s.conns) : list)
.sort((a, b) => a.lastUsed - b.lastUsed)[0];
if (pick) stopEntry(pick, '槽满挤占');
}
const port = await allocPort();
try { await fsp.mkdir(RUNTIME, { recursive: true }); } catch (_) {}
const logPath = path.join(RUNTIME, 'watch-' + port + '.log');
const fd = fs.openSync(logPath, 'a');
const child = spawn(bin, ['watch', t.abs, '--port', String(port)], {
cwd: t.dir,
detached: !WIN, // POSIX:自成进程组便于整组回收;Windows 靠 taskkill /T
windowsHide: true,
stdio: ['ignore', fd, fd],
env: Object.assign({}, process.env, {
// 与技能封装层同一组开关:不变式模式跑 .NET、改动即落盘、关自动 resident
DOTNET_SYSTEM_GLOBALIZATION_INVARIANT: '1',
OFFICECLI_NO_AUTO_RESIDENT: '1',
OFFICECLI_RESIDENT_FLUSH: 'each',
}),
});
try { fs.closeSync(fd); } catch (_) {}
const entry = {
file: t.abs, port, watch: child, pageDec: pageOf(t),
lastUsed: Date.now(), conns: 0, ready: false, readyP: null, navTimeouts: 0,
mtimeMs: 0, size: -1, logPath,
};
let exited = null;
child.on('exit', (code, sig) => {
exited = { code, sig };
if (slots.get(entry.file) === entry) slots.delete(entry.file); // 死了就别留在册(否则一直转发到死端口)
});
child.on('error', (e) => { exited = { code: -1, sig: String((e && e.message) || e) }; });
slots.set(entry.file, entry); // 同步占坑(未就绪):并发请求等 readyP,绝不盲转发
let markDead;
const dead = new Promise((_, rej) => { markDead = rej; });
const deadTimer = setInterval(() => { if (exited) markDead(new Error('watch 进程提前退出')); }, 100);
deadTimer.unref();
entry.readyP = Promise.race([
portUp(port).then(() => { entry.ready = true; log('起 watch ' + path.basename(t.abs) + ' @' + port); }),
dead,
]).catch((e) => {
if (slots.get(entry.file) === entry) slots.delete(entry.file);
killWatch(entry);
throw e instanceof Error ? e : new Error('watch 启动失败:' + ((e && e.message) || e));
}).finally(() => clearInterval(deadTimer));
try {
await entry.readyP;
} catch (e) {
let tail = '';
try { tail = fs.readFileSync(logPath, 'utf8').split('\n').slice(-3).join(' | ').trim(); } catch (_) {}
const err = new Error(e.message + (tail ? ':' + tail : ''));
err.logPath = logPath;
throw err;
}
// mtime+size 作为本次渲染的指纹:导航侧对照,外部写盘后回收重渲染
try { const st = await fsp.stat(t.abs); entry.mtimeMs = st.mtimeMs; entry.size = st.size; } catch (_) {}
return entry;
}
async function startWatch(t) {
const have = slots.get(t.abs);
if (have) { have.lastUsed = Date.now(); return have; }
const cool = cooldown.get(t.abs);
if (cool && Date.now() < cool) throw new Error('刚才启动失败,稍后再试');
if (starting.has(t.abs)) return starting.get(t.abs);
const p = spawnWatch(t).then(
(entry) => { starting.delete(t.abs); cooldown.delete(t.abs); return entry; },
(err) => {
starting.delete(t.abs);
cooldown.set(t.abs, Date.now() + COOLDOWN_MS);
log('watch 启动失败 ' + t.abs + ':' + err.message);
throw err;
},
);
starting.set(t.abs, p);
return p;
}
// 未命中兜底:请求路径本身就是存在的会话文档 → 就地冷启动。不行 = null。
async function revive(decRel) {
const rr = (decRel || '').replace(/\/+$/, '');
if (!rr) return null;
const segs = rr.split('/').filter(Boolean);
const sid = segs.shift() || '';
const t = await guard(sid, segs.join('/'));
if (!t) return null;
try { await startWatch(t); return { entry: slots.get(t.abs), exact: false }; } catch (_) { return null; }
}
// 数据请求用:拿到「就绪」的槽位,等正在启动的那次;启动刚失败就再补一次。
async function waitReady(decRel) {
for (let round = 0; round < 2; round++) {
let m = matchPage(decRel);
if (!m) m = await revive(decRel);
if (!m || !m.entry) return null;
if (m.entry.ready) return m;
await m.entry.readyP.catch(() => {});
if (m.entry.ready) return m;
}
return null;
}
// 探针预热:把槽位等到「就绪」(= 首帧渲染完成),复用时直接返回。任何失败/超时都静默。
async function warmSlot(decRel, t) {
let timer;
try {
await Promise.race([
(async () => {
const have = slots.get(t.abs);
if (have && have.ready) return;
const e = await startWatch(t);
if (!e.ready) await e.readyP.catch(() => {});
})(),
new Promise((r) => { timer = setTimeout(r, HEAD_WAIT_MS); }),
]);
} catch (_) {} finally { clearTimeout(timer); }
}
// 就地重读:POST watch /api/switch(同路径 = 强制从磁盘重载),watch 原生推 doc-switched,页面自刷。
function notifySwitch(entry) {
try {
const q = http.request({ host: '127.0.0.1', port: entry.port, path: '/api/switch', method: 'POST', timeout: 8000,
headers: { 'content-type': 'application/json' } }, (up) => { up.resume(); });
q.on('error', () => {});
q.on('timeout', () => { try { q.destroy(); } catch (_) {} });
q.end(JSON.stringify({ file: entry.file }));
} catch (_) {}
}
// ---------- 转发 ----------
const PASS_HEADERS = new Set(['accept', 'accept-encoding', 'cache-control', 'pragma', 'content-type',
'content-length', 'if-modified-since', 'if-none-match', 'last-event-id', 'referer', 'user-agent']);
// 单次转发:拒连/首响应超时 → reject(此时尚未向浏览器写出任何字节,可安全改道);
// 已出字节的流内失败只能毁掉响应(SSE 长流的正常路径不受看门狗影响)。
function tryForward(entry, req, res, innerPath, respondTimeoutMs) {
return new Promise((resolve, reject) => {
const selfHost = '127.0.0.1:' + entry.port;
const headers = {};
for (const k of Object.keys(req.headers)) if (PASS_HEADERS.has(k)) headers[k] = req.headers[k];
// watch 的同源校验只认回环:从别的名字(host 名解析到 127.0.0.1)打开 core 时会被 403
if (req.headers.origin) headers.origin = 'http://' + selfHost;
const search = req.url.indexOf('?') >= 0 ? req.url.slice(req.url.indexOf('?')) : '';
const inner = innerPath.startsWith('/') ? innerPath : '/' + innerPath;
entry.lastUsed = Date.now();
entry.conns = (entry.conns || 0) + 1;
let released = false;
const release = () => { if (!released) { released = true; entry.conns = Math.max(0, entry.conns - 1); } };
res.once('close', release);
res.once('finish', release);
let started = false;
let upRes = null;
const upstream = http.request(
{ host: '127.0.0.1', port: entry.port, path: encodeURI(inner) + search, method: req.method, headers },
(up) => {
started = true;
upRes = up;
clearTimeout(watchdog);
const h = Object.assign({}, up.headers);
delete h.connection; delete h['keep-alive'];
const isSSE = String(h['content-type'] || '').includes('text/event-stream');
if (isSSE) { h['cache-control'] = 'no-cache'; h['x-accel-buffering'] = 'no'; }
res.writeHead(up.statusCode || 502, h);
up.on('data', (d) => {
entry.lastUsed = Date.now();
// 抓到「真改文档」的原生推送(牢笼内 CLI 编辑会推 excel-patch/full 等):给轮询器一个吸收窗口。
// 只认改文档的 action —— selection-update/mark-update 是 UI 态,把页内编辑的救场 switch 也吸掉就永不刷新了
if (isSSE && /"action":"(?:full|excel-patch|word-patch|replace|add|remove)"/.test(String(d))) entry.lastNative = Date.now();
});
up.pipe(res);
resolve();
});
const watchdog = setTimeout(() => {
if (started) return;
try { upstream.destroy(); } catch (_) {}
release();
if (!res.headersSent) reject(new Error('watch 响应超时'));
}, respondTimeoutMs || RESPOND_TIMEOUT_MS);
upstream.on('error', () => {
clearTimeout(watchdog);
release();
if (!started && !res.headersSent) return reject(new Error('watch 不可达'));
// 已开始回写后上游报错:留一拍再判(watch 会在响应其实已完整时断链,对 HEAD 必现)
setTimeout(() => {
if (res.writableEnded) return;
try { res.destroy(); } catch (_) {}
}, upRes && upRes.complete ? 0 : 120);
});
req.pipe(upstream);
});
}
// 转发自愈一次:失败 → 摘槽 → 同页原地复活 → 重试。GET/HEAD 才可重试(无请求体,重放无副作用)。
async function forwardHealed(entry, req, res, innerPath) {
try { await tryForward(entry, req, res, innerPath); return true; }
catch (e) {
stopEntry(entry, '转发失败:' + String((e && e.message) || e));
if (res.headersSent || !/^(GET|HEAD)$/.test(req.method)) return false;
await new Promise((r) => setTimeout(r, 400)); // 给内核回收旧 listen 套接字留个极短窗口
const m2 = await waitReady(entry.pageDec);
if (!m2 || !m2.entry) return false;
try {
await tryForward(m2.entry, req, res, innerPath);
return true;
} catch (_) { return false; }
}
}
// 槽位过期:外部(非 officecli)写盘改的是文件,watch 内存里的渲染不感知 → 导航时比对指纹回收重渲染
function fileChanged(entry) {
try {
const st = fs.statSync(entry.file);
return st.mtimeMs !== entry.mtimeMs || st.size !== entry.size;
} catch (_) { return false; }
}
// 浏览器导航请求判定:只有地址栏/iframe 直开页面带 text/html
function isNav(req) {
return req.method === 'GET' && /text\/html/.test(String(req.headers.accept || ''));
}
// 数据请求(资源/API/SSE/Referer 兜底):按 Referer 找回来源页面
function refererRel(req) {
const ref = req.headers.referer || req.headers.referrer || '';
if (!ref) return null;
try {
const rp = decodeURIComponent(new URL(ref).pathname);
if (!rp.startsWith(PREFIX + '/')) return null;
return rp.slice(PREFIX.length);
} catch (_) { return null; }
}
// ---------- 编辑命令的事后一脚 ----------
// office 封装层改动成功后 fire-and-forget 打这里(本地没有沙箱,原生通知本来就能到 watch;
// 这一脚是无害的补强,也让行为与服务器保持一致)。
function handleTouch(req, res) {
let body = '';
req.on('data', (d) => { body += d; if (body.length > 4096) req.destroy(); });
req.on('end', () => {
let f = '';
try { f = String(JSON.parse(body || '{}').file || ''); } catch (_) {}
let hit = null;
if (f) {
const rp = path.resolve(f);
for (const s of slots.values()) if (s.file === rp) { hit = s; break; }
}
if (hit && hit.ready) {
hit.lastUsed = Date.now();
notifySwitch(hit);
try { const st = fs.statSync(hit.file); hit.mtimeMs = st.mtimeMs; hit.size = st.size; } catch (_) {}
res.writeHead(200, { 'content-type': 'application/json' }).end('{"touched":true}');
} else {
res.writeHead(200, { 'content-type': 'application/json' }).end('{"touched":false}');
}
});
req.on('error', () => {});
}
// ---------- 路由 ----------
const server = http.createServer((req, res) => {
route(req, res).catch((e) => {
log('请求失败 ' + req.url + ':' + ((e && e.message) || e));
if (!res.headersSent) res.writeHead(500, { 'content-type': 'text/plain; charset=utf-8' }).end('预览网关内部错误');
});
});
async function route(req, res) {
if (req.method === 'POST' && req.url.split('?')[0] === '/__pv-touch') return handleTouch(req, res);
let u;
try { u = decodeURIComponent((req.url || '/').split('?')[0]); } catch (_) { res.writeHead(400).end('bad path'); return; }
if (req.method === 'GET' && u === '/gateway-healthz') {
const body = JSON.stringify({ ok: true, prefix: PREFIX, slots: slots.size, bin: resolveBin() });
res.writeHead(200, { 'content-type': 'application/json' }).end(body);
return;
}
if (u === PREFIX + '/' || u.startsWith(PREFIX + '/')) {
const rel = u.slice(PREFIX.length) || '/';
const rr = rel.replace(/\/+$/, ''); // 去掉尾斜杠后的页面路径
const segs = rel.split('/').filter(Boolean);
const sid = segs.shift() || '';
const wantSlash = !/\/$/.test(u); // 缺尾斜杠:相对资源会解析错,要补 301
// HEAD = 前端预览窗的「这份文档能不能预览」探针。存在性只在本地按文件系统回答,绝不上探 watch;
// 但回 200 前要等槽位就绪(有上限):冷启动的首次渲染很贵,这里等掉,iframe 一挂上就是渲染好的页面。
if (req.method === 'HEAD') {
const t = await guard(sid, segs.join('/'));
if (t) {
if (!resolveBin()) {
res.writeHead(200, { 'content-type': 'text/plain; charset=utf-8', 'cache-control': 'no-store', 'content-length': '0' }).end();
return;
}
await warmSlot(rel, t);
res.writeHead(200, { 'content-type': 'text/plain; charset=utf-8', 'cache-control': 'no-store', 'content-length': '0' }).end();
return;
}
if (EXTS.has(path.extname(rr).toLowerCase())) return notFound(res);
}
if (isNav(req)) {
// 导航请求 = 用户正盯着这一刻:绝不为启动/自愈阻塞首字节。未就绪 → 中转页 + 后台热槽。
const t = await guard(sid, segs.join('/'));
if (!t) return notFound(res);
if (!resolveBin()) return installPage(res);
const m = matchPage(rr);
if (!m || !m.entry.ready) {
startWatch(t).catch(() => {});
return loading(res);
}
if (fileChanged(m.entry)) {
stopEntry(m.entry, '外部变更');
startWatch(t).catch(() => {});
return loading(res);
}
if (m.exact && wantSlash) { res.writeHead(301, { location: (req.url || u) + '/' }).end(); return; }
const cut = PREFIX.length + m.entry.pageDec.length;
try {
await tryForward(m.entry, req, res, u.length > cut ? u.slice(cut) : '/', NAV_TIMEOUT_MS);
m.entry.navTimeouts = 0;
return;
} catch (e) {
const msg = String((e && e.message) || e);
// 超时 ≠ 死:大文档首次渲染可能超过 5s。单次超时保留槽位,连续几次才判死重启。
m.entry.navTimeouts = /超时/.test(msg) ? (m.entry.navTimeouts || 0) + 1 : NAV_TIMEOUT_RETRIES;
if (m.entry.navTimeouts >= NAV_TIMEOUT_RETRIES) {
stopEntry(m.entry, msg);
startWatch(t).catch(() => {});
}
if (!res.headersSent) return loading(res);
return;
}
}
// 非导航(页面资源/API/SSE):等就绪槽位后自愈转发——用户看不见这些请求,值得原地救活
const m = await waitReady(rel);
if (m && m.entry) {
if (m.exact && wantSlash) { res.writeHead(301, { location: (req.url || u) + '/' }).end(); return; }
const cut = PREFIX.length + m.entry.pageDec.length;
if (await forwardHealed(m.entry, req, res, u.length > cut ? u.slice(cut) : '/')) return;
return fail502(res);
}
}
// vendor 页面把交互 API 与「自身最新 HTML」硬编码成根绝对路径(/、/events、/api/*):
// 按 Referer 找回来源页,原路径原样转发(不剥页面前缀)。`/` 尤其关键——回 404 页面会
// 判定自身过期并 location.reload(),用户看到的就是白屏后重新加载。
const rrel = refererRel(req);
if (rrel) {
const mv = await waitReady(rrel);
if (mv && mv.entry) {
if (await forwardHealed(mv.entry, req, res, u)) return;
return fail502(res);
}
}
notFound(res);
}
// 闲置回收:watch 是常驻进程,不回收会一直占着内存与端口(与服务器一致 6h)。
const idleTimer = setInterval(() => {
const now = Date.now();
for (const s of [...slots.values()]) {
if (!s.conns && now - s.lastUsed > IDLE_MS) stopEntry(s, '闲置回收');
}
for (const [k, v] of cooldown) if (v <= now) cooldown.delete(k);
}, 60000);
idleTimer.unref();
// 带外写盘兜底 + 页内编辑(POST /api/send 实测只落盘不推事件)的唯一刷新通道:
// 开着页面时比对 mtime,变了就对活槽位 POST /api/switch 就地重读。
const pollTimer = setInterval(() => {
const now = Date.now();
for (const s of [...slots.values()]) {
let st = null;
try { st = fs.statSync(s.file); } catch (_) {}
if (!st) { stopEntry(s, '文件已删除'); continue; } // 会话被删/文件被移走
if (!s.conns) continue; // 没人开着页面:导航侧的指纹门会兜住
if (!s.ready || st.mtimeMs === s.mtimeMs) continue;
if (now - (s.lastNative || 0) < 10000) { s.mtimeMs = st.mtimeMs; s.size = st.size; continue; }
s.mtimeMs = st.mtimeMs;
s.size = st.size;
notifySwitch(s);
}
}, 2000);
pollTimer.unref();
function shutdown() {
for (const s of [...slots.values()]) stopEntry(s);
process.exit(0);
}
process.on('SIGTERM', shutdown);
process.on('SIGINT', shutdown);
// 退出/崩溃时别把 spawn 出去的 watch 养成孤儿
process.on('exit', () => { for (const s of [...slots.values()]) killWatch(s); });
process.on('unhandledRejection', (e) => log('未处理的 Promise 拒绝:' + ((e && e.message) || e)));
server.listen(PORT, HOST, () => {
log('预览网关 listening ' + HOST + ':' + PORT + ' prefix=' + PREFIX + '/' +
' tasks=' + TASKS_ROOT + ' skills=' + SKILLS_ROOT + ' slots=' + SLOTS);
});
+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);
})();
+148 -52
View File
@@ -49,7 +49,7 @@ for p in "$MCP_WEB_PORT" "$MCP_IMAGE_PORT" "$MCP_VIDEO_PORT" "$MCP_ASR_PORT"; do
[ "$p" = "$PORT" ] && PORT_COLLIDE=1
done
mkdir -p "$RUNTIME" "$ROOT/data"
mkdir -p "$RUNTIME"
printf '\n==== %s 启动 ====\n' "$(date '+%Y-%m-%d %H:%M:%S')" >> "$LOG"
if [ -t 1 ]; then
@@ -257,12 +257,12 @@ CSS
elif [ -s "$UI_DIR/redirect" ] || [ -s "$UI_DIR/ready" ]; then
url=$(cat "$UI_DIR/redirect" 2>/dev/null)
[ -n "$url" ] || url=$(cat "$UI_DIR/ready")
# 后续启动:会自己跳;首次安装:只停在这页等点击。两种情况都留一个按钮兜底。
# auto 模式(写了 redirect)才会自己跳;click 模式就停在这页等点击。
if [ -s "$UI_DIR/redirect" ]; then
printf '<p class="note">2 秒后自动打开应用;没反应就点下面的按钮。</p>\n'
fi
printf '<p class="note"><a class="open" href="%s">打开应用</a> <span class="addr">%s</span></p>\n' "$url" "$url"
printf '<p class="tip">停止服务:运行 <code>./local/stop.sh</code>(关掉这个页面不影响服务)。</p>\n'
printf '<p class="tip">停止服务:运行 <code>./local/stop.sh</code>。</p>\n'
else
printf '<p class="tip">本页每秒自动刷新,进度会自己出现。</p>\n'
fi
@@ -319,15 +319,14 @@ ui_stop_ticker() {
ui_idle() { ui_stop_ticker; rm -f "$UI_DIR/busy"; ui_render; }
ui_done() {
# $1 应用地址 $2 auto|click(首次安装用 click:给链接让用户自己点,不自动跳)
# $1 应用地址 $2 auto|click(click = 停在状态页等用户点,不自动跳) $3 note(HTML,可选)
ui_stop_ticker
rm -f "$UI_DIR/busy" "$UI_DIR/error" "$UI_DIR/redirect" "$UI_DIR/ready" "$UI_DIR/note"
printf '%s\n' "${1:-}" > "$UI_DIR/ready"
if [ "${2:-auto}" = 'auto' ]; then
printf '%s\n' "${1:-}" > "$UI_DIR/redirect"
else
# 首次安装用户就停在这页,那下一步怎么配模型也得写在页上,不能只在终端里。
printf '<p class="hint">首次使用:进去后点左下角「用户区」→ 设置 → 模型池,添加平台和 API Key,再点「重启」(服务会自动拉起来)。</p>\n' > "$UI_DIR/note"
elif [ -n "${3:-}" ]; then
printf '%s\n' "$3" > "$UI_DIR/note"
fi
ui_title '已启动'
}
@@ -365,10 +364,10 @@ ui_checks() {
choose_workspace() {
ws=''
if [ "$(uname -s)" = 'Darwin' ] && command -v osascript >/dev/null 2>&1; then
ws=$(osascript -e 'POSIX path of (choose folder with prompt "选择 Agent 的工作目录:AI 会在这个目录里干活")' 2>/dev/null) || ws=''
ws=$(osascript -e 'POSIX path of (choose folder with prompt "选择 Agent 的工作目录:会在里面创建 data、skills、tasks 三个子目录")' 2>/dev/null) || ws=''
fi
if [ -z "$ws" ] && [ -t 0 ]; then
printf '工作目录(AI 会在这里干活)[%s/AgentWork]: ' "$HOME"
printf '工作目录(会在里面创建 data、skills、tasks)[%s/AgentWork]: ' "$HOME"
read -r ans || ans=''
if [ -n "${ans:-}" ]; then ws=$ans; else ws="$HOME/AgentWork"; fi
fi
@@ -378,21 +377,24 @@ choose_workspace() {
generate_config() {
ws=$1
mkdir -p "$ws" 2>/dev/null || { say "无法创建工作目录:$ws"; exit 1; }
mkdir -p "$ws/tasks" "$ws/data" "$ws/skills" 2>/dev/null || { say "无法创建工作目录:$ws"; exit 1; }
cat > "$CONFIG" <<EOF
# 本机 local 模式配置 —— 由 local/start.sh 首次启动时生成,之后不再覆盖。
# 改模型 / 密钥 / MCP:浏览器打开 http://$HOST_ADDR:$PORT → 左下角用户区 → 设置。
# 想彻底重来:删掉本文件再跑一次 ./local/start.sh(会话记录在 data/ 和工作目录里,不会被删)。
# 想彻底重来:删掉本文件再跑一次 ./local/start.sh(会话、技能、数据库都在工作目录里,不会被删)。
port: $PORT
# AI 的工作根。启动器注入 AGENT_FILE_SCOPE=workspace,文件工具可读写这个目录下的任意位置,
# 不再像服务器那样被限制在单个会话子目录里。路径一律加引号:用户选的目录带空格/':'/'#' 时
# 不加引号会被 YAML 当成注释或键值分隔符。
workspace_root: "$ws"
data_root: "$ROOT/data"
# 工作目录下的三个子目录分工:tasks=会话工作区(AI 的地盘)、data=数据库与调试产物、
# skills=技能(内置技能首次运行时复制过来,之后可自行增删改)。
# 路径一律加引号:用户选的目录带空格/':'/'#' 时,不加引号会被 YAML 当成注释或键值分隔符。
#
# AI 的工作根。启动器注入 AGENT_FILE_SCOPE=workspace,文件工具的根就是这个目录:
# AI 能在这里面任意读写,但看不到同级的 data/ 和 skills/。
workspace_root: "$ws/tasks"
data_root: "$ws/data"
skills:
# 指向 local/.runtime/skills:启动脚本按「有没有可用的 python3」把它软链到真技能目录或空目录。
# 这样装不装 python3 都不用改这份配置(改完重跑脚本即生效)。
skills_root: "$ROOT/local/.runtime/skills"
# 技能根。首次启动时把仓库 skills/ 里的内置技能复制到这里,之后只补缺不覆盖;
# pip 装的依赖落在同级的 deps/(AGENT_SKILLS_DEPS 指向它,已在 PYTHONPATH 里)。
skills_root: "$ws/skills"
# 故意留空:启动后在设置页添加平台与 API Key,再点「重启」——启动器会自动拉起。
platforms: []
log_level: info
@@ -415,19 +417,42 @@ EOF
say "工作目录:$ws"
}
# ---------- 技能目录:软链到仓库 skills,不动配置 ----------
# 为什么不再按 python3 有无切换成空目录:技能不一定是 Python 的。office 就是
# SKILL.md + scripts/office(Node)+ 二进制,跟 python3 无关;
# 一刀切会把这类技能一并藏起来。而 Python 技能缺解释器时,skills.js 的 runEntry 对
# spawn 的 error 有处理,模型拿到的是「技能入口启动失败:spawn python3 ENOENT」,
# 干净可读,不会崩也不会挂住——没必要靠藏清单来避险。
link_skills() {
link="$RUNTIME/skills"
dest="$ROOT/skills"
rm -f "$link" 2>/dev/null || true
# 万一上次留下了真目录(老版本行为),先挪走再建软链
if [ -d "$link" ] && [ ! -L "$link" ]; then rm -rf "$link"; fi
ln -s "$dest" "$link" || { warn "技能目录软链创建失败:$link"; return 1; }
# ---------- 技能目录:内置技能复制到工作目录,之后只补缺 ----------
# 技能根在用户选的工作目录里(<ws>/skills),与 data/、tasks/ 同级。仓库 skills/ 只是出厂副本:
# 这里只补缺——工作目录里没有的内置技能才复制,已存在的一律不动,所以用户改过的、
# AI 自己新建的技能都不会被覆盖。要拿仓库里的新版技能:删掉对应子目录再重跑本脚本。
# deps 不复制:仓库那份是服务器构建期产物,平台和版本都不该跟着走;本地 pip 自己装。
# 取配置里一个标量值(去掉引号)。不试图当 YAML 解析器用:配置是本脚本生成的,格式稳定。
cfg_get() {
sed -n "s/^[[:space:]]*$1:[[:space:]]*[\"']\{0,1\}\([^\"']*\)[\"']\{0,1\}[[:space:]]*$/\1/p" \
"$CONFIG" 2>/dev/null | head -n 1
}
# 技能根:配置里的 skills_root;留空则取 workspace_root 的同级 skills(与 core 的默认一致)。
skills_dir() {
d=$(cfg_get skills_root)
if [ -z "$d" ]; then
w=$(cfg_get workspace_root)
[ -n "$w" ] && d="$(dirname "$w")/skills"
fi
printf '%s' "$d"
}
sync_skills() {
dest=$1
[ -n "$dest" ] || { warn '配置里既没有 skills_root 也没有 workspace_root,技能不可用'; return 1; }
mkdir -p "$dest/deps" 2>/dev/null || { warn "无法创建技能目录:$dest"; return 1; }
added=0
for s in "$ROOT/skills"/*; do
[ -d "$s" ] || continue
name=${s##*/}
[ "$name" = 'deps' ] && continue
[ -e "$dest/$name" ] && continue
cp -R "$s" "$dest/$name" 2>/dev/null && added=$((added + 1))
done
[ "$added" -gt 0 ] && say "技能:复制 $added 个内置技能到 $dest"
return 0
}
# 依赖是否装全:0 = 齐全,非 0 = 缺(npm install 中途失败、被手工删过等)。
@@ -769,7 +794,7 @@ kill_tree_hard() {
do_cleanup() {
# 心跳子进程也得收掉,不然退出后它会继续每秒重绘页面。
ui_stop_ticker
rm -f "$RUNTIME/ui/busy" "$RUNTIME/supervisor.pid"
rm -f "$RUNTIME/ui/busy" "$RUNTIME/supervisor.pid" "$RUNTIME/preview.port" "$RUNTIME/tunnel.pid"
for p in $CORE_PID $MCP_PIDS; do kill_tree "$p"; done
CORE_PID=''
MCP_PIDS=''
@@ -817,8 +842,36 @@ check_mcp() {
fi
}
# ---------- 预览网关:office 文档的 iframe 预览 ----------
# 服务器上这条链是 core → 反代 /preview → executor 的 :3100 预览网关;本地没有 executor,
# 由 local/preview-gateway.js 顶上:收到预览请求就按需起 `officecli watch`,再转发页面与 SSE。
# 端口默认 3100(与服务器一致),被占就往后找几个:本机可能已经有别的服务占着 3100。
pick_preview_port() {
p="${PREVIEW_PORT:-3100}"
i=0
while [ "$i" -lt 10 ]; do
port_open "$p" || { printf '%s' "$p"; return 0; }
p=$((p + 1)); i=$((i + 1))
done
return 1
}
start_preview() {
printf '%s\n' "$PREVIEW_PORT" > "$RUNTIME/preview.port"
( cd "$ROOT" && exec env \
OFFICE_PREVIEW_HOST="$HOST_ADDR" \
OFFICE_PREVIEW_PORT="$PREVIEW_PORT" \
AGENT_TASKS_ROOT="$TASKS_DIR" \
AGENT_SKILLS_ROOT="$SKILLS_DIR" \
AGENT_REPO_ROOT="$ROOT" \
AGENT_CORE_URL="http://$HOST_ADDR:$PORT" \
AGENT_RUNTIME="$RUNTIME" \
node local/preview-gateway.js >>"$RUNTIME/preview.log" 2>&1 ) &
MCP_PIDS="$MCP_PIDS $!"
}
start_core() {
# PYTHONPATH 把技能共享依赖层 skills/deps 放进 python 的搜索路径(与服务器上 executor 容器
# PYTHONPATH 把技能依赖层 <工作目录>/skills/deps 放进 python 搜索路径(与服务器上 executor 容器
# 的 PYTHONPATH 对齐,那边由 compose 注入)。本地没有 agent-executor-init 替我们装包,
# 所以另外把目录路径作为 AGENT_SKILLS_DEPS 传下去:技能缺什么时,模型按该技能目录的
# AGENTS.md 自行安装(提示词里只给这一句指路),启动器不认识任何具体技能。
@@ -832,8 +885,10 @@ start_core() {
AGENT_LOCAL_PICK=1 \
AGENT_IMAGE_INLINE=1 \
ASR_URL="$ASR_URL" \
PYTHONPATH="$ROOT/skills/deps" \
AGENT_SKILLS_DEPS="$ROOT/skills/deps" \
PYTHONPATH="$SKILLS_DIR/deps" \
AGENT_SKILLS_DEPS="$SKILLS_DIR/deps" \
PREVIEW_PROXIES="[{\"name\":\"office\",\"prefix\":\"/preview\",\"host\":\"$HOST_ADDR\",\"port\":${PREVIEW_PORT:-3100}}]" \
OFFICE_GATEWAY_PORT="${PREVIEW_PORT:-3100}" \
node server/server.js >>"$LOG" 2>&1 ) &
CORE_PID=$!
}
@@ -846,7 +901,7 @@ open_browser() {
}
# ============ 后台化 ============
# start.sh 只做入口:把真正的启动器 nohup 到后台就返回,所以终端里跑完就能关窗口/做别的事。
# start.sh 只做入口:把真正的启动器甩到后台(独立会话)就返回,所以终端里跑完就能关窗口/做别的事。
# 停止统一走 ./local/stop.sh(或状态页上写的命令)。
# 前台模式(看实时日志、Ctrl-C 停):AGENT_LOCAL_DETACH=0 ./local/start.sh
# AGENT_LOCAL_DETACHED 是子进程标记,防自己无限重入。
@@ -882,10 +937,23 @@ if [ "${AGENT_LOCAL_DETACH:-1}" = 1 ] && [ "${AGENT_LOCAL_DETACHED:-0}" != 1 ];
generate_config "$WS"
first_run=1
fi
nohup env AGENT_LOCAL_DETACHED=1 AGENT_LOCAL_FIRST_RUN="$first_run" "$HERE/start.sh" >>"$LOG" 2>&1 </dev/null &
child=$!
# 用 node 起而不是 nohup:detached 会 setsid,子进程脱离终端的会话与进程组,关窗口/杀终端
# 都碰不到它。只靠 nohup 不行——子进程里 trap HUP 覆盖了 nohup 的忽略位,终端一关
# 就走到 on_signal,把 core 和 MCP 一起收掉(Terminal 上实测会挂,iTerm2 不断只是因为
# 它送信号的方式不同,不能指望)。
child=$(node -e '
const fs = require("fs");
const [log, script, first] = process.argv.slice(1);
const fd = fs.openSync(log, "a");
const c = require("child_process").spawn("/bin/sh", [script], {
detached: true, stdio: ["ignore", fd, fd],
env: Object.assign({}, process.env, { AGENT_LOCAL_DETACHED: "1", AGENT_LOCAL_FIRST_RUN: first })
});
c.unref();
process.stdout.write(String(c.pid));
' "$LOG" "$HERE/start.sh" "$first_run" 2>>"$LOG")
sleep 1
if kill -0 "$child" 2>/dev/null; then
if [ -n "$child" ] && kill -0 "$child" 2>/dev/null; then
printf '\n已转到后台运行(pid %s)\n' "$child"
printf '应用:http://%s:%s\n' "$HOST_ADDR" "$PORT"
printf '进度/日志:%s/status.html · %s\n' "$RUNTIME" "$LOG"
@@ -963,11 +1031,26 @@ if ! ensure_deps; then
exit 1
fi
if link_skills; then
if [ "$PY_OK" = 1 ]; then ui_step '技能:已启用' ok
else ui_step '技能:python3 未安装(Python 技能会失败)' warn; fi
SKILLS_DIR=$(skills_dir)
[ -n "$SKILLS_DIR" ] || SKILLS_DIR="$ROOT/skills" # 配置里两个键都被删掉时的兼底
if sync_skills "$SKILLS_DIR"; then
if [ "$PY_OK" = 1 ]; then ui_step "技能:$SKILLS_DIR" ok
else ui_step "技能:${SKILLS_DIR}(python3 未安装,Python 技能会失败)" warn; fi
else
ui_step '技能目录软链创建失败,技能不可用' warn
ui_step '技能目录不可用(检查配置里的 skills_root)' warn
fi
# 会话工作区:配置里的 workspace_root(local 形态 = <工作目录>/tasks);给预览网关解析会话目录用。
TASKS_DIR=$(cfg_get workspace_root)
[ -n "$TASKS_DIR" ] || TASKS_DIR="$(dirname "$SKILLS_DIR")/tasks"
if PREVIEW_PORT=$(pick_preview_port); then
start_preview
ui_step "预览网关:$HOST_ADDR:${PREVIEW_PORT}(office 文档)" ok
else
PREVIEW_PORT=''
warn '找不到空闲的预览端口(3100-3109),office 文档的预览将不可用'
ui_step '预览网关未启动(3100-3109 都被占用)' warn
fi
# 语音:ffmpeg 在就启用,两条线都靠同一个开关:
@@ -1016,15 +1099,28 @@ while :; do
check_mcp "$MCP_IMAGE_PORT" image
check_mcp "$MCP_VIDEO_PORT" video
[ "$FF_OK" = 1 ] && check_mcp "$MCP_ASR_PORT" asr
if [ "$FIRST_RUN" = 1 ]; then
# 首次安装:停在状态页,给一个按钮让用户自己点(先看完「首次使用」提示再进去)。
ui_done "http://${HOST_ADDR}:${PORT}" click
# 状态页没弹出来时(Linux / AGENT_LOCAL_UI=0)总得给个入口,否则用户什么都看不到。
[ "$UI_OPEN" = 1 ] || open_browser
else
ui_done "http://${HOST_ADDR}:${PORT}" auto
open_browser
# 预览网关挂了不会影响别的功能,但它静默失败时用户只会看到空白预览,所以点名。
if [ -n "${PREVIEW_PORT:-}" ] && ! port_open "$PREVIEW_PORT"; then
warn "预览网关没起来(端口 ${PREVIEW_PORT})——日志:local/.runtime/preview.log"
fi
# 隧道 client(可选):配了 tunnel/client.yml 才起,当第 5 个子进程,
# 停止时由 do_cleanup 的 kill_tree 一并收掉。它自带指数退避重连、进程不退出,
# 所以不需要守护循环;连不上时静默重试,真要查状态就看 local/.runtime/tunnel.log。
if [ -f "$ROOT/tunnel/client.yml" ]; then
( cd "$ROOT/tunnel" && exec node client.js >>"$RUNTIME/tunnel.log" 2>&1 ) &
MCP_PIDS="$MCP_PIDS $!"
printf '%s\n' "$!" > "$RUNTIME/tunnel.pid"
ui_step '隧道:已启动' ok
fi
# 一律停在状态页:启动摘要(语音/技能/隧道)和日志尾巴都留在屏幕上,
# 用户看完自己点「打开应用」,不会 2 秒就跳走。
if [ "$FIRST_RUN" = 1 ]; then
ui_done "http://${HOST_ADDR}:${PORT}" click '<p class="hint">首次使用:进去后点左下角「用户区」→ 设置 → 模型池,添加平台和 API Key,再点「重启」(服务会自动拉起来)。</p>'
else
ui_done "http://${HOST_ADDR}:${PORT}" click
fi
# 状态页没弹出来时(Linux / AGENT_LOCAL_UI=0)总得给个入口,否则用户什么都看不到。
[ "$UI_OPEN" = 1 ] || open_browser
printf '\n'
say "已启动:http://$HOST_ADDR:$PORT"
sleep 1
+17 -3
View File
@@ -17,6 +17,9 @@ PIDFILE="$RUNTIME/supervisor.pid"
PORT="${PORT:-8090}"
# 与 start.sh 的默认值一致;用 MCP_*_PORT 改过端口时这里也要跟着改(否则兜底那步找不到它们)。
MCP_PORTS="${MCP_WEB_PORT:-8091} ${MCP_IMAGE_PORT:-8092} ${MCP_VIDEO_PORT:-8093} ${MCP_ASR_PORT:-8094}"
# 预览网关端口是启动时从 3100 往后找的第一个空闲口,只能读它写下的记录。
pv_port=$(cat "$RUNTIME/preview.port" 2>/dev/null || printf '')
case "$pv_port" in ''|*[!0-9]*) pv_port='3100';; esac
stopped=0
@@ -81,7 +84,7 @@ if [ "$stopped" = 0 ]; then
fi
# 3) 兜底:还占着端口的直接收(启动器已经死了,剩下的都是孤儿)。
for p in "$PORT" $MCP_PORTS; do
for p in "$PORT" $MCP_PORTS "$pv_port"; do
for pid in $(pids_on_port "$p"); do
stop_pid "$pid" "端口 $p 上的进程"
done
@@ -89,14 +92,25 @@ done
[ "$stopped" = 1 ] && sleep 2
# 4) 收尾:仍占着端口的强制结束,避免下次启动被判「端口被占用」。
for p in "$PORT" $MCP_PORTS; do
for p in "$PORT" $MCP_PORTS "$pv_port"; do
for pid in $(pids_on_port "$p"); do
kill -KILL "$pid" 2>/dev/null || true
done
done
# 5) 隧道 client:它不监听端口,正常随启动器的 do_cleanup 一起收掉;
# 启动器被 kill -9 时 EXIT trap 不跑,会漏成孤儿,按它自己写的 pid 文件兜底。
if [ -f "$RUNTIME/tunnel.pid" ]; then
tpid=$(cat "$RUNTIME/tunnel.pid" 2>/dev/null || printf '')
case "$tpid" in ''|*[!0-9]*) tpid='';; esac
if [ -n "$tpid" ] && kill -0 "$tpid" 2>/dev/null; then
stop_pid "$tpid" '隧道 client'
fi
rm -f "$RUNTIME/tunnel.pid"
fi
if [ "$stopped" = 1 ]; then
say '已停止'
else
say "没有在运行($PORT 与 MCP 端口 $MCP_PORTS 都空闲)"
say "没有在运行(${PORT}、MCP 端口 ${MCP_PORTS}、预览端口 $pv_port 都空闲)"
fi
+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 自己。
## 端口与安全
+2 -2
View File
@@ -172,7 +172,7 @@ response_format=url
url: "http://mcp_image_task:3000/mcp"
headers:
Authorization: "Bearer <网关 KEY>"
X-Image-Task-Base-Url: "https://wb.ai.foresh.com/v1"
X-Image-Task-Base-Url: "https://your-gateway.example.com/v1"
X-Image-Task-Model: "global:gpt-image-2.5-sunburst"
mode: skill
```
@@ -258,7 +258,7 @@ curl -s -X POST http://localhost:8082/mcp \
-H "Content-Type: application/json" \
-H "Accept: application/json, text/event-stream" \
-H "Authorization: Bearer $TOKEN" \
-H "X-Image-Task-Base-Url: https://wb.ai.foresh.com/v1" \
-H "X-Image-Task-Base-Url: https://your-gateway.example.com/v1" \
-H "X-Image-Task-Model: global:gpt-image-2.5-sunburst" \
-H "Mcp-Session-Id: $SESSION" \
-d '{
+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");
-9
View File
@@ -1,9 +0,0 @@
# 国内网络
pip / npm / GitHub / brew 超时或装不上时换源:
- pip:加 `-i https://pypi.tuna.tsinghua.edu.cn/simple`
- npm:加 `--registry=https://registry.npmmirror.com`
- GitHub 下载:地址前加 `https://gh-proxy.com/`(备用 `https://ghfast.top/`)
- brew:换清华/中科大镜像,或让用户自己装
- 缺运行时/系统包用本机包管理器(`apt` / `dnf` / `pacman` / `brew` / `winget`);需要密码时先问用户
-1
View File
@@ -20,7 +20,6 @@
```
skills/
├── AGENTS.md # 技能排错与国内网络换源(可选参考;core 不读)
└── <skill-name>/
├── SKILL.md # 技能描述文件(必须)
├── run.py # 技能主入口(Python 脚本,推荐)或 run.sh
+7 -5
View File
@@ -1,11 +1,13 @@
# document-photo-to-pdf
`ModuleNotFoundError`(`numpy` / `PIL` / `fitz`):把依赖装进 `$AGENT_SKILLS_DEPS`
以下命令仅为示例,具体以本机平台实际情况为准。
## ModuleNotFoundError: numpy / PIL / fitz
把依赖装进 `$AGENT_SKILLS_DEPS`。
```sh
python3 -m pip install --target "$AGENT_SKILLS_DEPS" -r "$(dirname "$AGENT_SKILLS_DEPS")/document-photo-to-pdf/requirements.txt"
python3 -m pip install --upgrade --target "$AGENT_SKILLS_DEPS" -r "$(dirname "$AGENT_SKILLS_DEPS")/document-photo-to-pdf/requirements.txt"
```
`fitz` 是 `pymupdf` 的 import 名,`pypdfium2` 不用装。没有 `python3` 先装运行时(Windows 上解释器常是 `python` / `py`)。
网络慢或装不上(pip / GitHub 等):见技能根目录的 `AGENTS.md`。
`fitz` 是 `pymupdf` 的 import 名,`pypdfium2` 不用装;没有 `python3` 先装运行时(Windows 常是 `python` / `py`)。
+1 -1
View File
@@ -39,7 +39,7 @@ input_schema:
```json
{"ok":true,"summary":"3 页已生成;1 页建议在审核页确认;原始页图见 out/","pdf":"合同_校正.pdf","images":["out/合同_校正-01.png","out/合同_校正-02.png","out/合同_校正-03.png"]}
访问地址:https://agent.ai.foresh.com/app/task-20261023-001/doc-review/
访问地址:<站点地址>/app/task-20261023-001/doc-review/
```
审核页可拖角、旋转、删页/排序、改纸张与清晰度;改动后点「重新生成 PDF」覆盖同名文件。
+5 -1
View File
@@ -864,7 +864,11 @@ def process(args, t0):
if not state_ok:
warnings.append("state 文件写入失败:%s" % state_path)
if checks.get("ok") is False:
if checks.get("ok") is None:
# 自检根本没跑(无 PDF 渲染后端等):不能让它伪装成「建议确认」——
# 那种情况下页面压根没过边缘/短边检验,模型和用户都得知道判据缺失。
summary = "%d 页已生成;PDF 自检未能执行,请在审核页人工确认" % len(ordered_pages)
elif checks.get("ok") is False:
summary = "%d 页已生成;自检有未通过项" % len(ordered_pages)
elif needs:
summary = "%d 页已生成;%d 页建议在审核页确认" % (
+9 -5
View File
@@ -1,17 +1,21 @@
# image-process
`ModuleNotFoundError: No module named 'PIL'`:把依赖装进 `$AGENT_SKILLS_DEPS`
以下命令仅为示例,具体以本机平台实际情况为准。
## ModuleNotFoundError: No module named 'PIL'
把依赖装进 `$AGENT_SKILLS_DEPS`。
```sh
python3 -m pip install --target "$AGENT_SKILLS_DEPS" -r "$(dirname "$AGENT_SKILLS_DEPS")/image-process/requirements.txt"
python3 -m pip install --upgrade --target "$AGENT_SKILLS_DEPS" -r "$(dirname "$AGENT_SKILLS_DEPS")/image-process/requirements.txt"
```
`中文水印缺少字体`:传 `font` 参数,指向本机任意中文字体文件(ttf/ttc)
## 中文水印缺少字体
传 `font` 参数,指向本机任意中文字体文件(ttf/ttc)。
```json
{"action":"watermark","input":"a.jpg","text":"机密","font":"<本机中文字体路径>"}
```
找字体:Linux `fc-list :lang=zh`;macOS `ls /System/Library/Fonts`;Windows `C:\Windows\Fonts\msyh*`。
网络慢或装不上(pip / GitHub 等):见技能根目录的 `AGENTS.md`。
+10 -5
View File
@@ -1,12 +1,19 @@
# office
`office: command not found`:用技能自带入口
以下命令仅为示例,具体以本机平台实际情况为准(自行判断路径、可执行名、分隔符)。
## office: command not found
入口不在 PATH:建一次软链,之后一直能用。
```sh
PATH="$(dirname "$AGENT_SKILLS_DEPS")/office/scripts:$PATH" office help
mkdir -p "$HOME/.local/bin"
ln -sfn "$(dirname "$AGENT_SKILLS_DEPS")/office/scripts/office" "$HOME/.local/bin/office"
```
`office.core binary missing`:按本机平台下载对应资产到 `bin/officecli`(Windows 存成 `bin/officecli.exe`),再 `chmod +x`
## office.core binary missing
按本机平台下载对应资产到 `bin/officecli`(Windows 存成 `bin/officecli.exe`),再 `chmod +x`。
```sh
SK="$(dirname "$AGENT_SKILLS_DEPS")/office"
@@ -17,5 +24,3 @@ chmod +x "$SK/bin/officecli"
资产名是 `{mac,linux,win}-{x64,arm64}`,如 `officecli-mac-arm64`、`officecli-linux-x64`、`officecli-win-x64.exe`;
musl 系统(Alpine)用 `officecli-linux-alpine-{x64,arm64}`。`uname -sm` 可判断平台与架构。
网络慢或装不上(GitHub 下载 / brew 等):见技能根目录的 `AGENTS.md`。
+1 -2
View File
@@ -92,8 +92,7 @@ try {
}
if (r.error) {
if (r.error.code === 'ENOENT') {
err('office.core binary missing: ' + BIN + '\nLocal env: ' + path.resolve(__dirname, '..', 'AGENTS.md')
+ ' (server: docker compose up -d agent-executor-init)');
err('office.core binary missing: ' + BIN + ' (install per ' + path.resolve(__dirname, '..', 'AGENTS.md') + ')');
}
err(String(r.error.message || r.error));
}
+26 -9
View File
@@ -1,18 +1,35 @@
# x2pdf
`ModuleNotFoundError`(`markdown`)或提示 WeasyPrint 不可用:把依赖装进 `$AGENT_SKILLS_DEPS`
以下命令仅为示例,具体以本机平台实际情况为准。
## ModuleNotFoundError: markdown
把依赖装进 `$AGENT_SKILLS_DEPS`。
```sh
python3 -m pip install --target "$AGENT_SKILLS_DEPS" -r "$(dirname "$AGENT_SKILLS_DEPS")/x2pdf/requirements.txt"
python3 -m pip install --upgrade --target "$AGENT_SKILLS_DEPS" -r "$(dirname "$AGENT_SKILLS_DEPS")/x2pdf/requirements.txt"
```
WeasyPrint 还要系统库 pango/cairo:Linux `apt install libpango-1.0-0 libpangocairo-1.0-0 libcairo2`;
macOS `brew install pango`;Windows 装不起来就跳过——有 LibreOffice 时文本类会自动回落。
## 没有可用的 PDF 排版能力
Office 类(docx/xlsx/pptx)报「未找到 LibreOffice」:装一个 LibreOffice
(Linux `apt install libreoffice`;macOS `brew install --cask libreoffice`;
Windows `winget install TheDocumentFoundation.LibreOffice`)。
文本类有三个后端可退,从便宜到贵补,别一次全装:
装了 LibreOffice 后文本类也能用(回落路径,`page` 的边距/页码与部分 CSS 不生效),此时不必装 pango。
- 浏览器:有 Chrome / Chromium / Edge 就自动用,通常不用装
- LibreOffice:Office 类(docx/xlsx/pptx)必装——Linux `apt install libreoffice`;macOS `brew install --cask libreoffice`;Windows `winget install TheDocumentFoundation.LibreOffice`
- WeasyPrint:先装上面的 Python 包,再补系统库 pango/cairo(见下节)
网络慢或装不上(pip / brew / winget 等):见技能根目录的 `AGENTS.md`。
系统级安装几百 MB,先跟用户说清代价,由他决定装还是接受降级。
## could not import some external libraries
系统库没到位,不是 Python 包的问题:Linux `apt install libpango-1.0-0 libpangocairo-1.0-0 libcairo2`;macOS `brew install pango`;Windows 补 GTK 运行库,装不上就跳过。
装完验证:
```sh
python3 -c "import weasyprint; print(weasyprint.__version__)"
```
## 输出带「排版降级」
无页码或边距偏差不是失败,是后端不全,按需补。
+2 -4
View File
@@ -37,10 +37,8 @@ output_schema:
统一 PDF 转换入口,按扩展名自动分派两条渲染路径:
- **md / txt / html → WeasyPrint**(CSS 排版,字体走 fontconfig,中文用系统文泉驿/Noto,无需字体文件);
本机没有 WeasyPrint(缺包,或缺它依赖的 pango/cairo)时自动回落 LibreOffice——
能出件,但 `page`/`css` 只部分生效,不适合精确排版
- **docx / xlsx / pptx / odt / ods / odp → LibreOffice headless**(忠于原文档版式,`page`/`css` 参数不生效)
- **md / txt / html → 渲染成 PDF**(CSS 排版,字体走系统 fontconfig,中文用系统文泉驿/Noto,无需字体文件)
- **docx / xlsx / pptx / odt / ods / odp → 按原文档版式转换**(`page`/`css` 参数不生效)
### Markdown 输入(`.md` / `.markdown`)
- 标准语法之外,支持表格(管道语法)、围栏代码块(```/~~~)、脚注、定义列表、
+88 -14
View File
@@ -3,16 +3,19 @@
x2pdf 技能主入口:通用 PDF 转换。
分派策略(按输入文件扩展名):
- .md / .markdown / .txt / .html / .htm → WeasyPrint 渲染;本机没有 WeasyPrint
(缺包,或缺它要 dlopen 的 pango/cairo)时回落 LibreOffice,保真度略低但不缺库
- .md / .markdown / .txt / .html / .htm → 依次尝试 WeasyPrint / 无头浏览器 / LibreOffice
三者都是本机可能没有的渲染后端:WeasyPrint 缺包或缺 pango/cairo 时不可用,
浏览器(Chrome/Chromium/Edge)不需要任何 Python 依赖,保真度介于两者之间
- .docx / .xlsx / .pptx / .odt / .ods / .odp → LibreOffice headless 转换
依赖不假设镜像预烘:Python 包由 requirements.txt 声明,系统库由 install.sh 就绪校验。
LibreOffice 的定位不只看 PATH:macOS 的 app bundle 与 Windows 的安装目录都不进 PATH,
which() 找不到不等于没装(见 find_soffice)。
LibreOffice 与浏览器的定位不只看 PATH:macOS 的 app bundle 与 Windows 的安装目录都不进 PATH,
which() 找不到不等于没装(见 find_soffice / find_browser)。
中文字体走 fontconfig(系统文泉驿/Noto),技能不携带字体文件。
"""
import contextlib
import html as html_mod
import io
import json
import os
import re
@@ -50,6 +53,28 @@ def find_soffice():
return None
def find_browser():
"""定位支持 --headless --print-to-pdf 的浏览器(Chrome / Chromium / Edge)。
不要求用户为了转 PDF 装 Python 侧渲染栈:pango 在老系统上只能现编。
同 find_soffice:macOS app bundle 与 Windows 安装目录都不进 PATH。"""
for name in ('google-chrome', 'google-chrome-stable', 'chromium', 'chromium-browser',
'microsoft-edge', 'msedge'):
p = shutil.which(name)
if p:
return p
for c in ('/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
'/Applications/Chromium.app/Contents/MacOS/Chromium',
'/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge',
str(Path.home() / 'Applications/Google Chrome.app/Contents/MacOS/Google Chrome'),
r'C:\Program Files\Google\Chrome\Application\chrome.exe',
r'C:\Program Files (x86)\Google\Chrome\Application\chrome.exe',
r'C:\Program Files\Microsoft\Edge\Application\msedge.exe',
r'C:\Program Files (x86)\Microsoft\Edge\Application\msedge.exe'):
if Path(c).is_file():
return c
return None
def req_hint():
return '本机环境: %s' % (SKILL_DIR / 'AGENTS.md')
@@ -200,10 +225,18 @@ def convert_text_pdf(input_path, output_path, css_arg, page_arg):
output_path.parent.mkdir(parents=True, exist_ok=True)
try:
from weasyprint import CSS, HTML
# 导入失败时 WeasyPrint 会往 stdout 打一大段「could not import some external libraries」
# (text/ffi.py 里裸 print),模型会把这段当成真错。降级是预期行为,噪声吞掉,
# 由返回值那句 note 告知实际后端。
sink = io.StringIO()
with contextlib.redirect_stdout(sink), contextlib.redirect_stderr(sink):
from weasyprint import CSS, HTML
except (ImportError, OSError):
# 缺 Python 包是 ImportError;装了包但缺它要 dlopen 的 libpango/libgobject 时是 OSError。
# 两种都当作「本机没有 WeasyPrint」,回落 LibreOffice(Office 分支本来也要它)。
# 两种都当作「本机没有 WeasyPrint」:先试浏览器(只需装了 Chrome 系),再回落 LibreOffice。
browser = find_browser()
if browser:
return convert_html_browser(browser, document, output_path, base_url, sheets, ext)
return convert_html_pdf(document, output_path, ext)
# 注:stylesheets 参数只接受 CSS 对象,传字符串会被当成文件路径
HTML(string=document, base_url=base_url).write_pdf(
@@ -211,14 +244,56 @@ def convert_text_pdf(input_path, output_path, css_arg, page_arg):
return ''
def inject_styles(document, sheets, base_url):
"""把 CSS 与 base 标签塞进已有 HTML:浏览器后端只能吃单个文件。
注入点是 </head>(其次 <body>),绝不能落到 doctype 前面——那会触发怪异模式。"""
head = ''
if base_url:
head += '<base href="%s/">\n' % Path(base_url).resolve().as_uri()
if sheets:
head += '<style>\n%s\n</style>\n' % '\n'.join(sheets)
if not head:
return document
m = re.search(r'</head\s*>', document, re.I) or re.search(r'<body[^>]*>', document, re.I)
if m:
return document[:m.start()] + head + document[m.start():]
d = re.match(r'\s*<!doctype[^>]*>', document, re.I)
if d:
return document[:d.end()] + '\n' + head + document[d.end():]
return head + document
def convert_html_browser(browser, document, output_path, base_url, sheets, ext):
"""HTML → 无头浏览器打印:WeasyPrint 不可用时的中间档。
浏览器能完整解析 CSS(表格边框/底纹/分页),但页码是 WeasyPrint 的 CSS 计数器特性,
这里不生效;@page 的 size/margin 视浏览器版本部分生效。"""
output_path.parent.mkdir(parents=True, exist_ok=True)
tmp_root = Path(tempfile.mkdtemp(prefix='x2pdf-browser-'))
try:
# 浏览器默认纸张是 Letter,WeasyPrint 默认 A4。文档自己没写 @page 时补上 A4,
# 否则同一份 html 换后端就换纸型。
if not any('@page' in s for s in sheets) and '@page' not in document:
sheets = list(sheets) + ['@page { size: A4; }']
src = tmp_root / 'document.html'
src.write_text(inject_styles(document, sheets, base_url), encoding='utf-8')
cmd = [browser, '--headless', '--disable-gpu', '--no-pdf-header-footer',
'--virtual-time-budget=2000',
'--print-to-pdf=%s' % str(output_path.resolve()), src.as_uri()]
proc = subprocess.run(cmd, capture_output=True, text=True, timeout=120)
if not output_path.is_file() or output_path.stat().st_size == 0:
detail = (proc.stderr or proc.stdout or '').strip().replace('\n', ' ')[:300]
raise RuntimeError('PDF 生成失败(exit=%s):%s' % (proc.returncode, detail or '无输出'))
finally:
shutil.rmtree(tmp_root, ignore_errors=True)
return '排版降级:无页码,尺寸/边距可能与预期有偏差'
def convert_html_pdf(document, output_path, ext):
"""HTML → LibreOffice:WeasyPrint 不可用时的回落路径。
"""HTML → LibreOffice:最后一道回落(浏览器也没有时)。
代价是保真度:@page 的边距/页码与大部分 CSS 在 LibreOffice 的 HTML 导入里不生效,
适合「拿到一份能看的 PDF」,不适合精确排版。"""
if not find_soffice():
raise RuntimeError('这台机器没有可用的 PDF 渲染后端:%s 需 WeasyPrint,但 WeasyPrint 不可用'
'(缺 Python 包,或缺系统库 pango/cairo);也没找到 LibreOffice。%s'
% (ext, req_hint()))
raise RuntimeError('这台机器没有可用的 PDF 排版能力,无法转换 %s;%s' % (ext, req_hint()))
tmp_root = Path(tempfile.mkdtemp(prefix='x2pdf-html-'))
try:
src = tmp_root / 'document.html'
@@ -226,7 +301,7 @@ def convert_html_pdf(document, output_path, ext):
convert_office_pdf(src, output_path)
finally:
shutil.rmtree(tmp_root, ignore_errors=True)
return '用 LibreOffice 渲染(WeasyPrint 不可用):@page 边距/页码与部分 CSS 不生效'
return '排版降级:边距/页码与部分 CSS 不生效'
def convert_office_pdf(input_path, output_path):
@@ -234,8 +309,7 @@ def convert_office_pdf(input_path, output_path):
每次用独立临时 UserInstallation/HOME,避免并发实例互踩共享配置。"""
soffice = find_soffice()
if not soffice:
raise FileNotFoundError('未找到 LibreOffice(soffice),无法转换 Office 文档。'
'服务器镜像已预装;本机装一个 LibreOffice 即可。')
raise FileNotFoundError('这台机器没有可用于转换 Office 文档的组件;%s' % req_hint())
output_path.parent.mkdir(parents=True, exist_ok=True)
tmp_root = Path(tempfile.mkdtemp(prefix='x2pdf-office-'))
@@ -256,7 +330,7 @@ def convert_office_pdf(input_path, output_path):
generated = pdf_dir / (input_path.stem + '.pdf')
if not generated.exists():
detail = (proc.stderr or proc.stdout or '').strip().replace('\n', ' ')[:300]
raise RuntimeError('LibreOffice 转换失败(exit=%s):%s' % (proc.returncode, detail or '无输出'))
raise RuntimeError('文档转换失败(exit=%s):%s' % (proc.returncode, detail or '无输出'))
shutil.move(str(generated), str(output_path))
finally:
shutil.rmtree(tmp_root, ignore_errors=True)
+5
View File
@@ -0,0 +1,5 @@
node_modules/
server.yml
client.yml
*.log
data/
+20
View File
@@ -0,0 +1,20 @@
FROM node:20-slim
ENV TZ=Asia/Shanghai
WORKDIR /app
# 国内构建慢:npm 默认源在国外。默认换成腾讯云镜像(与 app/Dockerfile 同源)。
# 境外构建或想换源:docker compose build --build-arg NPM_REGISTRY=https://registry.npmjs.org/
ARG NPM_REGISTRY=https://mirrors.cloud.tencent.com/npm/
# 只依赖 ws(纯 JS,无预编译二进制,不需要 better-sqlite3 那套 binary mirror 配置)
# 基础镜像与 app/Dockerfile 同版本(node:20-slim):服务器上已有,构建时不用再拉一遍
COPY package.json package-lock.json ./
RUN npm config set registry "$NPM_REGISTRY" \
&& npm install --omit=dev --no-audit --no-fund
COPY server.js ./
EXPOSE 19000
CMD ["node", "server.js"]
+190
View File
@@ -0,0 +1,190 @@
# tunnel · 通用反向隧道
把本机(家里)的 HTTP 服务,经一台有公网 IP 的服务器中转出去。对访问方**完全透明**——
浏览器看到的仍是标准 HTTP/SSE,服务本身不需要任何改造。
```
手机/浏览器 ──https──> nginx:443 ──> server.js ──WebSocket──> client.js ──> 127.0.0.1:<port>
(服务器) (家里)
```
- **server.js** 不认识任何业务:只按 `Host` 头(或固定端口)把字节搬给 client
- **client.js** 按 `services` 配置把请求映射到本地端口
- 新增服务 = 改 client 配置一行,**两边代码都不用动**
## 启动顺序
没有严格要求。client 连不上会 1s→30s 指数退避重连,先起谁都能自动接上。
第一次配置建议先起 server,日志会直接告诉你 client 是否连上、token 对不对。
## 快速验证(本机,不碰 nginx)
```bash
cd tunnel && npm install # 国内慢就加 --registry=https://registry.npmmirror.com
cp client.example.yml client.yml # server 改成 ws://127.0.0.1:19000/tunnel,token 先留空
node server.js & # 首次启动生成 server.yml,日志打印 TOKEN
# 把 TOKEN 填进 client.yml 的 token,再:
node client.js &
curl -H "Host: agent.home.example.com" http://127.0.0.1:19000/api/health
curl -s http://127.0.0.1:19000/__tunnel/health # {"ok":true,"client":"online",...}
```
## 服务器部署
```bash
cd tunnel
docker compose up -d
docker compose logs | grep TOKEN # 首次启动自动生成,记下来填到家里 client.yml
```
**不需要先写配置**:首次启动会自动生成 `./data/server.yml`,里面带一个随机 token 并打印到日志。
第二次启动直接复用,token 不会变。
裸跑也行(不写配置同样自动生成):
```bash
node server.js # 配置落在 ./server.yml
TUNNEL_CONFIG=/path/to/server.yml node server.js
```
## 请求怎么找到对应的服务
一台服务器、一个端口,请求进来后要决定「这个请求是给 agent 还是给 NAS」。三种做法:
### 1. 看域名(有域名时最自然)
```
agent.home.example.com → 家里 8090
nas.home.example.com → 家里 5000
```
隧道读请求里的 `Host` 头决定转发给谁。配置就是 `client.yml` 的 `host` 字段:
```yaml
services:
- host: agent.home.example.com
port: 8090
```
需要 DNS 泛解析 `*.home.example.com` 指到服务器,前面再套一层 nginx 做 TLS。
### 2. 一个端口钉一个服务(没有域名,又要多个服务)
隧道同时监听好几个端口,每个端口只认一个服务名:
```
http://<服务器IP>:19001 → 固定给 agent
http://<服务器IP>:19002 → 固定给 NAS
```
`server.yml` 声明端口归属:
```yaml
routes:
- port: 19001
service: agent
- port: 19002
service: nas
```
`client.yml` 用 `name` 对上:
```yaml
services:
- name: agent
port: 8090
- name: nas
port: 5000
```
`docker-compose.yml` 里把 19001/19002 的 `ports` 放开。**完全不看 Host 头**。
### 3. 一个端口 + 通配(没有域名,只有一个服务)
最简单:所有请求都给同一个服务。
```yaml
services:
- host: "*"
port: 8090
```
浏览器开 `http://<服务器IP>:19000` 就是它。
### 怎么选
| 你的情况 | 用哪个 |
|---|---|
| 有域名 | 方式 1 |
| 没域名,只暴露一个服务 | 方式 3(一行配置) |
| 没域名,要暴露多个服务 | 方式 2(一个服务一个端口) |
方式 1 和 2 **可以同时开**:19000 走 Host 路由,19001/19002 各钉死一个服务,互不干扰。
## 家里部署
```bash
node client.js # 读同目录 client.yml
node client.js /path/to/client.yml
```
```yaml
server: "wss://agent.home.example.com/tunnel"
token: "<和服务器同一个>"
userAgent: "Mozilla/5.0 (...) Chrome/131.0.0.0 Safari/537.36"
services:
- name: agent
host: agent.home.example.com
port: 8090
```
- `name`:固定端口路由用的服务标识(有域名时可省略)
- `host`:`域名` / `*.example.com` / `"*"`(兜底)
- `userAgent`:可选,握手时伪装浏览器 UA,降低被 DPI 盯上的概率
- 断线自动重连(含半死链路:75 秒收不到任何帧即主动断开重连),启动时自检每个端口可达性(不可达只告警不退出)
## 隧道协议
一条 WebSocket 承载所有请求,用 `id` 多路复用。
```jsonc
// 服务器 → 家里
{"id":"r1","op":"req","method":"POST","path":"/api/x","headers":{...},"service":"agent"}
{"id":"r1","op":"body","b64":"..."} // 请求体分帧
{"id":"r1","op":"end"}
{"id":"r1","op":"abort"} // 浏览器提前断开
// 家里 → 服务器(响应分帧,边收边转)
{"id":"r1","ev":"head","status":200,"headers":{...}}
{"id":"r1","ev":"data","b64":"..."}
{"id":"r1","ev":"end"}
{"id":"r1","ev":"error","msg":"..."}
```
`service` 只在「固定端口路由」时出现;没有它 client 就按 Host 头匹配。
## 已知边界
| 能力 | 状态 |
|---|---|
| 普通 HTTP / 大 body(测过 27 MB) | ✅ |
| SSE / 流式响应 | ✅ 逐帧透传(800ms/帧测试,间隔与直连一致) |
| 重定向(302) | ✅ 原样透传,不在隧道里跟跳 |
| 未知 Host | 502 |
| client 离线 | 503(快速失败,不挂住) |
| 固定端口路由 / `*` 通配 | ✅ |
| **WebSocket 升级** | ❌ 未实现(需双向字节流,二期) |
| HTTP/2 | ❌ 对外仍是 1.1,影响不大 |
## 排错
```bash
curl -s http://127.0.0.1:19000/__tunnel/health # client 在不在线
tail -f /tmp/tunnel-client.log # 家里端
tail -f /tmp/tunnel-server.log # 服务器端
```
- **502 没有匹配的本地服务**:`services[].host` 和请求 Host 不一致;无域名时用 `"*"` 或固定端口
- **SSE 憋着不出来**:nginx 少了 `proxy_buffering off`
- **大 body 报 `expect header not supported`**:旧版本才有,client 现在会剥掉 `Expect` 头
- **握手 401**:两边 token 不一致
+32
View File
@@ -0,0 +1,32 @@
# tunnel 本机端配置 —— 复制为 client.yml 后改(client.yml 不进版本库)
# 服务器隧道地址,两种形态按需选:
# 只有 IP(最省事,但要求服务器把 19000 映射到 0.0.0.0)
# ws://1.2.3.4:19000/tunnel ← 明文,token 在公网裸奔,仅限内网/临时调试
# 有域名 + 证书(推荐,前面套 nginx 反代)
# wss://tunnel.example.com/tunnel
server: "ws://1.2.3.4:19000/tunnel"
# 和服务器 server.yml 里自动生成的 token 一致
token: ""
# 握手 UA:伪装成浏览器,降低被 DPI 盯上的概率。不写就用内置默认值
# userAgent: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36"
# 请求体上限(MB),和服务端双保险
maxBodyMb: 64
# 要暴露的本地服务:加服务 = 加一项,两边代码都不用动
# 路由优先级:固定端口指定的 name → host 精确 → *.域名 通配 → "*" 兜底
services:
# 直接按 IP 访问时,请求的 Host 头就是那个 IP,用 "*" 兜底最省事(单服务形态)
- host: "*"
port: 8090
# 有域名时按 Host 精确匹配,一个域名对一个服务
# - name: agent
# host: agent.example.com
# port: 8090
# - name: nas
# host: nas.example.com
# port: 5000
+241
View File
@@ -0,0 +1,241 @@
#!/usr/bin/env node
'use strict';
// 通用反向隧道 · 本机端(家里那台)
// 主动连服务器 → 收请求 → 按 Host 找本地端口 → 转发 → 流式回传
//
// 用法: node client.js [config.yml] 环境变量 TUNNEL_SERVER / TUNNEL_TOKEN 覆盖配置
// 断线自动重连(指数退避 1s → 30s)。心跳由服务端 ping 驱动、本端 ws 库自动回 pong;
// 但半死链路(Mac 睡眠/切网后 TCP 还在、实际不通)不会触发 close,所以本端另设看门狗。
const fs = require('node:fs');
const path = require('node:path');
const http = require('node:http');
const zlib = require('node:zlib');
const YAML = require('yaml');
const WebSocket = require('ws');
// ---------- 配置 ----------
function loadConfig() {
const file = process.argv[2] || path.join(__dirname, 'client.yml');
let cfg = {};
if (fs.existsSync(file)) {
try { cfg = YAML.parse(fs.readFileSync(file, 'utf8')) || {}; } catch (e) {
console.error('[tunnel] ' + file + ' 不是合法 YAML:' + e.message);
process.exit(1);
}
}
cfg.server = String(process.env.TUNNEL_SERVER || cfg.server || '').trim();
cfg.token = String(process.env.TUNNEL_TOKEN || cfg.token || '').trim();
cfg.services = Array.isArray(cfg.services) ? cfg.services : [];
// 默认 UA 伪装成浏览器:跨境链路上「frp/x.x」这种 UA 是明显特征
cfg.userAgent = cfg.userAgent ||
'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0 Safari/537.36';
cfg.maxBodyMb = Number(cfg.maxBodyMb || 64);
if (!cfg.server || !cfg.token) {
console.error('[tunnel] 需要 server 和 token:写进 client.yml,或设 TUNNEL_SERVER / TUNNEL_TOKEN');
process.exit(1);
}
if (!cfg.services.length) {
console.error('[tunnel] services 为空:至少配一项 {host, port}');
process.exit(1);
}
return cfg;
}
const CFG = loadConfig();
// 日志时间固定东八区:本机时区可能变,跨时区看日志不该换算
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 通配一项
// 服务匹配优先级:固定端口指定的 name → host 精确 → *.域名 通配 → "*" 兜底
// "*" 是给「服务器没有域名」的场景用的:浏览器访问 http://1.2.3.4:19000,
// Host 头是 IP,对不上任何域名,此时所有请求都交给这个服务(单服务形态)。
function pickService(meta) {
const list = CFG.services || [];
if (meta.service) {
const byName = list.find(s => String(s.name || '') === String(meta.service));
if (byName) return byName;
}
const host = String((meta.headers && meta.headers.host) || '').toLowerCase().split(':')[0];
for (const s of list) if (String(s.host || '').toLowerCase() === host) return s;
for (const s of list) {
const h = String(s.host || '').toLowerCase();
if (h.startsWith('*.') && host.endsWith(h.slice(1))) return s;
}
for (const s of list) if (s.host === '*') return s;
return null;
}
// ---------- 在途请求 ----------
// 收到 op=req 建条目,body 帧往里堆,op=end 才真正发出去;
// op=abort(手机提前断开)→ abort 本地请求,别让上游白跑。
const inflight = new Map();
let ws = null;
let backoff = 1000;
let stopping = false;
let lastSeen = 0; // 最近一次收到服务端任何帧的时刻
function send(obj) {
if (ws && ws.readyState === 1) {
try { ws.send(JSON.stringify(obj)); } catch (_) {}
}
}
function onMessage(raw) {
let m;
try { m = JSON.parse(raw); } catch (_) { return; }
if (m.op === 'req') {
inflight.set(m.id, { meta: m, chunks: [], size: 0, ac: new AbortController() });
} else if (m.op === 'body') {
const st = inflight.get(m.id);
if (!st) return;
const buf = Buffer.from(m.b64 || '', 'base64');
st.size += buf.length;
if (st.size > CFG.maxBodyMb * 1048576) { // 和服务端同一个上限,双保险
st.ac.abort();
inflight.delete(m.id);
return send({ id: m.id, ev: 'error', msg: 'body too large' });
}
st.chunks.push(buf);
} else if (m.op === 'end') {
const st = inflight.get(m.id);
if (!st) return;
inflight.delete(m.id);
handleRequest(m.id, st);
} else if (m.op === 'abort') {
const st = inflight.get(m.id);
if (st) { st.ac.abort(); inflight.delete(m.id); }
}
}
// gzip 阈值:小于 1KB 压了反而亏(gzip 头开销),超过 8MB 不进内存直接流式
const COMPRESSIBLE = /^(text\/|application\/(json|javascript|xml|x-javascript)|image\/svg)/i;
const GZ_MIN = 1024;
const GZ_MAX = 8 * 1024 * 1024;
async function handleRequest(id, st) {
const { meta, chunks, ac } = st;
const svc = pickService(meta);
if (!svc) {
return send({ id, ev: 'error', msg: '没有匹配的本地服务: host=' + ((meta.headers || {}).host || '?') });
}
const headers = {};
for (const [k, v] of Object.entries(meta.headers || {})) {
const lk = k.toLowerCase();
if (lk === 'host' || lk === 'connection' || lk === 'content-length' || lk === 'expect') continue;
headers[k] = v;
}
// 强制不压缩:本端 fetch 会自动解压响应体,若保留 gzip 头,下游浏览器会拿明文当压缩流解析
headers['accept-encoding'] = 'identity';
const body = chunks.length ? Buffer.concat(chunks) : undefined;
try {
const r = await fetch('http://127.0.0.1:' + svc.port + meta.path, {
method: meta.method,
headers,
body,
signal: ac.signal,
redirect: 'manual', // 302 要原样交给浏览器,别在这里跟丢
});
const outHeaders = {};
r.headers.forEach((v, k) => { outHeaders[k] = v; });
const ct = String(outHeaders['content-type'] || '');
const cl = Number(outHeaders['content-length']) || 0;
delete outHeaders['content-encoding']; // 体已被 fetch 解压,长度也对不上,统一走 chunked
delete outHeaders['content-length'];
delete outHeaders['transfer-encoding'];
// 可压缩、大小已知且在阈值内:缓冲后 gzip 再发。跨境链路上带宽是瓶颈,
// JS/CSS/JSON 能压到 1/4 左右。SSE 不能缓冲(会毁掉流式),大文件不进内存,
// 已压缩的二进制(图片/zip)压了反而变大——这几种都走下面的原路径。
if (COMPRESSIBLE.test(ct) && !/event-stream/i.test(ct) && cl > 0 && cl <= GZ_MAX) {
const buf = Buffer.from(await r.arrayBuffer());
const gz = buf.length >= GZ_MIN ? zlib.gzipSync(buf, { level: 6 }) : null;
if (gz && gz.length < buf.length * 0.9) { // 压不动(已压缩/随机数据)就发明文
outHeaders['content-encoding'] = 'gzip';
send({ id, ev: 'head', status: r.status, headers: outHeaders });
send({ id, ev: 'data', b64: gz.toString('base64') });
} else {
send({ id, ev: 'head', status: r.status, headers: outHeaders });
send({ id, ev: 'data', b64: buf.toString('base64') });
}
send({ id, ev: 'end' });
return;
}
send({ id, ev: 'head', status: r.status, headers: outHeaders });
if (r.body) {
for await (const chunk of r.body) send({ id, ev: 'data', b64: Buffer.from(chunk).toString('base64') });
}
send({ id, ev: 'end' });
} catch (e) {
if (ac.signal.aborted) return; // 对端主动取消,不算错误
send({ id, ev: 'error', msg: (e.message || String(e)) + (e.cause ? ' | cause: ' + (e.cause.message || e.cause) : '') });
}
}
// ---------- 连接 / 重连 ----------
// 日志只在状态变化时说:启动一条、连上一条、断开一条,重试过程完全静默
// (和 MCP 服务一个风格:启动时报一次自己在哪,之后没人连也不刷屏)。
let linked = false; // 当前是否连着
let everLinked = false; // 是否连上过(区分首连和重连)
function connect() {
if (stopping) return;
const sep = CFG.server.includes('?') ? '&' : '?';
const url = CFG.server + sep + 'token=' + encodeURIComponent(CFG.token);
ws = new WebSocket(url, {
headers: { 'User-Agent': CFG.userAgent },
handshakeTimeout: 20000,
perMessageDeflate: false, // 关压缩:SSE 小帧多,压缩反而添乱且增加特征
});
ws.on('open', () => {
backoff = 1000;
linked = true;
lastSeen = Date.now();
log(everLinked ? '已重新连接' : '已连接 ' + CFG.server);
everLinked = true;
});
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) { // 只在「连着 → 断开」这个跳变上说一次
linked = false;
log('断开' + (reason ? ':' + reason : '') + ',重连中');
}
setTimeout(connect, backoff);
backoff = Math.min(backoff * 2, 30000); // 指数退避,封顶 30s
});
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); });
// 启动:一条说清楚往哪连、暴露了什么(之后只在状态变化时再说)
log('隧道 → ' + CFG.server + '(' + CFG.services.map(s => s.host + '→127.0.0.1:' + s.port).join(', ') + ')');
// 本地端口不通时早点说(只报问题,正常不吭声)
for (const s of CFG.services) {
const req = http.request({ host: '127.0.0.1', port: s.port, path: '/', method: 'HEAD', timeout: 3000 }, (res) => res.resume());
req.on('error', (e) => log('警告:127.0.0.1:' + s.port + ' 不可达(' + e.code + '),本地服务没起来?'));
req.on('timeout', () => { req.destroy(); log('警告:127.0.0.1:' + s.port + ' 超时'); });
req.end();
}
connect();
+24
View File
@@ -0,0 +1,24 @@
# tunnel 独立编排:只跑隧道服务端,和 agent 的 compose 互不相干
# cd tunnel && docker compose up -d
#
# 首次启动会自己生成 ./data/server.yml(含随机 token)并打印到日志:
# docker compose logs | grep TOKEN
# 把那个 token 填到家里 client.yml 的 token 即可。
services:
tunnel:
build: .
image: agent-tunnel:latest
container_name: agent-tunnel
restart: unless-stopped
ports:
# IP 直连:http://<服务器IP>:19000
- "${TUNNEL_PORT:-19000}:19000"
# 固定端口路由(一个端口钉一个服务):先在 data/server.yml 的 routes 里配好,再放开对应端口
# - "${TUNNEL_PORT_AGENT:-19001}:19001"
# - "${TUNNEL_PORT_NAS:-19002}:19002"
volumes:
# 挂目录而不是单文件:server.yml 不存在时 docker 会造个同名目录,单文件挂载会踩这个坑
- ./data:/app/data
environment:
- TZ=Asia/Shanghai
- TUNNEL_CONFIG=/app/data/server.yml
+48
View File
@@ -0,0 +1,48 @@
{
"name": "agent-tunnel",
"version": "0.1.0",
"lockfileVersion": 3,
"requires": true,
"packages": {
"": {
"name": "agent-tunnel",
"version": "0.1.0",
"dependencies": {
"ws": "8.23.0",
"yaml": "2.6.1"
}
},
"node_modules/ws": {
"version": "8.23.0",
"resolved": "https://registry.npmjs.org/ws/-/ws-8.23.0.tgz",
"integrity": "sha512-wCkmX8QMOrKjgO8HW2WyDbTSGeqkocxgDzS9iR79rEAexty6/2qzilx3Ag8Tqf9ykop3irLKle0MtVn5qjVnoQ==",
"license": "MIT",
"engines": {
"node": ">=10.0.0"
},
"peerDependencies": {
"bufferutil": "^4.0.1",
"utf-8-validate": ">=5.0.2"
},
"peerDependenciesMeta": {
"bufferutil": {
"optional": true
},
"utf-8-validate": {
"optional": true
}
}
},
"node_modules/yaml": {
"version": "2.6.1",
"resolved": "https://registry.npmjs.org/yaml/-/yaml-2.6.1.tgz",
"integrity": "sha512-7r0XPzioN/Q9kXBro/XPnA6kznR73DHq+GXh5ON7ZozRO6aMjbmiBuKste2wslTFkC5d1dw0GooOCepZXJ2SAg==",
"bin": {
"yaml": "bin.mjs"
},
"engines": {
"node": ">= 14"
}
}
}
}
+15
View File
@@ -0,0 +1,15 @@
{
"name": "agent-tunnel",
"version": "0.1.0",
"private": true,
"description": "通用反向隧道:把本机 HTTP 服务经服务器中转,按 Host 路由,支持流式响应",
"main": "server.js",
"scripts": {
"server": "node server.js",
"client": "node client.js"
},
"dependencies": {
"ws": "8.23.0",
"yaml": "2.6.1"
}
}
+257
View File
@@ -0,0 +1,257 @@
#!/usr/bin/env node
'use strict';
// 通用反向隧道 · 服务器端
// 浏览器/手机 ──https──> nginx ──> 本进程 ──WebSocket──> 本机(家里) client ──> 127.0.0.1:port
//
// 本进程不认识任何业务:只按请求的 Host 头把字节搬给 client,client 再按自己的
// services 配置找本地端口。所以任何 HTTP 服务接进来都不用改这里的代码。
//
// 用法: node server.js [config.yml] 环境变量 TUNNEL_PORT / TUNNEL_TOKEN 覆盖配置
// 协议: 见 README.md「隧道协议」一节
const http = require('node:http');
const fs = require('node:fs');
const crypto = require('node:crypto');
const path = require('node:path');
const YAML = require('yaml');
const { WebSocketServer } = require('ws');
// ---------- 配置 ----------
function loadConfig() {
const file = process.env.TUNNEL_CONFIG || process.argv[2] || path.join(__dirname, 'server.yml');
let cfg = {};
let dirty = false;
if (fs.existsSync(file)) {
try { cfg = YAML.parse(fs.readFileSync(file, 'utf8')) || {}; } catch (e) {
console.error('[tunnel] ' + file + ' 不是合法 YAML:' + e.message);
process.exit(1);
}
} else {
dirty = true; // 没有配置文件 → 首次启动
}
cfg.port = Number(process.env.TUNNEL_PORT || cfg.port || 19000);
cfg.token = String(process.env.TUNNEL_TOKEN || cfg.token || '');
cfg.maxBodyMb = Number(cfg.maxBodyMb || 64);
cfg.heartbeatMs = Number(cfg.heartbeatMs || 25000);
// 没 token 就现生成一个随机串并落盘:省掉「先手写配置再启动」这一步,
// docker compose up -d 直接就能跑。落盘失败也不阻断(本次仍可用)。
if (!cfg.token) {
cfg.token = crypto.randomBytes(24).toString('base64url');
dirty = true;
}
if (dirty) {
try {
fs.mkdirSync(path.dirname(file), { recursive: true });
const out = { port: cfg.port, token: cfg.token, maxBodyMb: cfg.maxBodyMb, heartbeatMs: cfg.heartbeatMs };
if (Array.isArray(cfg.routes) && cfg.routes.length) out.routes = cfg.routes;
// 写回带注释的模板:YAML.stringify 本身会丢掉注释,头部这几行手动拼。
// 这份自动生成的 server.yml 就是字段说明的唯一出处(不另维护示例文件)。
const head = '# tunnel 服务端配置(首次启动自动生成,可直接改,改完重启生效)\n'
+ '# port 本端口,按 Host 头路由\n'
+ '# token 必须和家里 client.yml 里的一致\n'
+ '# maxBodyMb 单请求体上限(MB)\n'
+ '# heartbeatMs 心跳间隔(ms),跨境链路靠它发现半死连接\n'
+ '# routes 可选,固定端口路由:一个端口钉死一个服务(每个 port 还要在\n'
+ '# docker-compose.yml 的 ports 里放开)。写法:\n'
+ '# routes:\n'
+ '# - port: 19001\n'
+ '# service: agent\n';
fs.writeFileSync(file, head + YAML.stringify(out));
console.log('============================================================');
console.log(' 首次启动,已生成配置:' + file);
console.log(' TOKEN: ' + cfg.token);
console.log(' ↑ 填到家里 client.yml 的 token,然后重启 client');
console.log('============================================================');
} catch (e) {
console.error('[tunnel] 写配置失败:' + e.message + '(本次 token 仅进程内有效)');
}
}
return cfg;
}
const CFG = loadConfig();
// ---------- 连接状态 ----------
let client = null; // 家里那条 WS(只允许一条,新的顶掉旧的)
const pending = new Map(); // id -> { res, timer }
let seq = 0;
const nextId = () => 'r' + (++seq).toString(36) + Math.random().toString(36).slice(2, 6);
// 逐跳头:只对单段连接有意义,不能透传
const HOP_BY_HOP = new Set(['connection', 'keep-alive', 'proxy-authenticate', 'proxy-authorization',
'te', 'trailer', 'transfer-encoding', 'upgrade']);
function log(...a) { console.log(new Date().toISOString().slice(11, 19), '[server]', ...a); }
// ---------- HTTP:把请求搬给 client ----------
// fixedService:由「固定端口路由」传进来(无域名时一个端口对一个服务);null = 按 Host 头路由
function handleRequest(req, res, fixedService) {
// 健康检查:只在主端口答,固定端口一律当业务流量转走
if (!fixedService && req.url === '/__tunnel/health') {
return json(res, 200, {
ok: true,
client: client ? 'online' : 'offline',
pending: pending.size,
uptime_s: Math.round(process.uptime()),
});
}
if (!client || client.readyState !== 1) {
return json(res, 503, { error: 'tunnel client offline', hint: '家里那台没连上,或 token 不对' });
}
const id = nextId();
const headers = {};
for (const [k, v] of Object.entries(req.headers)) if (!HOP_BY_HOP.has(k)) headers[k] = v;
pending.set(id, { res, timer: null });
const frame = { id, op: 'req', method: req.method, path: req.url, headers };
if (fixedService) frame.service = fixedService; // 端口绑定的服务名,client 优先按它找
client.send(JSON.stringify(frame));
let size = 0;
let overflow = false;
req.on('data', (chunk) => {
if (overflow) return;
size += chunk.length;
if (size > CFG.maxBodyMb * 1048576) { // 超限直接掐,别把内存吃穿
overflow = true;
client.send(JSON.stringify({ id, op: 'abort' }));
pending.delete(id);
return json(res, 413, { error: 'body too large', limit_mb: CFG.maxBodyMb });
}
client.send(JSON.stringify({ id, op: 'body', b64: chunk.toString('base64') }));
});
req.on('end', () => { if (!overflow) client.send(JSON.stringify({ id, op: 'end' })); });
// 客户端提前断开:让家里把上游请求也停掉,别白跑。
// 必须挂在 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);
});
}
// 主端口:按 Host 路由(有域名时的常规形态)
const server = http.createServer((req, res) => handleRequest(req, res, null));
// 固定端口:routes[{port, service}],一个端口钉死一个服务(没有域名也能多服务)
const extraServers = [];
for (const r of (CFG.routes || [])) {
const port = Number(r && r.port);
const service = String((r && r.service) || '').trim();
if (!port || !service) continue;
const s2 = http.createServer((req, res) => handleRequest(req, res, service));
s2.on('error', (e) => log('固定端口 ' + port + ' 起不来:' + e.message));
s2.listen(port, () => log('固定端口 ' + port + ' → 服务 "' + service + '"'));
extraServers.push(s2);
}
// ---------- client 回传的响应事件 ----------
function onClientMessage(raw) {
let m;
try { m = JSON.parse(raw); } catch (_) { return log('丢弃坏帧'); }
const entry = pending.get(m.id);
if (!entry) return; // 已超时/已断开,安静丢弃
const { res } = entry;
try {
if (m.ev === 'head') {
const h = {};
for (const [k, v] of Object.entries(m.headers || {})) {
const lk = k.toLowerCase();
// content-length 必然对不上(客户端已解压 / 分帧传输),交给 chunked
if (HOP_BY_HOP.has(lk) || lk === 'content-length') continue;
h[k] = v;
}
res.writeHead(m.status || 502, h);
} else if (m.ev === 'data') {
res.write(Buffer.from(m.b64 || '', 'base64'));
} else if (m.ev === 'end') {
res.end();
pending.delete(m.id);
} else if (m.ev === 'error') {
if (!res.headersSent) res.writeHead(502, { 'content-type': 'text/plain; charset=utf-8' });
res.end('tunnel error: ' + (m.msg || 'unknown'));
pending.delete(m.id);
}
} catch (e) {
log('回写失败', m.id, e.message);
try { res.destroy(); } catch (_) {}
pending.delete(m.id);
}
}
// ---------- WebSocket 升级:家里连上来 ----------
const wss = new WebSocketServer({ noServer: true });
server.on('upgrade', (req, socket, head) => {
const url = new URL(req.url, 'http://placeholder');
if (url.pathname !== '/tunnel') { socket.destroy(); return; }
if (url.searchParams.get('token') !== CFG.token) {
socket.write('HTTP/1.1 401 Unauthorized\r\n\r\n');
socket.destroy();
return log('拒绝:token 不匹配', req.socket.remoteAddress);
}
wss.handleUpgrade(req, socket, head, (ws) => {
if (client && client.readyState === 1) {
log('新连接顶掉旧连接');
try { client.close(4000, 'replaced by new connection'); } catch (_) {}
}
client = ws;
ws.isAlive = true;
log('client 已连接', req.socket.remoteAddress);
ws.on('pong', () => { ws.isAlive = true; });
ws.on('message', onClientMessage);
ws.on('close', () => {
if (client === ws) client = null;
log('client 断开,未完成请求 ' + pending.size + ' 个一并收尾');
// 连接没了,等在途的请求不可能再有响应,直接 502,别让浏览器干等
for (const [id, e] of pending) {
try { if (!e.res.headersSent) e.res.writeHead(502); e.res.end('tunnel client disconnected'); } catch (_) {}
pending.delete(id);
}
});
ws.on('error', (e) => log('client 错误', e.message));
});
});
// 心跳:跨境链路半死状态(TCP 还在但早不通了)靠这个发现
setInterval(() => {
if (!client || client.readyState !== 1) return;
if (client.isAlive === false) { log('心跳超时,踢掉 client'); try { client.terminate(); } catch (_) {} client = null; return; }
client.isAlive = false;
try { client.ping(); } catch (_) {}
}, CFG.heartbeatMs).unref();
// 在途请求超时兜底:SSE 长连接不该被砍,所以只在「还没收到 head」时计时
setInterval(() => {
const now = Date.now();
for (const [id, e] of pending) {
if (e.res.headersSent) continue;
if (!e.born) { e.born = now; continue; }
if (now - e.born > 120000) {
log('请求 120s 无响应,放弃', id);
try { e.res.writeHead(504); e.res.end('tunnel upstream timeout'); } catch (_) {}
pending.delete(id);
if (client && client.readyState === 1) client.send(JSON.stringify({ id, op: 'abort' }));
}
}
}, 10000).unref();
function json(res, code, obj) {
const body = JSON.stringify(obj);
res.writeHead(code, { 'content-type': 'application/json; charset=utf-8', 'content-length': Buffer.byteLength(body) });
res.end(body);
}
// SSE / 长轮询不能被 Node 的默认超时砍掉
server.timeout = 0;
server.headersTimeout = 60000;
server.keepAliveTimeout = 65000;
server.listen(CFG.port, () => {
log('监听 0.0.0.0:' + CFG.port + ',健康检查 /__tunnel/health');
log('等待 client 连接 wss://<本机域名>/tunnel?token=***');
});
+1 -1
View File
@@ -1,7 +1,7 @@
{
"name": "wxbot",
"version": "1.0.0",
"description": "wxbot.foresh.com: WeChat iLink bot console - QR login page + echo bot via @wechatbot/wechatbot",
"description": "WeChat iLink bot console - QR login page + echo bot via @wechatbot/wechatbot",
"type": "module",
"main": "src/server.js",
"scripts": {