101 Commits
Author SHA1 Message Date
kicer 3df103cd45 feat(device): 0.1.1——shell_ver 编码兜底、all 目标补 linux/mips 软浮点
- shellInfo 拿到的版本号先过 toUTF8:utf8.Valid 为真(英文版 Windows 的
  纯 ASCII、本来就是 UTF-8 的系统)原样返回,只有不是合法 UTF-8 时才按
  GBK 解,解不出来保留原样。中文 Windows 的 `cmd /c ver` 是 GBK,之前
  hello 上报的 shell_ver 显示成「Microsoft Windows [�汾 10.0.19045.7807]」。
- build.sh 的 all 目标补 linux/mips,并固定 GOMIPS=softfloat(AR9331 这类
  OpenWrt 设备没有 FPU,硬浮点二进制一跑就是非法指令);docker 分支同步。
- version 0.1.0 → 0.1.1,两台设备版本号一致但代码不同的坑到此为止。
2026-11-20 14:50:29 +08:00
kicer c9dd5e48bd fix(device): 所有 exec 统一走 newCmd,不再让 os/exec 去打开 NUL
上一版只给 run() 的命令加了空 stdin,实测命令能跑了,但设备 hello 里
shell_ver 仍然是空——启动时 shellInfo 探测 `cmd /c ver` 走的是同一条
os/exec 路径,照样死在 open NUL 上。同一个坑还有 killProc 里的 taskkill:
超时终止时那一步失败,进程组杀不掉。

- 抽出 newCmd(ctx, name, args...):Stdin 统一给 strings.NewReader(""),
  空 reader 与 NUL 语义一致(子进程读到立即 EOF),不依赖进程 cwd。
- run() / shellInfo() / proc_windows.killProc() 三处都改走 newCmd。
- 保留上一版 main() 里的 os.Chdir(r.root):本机 NUL 打不开不是 cwd 的锅,
  但把进程 cwd 钉在工作根上没坏处(相对路径的设备名和相对路径文件都更稳)。
2026-11-20 14:26:31 +08:00
kicer 47a0b9e50d fix(device): Windows 上命令起不来——不依赖 os/exec 打开空设备 NUL
设备 pc-gd(windows/amd64)执行任何命令都返回
  device=pc-gd exit=127 启动失败:open NUL: The system cannot find the file specified.

os/exec 在 Stdin 为 nil 时会自己 os.Open(os.DevNull),Windows 上那是相对路径的
设备名 "NUL",CreateFile 解析它要先拼进程的当前目录;cwd 失效(快捷方式起始位置
指向已删目录、启动目录被改名等)时直接 ERROR_FILE_NOT_FOUND,命令还没到 cmd.exe
就死了。旁证:同一台设备 hello 里 shell_ver 为空——启动时探测 `cmd /c ver` 走的
是同一条路,一样失败。

- run(): 显式给 cmd.Stdin 一个空 reader,绕开 os/exec 内部的 open("NUL")。
  空 reader 与 NUL 语义一致(子进程读到立即 EOF),且不依赖进程 cwd。
- main(): MkdirAll 工作根之后 os.Chdir(r.root),把 cwd 钉在一个确定存在的绝对
  路径上(失败只记日志,不致命),顺带让 shellInfo 的版本探测能跑通。
2026-11-20 14:09:57 +08:00
kicer 490afd6977 fix(engine): 压缩回合带工具时摘要仍算摘要,工具回执直接当续跑输入
自动压缩切进压缩回合后,模型常为了把交接摘要写准先调一次工具查证
(实测 grep style.css 核对「已改/未改」)。原判定是 !hasTools && compressing,
于是这一轮的文字被当成普通回复落库并推给前端,回合继续执行工具后模型又从头
重写一遍摘要——库里留下两条正文不同的交接说明(5350 字 / 5640 字),
用户侧看到两条【交接说明】。

- 判定改成「压缩回合回来的第一段非空文本就是摘要」,带不带工具都算;
  空文本(纯工具调用)不算,run.summarizing 保持,下一轮继续压。
- 摘要行连 tool_calls 一起落库(type='summary' 照常是上下文起点,回执紧跟其后
  不会被归档,配对合法),工具执行完回执本身就是续跑输入,不再插
  「上下文已压缩,请继续完成原任务。」;无工具回执时才补那条 user 指令。
- 顺带修正两处与代码相反的注释(压缩回合其实是带 tools 发的,为保前缀缓存)。
2026-11-20 12:42:13 +08:00
kicer 7dd6e5d12d feat(chat): 工具卡状态标记统一为灰弧旋转;思考面板改标题行动态文字
工具卡:
- 参数生成阶段原来是蓝色脉冲、执行阶段变灰转圈,颜色跳变突兀;
  现在两段共用同一段 SVG 弧和同一个 tool-spin 动画,只在完成后停转换成
  灰色 ✓/✕(用 sprite 里的 #i-check / #i-x-line,不加颜色)。
- 转圈动画挂在 .spin 容器上而不是 svg 元素:CSS transform 默认原点是 0 0,
  直接转 svg 会绕左上角甩,看着像没动。
- 文本 ◌ 是对称圆,转起来看不出在动,换成缺一角的弧。

思考面板:
- 流式阶段不再展开(展开的大段思考会把下面的内容一路顶下去),
  改为在「思考过程」标题行挂一行灰色省略文字,持续换最后一行;
  正文开始后清空,需要看全文再点开。
- 工具输出跟随滚动阈值 40→8 并补一帧贴底,避免大 chunk 一次没滚到底。
2026-11-20 12:21:01 +08:00
kicer e0cba62a0c fix(engine): 中断/网络失败后作废增量指针,避免与 relay 缓存错位
「停止」「立即发送」会在 fetch 拿到响应头前 abort,而 relay 侧收到上游 200 就把增量写进缓存了。core 的 ctxState 还停在上一轮,下一轮把同一批增量再发一次,relay 重复拼接 → 上游 tool_call_mismatch 400,之后每轮都错。

catch 里对没有 upstream_status 的错误(网络中断、AbortError)作废指针,下一轮走全量 + Reset 覆盖;有 upstream_status 的 429/5xx 保留指针(relay 确定没写缓存),继续用空增量重试更省。
2026-11-20 11:17:45 +08:00
kicer ba20a4f39d feat: terminal 执行中增量输出走 SSE(tool_output),工具卡实时滚动 2026-11-20 11:03:18 +08:00
kicer 02c154ae24 feat(profile): 偏好改多行原样文本(PREF_MAX 1000);移除 AI 侧 profile 工具 2026-11-20 09:28:02 +08:00
kicer 2f0b056a63 feat(device): 工作根支持相对路径,按可执行文件目录解析(不越出该目录) 2026-11-20 09:18:00 +08:00
kicer 7212e0dfee ci: agent-device release 支持手动触发(workflow_dispatch 输入 tag)
agent-device release / release (push) Waiting to run
2026-11-20 08:09:48 +08:00
kicer 29e4690982 ci: GitHub Actions 按 agent-device-v* 标签编译并发布 Release
agent-device release / release (push) Waiting to run
2026-11-19 22:16:54 +08:00
kicer 1eeaf38009 docs: AGENTS.md / README.md 补 device 执行端(架构、端口、env、主链路、工具与约束) 2026-11-19 21:55:06 +08:00
kicer 1fd04e2607 chore: core 日志轮转 20m×5;device push 日志补本地文件名 2026-11-19 21:34:44 +08:00
kicer 92f0f16070 feat(device): 工具调用加日志(info 记动作/设备/耗时/命令截断)
exec/pull/push 记 info,失败升 warn,list/health 走 debug。
命令压成一行截断 120 字符,不记录 stdout/stderr 内容。
2026-11-19 21:32:49 +08:00
kicer 0e2f7c219f refactor(device): list 不再带 health 快照
那份值是设备上线时取的一次性快照,会随连接时长过期,放在 list 里容易被当成实时状态。
health 改为纯按需查询(action=health),list 只留设备身份与在线信息。
2026-11-19 19:50:20 +08:00
kicer 1e7f3e76ee fix(device): macOS 补上 uptime / load / 可用内存
darwin 分支原来只取内存总量,其余一律 -1。改为调 sysctl(kern.boottime /
vm.loadavg) 与 vm_stat;可用内存按 free+inactive+speculative 算(只看 free
会把缓存当占用,数字小得吓人)。温度需要 SMC,保持 -1。
2026-11-19 19:31:36 +08:00
kicer 938a99cabe perf(device): 大文件支持到 2GiB,超时改空闲判定
- 单文件上限 50MiB → 2GiB(两侧)
- pull 超时改成空闲看门狗:首块 30s,之后每块重置 30s,稳定但慢的链路不再被误杀
- pull 写盘背压:磁盘慢时 ws.pause(),drain 后 resume,结束时兜底恢复(否则连接会永久停住)
- push 改流式读 + 流式算 sha,不再整文件进内存;发完最后一包才等设备确认
2026-11-19 19:22:08 +08:00
kicer 3c9f9d2bdb feat(device): 文件通道 pull/push
core 与设备复用同一条 WS 搬文件:256KiB 分块、base64、50MiB 上限,
写盘先 .part 再校验 size/sha256 后 rename;device 工具新增 pull/push 两个动作。
2026-11-19 19:01:34 +08:00
kicer 4a36cc0266 feat(device): shell 支持配置绝对路径与 busybox,默认仍为 sh/cmd
不做自动探测(各系统 shell 变体太多,交给配置);配了路径就按 POSIX 语义 -c 执行,
busybox 走 sh -c;上报给 core 的 shell 归成短标签(bash/busybox/sh/cmd/powershell)。
2026-11-19 18:16:32 +08:00
kicer af2e4a1c20 refactor(device): 二进制改名 agent-device,默认读同目录 config.json
- 输出名 agent-device-<os>-<arch>,避免和仓库名/agent-core 在 ps 里混淆
- 不带 -config 时自动加载可执行文件同目录的 config.json(存在才读)
- 启动日志打印实际加载的配置文件路径
2026-11-19 17:31:21 +08:00
kicer 4333a53dd3 feat(device): 设备端源码独立成 device/,可脱离具体服务器编译运行
- 模块名去掉私有域名(agent-device),import 路径中性化
- 二进制不内置任何服务器地址与 token,-server 必填
- 新增 -config:token 可放 JSON 文件,避免 ps 泄露
- scripts/build.sh 只做本地构建(有 Go 用 Go,没 Go 用 docker 镜像)
- README 面向使用者,部署细节不进仓库
2026-11-19 17:21:12 +08:00
kicer 7d855454a8 refactor(device): 去掉 caps,shell 改报路径与版本
能力清单会过期且探测不可靠(Store stub、非登录 shell 的 PATH 差异),
交给模型现场自查;shell 是命令入口,补 shell_path/shell_ver。
2026-11-19 16:56:51 +08:00
kicer 1859fe0d5b feat(init): init.sh 生成并复用 DEVICE_TOKEN(设备接入用) 2026-11-19 16:42:01 +08:00
kicer 925cf18da9 chore(compose): core 注入 DEVICE_TOKEN(可选,留空不启用设备接入) 2026-11-19 16:38:25 +08:00
kicer 54c33dd7f1 feat(device): 新增 device 工具,远端设备执行 list/health/exec
设备主动出站连 wss://<公网前缀>/dev/ws,core 维护连接表;本地无公网前缀或未配
DEVICE_TOKEN 时端点不挂,行为与原来一致。
2026-11-19 16:37:49 +08:00
kicer 4ff8b93025 fix(engine): 增量上下文作废按 sessionId 现查,修复编辑后仍发增量
getSession() 只查 sessions 表,返回对象没有 history 字段,contextIdOf 里 archivedCount(session.history) 恒得 0。编辑/删除/清空四处入口的 invalidateContext 于是全作用在 "…:0" 上,压缩过的会话真实 cid(如 "…:3031")从没被作废,编辑完仍旧发增量,relay 缓存里留着已删除的行,上游随即 tool_call_mismatch。

改为拿不到 history 时按 sessionId 现查 count(type='archived');runLoop 热路径仍走内存计数。另把「模型调用失败」文案落库标为 type='error_note':buildMessages 跳过、微信不外发,避免失败文案被当成模型回复带进后续轮次。
2026-11-19 15:42:48 +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
102 changed files with 6563 additions and 1620 deletions
+53
View File
@@ -0,0 +1,53 @@
name: agent-device release
# 只认设备端标签(agent-device-v0.1.0),不碰主项目的 v2.5.0 这类版本号。
on:
push:
tags:
- 'agent-device-v*'
workflow_dispatch: # 兜底:页面上手动跑,填一个已存在的标签
inputs:
tag:
description: '要发布的标签(已存在),如 agent-device-v0.1.0'
required: true
permissions:
contents: write # action-gh-release 需要建 release、传附件
jobs:
release:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: actions/setup-go@v5
with:
go-version-file: device/go.mod
cache-dependency-path: device/go.sum
# 复用仓库里的脚本,本地和 CI 一套目标列表
- name: 编译各平台
working-directory: device
run: sh scripts/build.sh all
- name: 发布 Release
uses: softprops/action-gh-release@v2
with:
name: ${{ inputs.tag || github.ref_name }}
tag_name: ${{ inputs.tag || github.ref_name }}
files: device/bin/agent-device-*
fail_on_unmatched_files: true
body: |
设备执行端 agent-device(`device/`)。
- 设备主动出站连 core 的 `/dev/ws`,不需要公网 IP、不需要开端口
- 二进制不含服务器地址与 token,启动时用 `-server` 或同目录 `config.json` 指定
- 模型侧可用 `device` 工具跑命令、看负载、收发文件
| 平台 | 文件 |
| --- | --- |
| Linux amd64 / arm64 / mips | `agent-device-linux-*` |
| macOS amd64 / arm64 | `agent-device-darwin-*` |
| Windows amd64 | `agent-device-windows-amd64.exe` |
`linux-mips` 是软浮点(`GOMIPS=softfloat`),给 AR9331 这类没 FPU 的 OpenWrt 设备用。
+6
View File
@@ -14,8 +14,14 @@ local/config.local.yml
skills/office/bin/
skills/**/__pycache__/
*.log
# 读图压缩缓存(会话工作目录 = 仓库根时落在仓库里)
.imgcache/
.DS_Store
app/server/version.json
*.apk
# 部署配置真身(含密钥,模板见 scripts/deploy.conf.example);
deploy.conf
relay/config.json
# 设备端编译产物(交叉编译后本地生成,不入库)
device/bin/
+31 -5
View File
@@ -10,6 +10,9 @@
`/chat/completions`)→ 模型调用内置工具 / MCP / 技能 → 命令在 `agent-executor` 隔离容器里执行 →
产物落在会话工作目录并回传。每个会话 = 一个真实 Linux 工作目录 + 一条 SQLite 会话记录。
另有一个可选的**设备执行端** `device/`:设备主动出站连 core 的 `/dev/ws`,模型用 `device`
工具在远端机器(Mac / Windows / OpenWrt 盒子)上跑命令、拉推文件。
设计基调:**单进程内存模型 + SQLite 同步 API**(JS 单线程,不存在跨进程竞争);**配置冷加载**
(改 `config.yml` 需重启,少数写盘接口例外);**单租户**(登录只把门,不做资源级授权)。
@@ -21,10 +24,12 @@
| `app/server/` | 后端全部代码(入口 `server.js`) | 见 `app/AGENTS.md` |
| `app/server/public/` | 前端静态资源,经典脚本按序加载,共享全局作用域 | 无构建步骤 |
| `executor/` | **agent-executor**:`/exec` 隔离命令执行 + Office 预览网关 | 零依赖 Node,独立容器 |
| `device/` | **agent-device**:设备执行端,出站连 core 的 `/dev/ws`,提供 exec / 文件传输 | Go 单二进制,交叉编译(amd64/arm64/mips/mipsle/windows),见 `device/README.md` |
| `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` |
| `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,13 +43,17 @@
```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
DEV["设备:Mac / Windows / OpenWrt"] -->|"wss 出站 /dev/ws"| CORE
```
- **对外只暴露 `agent-core` 一个端口**(宿主 `AGENT_PORT`,默认 8090)。executor、wxbot、MCP
@@ -53,12 +62,15 @@ flowchart TD
- 容器间按容器名访问(`http://agent-executor:9000`、`http://mcp_web_search:3000/`);
所有业务容器同在 `agent-mcp-net`(compose 里固定网络名,避免被加上项目名前缀)。
- `agent-executor-init` 是一次性容器:把技能依赖装进 `./skills/deps` 后退出,属正常现象。
- 设备(`device/`)**不需要任何入站端口**:设备主动连 `wss://<PUBLIC_BASE_URL 的 host>/dev/ws`,
core 按 `DEVICE_TOKEN` 校验。本地部署没有公网前缀,端点不挂,`device` 工具直接回“未启用”。
### 端口与网络(要改先看这里)
| 服务 | 端口 | 可见性 |
|---|---|---|
| `agent-core` | 8090 | 宿主机映射,**唯一对外** |
| `tunnel` server | 19000 | 仅 `127.0.0.1`,对外经 nginx 反代 |
| `agent-executor` | 9000(exec)、3100(预览网关) | 仅 `expose`,内网 |
| `agent-wxbot` | 8093 | 仅内网 |
| `mcp_*` | 3000 | 仅内网 |
@@ -72,6 +84,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) | 微信登录凭证 |
推论:
@@ -84,12 +97,12 @@ flowchart TD
### 环境变量(接线全靠根 `.env` + compose)
`AGENT_CONFIG`、`PORT`、`EXECUTOR_URL`、`EXECUTOR_TOKEN`、`WXBOT_URL`、`WXBOT_TOKEN`、
`PUBLIC_BASE_URL`、`ASR_URL`、`PREVIEW_PROXIES`、`EXECUTOR_LOG_LEVEL`、`WXBOT_LOG_LEVEL`、`ASR_LOG_LEVEL`。
`PUBLIC_BASE_URL`、`DEVICE_TOKEN`、`ASR_URL`、`PREVIEW_PROXIES`、`EXECUTOR_LOG_LEVEL`、`WXBOT_LOG_LEVEL`、`ASR_LOG_LEVEL`。
密钥生成:`./scripts/init.sh`(幂等,重跑不掉登录态;**从不覆盖已有 config.yml**,只在其缺失时创建
最小骨架)。语音识别的上游 key/base/model 不在 env,
写在 `config.yml` 的 `mcp_servers[name=asr].headers`(容器不存平台密钥)。
## 三条主链路
## 四条主链路
1. **Web / HTTP**:`app/server/server.js` 装配 → 路由 → `engine.js` 起回合 →
`llm.js` 组装并流式调用上游 → `tools/executor.js` 执行工具(`terminal` / `skill` 走
@@ -97,7 +110,10 @@ flowchart TD
2. **微信**:`agent-wxbot` 收消息 → 回调 core `/wxhook/inbox` → `wechat.js` 落媒体、注入上下文 →
`routes/channel.js` 的命令层(`/new` `/switch` `/think` …)→ 同一套 `engine`;回合结束由
SSE 内部订阅者(`bus.onInternal`)分段推回微信。
3. **定时任务**:`scheduler.js` 每 30s tick → 到期则先 `archiveHistory`(历史整体 `archived`,
3. **远端设备**:设备上的 `agent-device` 出站连 core `/dev/ws` → `devices.js` 维护连接表 →
模型调 `device` 工具(`list` / `health` / `exec` / `pull` / `push`)→ 命令经 WS 下发、输出分片
回传;`pull` 落到会话目录后,`read_file` / 技能可直接消费。
4. **定时任务**:`scheduler.js` 每 30s tick → 到期则先 `archiveHistory`(历史整体 `archived`,
模型等价新会话)→ `engine.postUserMessage` 投递 → 结束后 `wechat.notifyTask` 通知。
## 数据与状态
@@ -127,7 +143,9 @@ flowchart TD
「回合中会话数 → 在用会话数 → 最久未用」择优(详见 `app/AGENTS.md`)。
7. **运行时目录不入库**。`tasks/`、`data/`、`skills/deps/`、`wxbot/data/` 已被 gitignore;
不要把样例任务、数据库、密钥当成源码提交。
8. **工具 schema 是每轮全量重发的上下文成本**。新增工具前先读 `docs/tool-design.md`:能用已有工具
8. **设备是远端 shell**。`device exec` 在设备上就是 `sh -c` / `cmd /c`;`root` 只约束**起始
cwd**,命令里 `cd /etc` 照样能跑。`DEVICE_TOKEN` 泄漏等价于那台机器的 shell 泄漏,按这个等级管理。
9. **工具 schema 是每轮全量重发的上下文成本**。新增工具前先读 `docs/tool-design.md`:能用已有工具
的 `op` 扩展就不要新开工具。
## 开发与验证
@@ -163,6 +181,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 +199,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 +216,8 @@ 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`(先读顶部安全模型注释) |
| 改设备执行 / 文件传输 | `app/server/devices.js`(连接表 + exec/health/pull/push)+ `app/server/tools/executor.js` 的 `toolDevice` |
| 改设备端行为 | `device/cmd/agent/`(协议 `device/pkg/proto`,连接基座 `device/pkg/wsnode`) |
| 改隧道路由 / 转发 | `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` |
+48 -427
View File
@@ -1,483 +1,104 @@
# 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/` |
| 用户 | 其余账号、角色、默认模型;改密码在「账户」 |
| [`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) | 反向隧道:把本机服务经服务器中转,供外网访问 |
| [`device/`](device/README.md) | 设备执行端:任意机器装上就连回来,模型可在上面跑命令、传文件 |
对外只需要放行 core 这一个端口。`agent-executor`、`wxbot` 和 MCP 服务都只在 Docker 内网,不映射到宿主机。
## 远端设备
### 4. 同栈 MCP 服务
把任意一台机器(Mac / Linux / Windows / OpenWrt 盒子)接进来,让模型在它上面执行命令、读写文件:
初始 `config.yml` 不包含任何 MCP 服务。设置页「MCP」会把四个同栈服务作为**内置服务卡片**列出来,
点卡片 → 填表 → 保存即可(url 与 header 名由 `app/server/presets.json` 提供,不用记)。
`web_search` 免费、无需 key;另外三个要填上游 key。手工写 YAML 的形状如下(容器不存密钥):
1. 编译或下载 `device/` 的二进制,和 `config.json` 放在同一个目录:
```yaml
mcp_servers:
- name: web_search
url: "http://mcp_web_search:3000/"
```json
{ "server": "wss://你的域名/dev/ws", "token": "<DEVICE_TOKEN>", "root": "/Users/you", "name": "mac-01" }
```
# - 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
```
2. 直接运行(默认读同目录的 `config.json`,token 不会出现在 `ps` 里):
`web_search` / `image_task` / `video_task` / `asr` 四个容器与 core 由同一个根 `docker-compose.yml` 启动(与是否写进配置无关),没有先后顺序,也不占宿主机端口。工具说明、header 覆盖项与调试方式见 [mcp/README.md](mcp/README.md)。
```bash
./agent-device-darwin-amd64
```
`ASR_URL`(`docker-compose.yml` 里固定为 `http://mcp_asr:3000`)是 core 调用语音转写的基地址;把 `mcp_asr` 放到另一台机器时改这一行即可(那台要能接受 `Authorization` / `X-ASR-Base-Url` / `X-ASR-Model` 三个 header)。
3. 服务器 `.env` 里配同一个 `DEVICE_TOKEN` 并重启 core。
语音输入(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`。
---
设备**主动出站**连接,不需要公网 IP、不需要开端口。连上后模型侧多出 `device` 工具:
`list` 看在线设备、`health` 看负载、`exec` 跑命令、`pull`/`push` 收发文件(单个 2 GiB 以内)。
盒子上的常驻用系统自带的服务管理器(systemd / procd / schtasks),细节见 [`device/README.md`](device/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)。
+8 -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` |
@@ -211,6 +211,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 +359,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`。
## 扩展指南
+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 一致)。
+1 -1
View File
@@ -46,7 +46,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 又说了几句话」)
+22
View File
@@ -14,6 +14,7 @@
"multer": "1.4.5-lts.1",
"sharp": "0.35.4",
"turndown": "7.2.0",
"ws": "^8.23.0",
"yaml": "2.6.1"
}
},
@@ -2002,6 +2003,27 @@
"resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
"integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ=="
},
"node_modules/ws": {
"version": "8.23.0",
"resolved": "https://registry.npmmirror.com/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/xtend": {
"version": "4.0.2",
"resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.2.tgz",
+1
View File
@@ -13,6 +13,7 @@
"multer": "1.4.5-lts.1",
"sharp": "0.35.4",
"turndown": "7.2.0",
"ws": "^8.23.0",
"yaml": "2.6.1"
}
}
+14 -2
View File
@@ -83,7 +83,7 @@ const DEFAULTS = {
// 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 +93,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 +102,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 +240,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 +369,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 补过列(当时默认开,存量行都是默认值回填而非用户显式选择),
+448
View File
@@ -0,0 +1,448 @@
// 设备(远端执行节点)接入层。
//
// 设备主动出站连 wss://<公网前缀>/dev/ws,core 维护连接表;工具调用时把命令推下去、
// 把 stdout/stderr/退出码收回来。设备侧不需要任何入站端口,所以家里的盒子、公司的
// Windows 都能直接在 NAT 后面接进来。
//
// 启用条件:有公网前缀(config.yml public_link.base_url 或 env PUBLIC_BASE_URL)
// 且配了 DEVICE_TOKEN。本地部署两者都没有,设备也连不进来,端点干脆不挂。
const crypto = require('crypto');
const fs = require('fs');
const WebSocket = require('ws');
const log = require('./log');
const PATH = '/dev/ws';
const PING_MS = 20000; // nginx 默认 60s 空闲断,20s 足够安全
const DEAD_SEC = 61; // 超过这么久没任何消息 → 判假死
const HELLO_MS = 10000; // 连上后多久没 hello 就踢
const DEFAULT_TIMEOUT_MS = 120000;
const MAX_TIMEOUT_MS = 600000;
const MAX_OUT_CHARS = 256 * 1024; // 单流回传上限,超出截断(免得一次把上下文塞爆)
const state = {
enabled: false,
token: '',
wss: null,
byName: new Map(), // name -> device
pending: new Map(), // 请求 id -> { onChunk, onExit, onHealth }
};
function init(cfg) {
const base = String((cfg.public_link && cfg.public_link.base_url) || '').trim();
state.token = String(process.env.DEVICE_TOKEN || '').trim();
state.enabled = !!(base && state.token);
if (state.enabled) {
let host = base;
try { host = new URL(base).host; } catch (_) { /* 保留原文 */ }
log.info('devices', '设备接入已启用:wss://' + host + PATH);
} else {
log.info('devices', '设备接入未启用(' + (base ? '缺 DEVICE_TOKEN' : '无公网前缀') + ')');
}
return state.enabled;
}
function enabled() {
return state.enabled;
}
function tokenOK(given) {
if (!state.token) return false;
const a = Buffer.from(String(given || ''));
const b = Buffer.from(state.token);
return a.length === b.length && crypto.timingSafeEqual(a, b);
}
function attach(server) {
if (!state.enabled) return;
state.wss = new WebSocket.Server({ noServer: true, maxPayload: 8 * 1024 * 1024 });
server.on('upgrade', (req, socket, head) => {
let url;
try { url = new URL(req.url, 'http://x'); } catch (_) { return; }
if (url.pathname !== PATH) return; // 不认识的 upgrade 不归这层管
const hdr = String(req.headers.authorization || '');
const bearer = hdr.toLowerCase().startsWith('bearer ') ? hdr.slice(7).trim() : '';
if (!tokenOK(bearer || url.searchParams.get('token'))) {
log.warn('devices', '设备接入被拒:token 不匹配(来自 ' + (req.socket.remoteAddress || '?') + ')');
socket.write('HTTP/1.1 401 Unauthorized\r\n\r\n');
socket.destroy();
return;
}
state.wss.handleUpgrade(req, socket, head, ws => state.wss.emit('connection', ws, req));
});
state.wss.on('connection', onConnection);
setInterval(() => {
const now = Date.now();
for (const dev of state.byName.values()) {
if (now - dev.lastSeen > DEAD_SEC * 1000) {
log.warn('devices', '设备无消息超时,断开:' + dev.name);
try { dev.ws.terminate(); } catch (_) {}
continue;
}
try { dev.ws.send(JSON.stringify({ t: 'ping' })); } catch (_) {}
}
}, PING_MS).unref();
}
function onConnection(ws) {
const dev = {
ws, name: null, os: '', arch: '', shell: '', shellPath: '', shellVer: '', root: '', ver: '',
connectedAt: Date.now(), lastSeen: Date.now(), helloTimer: null,
};
dev.helloTimer = setTimeout(() => {
if (!dev.name) { try { ws.close(4001, 'hello timeout'); } catch (_) {} }
}, HELLO_MS);
ws.on('message', raw => {
let m;
try { m = JSON.parse(String(raw)); } catch (_) { return; }
dev.lastSeen = Date.now();
if (m.t === 'hello') return onHello(dev, m);
if (m.t === 'chunk') {
const p = state.pending.get(m.id);
if (p && p.onChunk) p.onChunk(m);
return;
}
if (m.t === 'exit') {
const p = state.pending.get(m.id);
if (p && p.onExit) p.onExit(m);
return;
}
if (m.t === 'file.chunk') {
const p = state.pending.get(m.id);
if (p && p.onFileChunk) p.onFileChunk(m);
return;
}
if (m.t === 'file.done') {
const p = state.pending.get(m.id);
if (p && p.onFileDone) p.onFileDone(m);
return;
}
if (m.t === 'health') {
const p = state.pending.get(m.id);
if (p && p.onHealth) p.onHealth(m);
}
});
ws.on('close', () => {
clearTimeout(dev.helloTimer);
if (dev.name && state.byName.get(dev.name) === dev) {
state.byName.delete(dev.name);
log.info('devices', '设备下线:' + dev.name);
}
});
ws.on('error', () => {});
}
function onHello(dev, m) {
clearTimeout(dev.helloTimer);
dev.name = String(m.name || '').trim() || ('dev-' + crypto.randomBytes(3).toString('hex'));
dev.os = String(m.os || '');
dev.arch = String(m.arch || '');
dev.shell = String(m.shell || '');
dev.shellPath = String(m.shell_path || '');
dev.shellVer = String(m.shell_ver || '');
dev.root = String(m.root || '');
dev.ver = String(m.ver || '');
const old = state.byName.get(dev.name);
if (old && old !== dev) {
log.warn('devices', '同名设备重新接入,踢掉旧连接:' + dev.name);
try { old.ws.close(4000, 'replaced'); } catch (_) {}
}
state.byName.set(dev.name, dev);
log.info('devices', `设备上线:${dev.name}(${dev.os}/${dev.arch} shell=${dev.shellPath || dev.shell} ${dev.shellVer} root=${dev.root})`);
}
function pick(name) {
if (name) return state.byName.get(String(name).trim()) || null;
const first = state.byName.values().next();
return first.done ? null : first.value;
}
function list() {
const now = Date.now();
return [...state.byName.values()].map(d => ({
device: d.name,
os: d.os,
arch: d.arch,
// shell 是模型的命令入口:kind 决定调用形式(sh -c / cmd /c),path 决定实际解释器
//(/bin/sh 可能是 dash、bash 或 busybox),ver 拿得到就给。
shell: d.shell,
shell_path: d.shellPath,
shell_ver: d.shellVer,
root: d.root,
ver: d.ver,
connected_sec: Math.round((now - d.connectedAt) / 1000),
idle_sec: Math.round((now - d.lastSeen) / 1000),
}));
}
function health(name) {
const dev = pick(name);
if (!dev) return Promise.reject(new Error(name ? `设备 ${name} 不在线` : '当前没有设备在线'));
const id = newJobId();
return new Promise((resolve, reject) => {
const timer = setTimeout(() => {
state.pending.delete(id);
reject(new Error(`设备 ${dev.name} 未在 5s 内回应 health`));
}, 5000);
state.pending.set(id, {
onHealth(m) {
clearTimeout(timer);
state.pending.delete(id);
resolve({
device: dev.name, os: dev.os, arch: dev.arch,
uptime_sec: m.uptime_sec, host_uptime_sec: m.host_uptime_sec,
load1: m.load1, load5: m.load5, load15: m.load15,
mem_total_mb: m.mem_total_mb, mem_free_mb: m.mem_free_mb,
disk_total_gb: m.disk_total_gb, disk_free_gb: m.disk_free_gb, temp_c: m.temp_c,
});
},
});
try {
dev.ws.send(JSON.stringify({ t: 'health', id }));
} catch (e) {
clearTimeout(timer);
state.pending.delete(id);
reject(new Error('下发 health 失败:' + e.message));
}
});
}
function newJobId() {
return crypto.randomBytes(6).toString('hex');
}
function exec({ device, command, cwd, timeout_ms }) {
return new Promise((resolve, reject) => {
const dev = pick(device);
if (!dev) return reject(new Error(device ? `设备 ${device} 不在线` : '当前没有设备在线'));
const cmd = String(command || '');
if (!cmd.trim()) return reject(new Error('command 不能为空'));
const tmo = Math.min(Math.max(Number(timeout_ms) || DEFAULT_TIMEOUT_MS, 1000), MAX_TIMEOUT_MS);
const id = newJobId();
const started = Date.now();
let out = '';
let err = '';
let truncated = false;
let settled = false;
const done = payload => {
if (settled) return;
settled = true;
clearTimeout(watchdog);
state.pending.delete(id);
resolve(payload);
};
// 兜底看门狗:设备侧本来就会按 timeout 杀进程,这里再晚 10s 收尸,防止设备掉线后永远挂着
const watchdog = setTimeout(() => {
done({
device: dev.name, code: -1, killed_by: 'watchdog', ms: Date.now() - started,
stdout: out, stderr: err, truncated,
note: '设备未在超时后回传结果(可能已掉线)',
});
}, tmo + 10000);
state.pending.set(id, {
onChunk(m) {
const text = Buffer.from(String(m.chunk || ''), 'base64').toString('utf8');
if (m.out === 'err') {
if (err.length + text.length > MAX_OUT_CHARS) { truncated = true; err += text.slice(0, Math.max(0, MAX_OUT_CHARS - err.length)); }
else err += text;
} else {
if (out.length + text.length > MAX_OUT_CHARS) { truncated = true; out += text.slice(0, Math.max(0, MAX_OUT_CHARS - out.length)); }
else out += text;
}
},
onExit(m) {
done({
device: dev.name,
code: typeof m.code === 'number' ? m.code : -1,
killed_by: m.killed_by || '',
ms: Number(m.ms) || Date.now() - started,
stdout: out,
stderr: err + (m.err ? String(m.err) : ''),
truncated: truncated || !!m.truncated,
});
},
});
try {
dev.ws.send(JSON.stringify({
t: 'exec', id, cmd, cwd: cwd ? String(cwd) : '', timeout_ms: tmo,
}));
} catch (e) {
state.pending.delete(id);
clearTimeout(watchdog);
reject(new Error('下发命令失败:' + e.message));
}
});
}
// ---------- 文件通道 ----------
// core 与设备之间拉/推单个文件,复用同一条 WS:256 KiB 一块,base64 传输。
// 写盘一律先落 .part,size 与 sha256 都对上才 rename——不留半截文件。
const FILE_CHUNK = 256 * 1024; // 每块 256 KiB
const MAX_FILE = 2 * 1024 * 1024 * 1024; // 单文件上限 2 GiB
const FIRST_CHUNK_MS = 30000; // 请求发出后等第一块(覆盖设备端 open/stat)
const IDLE_MS = 30000; // 块与块之间的空闲超时:只看卡不卡,不看总共多久
const DONE_WAIT_MS = 60000; // push 发完最后一包后等设备确认
const WS_HIGH = 4 * 1024 * 1024; // 发送缓冲高水位,超了就歇一会
const sleep = ms => new Promise(r => setTimeout(r, ms));
// 流式算 sha256:2 GiB 不能整块读进内存
function hashFile(p) {
return new Promise((resolve, reject) => {
const h = crypto.createHash('sha256');
fs.createReadStream(p)
.on('data', c => h.update(c))
.on('end', () => resolve(h.digest('hex')))
.on('error', reject);
});
}
// pull:设备 → 会话目录
// 超时按「空闲」算:首块 30s,之后每收到一块重置 30s。稳定但慢的链路不会被误杀。
function pull({ device, remotePath, localPath }) {
return new Promise((resolve, reject) => {
const dev = pick(device);
if (!dev) return reject(new Error(device ? `设备 ${device} 不在线` : '当前没有设备在线'));
if (!remotePath) return reject(new Error('remote_path 不能为空'));
const id = newJobId();
const tmp = localPath + '.part';
const out = fs.createWriteStream(tmp);
const hash = crypto.createHash('sha256');
let got = 0;
let settled = false;
let paused = false;
let idle = null;
const finish = () => {
if (settled) return false;
settled = true;
clearTimeout(idle);
state.pending.delete(id);
// 背压可能把连接停在 pause 上:结束时必须恢复,否则后续所有消息都收不到
if (paused) {
paused = false;
try { dev.ws.resume(); } catch (_) {}
}
return true;
};
const fail = msg => {
if (!finish()) return;
try { out.destroy(); } catch (_) {}
try { fs.unlinkSync(tmp); } catch (_) {}
reject(new Error(msg));
};
const bump = ms => {
clearTimeout(idle);
idle = setTimeout(() => fail(`${ms / 1000}s 没有收到数据,判定卡住`), ms);
};
bump(FIRST_CHUNK_MS);
state.pending.set(id, {
onFileChunk(m) {
if (settled) return;
bump(IDLE_MS);
let b;
try { b = Buffer.from(String(m.data || ''), 'base64'); } catch (_) { return fail('数据块解码失败'); }
got += b.length;
if (got > MAX_FILE) return fail('文件超过 2GiB 上限');
hash.update(b);
// 磁盘比网络慢时暂停从连接读,等 drain 再恢复——否则缓冲会在内存里堆到 OOM
if (!out.write(b) && !paused) {
paused = true;
try { dev.ws.pause(); } catch (_) {}
out.once('drain', () => {
paused = false;
try { dev.ws.resume(); } catch (_) {}
});
}
},
onFileDone(m) {
if (settled) return;
clearTimeout(idle);
if (m.err) return fail(String(m.err));
out.end(() => {
if (!finish()) return;
const sum = hash.digest('hex');
if (typeof m.size === 'number' && m.size !== got) {
try { fs.unlinkSync(tmp); } catch (_) {}
return reject(new Error(`大小不符:收到 ${got},设备报 ${m.size}`));
}
if (m.sha256 && String(m.sha256).toLowerCase() !== sum) {
try { fs.unlinkSync(tmp); } catch (_) {}
return reject(new Error('sha256 不符'));
}
try { fs.renameSync(tmp, localPath); } catch (e) { return reject(e); }
resolve({ device: dev.name, bytes: got, sha256: sum, path: localPath });
});
},
});
dev.ws.send(JSON.stringify({ t: 'file', id, op: 'read', path: remotePath }));
});
}
// push:会话目录 → 设备
// 发送阶段不设总超时(core 自己知道在发,靠 bufferedAmount 控节奏),
// 发完最后一包才开始等设备确认(60s)。
async function push({ device, localPath, remotePath }) {
const dev = pick(device);
if (!dev) throw new Error(device ? `设备 ${device} 不在线` : '当前没有设备在线');
if (!remotePath) throw new Error('remote_path 不能为空');
const st = fs.statSync(localPath);
if (!st.isFile()) throw new Error('只能推文件,不能推目录:' + localPath);
if (st.size > MAX_FILE) throw new Error('文件超过 2GiB 上限');
const size = st.size;
const sum = await hashFile(localPath);
const id = newJobId();
let settled = false;
let doneTimer = null;
let rejectDone = null;
const done = new Promise((resolve, reject) => {
rejectDone = reject;
state.pending.set(id, {
onFileDone(m) {
if (settled) return;
settled = true;
clearTimeout(doneTimer);
state.pending.delete(id);
if (m.err) return reject(new Error(String(m.err)));
resolve({ device: dev.name, bytes: size, sha256: sum, path: remotePath });
},
});
});
try {
dev.ws.send(JSON.stringify({ t: 'file', id, op: 'write', path: remotePath, size, sha256: sum }));
for await (const chunk of fs.createReadStream(localPath, { highWaterMark: FILE_CHUNK })) {
dev.ws.send(JSON.stringify({ t: 'file.chunk', id, data: chunk.toString('base64') }));
while (dev.ws.bufferedAmount > WS_HIGH) await sleep(10);
}
dev.ws.send(JSON.stringify({ t: 'file.done', id }));
} catch (e) {
settled = true;
state.pending.delete(id);
throw e;
}
// 发完最后一包才开始看门狗:设备还要算 sha、rename,慢盘上会停几秒
doneTimer = setTimeout(() => {
if (settled) return;
settled = true;
state.pending.delete(id);
rejectDone(new Error(`发完最后一包后 ${DONE_WAIT_MS / 1000}s 仍未收到设备确认`));
}, DONE_WAIT_MS);
return done;
}
module.exports = { init, attach, enabled, list, health, exec, pull, push, PATH };
+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 };
+199 -16
View File
@@ -2,7 +2,8 @@
// 单进程内存模型: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');
@@ -109,6 +110,29 @@ 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;
}
// 同上,但按 sessionId 现查:编辑/删除入口拿到的是裸 sessions 行(不含 history),
// 用 archivedCount(session.history) 会恒得 0,作废的 cid 就打到别的 key 上(压缩过的会话必踩)。
function archivedCountOf(sessionId) {
const r = db.prepare("SELECT COUNT(*) AS n FROM messages WHERE session_id = ? AND type = 'archived'").get(sessionId);
return r ? r.n : 0;
}
// 增量上下文 id 的拼法(与 llm.js 的 X-Context-Id 一致):<core_id>:<user>:<session_id>:<archived_cnt>。
// 删除消息后要把这个 key 作废,让下一轮走全量重建。
// runLoop 里 session.history 已就绪,走内存计数;其余入口现查库,两条路结果一致。
function contextIdOf(session) {
const n = session.history ? archivedCount(session.history) : archivedCountOf(session.id);
return instanceId(cfg.data_root) + ':' + (session.user || '-') + ':' + session.id + ':' + n;
}
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 +229,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 +411,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。
@@ -546,7 +631,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 +646,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 +811,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 +869,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;
@@ -754,15 +881,26 @@ async function runLoopInner(sessionId, run) {
break;
} catch (err) {
lastErr = err;
// 无 upstream_status = 网络层失败或中断(含「停止」「立即发送」的 abort):relay 在收到
// 上游 200 头时就已 put,而这边没拿到响应头、指针还停在上一轮,不作废就会在下一轮把
// 重复的增量再拼一遍 → tool_call_mismatch。直接清指针,下一轮走全量 + Reset 覆盖。
// 有 upstream_status 的 429/5xx 则确定没写缓存,保留指针,重试发空增量最省。
if (!err.upstream_status) invalidateContext(contextIdOf(session));
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));
}
}
if (run.cancelled) break;
if (!result) {
const text = '⚠️ 模型调用失败:' + (lastErr && lastErr.message || '未知错误');
const errId = saveMessage(sessionId, { role: 'assistant', content: text });
// type='error_note':留痕给 UI,但不进模型上下文(buildMessages 跳过),
// 否则失败文案会当成模型的真实回复一直带下去。
const errId = saveMessage(sessionId, { role: 'assistant', content: text, type: 'error_note' });
bus.emit(sessionId, 'assistant_message', { id: errId, content: text, error: true, created_at: now() });
break;
}
@@ -833,10 +971,10 @@ async function runLoopInner(sessionId, run) {
recordModelUsage(sessionId, session.model_id, result.usage);
// 回合级 In token 峰值:工具迭代只会越滚越大,取各轮 prompt_tokens 最大值作自动压缩判据
if (msgRow.usage && msgRow.usage.pt > (run.turnMaxPt || 0)) run.turnMaxPt = msgRow.usage.pt;
// 「压缩」回合的总结判定:压缩时不传 tools,因此本回合第一条「无 tool_calls 的收尾回复」
// 就是摘要(compressing 取自本回合的 run.summarizing 标记);回合中间若有异常产生的
// 工具轮(理论上不会)都是普通消息,前端照常渲染。
const isSummary = !hasTools && compressing;
// 「压缩」回合的总结判定:压缩指令发出去,模型回来的第一段非空文本就是摘要——带不带
// 工具都算(模型常为了把摘要写准先调一次工具查证,这一轮的文字同样是摘要,不能当普通
// 回复落库)。空文本(纯工具调用、一个字没写)不算,run.summarizing 保持,下一轮继续压。
const isSummary = compressing && !!String(msgRow.content || '').trim();
bus.emit(sessionId, 'assistant_message', {
id: assistantId, content: msgRow.content, reasoning: msgRow.reasoning,
tool_calls: msgRow.tool_calls, type: msgRow.type, created_at: msgRow.created_at,
@@ -849,6 +987,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 +998,19 @@ async function runLoopInner(sessionId, run) {
).run(sessionId, assistantId).changes;
log.info('msg', sessionId + ' 压缩摘要 ' + assistantId + ' 落库,存档之前 ' + n + ' 条消息(不再发给模型)');
}
// 回合内自动压缩把正在跑的任务切成了摘要,摘要一落地就地续跑:
// 没有工具回执可用时补一条 user 指令接回原任务,否则会直接走到下面的 !hasTools 收尾,
// 任务停在半路,要用户再喊一声才动。有工具回执时不插消息也不 continue——落到下面
// 执行工具,回执紧跟在摘要后面,本身就是续跑输入。
if (run.compactAuto) {
run.compactAuto = false;
if (!hasTools) {
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) {
@@ -902,9 +1056,20 @@ async function runLoopInner(sessionId, run) {
output = chk.error;
isError = true;
} else {
// 工具执行中的增量输出(terminal 长命令):50ms 或 16KB 合并成一帧 SSE,避免逐行刷包
let liveBuf = '';
let liveTimer = null;
const flushLive = () => {
if (liveTimer) { clearTimeout(liveTimer); liveTimer = null; }
if (!liveBuf) return;
const chunk = liveBuf;
liveBuf = '';
bus.emit(sessionId, 'tool_output', { id, chunk });
};
try {
output = await executeTool({ sessionId, taskDir: taskDirOf(sessionId), workDir: sessionWorkDir(sessionId), run, cfg, db, vision,
onTaskCreated: () => { run.taskWrap = true; }, onCard: (card) => bus.emit(sessionId, 'ui_card', card),
onOutput: (s) => { liveBuf += s; if (liveBuf.length >= 16384) flushLive(); else if (!liveTimer) liveTimer = setTimeout(flushLive, 50); },
onDeepThink: (info) => {
const m = (cfg.models || []).find(x => x.id === session.model_id);
const supported = !!(m && m.thinking_params && Object.keys(m.thinking_params).length);
@@ -917,6 +1082,7 @@ async function runLoopInner(sessionId, run) {
output = 'Error: ' + (err && err.message || String(err));
isError = true;
}
flushLive();
}
// 工具可返回 {text, image_rel}(read_file 读图且模型支持 vision,压缩产物在 .imgcache/,
// text 是 imageReceipt 生成的结构化 JSON 回执):落库时以 image_ref 内容块拼进 tool 消息
@@ -1043,6 +1209,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 +1369,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 +1532,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 +1637,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 +1890,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 +1928,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 +1940,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 +1960,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 +1992,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 };
+107 -17
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):点「压缩」时不插入指令消息。
@@ -305,10 +310,12 @@ function buildMessages(session, language, mintUrl, profile, withProfile, trimOn)
history.forEach((row, i) => {
// archived:UI 可见,但不进入模型上下文(节省 token)
if (row.type === 'archived') return;
// error_note:失败文案,只给 UI 留痕,不进模型(否则被当成模型的真实回复带下去)
if (row.type === 'error_note') return;
// 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 +345,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 +426,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 });
}
});
// 未消费图片合并发送:图上文字置顶、图块紧随(同序)。
@@ -531,7 +538,8 @@ function trimToolContent(content, row, callById, roundsAfter, turnsAfter) {
// 拼压缩回合的 messages(参考 titleMessages 的拼法):默认 system prompt + 正常历史
//(与 buildMessages 同取舍:archived 不发、旧摘要/工具轮照常),末尾追加一条 user
//(prompt-compress.txt 原文,历史就在它前面的 messages 里,不再填占位符)。
// 调用方(engine.runLoopInner 的 compressing 分支)需同时不传 tools。
// 调用方(engine.runLoopInner 的 compressing 分支)照常带 tools:工具段在最前,删掉等于断整段
// 前缀缓存;模型偶尔会为核对事实调一次,那一轮的文字仍按摘要处理(见 isSummary 判定)。
// 【缓存铁律】压缩请求必须与上一次常规请求字节同构、只在尾部追加指令:画像快照与
// 占位裁剪一律照常(不传 withProfile/trim = 同一拼法),也不裁历史中间任何注入行——
// 从首个被删/被改动行起前缀缓存全断,等于全价重读(旧代码 withProfile=false 把坐在
@@ -649,6 +657,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 +699,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 +733,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 +894,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>
+59 -22
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');
@@ -181,7 +192,7 @@
const gen = !!(opts && opts.generating);
if (gen) div.classList.add('tool-generating');
div.innerHTML =
'<details' + (open ? ' open' : '') + '><summary><span class="spin">◌</span>' +
'<details' + (open ? ' open' : '') + '><summary><span class="spin"><svg class="ic sm" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5" stroke-linecap="round"><path d="M21 12a9 9 0 1 1-6.2-8.6"/></svg></span>' +
'<span class="tool-name">' + esc(name) + '</span>' +
'<span class="tool-args">' + (gen ? '生成参数中…' : esc(toolArgsSummary(name, argsStr))) + '</span></summary>' +
'<pre class="tool-args-full">' + (gen ? '' : esc(toolArgsFull(argsStr))) + '</pre>' +
@@ -238,7 +249,10 @@
const card = document.getElementById('tool-' + id);
if (!card) return;
if (isError) card.classList.add('error');
card.querySelector('.spin').textContent = isError ? '✕' : '✓';
card.classList.remove('running'); // 停止转圈,换成结果标记
card.querySelector('.spin').innerHTML = isError
? '<svg class="ic sm" viewBox="0 0 24 24"><use href="#i-x-line"/></svg>'
: '<svg class="ic sm" viewBox="0 0 24 24"><use href="#i-check"/></svg>';
const parsed = parseToolContent(content);
const pre = card.querySelector('.tool-result');
if (!pre) return;
@@ -263,6 +277,20 @@
pre.insertAdjacentElement('afterend', el);
}
}
// 工具执行中的增量输出(terminal 长命令):边跑边填;只留尾部 2000 行,避免长跑命令撑爆 DOM
function appendToolOutput(id, chunk) {
const card = document.getElementById('tool-' + id);
if (!card) return;
const pre = card.querySelector('.tool-result');
if (!pre) return;
if (!pre.dataset.streaming) { pre.textContent = ''; pre.dataset.streaming = '1'; } // 首块到达:清掉“执行中…”占位
const follow = pre.scrollHeight - pre.scrollTop - pre.clientHeight < 8; // 用户往上翻时不抢滚动
pre.appendChild(document.createTextNode(chunk));
const lines = pre.textContent.split('\n');
if (lines.length > 2000) pre.textContent = '…(更早输出已折叠)\n' + lines.slice(-2000).join('\n');
// 追加后滚到底:读 scrollHeight 会强制布局拿到新高度;再补一帧,避免大 chunk 一次没贴到底
if (follow) { pre.scrollTop = pre.scrollHeight; requestAnimationFrame(() => { pre.scrollTop = pre.scrollHeight; }); }
}
// 把 assistant 消息里的 tool_calls 建成工具卡片(历史渲染与 assistant_message 事件共用)
function appendToolCardsFromAssistant(m, container) {
if (!m.tool_calls) return;
@@ -322,7 +350,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 +397,7 @@
}
// 历史渲染收口:给本轮新渲染出的代码块补复制按钮(目标可能是分页离屏容器,装饰后再随节点搬迁)
decorateCodePre(target);
pvHighlightMdCode(target); // 对话正文里的围栏代码块也上色(与预览同一套)
return { closeArc };
}
@@ -431,9 +464,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 +537,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;">' +
+83 -33
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>');
}
@@ -362,29 +362,55 @@
} catch (e) { toast('修改失败:' + e.message); }
}
// ---------- 页:账户——用户画像编辑卡直接渲染在账户页(无二级页;保存后 renderSetPage 重拉刷新停用徽标) ----------
const PREF_MAX = 1000; // 与后端 user-profile.js 的 PREF_MAX 对齐
const PROFILE_FIELDS = [
['honorific', '称谓', '希望被怎么称呼', 80],
['industry', '行业', '影响术语与默认假设', 80],
['preference', '偏好', '顿号分隔标签(AI 会在沟通中自动补充,可手动增删)', 300],
['preference', '偏好', '一行一条', 0, 'textarea'],
];
function prefCountText(n) {
return '已用 ' + n + ' / ' + PREF_MAX + ' 字' + (n > PREF_MAX ? ',超出部分保存时截断' : '');
}
function prefCount() {
const el = $('prof-preference'), out = $('prof-count-preference');
if (!el || !out) return;
const n = el.value.trim().length;
out.textContent = prefCountText(n);
out.style.color = n > PREF_MAX ? 'var(--fg-c0392b)' : '';
}
function profileCardHtml(p) {
let html = '<div class="settings-card"><h4>用户画像' +
(p.enabled === false ? ' <span class="badge held">已停用</span>' : '') + '</h4>' +
'<div class="cfg-kv"><label>启用</label><input type="checkbox" id="prof-enabled"' + (p.enabled === false ? '' : ' checked') + '></div>';
for (const [k, name, ph, maxLen] of PROFILE_FIELDS) {
for (const [k, name, ph, maxLen, kind] of PROFILE_FIELDS) {
const v = String(p[k] || '');
html += '<div class="cfg-kv"><label>' + esc(name) + '</label>' +
'<input class="cfg-input" id="prof-' + k + '" type="text" maxlength="' + (maxLen || 80) + '" data-orig="' + att(v) + '" value="' + att(v) + '" placeholder="' + esc(ph) + '"></div>';
if (kind === 'textarea') {
// 用户输入什么就存什么、注入什么:不拆不拼、不规范化分隔符,换行原样保留
html += '<div class="cfg-kv stack"><label>' + esc(name) + '</label>' +
'<textarea class="cfg-textarea" id="prof-' + k + '" rows="8" placeholder="' + esc(ph) + '" oninput="sUI.prefCount()">' + esc(v) + '</textarea>' +
'<div class="cfg-note" id="prof-count-' + k + '">' + prefCountText(v.length) + '</div></div>';
} else {
html += '<div class="cfg-kv"><label>' + esc(name) + '</label>' +
'<input class="cfg-input" id="prof-' + k + '" type="text" maxlength="' + (maxLen || 80) + '" data-orig="' + att(v) + '" value="' + att(v) + '" placeholder="' + esc(ph) + '"></div>';
}
}
html += '<button class="primary-btn" style="margin-top:8px" onclick="sUI.saveProfile()">保存</button>' +
'<div class="cfg-note">画像只记「不知道就会做错」的信息,新会话开始时作为背景注入(会话内不更新;清空字段保存即抹除)。' +
'AI 会在沟通中持续维护(尤其偏好标签,只记明确表达过的,写入自下个会话生效),这里手动改随时可覆盖。' +
'停用后不再注入,AI 的记录请求也会被拒。近期关注(最近会话标题)自动带入背景,无需维护。</div></div>';
'<div class="cfg-note">新会话生效</div></div>';
return html;
}
async function saveProfile() {
const body = { enabled: $('prof-enabled').checked };
for (const [k] of PROFILE_FIELDS) { const el = $('prof-' + k); if (el) body[k] = el.value.trim(); }
for (const [k, , , , kind] of PROFILE_FIELDS) {
const el = $('prof-' + k);
if (!el) continue;
const v = el.value.trim();
if (kind === 'textarea' && v.length > PREF_MAX) {
body[k] = v.slice(0, PREF_MAX);
toast('偏好超过 ' + PREF_MAX + ' 字,已截断保存');
} else {
body[k] = v;
}
}
try { await req('PUT', '/api/profile', body); toast('已保存,新会话生效'); renderSetPage(); }
catch (e) { toast('保存失败:' + e.message); }
}
@@ -395,7 +421,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 +715,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 +795,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 +838,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 +881,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 +897,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 +911,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 +1092,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 +1185,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 +1238,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 +1286,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 +1309,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 +1391,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 +1401,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 +1456,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 +1535,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 +1657,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);
}
@@ -1979,6 +2024,7 @@
// 账户
changePassword: changePassword,
saveProfile: saveProfile,
prefCount: prefCount,
// 用户管理(仅管理员)
openUserAdd: openUserAdd,
openUserEdit: openUserEditor,
@@ -2075,11 +2121,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);
});
}
})();
+78 -19
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);
@@ -159,15 +182,16 @@
state.streamEl = bubble;
return wrap;
}
// 思考面板:首次思考 delta 到达时创建,带 open 状态(流式中默认展开)
// 思考面板:首次思考 delta 到达时创建。**不展开**,只在 summary 里挂一段动态文字,
// 让人感觉到在干活;正文开始后清空那段文字,需要看全文再点开。
function ensureStreamThinkPanel() {
if (state.streamThinkEl) return state.streamThinkEl;
if (!state.streamWrap) ensureStreamWrap();
const det = document.createElement('details');
det.className = 'msg-think streaming';
det.open = true; // 流式阶段默认展开,看思考增量
det.open = false; // 流式阶段也不展开:展开的大段思考会把下面的内容一路顶下去
const sum = document.createElement('summary');
sum.innerHTML = '思考过程' + THINK_COPY_BTN;
sum.innerHTML = '思考过程<span class="msg-think-live"></span>' + THINK_COPY_BTN;
const body = document.createElement('div');
body.className = 'msg-think-body';
det.appendChild(sum);
@@ -175,10 +199,12 @@
// 插在气泡之前(思考 → 结论 的顺序)
state.streamWrap.insertBefore(det, state.streamEl);
state.streamThinkEl = body;
state.streamThinkLive = sum.querySelector('.msg-think-live');
return body;
}
// 思考结束(正文开始流式或本轮收尾):自动折叠思考面板并去掉流式高亮边框;用户仍可手动点开回看
// 思考结束(正文开始流式或本轮收尾):清空标题行那段动态文字、折叠面板、去掉流式标记
function collapseStreamThink() {
if (state.streamThinkLive) state.streamThinkLive.textContent = '';
if (!state.streamThinkEl) return;
const det = state.streamThinkEl.closest('details');
if (det) { det.open = false; det.classList.remove('streaming'); }
@@ -200,13 +226,22 @@
el.textContent = full; // 结构不符(收尾后重建/罕见回退)才整段重写
}
// 标题行里的动态文字:只取最后一行(单行截断),持续换内容形成“在动”的感觉。
// 不能像正文那样 appendData:这里是一行标题,追加只会无限变长。
function paintThinkLive(el, full) {
if (!el) return;
const lines = String(full || '').split('\n').filter(Boolean);
const tail = lines.length ? lines[lines.length - 1] : '';
if (el.textContent !== tail) el.textContent = tail;
}
function scheduleStreamPaint() {
if (streamPaintQueued) return;
streamPaintQueued = true;
requestAnimationFrame(() => {
streamPaintQueued = false;
paintStreamingText(state.streamEl, state.streamText);
paintStreamingText(state.streamThinkEl, state.streamReasoning);
paintThinkLive(state.streamThinkLive, state.streamReasoning);
maybeAutoScroll();
updateScrollBottomBtn();
});
@@ -220,7 +255,7 @@
state.lastSseAt = Date.now(); // 建连即重置静默计时
// 任何具名事件都算连接存活:静默看门狗与回前台宽限共用(error 不列,原生连接错误也走 error)
['ping', 'status', 'assistant_delta', 'reasoning_delta', 'assistant_message', 'tool_call_start',
'tool_call_args', 'tool_call', 'tool_result', 'ui_card', 'auto_compress', 'done', 'title', 'think_auto',
'tool_call_args', 'tool_call', 'tool_output', 'tool_result', 'ui_card', 'auto_compress', 'done', 'title', 'think_auto',
'pending_added', 'pending_removed', 'user_message']
.forEach(function (n) { es.addEventListener(n, function () { markSseAlive(n); }); });
es.addEventListener('status', ev => {
@@ -290,6 +325,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 +339,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');
@@ -392,14 +428,20 @@
if (state.toolCards[d.id]) {
// 执行时的完整参数事件:若为流式早卡则回填收尾(unwrap 后的干净参数),普通卡不动
finalizeToolCardArgs(d.id, d.name, d.arguments);
state.toolCards[d.id].classList.add('running'); // 执行中:摘要行圆点转起来
return;
}
// 无早卡(旧行为/刷新后重连):直接建展开卡
const card = renderToolCard(d.id, d.name, d.arguments, Date.now(), { open: true });
card.classList.add('running');
$('chat-view').appendChild(card);
state.toolCards[d.id] = card;
maybeAutoScroll();
});
es.addEventListener('tool_output', ev => {
const d = JSON.parse(ev.data);
appendToolOutput(d.id, d.chunk);
});
es.addEventListener('tool_result', ev => {
const d = JSON.parse(ev.data);
fillToolResult(d.tool_call_id, d.content, d.is_error, d.image_url, d.msg_id);
@@ -473,6 +515,9 @@
state.toolCallStreaming = {}; // 流式参数早卡映射随会话/回合重置
updateScrollBottomBtn();
loadSessionList();
// 一轮完整跑完(agent 循环退出才发 done):工具/技能产物可能新增或改名,文件树就地刷新;
// 不在文件树面板时 reloadFileTree 只标脏,等切回去再重拉
if (typeof window.reloadFileTree === 'function') window.reloadFileTree();
});
// 服务端首次交互后自动生成的标题(finalize 后约 1s 到达):即时刷新顶栏 + 重拉会话列表(PC 常驻侧边栏/移动抽屉)
es.addEventListener('title', ev => {
@@ -517,7 +562,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 +583,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 +746,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
+6 -2
View File
@@ -19,7 +19,7 @@ function reqHeaders(cfg) {
}
// 执行一条命令。返回 { code, killed_by, out };传输层失败抛 Error(由调用方决定如何呈现)。
// opts: { command, cwd?, timeout_ms?, env?, run? }(run = engine 的 {cancelled, procs},可省略)
// opts: { command, cwd?, timeout_ms?, env?, run?, onChunk? }(run = engine 的 {cancelled, procs},可省略)
async function run(cfg, opts) {
const base = cfg.executor.url;
const timeoutMs = opts.timeout_ms && opts.timeout_ms > 0 ? opts.timeout_ms : 300000;
@@ -73,7 +73,11 @@ async function run(cfg, opts) {
let ev;
try { ev = JSON.parse(line.slice(6)); } catch (_) { continue; }
if (ev.type === 'start') id = ev.id;
else if (ev.type === 'out' || ev.type === 'err') out += ev.chunk;
else if (ev.type === 'out' || ev.type === 'err') {
out += ev.chunk;
// 增量回调(UI 实时显示用):失败不影响主流程
if (opts.onChunk) { try { opts.onChunk(ev.chunk); } catch (_) {} }
}
else if (ev.type === 'exit') { exit = ev; break outer; }
}
}
+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,
// 待投递队列(刷新/换设备后条幅能原样恢复):只在服务端内存里,重启即空
+12
View File
@@ -13,6 +13,7 @@ const scheduler = require('./scheduler');
const wechat = require('./wechat');
const llm = require('./llm');
const mcp = require('./mcp');
const devices = require('./devices');
const skills = require('./tools/skills');
const log = require('./log');
@@ -48,6 +49,11 @@ wechat.init(cfg, db, bus);
const app = express();
const server = http.createServer(app);
// 设备接入(devices.js):设备主动出站连 wss://<公网前缀>/dev/ws。
// 只在「有公网前缀 + 配了 DEVICE_TOKEN」时真正挂升级处理器,本地部署静默跳过。
devices.init(cfg);
devices.attach(server);
// wxbot 内网回调(/wxhook/inbox|hook):凭共享服务 token(Bearer)把门,微信用户永远不该直接碰
// 这两个端点(wxbot 只挂内网)。必须挂在全局 express.json(2mb) 之前:媒体 base64 转发体远超 2mb,
// 由 hookRouter 自带的 32mb 解析器先读掉并置 req._body,下游全局 json 解析器自动跳过(同 executor 不冲突)。
@@ -179,6 +185,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:单机自用不该让同一局域网的人直接访问。
+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)) {
+58 -19
View File
@@ -198,23 +198,6 @@
}
}
},
{
"type": "function",
"function": {
"name": "profile",
"description": "Maintain the current user's profile — stable facts that persist across conversations and get injected into the context of NEW sessions (the current session's injected copy is frozen). Ops: list (read the live profile), set (honorific or industry, single short value), add (append preference tags), remove (delete exact preference tags). Rules: only record what the user has clearly stated or asked to be remembered (form of address, domain, stable output/work preferences); never guess personality, never store one-time task parameters; brief tags beat essays. Preference is a 、-separated tag list (each tag ≤15 chars, ≤24 tags, ≤300 chars total; overflow is rejected — consolidate or remove first). When unsure what is already recorded, op=list returns live state — trust it over memory.",
"parameters": {
"type": "object",
"required": ["op"],
"properties": {
"op": { "type": "string", "enum": ["list", "set", "add", "remove"], "description": "list = read live profile; set = single-value honorific/industry; add/remove = preference tags." },
"honorific": { "type": "string", "description": "op=set: how to address the user (≤20 chars, e.g. 王工). Pass empty string to clear. Exactly one of honorific/industry per call." },
"industry": { "type": "string", "description": "op=set: the user's industry/domain (≤20 chars, e.g. 金融). Pass empty string to clear." },
"tags": { "type": "array", "items": { "type": "string" }, "description": "op=add/remove: preference tag list, e.g. [\"偏好简洁回复\", \"图表中文标注\"]. Matching is exact text." }
}
}
}
},
{
"type": "function",
"function": {
@@ -340,11 +323,17 @@
"description": "Run or inspect the skills installed on this server. Each skill describes its purpose and input_schema.\n\n{\"op\":\"list\"} list every skill with a one-line description\n{\"op\":\"get\",\"name\":\"<skill>\"} return the skill's full details; call it before the first run\n{\"op\":\"run\",\"name\":\"<skill>\",\"args\":{...}} execute it; args follow its input_schema\n\nop is required. op=get and op=run require name. Put skill arguments inside args, never at the top level.",
"parameters": {
"type": "object",
"required": ["op"],
"required": [
"op"
],
"properties": {
"op": {
"type": "string",
"enum": ["list", "get", "run"],
"enum": [
"list",
"get",
"run"
],
"description": "Operation to perform on skills."
},
"name": {
@@ -403,6 +392,56 @@
}
}
},
{
"type": "function",
"function": {
"name": "device",
"description": "Operate the remote devices (other machines) connected to this server. Devices dial out to this server, so they need no inbound port; they stay connected until closed.\n\n- action=list: no other params. Returns every online device with os/arch/shell/root. Always call this first when you don't know device names.\n- action=health: requires device. Returns host uptime, load, memory, disk and temperature (fields the platform can't provide are -1).\n- action=exec: requires device and command. Runs the command through a shell on that device (sh -c on Unix, cmd /c on Windows) and returns stdout, stderr and the exit code. `cwd` must be inside that device's work root; omit it to use the root.\n\n- action=pull: requires device and remote_path; copies a file from the device into the session directory so read_file / skills can use it.\n- action=push: requires device, local_path and remote_path; sends a session file to the device.\n\nUse it when the work has to happen on the user's own machine (laptop, box, Windows PC). For the machine running this server use `terminal` instead. If a device is offline, say so explicitly — do not silently run the command elsewhere.",
"parameters": {
"type": "object",
"required": [
"action"
],
"properties": {
"action": {
"type": "string",
"enum": [
"list",
"health",
"exec",
"pull",
"push"
],
"description": "Operation to perform."
},
"device": {
"type": "string",
"description": "Device name from action=list."
},
"command": {
"type": "string",
"description": "Shell command line (action=exec). Avoid interactive commands."
},
"cwd": {
"type": "string",
"description": "Working directory on the device; must be inside its work root (action=exec)."
},
"timeout_ms": {
"type": "integer",
"description": "Default 120000, max 600000 (action=exec)."
},
"remote_path": {
"type": "string",
"description": "设备上的绝对路径,必须在设备工作根内(pull/push)。"
},
"local_path": {
"type": "string",
"description": "会话目录内的相对路径。pull 省略则用远端文件名;push 必填(源文件)。"
}
}
}
}
},
{
"type": "function",
"function": {
+122 -38
View File
@@ -11,9 +11,10 @@ const skills = require('./skills');
const Database = require('better-sqlite3'); // db 工具:会话目录下的 data.db(同步 API,与单进程模型契合)
const TurndownService = require('turndown'); // fetch 工具:HTML→Markdown 用真解析器(内置 htmlparser2,容错截断/畸形文档)
const rexec = require('../remote-exec');
const devices = require('../devices'); // device 工具:远端执行节点(设备主动出站连 core,见 devices.js)
const log = require('../log'); // device 工具调用日志(info 记动作+设备+耗时+命令截断)
const publicFiles = require('../public-files');
const scheduler = require('../scheduler'); // 只依赖 log/cron-parser/time.js,不成环(engine→executor→scheduler 单向)
const profile = require('../user-profile'); // profile 工具的数据面(仅 llm/log 依赖,无环)
const memory = require('../memory'); // recall 工具的数据面(日记翻阅;仅依赖 time.js,无环)
// lab 的 help 伪工具要读全量定义:与 engine 同路径 require → node 缓存同一对象,单一事实源。
const BUILTIN_TOOL_DEFS = require('./definitions.json');
@@ -784,6 +785,116 @@ function drainUiCards(text, ctx) {
return keep.join('\n');
}
// device 工具:把命令送到远端设备执行(设备主动出站连 core,连接表在 devices.js)。
// 与 terminal 的分工:terminal 只在 core 所在机器/容器里跑,需要落在用户自己的电脑、盒子、
// Windows 上时用 device。设备不在线就明确报错,不自动降级到本机执行。
// device 日志用:命令压成一行并截断,避免长命令刷屏
function devCmd(s, n) {
const t = String(s || '').replace(/\s+/g, ' ').trim();
return t.length > (n || 120) ? t.slice(0, n || 120) + '…' : t;
}
// device 日志用:字节数human化
function devBytes(n) {
if (!n) return '0B';
if (n < 1024) return n + 'B';
if (n < 1024 * 1024) return (n / 1024).toFixed(1) + 'KB';
return (n / 1024 / 1024).toFixed(2) + 'MB';
}
async function toolDevice(ctx, args) {
if (!devices.enabled()) {
return '设备接入未启用:需要配置公网前缀(PUBLIC_BASE_URL 或设置页「公网地址」)和 DEVICE_TOKEN,重启 core 后生效。';
}
const action = String(args.action || '').trim();
if (action === 'list') {
const list = devices.list();
log.debug('device', 'list → ' + list.length + ' 台');
if (!list.length) return '当前没有设备在线(设备需主动连 wss://<公网前缀>/dev/ws)。';
return JSON.stringify(list, null, 2);
}
if (action === 'health') {
const name = String(args.device || '').trim();
if (!name) return 'Error: action=health 需要 device 参数(先调 action=list 看设备名)';
try {
const h = await devices.health(name);
log.debug('device', 'health ' + name + ' ok');
return JSON.stringify(h, null, 2);
} catch (e) {
log.warn('device', 'health ' + name + ' 失败:' + e.message);
return 'Error: ' + e.message;
}
}
if (action === 'exec') {
const name = String(args.device || '').trim();
if (!name) return 'Error: action=exec 需要 device 参数(先调 action=list 看设备名)';
if (!String(args.command || '').trim()) return 'Error: action=exec 需要 command 参数';
try {
const r = await devices.exec({
device: name,
command: args.command,
cwd: args.cwd,
timeout_ms: args.timeout_ms,
});
log.info('device', `exec ${r.device} code=${r.code} ${r.ms}ms cmd="${devCmd(args.command)}"`);
const head = `device=${r.device} exit=${r.code}`
+ (r.killed_by ? ` killed_by=${r.killed_by}` : '')
+ ` ${r.ms}ms` + (r.truncated ? '(输出已截断)' : '');
const parts = [head];
if (r.note) parts.push('note: ' + r.note);
if (r.stdout && r.stdout.trim()) parts.push('--- stdout ---\n' + r.stdout.replace(/\s+$/, ''));
if (r.stderr && r.stderr.trim()) parts.push('--- stderr ---\n' + r.stderr.replace(/\s+$/, ''));
return parts.join('\n');
} catch (e) {
log.warn('device', `exec ${name} 失败:${e.message} cmd="${devCmd(args.command)}"`);
return 'Error: ' + e.message;
}
}
if (action === 'pull') {
const name = String(args.device || '').trim();
const remote = String(args.remote_path || '').trim();
if (!name) return 'Error: action=pull 需要 device 参数(先调 action=list 看设备名)';
if (!remote) return 'Error: action=pull 需要 remote_path 参数';
try {
const rel = String(args.local_path || '').trim() || path.basename(remote);
const abs = resolveInTask(ctx.taskDir, rel, fsRoot(ctx));
const t0 = Date.now();
const r = await devices.pull({ device: name, remotePath: remote, localPath: abs });
recordFile(ctx, abs);
log.info('device', `pull ${name} ${remote} → ${path.relative(ctx.taskDir, abs) || path.basename(abs)} ${devBytes(r.bytes)} ${Date.now() - t0}ms`);
return `已拉到 ${path.relative(ctx.taskDir, abs) || path.basename(abs)}(${r.bytes} 字节,sha256 ${r.sha256.slice(0, 16)}…)`;
} catch (e) {
log.warn('device', `pull ${name} ${remote} 失败:${e.message}`);
return 'Error: ' + e.message;
}
}
if (action === 'push') {
const name = String(args.device || '').trim();
const local = String(args.local_path || '').trim();
const remote = String(args.remote_path || '').trim();
if (!name) return 'Error: action=push 需要 device 参数(先调 action=list 看设备名)';
if (!local) return 'Error: action=push 需要 local_path 参数(会话目录内的相对路径)';
if (!remote) return 'Error: action=push 需要 remote_path 参数(设备上的绝对路径,须在工作根内)';
try {
const abs = resolveInTask(ctx.taskDir, local, fsRoot(ctx));
const t0 = Date.now();
const r = await devices.push({ device: name, localPath: abs, remotePath: remote });
log.info('device', `push ${name} ${remote} ← ${path.relative(ctx.taskDir, abs) || path.basename(abs)} ${devBytes(r.bytes)} ${Date.now() - t0}ms`);
return `已推到 ${name}:${remote}(${r.bytes} 字节,sha256 ${r.sha256.slice(0, 16)}…)`;
} catch (e) {
log.warn('device', `push ${name} ${remote} 失败:${e.message}`);
return 'Error: ' + e.message;
}
}
return 'Error: action 必须是 list / health / exec / pull / push';
}
async function toolTerminal(ctx, args) {
const cfg = ctx.cfg;
const timeout = args.timeout_ms || cfg.terminal.default_timeout_ms;
@@ -794,7 +905,7 @@ async function toolTerminal(ctx, args) {
// 配了 executor.url(或 env EXECUTOR_URL):命令交给远端 agent-executor 执行,文本拼回与本地完全一致。
if (rexec.isRemote(cfg)) {
const r = await rexec.run(cfg, { command: args.command, cwd, timeout_ms: timeout, run: ctx.run });
const r = await rexec.run(cfg, { command: args.command, cwd, timeout_ms: timeout, run: ctx.run, onChunk: ctx.onOutput });
r.out = drainUiCards(r.out, ctx);
let text = selectOutput(r.out.replace(/\n+$/, ''), args.head_lines, args.tail_lines);
if (r.killed_by === 'timeout') {
@@ -820,7 +931,11 @@ async function toolTerminal(ctx, args) {
killGroup(child);
}, timeout);
const onData = (d) => { out += d.toString(); };
const onData = (d) => {
const s = d.toString();
out += s;
if (ctx.onOutput) { try { ctx.onOutput(s); } catch (_) {} }
};
child.stdout.on('data', onData);
child.stderr.on('data', onData);
@@ -1346,39 +1461,6 @@ function toolScheduleTask(ctx, args) {
}
}
// profile:用户画像增量维护(op 分派同 schedule 风格)。user 取自会话行,AI 不可指定他人;
// 条件必填/帽子校验全在 user-profile.js(抛错由引擎包成 is_error 回执),停用拒写不拒读。
function toolProfile(ctx, args) {
const op = String(args.op || '').trim().toLowerCase();
const s = ctx.db.prepare('SELECT user FROM sessions WHERE id = ?').get(ctx.sessionId);
if (!s) throw new Error('会话不存在');
const user = s.user;
switch (op) {
case 'list': {
const p = profile.getProfile(ctx.db, user);
const lines = [
'称谓:' + (p.honorific || '(未记录)'),
'行业:' + (p.industry || '(未记录)'),
'偏好:' + (p.preference || '(未记录)'),
];
if (!p.enabled) lines.push('(该用户已停用画像注入;set/add/remove 会被拒绝)');
lines.push('本会话已注入的快照不会因写入而变;新会话自动携带最新画像。');
return lines.join('\n');
}
case 'set': {
const keys = ['honorific', 'industry'].filter(k => typeof args[k] === 'string');
if (keys.length !== 1) throw new Error('op=set 需要 honorific 或 industry 恰一个字符串参数(偏好标签用 add/remove)');
return profile.setProfileField(ctx.db, user, keys[0], args[keys[0]]);
}
case 'add':
return profile.addProfileTags(ctx.db, user, args.tags);
case 'remove':
return profile.removeProfileTags(ctx.db, user, args.tags);
default:
throw new Error('未知的 op:"' + op + '"。可用:list / set(honorific|industry) / add(tags) / remove(tags)');
}
}
// db:会话本地 SQLite(taskDir/data.db,随会话目录隔离,首次使用自动建库建文件)。
// 连接策略:每次调用 open→用→close,不缓存句柄(会话删目录后不留脏连接);
// 单进程 + better-sqlite3 同步 API,同进程内不存在交叠。busy_timeout 兼容
@@ -1757,7 +1839,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': {
@@ -1786,9 +1868,9 @@ const HANDLERS = {
terminal: toolTerminal,
fetch: toolFetch,
schedule: toolScheduleTask,
profile: toolProfile,
recall: toolRecall,
db: toolDb,
device: toolDevice,
skill: toolSkill,
lab: toolLab,
};
@@ -1798,6 +1880,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 服务
+9 -83
View File
@@ -7,19 +7,15 @@
// - 注入:会话创建/清空时把渲染文本冻结进 sessions.profile_snapshot,
// buildMessages 每轮以 system 后首条 user 消息注入——内容字节恒定不破坏前缀缓存,
// 且不落 messages 表,阶段切换归档/压缩都动不到它。
// - 更新(原 handoff 落槌一次性提取链路已移除):AI 沟通中经 profile 工具增量维护
// (list/set/add/remove,见 executor.js;写入只影响下个会话——快照冻结语义不变),
// 用户也可在设置页手动编辑。preference 按顿号标签列表管理,工具只做增量增删、
// 不做整段覆写——防模型重写时吃掉旧标签;停用(enabled=0)时拒写不拒读。
// - 更新:只由用户在设置页手动编辑。原 AI 侧的 profile 工具(list/set/add/remove)已移除:
// 模型自主记录容易把错的东西冻结成长期上下文,记什么由用户把关。
// - preference 是用户自由输入的多行文本(一行一条即可):原样入库、原样注入,不拆不拼、
// 不把分隔符规范化;只卡一个总长帽(PREF_MAX)。
const log = require('./log');
const FIELDS = ['honorific', 'industry', 'preference'];
const MAX_FIELD = 80; // honorific/industry 长度帽(Web 手改与工具共用)
const PREF_MAX = 300; // preference 总长帽
const SET_MAX = 20; // AI 写 honorific/industry 的单值帽(称谓应当短小)
const TAG_MAX = 15; // 单个偏好标签长度帽
const TAGS_MAX = 24; // 偏好标签数量帽
const TAG_SPLIT = /[、,,;;\n]+/;
const MAX_FIELD = 80; // honorific/industry 长度帽
const PREF_MAX = 1000; // preference 总长帽(用户自由输入的多行文本,只卡总量)
// 画像快照头:AI 友好的分块标记(与 channel_note/memory_note 同款「# [CTX] <名>」体例,
// buildMessages 把快照作 system 后首条 user 注入,标题即自描述来源)。
const SNAPSHOT_HEAD = '# [CTX] user_profile\n\n以下为历史会话沉淀的粗粒度认知,非任务约束;与当前请求冲突时,一律以当前请求为准。';
@@ -54,7 +50,9 @@ function sanitizePatch(body) {
const patch = { fields: {}, enabled: undefined };
for (const k of FIELDS) {
if (typeof b[k] === 'string') {
patch.fields[k] = b[k].replace(/\s+/g, ' ').trim().slice(0, k === 'preference' ? PREF_MAX : MAX_FIELD);
// preference 是用户按条目输入的自由文本:保留换行,只去首尾空白;另两字段压成单行
const v = k === 'preference' ? b[k].trim() : b[k].replace(/\s+/g, ' ').trim();
patch.fields[k] = v.slice(0, k === 'preference' ? PREF_MAX : MAX_FIELD);
}
}
if (typeof b.enabled === 'boolean' || b.enabled === 0 || b.enabled === 1) patch.enabled = !!b.enabled;
@@ -70,77 +68,6 @@ function saveProfile(db, user, patch) {
writeRow(db, user, data, enabled);
}
// ---------- profile 工具(AI 增量维护入口;op 语义与 executor.js toolProfile 对应) ----------
// preference 存顿号连接的标签串;读取按分隔符拆 token(人工输入的整句会被拆为 token 存留,可接受)。
function profileTokens(preference) {
return String(preference || '').split(TAG_SPLIT).map(t => t.trim()).filter(Boolean);
}
// 所有写 op 的统一后缀:快照「新会话冻结注入」语义不因工具改变,明说免 AI 在本会话里困惑等待。
const WRITE_NOTE = '(新会话开始时注入,本会话内不变;可用 op=list 查看实时状态)';
function requireEnabled(db, user) {
if (!getProfile(db, user).enabled) {
throw new Error('该用户已停用画像(设置页·账户·用户画像可重新启用),本次未写入。');
}
}
// 单值字段(称谓/行业)设置;空串 = 清除。
function setProfileField(db, user, field, value) {
if (!FIELDS.includes(field) || field === 'preference') {
throw new Error('op=set 仅支持 honorific / industry(偏好标签请用 op=add / op=remove)');
}
requireEnabled(db, user);
const v = String(value == null ? '' : value).replace(/\s+/g, ' ').trim().slice(0, SET_MAX);
const cur = getProfile(db, user)[field];
if (cur === v) return FIELD_LABELS[field] + '已是「' + v + '」,未改动。';
saveProfile(db, user, { fields: { [field]: v } });
return v
? FIELD_LABELS[field] + '已设为「' + v + '」' + WRITE_NOTE
: FIELD_LABELS[field] + '已清除(下次冻结时将不再出现)。';
}
// 追加偏好标签:清洗 → 逐条校验长度 → 去重 → 数量/总长帽(整批原子:任一带帽违例则不落库)
function addProfileTags(db, user, tags) {
const list = (Array.isArray(tags) ? tags : [tags])
.map(t => String(t == null ? '' : t).replace(TAG_SPLIT, ' ').replace(/\s+/g, ' ').trim())
.filter(Boolean);
if (!list.length) throw new Error('op=add 需要非空的 tags 字符串数组(单个标签也用数组传)');
requireEnabled(db, user);
const cur = profileTokens(getProfile(db, user).preference);
const added = [], dup = [];
for (const t of list) {
if (t.length > TAG_MAX) throw new Error('标签「' + t + '」超过 ' + TAG_MAX + ' 字上限,请换成更概括的说法');
if (cur.includes(t)) { dup.push(t); continue; }
cur.push(t); added.push(t);
}
if (cur.length > TAGS_MAX) throw new Error('偏好标签已达 ' + TAGS_MAX + ' 个上限(本次将到 ' + cur.length + '),先用 op=remove 合并精简');
const joined = cur.join('、');
if (joined.length > PREF_MAX) throw new Error('偏好总长将超 ' + PREF_MAX + ' 字(现 ' + joined.length + '),先用 op=remove 精简');
if (!added.length) {
return '均已存在,未新增(' + dup.join('、') + ');当前偏好 ' + cur.length + ' 条。';
}
saveProfile(db, user, { fields: { preference: joined } });
return '已记录:' + added.join('、')
+ (dup.length ? '(已存在未重复:' + dup.join('、') + ')' : '')
+ ';偏好现共 ' + cur.length + ' 条' + WRITE_NOTE;
}
// 删除偏好标签:按 token 精确匹配;未命中的回报(引导先 list 核对写法)。
function removeProfileTags(db, user, tags) {
const list = (Array.isArray(tags) ? tags : [tags]).map(t => String(t == null ? '' : t).trim()).filter(Boolean);
if (!list.length) throw new Error('op=remove 需要非空的 tags 字符串数组');
requireEnabled(db, user);
const cur = profileTokens(getProfile(db, user).preference);
const removed = list.filter(t => cur.includes(t));
const missing = list.filter(t => !cur.includes(t));
if (!removed.length) return '未找到要删除的标签:' + missing.join('、') + '(op=list 可查看当前精确标签)';
saveProfile(db, user, { fields: { preference: cur.filter(t => !removed.includes(t)).join('、') } });
return '已移除:' + removed.join('、')
+ (missing.length ? ';未找到:' + missing.join('、') : '')
+ ';偏好现共 ' + (cur.length - removed.length) + ' 条' + WRITE_NOTE;
}
// 渲染注入文本:三字段(非空才成行);停用或全空 → 空串(不注入)。
function snapshotText(db, user) {
const p = getProfile(db, user);
@@ -161,5 +88,4 @@ function freezeSnapshot(db, sessionId) {
module.exports = {
getProfile, sanitizePatch, saveProfile, snapshotText, freezeSnapshot,
setProfileField, addProfileTags, removeProfileTags,
};
+1 -1
View File
@@ -489,7 +489,7 @@ function getTurn(bid) { return turnState.get(bid) || resetTurn(bid); }
// 投递前的内容归一(语义同旧 deliverNow):errAck / 空文本 → 不可投;富文本 blocks → 占位文案。
function normalizeContent(m) {
if (!m || m.type === 'errAck') return '';
if (!m || m.type === 'errAck' || m.type === 'error_note') return '';
let content = String(m.content || '').trim();
if (!content) return '';
if (content.startsWith('{"__blocks__"')) content = '【富文本消息,请到网页端查看】';
+140
View File
@@ -0,0 +1,140 @@
# agent-device:远端设备执行端
把一台机器(Linux 盒子、Windows、macOS)变成 agent 的一双“手”:**主动出站**连到 core 的
WebSocket 端点,接收 shell 命令、流式回传输出与退出码、上报主机指标。
设备不需要公网 IP、不需要开任何入站端口,NAT、公司网络、随身热点都能用。
> 这不是通用 agent,只是执行端。会话、模型、记忆都在服务端;这里只负责“在那台机器上跑东西”。
## 二进制里没有服务器地址
`-server` 与 token 都**没有默认值**,不显式给就启动失败。所以拿到的二进制不会连到别人的服务器上——
它只连你指定的那一台。
## 安装
### 自己编译
需要 Go 1.22+:
```sh
git clone <本仓库> && cd device
go build -trimpath -ldflags "-s -w" -o bin/agent-device ./cmd/agent
```
交叉编译(一次出六个平台):
```sh
sh scripts/build.sh all
```
脚本只做构建:不联网、不推送、不依赖任何特定服务器。本机没有 Go 但装了 docker 时,
会自动用 `golang:1.23-alpine` 容器编译。
### 下载预编译
从本仓库的 Releases 页面取对应平台的文件(`agent-device-linux-arm64`、`agent-device-windows-amd64.exe` 等),
`chmod +x` 即可,静态链接、无运行时依赖,一个文件约 5.5 MB。
## 运行
```sh
# 推荐:二进制旁边放一个 config.json,直接启动(token 不出现在 ps 里)
./agent-device
# 或者全走命令行
./agent-device -server wss://your-host.example/dev/ws -token <TOKEN> -root /var/agent-work -name box-01
# 配置文件不在默认位置时显式指定
./agent-device -config /etc/agent-device.json
```
**默认会自动读可执行文件同目录的 `config.json`**(存在才读,不存在就当没配),所以部署时把二进制和配置放一个目录、直接跑就行:
```json
{
"server": "wss://your-host.example/dev/ws",
"token": "…",
"root": "/var/agent-work",
"name": "box-01"
}
```
优先级:**命令行显式参数 > 环境变量 `NODE_TOKEN`(仅 token)> 配置文件 > 默认值**。
### shell 用哪个
默认:macOS / Linux 用 `/bin/sh`(固定,不读 `$SHELL`——用户把默认 shell 设成 fish 时,
模型写的 POSIX 语法会全废);Windows 用 `cmd`。
想换就在 `config.json` 里写 `shell`,**不做自动探测**:装了 Git Bash / busybox 就写路径,
没装就保持默认。
```json
{ "shell": "C:\\Program Files\\Git\\bin\\bash.exe" }
```
报给 core 的是短标签(`sh` / `bash` / `busybox` / `cmd` / `powershell`),同时带上解释器路径与版本。
| 参数 | 说明 |
|---|---|
| `-server` | core 的接入地址,`wss://…/dev/ws` |
| `-token` | Bearer token,须与服务端 `DEVICE_TOKEN` 一致 |
| `-root` | 工作根目录,命令的 `cwd` 必须落在它之内(默认 `~/agent-work`,会自动建)。写相对路径时按**二进制所在目录**解析,如 `workspace` / `.`,不能越出该目录 |
| `-name` | 设备名,服务端用它区分设备(默认 hostname) |
| `-shell` | `sh` / `cmd` / `powershell`,默认按平台 |
| `-config` | 配置文件路径,默认 `<二进制所在目录>/config.json` |
| `-insecure` | 跳过证书校验(自签证书调试用) |
| `-fix-clock` | 证书报错时用服务器 `Date` 头校准本机时间(小设备没有 RTC 时用,Linux 需 root) |
设备名重复时后接入的会顶掉前一个连接(换机、重装不留僵尸连接)。
## 协议
一条 WebSocket 上全是 JSON 文本帧,`t` 区分类型:
| 方向 | 消息 |
|---|---|
| 设备 → core | `{t:"hello", ver, name, os, arch, shell, shell_path, shell_ver, root}` |
| core → 设备 | `{t:"exec", id, cmd, cwd, timeout_ms}` · `{t:"kill", id}` · `{t:"ping"}` · `{t:"health", id}` |
| 文件通道 | `{t:"file", id, op:"read"\|"write", path, size?, sha256?}` · `{t:"file.chunk", id, data:<base64>}` ×N · `{t:"file.done", id, size?, sha256?, err?}` |
| 设备 → core | `{t:"chunk", id, out:"out"\|"err", chunk:<base64>}` · `{t:"exit", id, code, killed_by, ms, truncated}` · `{t:"pong"}` · `{t:"health", …}` |
- 保活:core 每 20 秒发 `ping`,设备回 `pong`;90 秒无任何消息即断开重连。
- 断线:指数退避 1s → 2s → 4s → … 上限 30s,连上后重置。
- 超时:命令超过 `timeout_ms` 由设备侧杀**进程组**,回 `killed_by:"timeout"`。
- 输出:单流超过上限截断并置 `truncated`。
- `shell` 报的是实际解释器(`/bin/sh` 可能是 dash / bash / busybox),连同版本,供模型决定命令语法。
## 文件通道
core 通过同一条连接搬文件,**设备不需要任何额外端口**:
| 方向 | 流程 |
|---|---|
| 拉取(设备 → 会话目录) | `file{op:read}` → 设备分块回 `file.chunk` → `file.done{size,sha256}` |
| 推送(会话目录 → 设备) | `file{op:write,size,sha256}` → 分块 `file.chunk` → `file.done` |
- 每块 256 KiB(base64 后约 341 KiB),单文件上限 2 GiB;
- 超时按**空闲**算:首块 30s,之后每收到一块重置 30s——链路慢但不卡就不会被误杀;
- 写盘先落 `<path>.part`,`size` 与 `sha256` 都对上才 `rename`;
- 设备侧路径必须在工作根内(与 `exec` 的 cwd 校验同一套)。
## 安全边界
- 设备主动出站,服务端不需要知道设备 IP;
- token 走 `Authorization: Bearer`,与业务 token 分开;
- `cwd` 只约束**起始目录**,命令内部仍可 `cd` 到别处——给了 shell 就是这个语义,需要强隔离请用容器/namespaces;
- 同一个 token 可被多台设备共用(当前设计),吊销需换 token 并重启所有设备。
## 实测
| 用例 | 结果 |
|---|---|
| exec 基本 | cwd 自动创建,stdout/stderr 分流,退出码透传 |
| 超时 | 杀进程组,`killed_by=timeout` |
| 起始 cwd 越界 | 拒绝 |
| 断线重连 | 1s→2s→4s 退避,恢复后自动注册 |
在 Linux / macOS / Windows 三平台编译验证(amd64 + arm64);另出 `linux-mips` 软浮点版给 OpenWrt 设备。
+237
View File
@@ -0,0 +1,237 @@
package main
// 文件通道:core 通过同一条 WS 拉取 / 推送文件。
//
// 协议(与 core 的 devices.js 一一对应):
//
// core → 节点 {t:"file", id, op:"read", path}
// 节点 → core {t:"file.chunk", id, data:<base64>} ×N → {t:"file.done", id, size, sha256}
//
// core → 节点 {t:"file", id, op:"write", path, size, sha256}
// core → 节点 {t:"file.chunk", id, data} ×N → {t:"file.done", id}
// 节点 → core {t:"file.done", id, size} 或 {t:"file.done", id, err}
//
// 写盘一律先落 <path>.part,校验通过再 rename——半截文件不能留在原地。
import (
"crypto/sha256"
"encoding/hex"
"errors"
"hash"
"io"
"os"
"path/filepath"
"strconv"
"strings"
"sync"
"agent-device/pkg/wsnode"
"agent-device/pkg/proto"
)
const (
fileChunkSize = 256 << 10 // 每块 256 KiB(base64 后约 341 KiB)
maxFileBytes = 2 << 30 // 单文件上限 2 GiB
)
type fileWriter struct {
path string
tmp *os.File
tmpPath string
hash hash.Hash
got int64
// 期望值(core 下发时给的,用于对账)
size int64
sha string
}
type fileMgr struct {
mu sync.Mutex
writers map[string]*fileWriter
}
func newFileMgr() *fileMgr {
return &fileMgr{writers: map[string]*fileWriter{}}
}
// safePath 把设备侧路径限制在 root 之内(与 exec 的 cwd 校验同一套语义)。
func (r *runner) safePath(raw string) (string, error) {
if raw == "" {
return "", errors.New("path 不能为空")
}
p := raw
if !filepath.IsAbs(p) {
p = filepath.Join(r.root, p)
}
p = filepath.Clean(p)
rel, err := filepath.Rel(r.root, p)
if err != nil || rel == ".." || strings.HasPrefix(rel, ".."+string(filepath.Separator)) {
return "", errors.New("path 超出工作根:" + raw)
}
return p, nil
}
func (r *runner) fileStart(c *wsnode.Conn, m proto.Msg) {
switch m.Op {
case "read":
go r.fileRead(c, m)
case "write":
r.fileBegin(c, m)
default:
r.fileFail(c, m.ID, "未知的 file.op:"+m.Op)
}
}
func (r *runner) fileFail(c *wsnode.Conn, id, msg string) {
_ = c.Send(proto.Msg{T: proto.TKindFileDone, ID: id, Err: msg})
}
// fileRead 把设备上的文件分块推回 core。
func (r *runner) fileRead(c *wsnode.Conn, m proto.Msg) {
p, err := r.safePath(m.Path)
if err != nil {
r.fileFail(c, m.ID, err.Error())
return
}
f, err := os.Open(p)
if err != nil {
r.fileFail(c, m.ID, err.Error())
return
}
defer f.Close()
st, err := f.Stat()
if err != nil {
r.fileFail(c, m.ID, err.Error())
return
}
if st.IsDir() {
r.fileFail(c, m.ID, "是目录,不是文件:"+p)
return
}
if st.Size() > maxFileBytes {
r.fileFail(c, m.ID, "文件超过 2GiB 上限")
return
}
h := sha256.New()
buf := make([]byte, fileChunkSize)
var sent int64
for {
n, rerr := f.Read(buf)
if n > 0 {
h.Write(buf[:n])
sent += int64(n)
if err := c.Send(proto.Msg{
T: proto.TKindFileChunk, ID: m.ID,
Data: append([]byte(nil), buf[:n]...),
}); err != nil {
return
}
}
if rerr == io.EOF {
break
}
if rerr != nil {
r.fileFail(c, m.ID, rerr.Error())
return
}
}
_ = c.Send(proto.Msg{
T: proto.TKindFileDone, ID: m.ID,
Size: sent, SHA: hex.EncodeToString(h.Sum(nil)),
})
}
// fileBegin 为一次 write 建立临时文件。
func (r *runner) fileBegin(c *wsnode.Conn, m proto.Msg) {
p, err := r.safePath(m.Path)
if err != nil {
r.fileFail(c, m.ID, err.Error())
return
}
if m.Size > maxFileBytes {
r.fileFail(c, m.ID, "文件超过 2GiB 上限")
return
}
if err := os.MkdirAll(filepath.Dir(p), 0o755); err != nil {
r.fileFail(c, m.ID, err.Error())
return
}
tmpPath := p + ".part"
f, err := os.OpenFile(tmpPath, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0o644)
if err != nil {
r.fileFail(c, m.ID, err.Error())
return
}
r.files.mu.Lock()
r.files.writers[m.ID] = &fileWriter{
path: p, tmp: f, tmpPath: tmpPath, hash: sha256.New(),
size: m.Size, sha: m.SHA,
}
r.files.mu.Unlock()
}
func (r *runner) fileChunk(c *wsnode.Conn, m proto.Msg) {
r.files.mu.Lock()
w := r.files.writers[m.ID]
r.files.mu.Unlock()
if w == nil {
return
}
if w.got+int64(len(m.Data)) > maxFileBytes {
r.abortWriter(m.ID, w, "超过 2GiB 上限")
r.fileFail(c, m.ID, "超过 2GiB 上限")
return
}
if _, err := w.tmp.Write(m.Data); err != nil {
r.abortWriter(m.ID, w, err.Error())
r.fileFail(c, m.ID, err.Error())
return
}
w.hash.Write(m.Data)
w.got += int64(len(m.Data))
}
// fileEnd 收尾写入:校验大小与 sha256,通过才改名到正式路径。
func (r *runner) fileEnd(c *wsnode.Conn, m proto.Msg) {
r.files.mu.Lock()
w := r.files.writers[m.ID]
delete(r.files.writers, m.ID)
r.files.mu.Unlock()
if w == nil {
return
}
defer func() { _ = w.tmp.Close() }()
sum := hex.EncodeToString(w.hash.Sum(nil))
if w.size > 0 && w.got != w.size {
_ = os.Remove(w.tmpPath)
r.fileFail(c, m.ID, "大小不符:收到 "+strconv.FormatInt(w.got, 10)+",应为 "+strconv.FormatInt(w.size, 10))
return
}
if w.sha != "" && !strings.EqualFold(w.sha, sum) {
_ = os.Remove(w.tmpPath)
r.fileFail(c, m.ID, "sha256 不符")
return
}
if err := w.tmp.Close(); err != nil {
_ = os.Remove(w.tmpPath)
r.fileFail(c, m.ID, err.Error())
return
}
if err := os.Rename(w.tmpPath, w.path); err != nil {
_ = os.Remove(w.tmpPath)
r.fileFail(c, m.ID, err.Error())
return
}
_ = c.Send(proto.Msg{T: proto.TKindFileDone, ID: m.ID, Size: w.got, SHA: sum})
}
func (r *runner) abortWriter(id string, w *fileWriter, why string) {
r.files.mu.Lock()
delete(r.files.writers, id)
r.files.mu.Unlock()
_ = w.tmp.Close()
_ = os.Remove(w.tmpPath)
}
+162
View File
@@ -0,0 +1,162 @@
//go:build !windows
package main
// 主机指标:Linux 读 /proc,macOS 调 sysctl / vm_stat(health 调用不频繁,允许 fork)。
// 拿不到的指标给 -1,不编数据。
import (
"context"
"os"
"os/exec"
"runtime"
"strconv"
"strings"
"syscall"
"time"
)
type healthInfo struct {
HostUptimeSec int64
Load1, Load5, Load15 float64
MemTotalMB, MemFreeMB int64
DiskTotalGB, DiskFreeGB float64
TempC float64
}
func hostHealth() healthInfo {
h := healthInfo{
HostUptimeSec: -1, Load1: -1, Load5: -1, Load15: -1,
MemTotalMB: -1, MemFreeMB: -1, DiskTotalGB: -1, DiskFreeGB: -1, TempC: -1,
}
switch runtime.GOOS {
case "linux":
if b, err := os.ReadFile("/proc/uptime"); err == nil {
if f := strings.Fields(string(b)); len(f) > 0 {
if v, err := strconv.ParseFloat(f[0], 64); err == nil {
h.HostUptimeSec = int64(v)
}
}
}
if b, err := os.ReadFile("/proc/loadavg"); err == nil {
if f := strings.Fields(string(b)); len(f) >= 3 {
h.Load1, _ = strconv.ParseFloat(f[0], 64)
h.Load5, _ = strconv.ParseFloat(f[1], 64)
h.Load15, _ = strconv.ParseFloat(f[2], 64)
}
}
if b, err := os.ReadFile("/proc/meminfo"); err == nil {
for _, line := range strings.Split(string(b), "\n") {
f := strings.Fields(line)
if len(f) < 2 {
continue
}
kb, _ := strconv.ParseInt(f[1], 10, 64)
switch f[0] {
case "MemTotal:":
h.MemTotalMB = kb / 1024
case "MemAvailable:":
h.MemFreeMB = kb / 1024
}
}
}
if b, err := os.ReadFile("/sys/class/thermal/thermal_zone0/temp"); err == nil {
if v, err := strconv.ParseFloat(strings.TrimSpace(string(b)), 64); err == nil {
h.TempC = v / 1000
}
}
case "darwin":
// macOS 没有 /proc,走 sysctl / vm_stat;每次 health 只 fork 三四个进程,频率极低
if v, err := sysctlValue("hw.memsize"); err == nil {
if n, err := strconv.ParseInt(v, 10, 64); err == nil {
h.MemTotalMB = n >> 20
}
}
// 开机时长:kern.boottime 形如 { sec = 1794298276, usec = 155984 } Tue Nov 10 …
if v, err := sysctlValue("kern.boottime"); err == nil {
if i := strings.Index(v, "sec = "); i >= 0 {
rest := v[i+6:]
if j := strings.IndexAny(rest, ",}"); j > 0 {
if sec, err := strconv.ParseInt(strings.TrimSpace(rest[:j]), 10, 64); err == nil {
h.HostUptimeSec = time.Now().Unix() - sec
}
}
}
}
// 负载:vm.loadavg 形如 { 1.11 1.40 1.59 }
if v, err := sysctlValue("vm.loadavg"); err == nil {
f := strings.FieldsFunc(v, func(r rune) bool { return r == '{' || r == '}' || r == ' ' })
if len(f) >= 3 {
h.Load1, _ = strconv.ParseFloat(f[0], 64)
h.Load5, _ = strconv.ParseFloat(f[1], 64)
h.Load15, _ = strconv.ParseFloat(f[2], 64)
}
}
// 可用内存 ≈ free + inactive + speculative:macOS 上只看 free 会小得吓人(大半是缓存)
if mb := darwinAvailableMB(); mb >= 0 {
h.MemFreeMB = mb
}
}
var st syscall.Statfs_t
if err := syscall.Statfs("/", &st); err == nil {
h.DiskTotalGB = float64(st.Blocks) * float64(st.Bsize) / (1 << 30)
h.DiskFreeGB = float64(st.Bavail) * float64(st.Bsize) / (1 << 30)
}
return h
}
// sysctlValue 读一个 sysctl 键,1s 超时兜底。
func sysctlValue(key string) (string, error) {
ctx, cancel := context.WithTimeout(context.Background(), time.Second)
defer cancel()
out, err := exec.CommandContext(ctx, "sysctl", "-n", key).Output()
if err != nil {
return "", err
}
return strings.TrimSpace(string(out)), nil
}
// darwinAvailableMB 解析 vm_stat,返回 free+inactive+speculative 的 MB 数;解析失败给 -1。
func darwinAvailableMB() int64 {
ctx, cancel := context.WithTimeout(context.Background(), 1200*time.Millisecond)
defer cancel()
out, err := exec.CommandContext(ctx, "vm_stat").Output()
if err != nil {
return -1
}
pageSize := int64(4096)
free, inactive, speculative := int64(-1), int64(0), int64(0)
for _, line := range strings.Split(string(out), "\n") {
if i := strings.Index(line, "page size of "); i >= 0 {
rest := line[i+len("page size of "):]
if j := strings.Index(rest, " bytes"); j > 0 {
if v, err := strconv.ParseInt(rest[:j], 10, 64); err == nil {
pageSize = v
}
}
continue
}
num := func(prefix string) (int64, bool) {
if !strings.HasPrefix(line, prefix) {
return 0, false
}
v, err := strconv.ParseInt(strings.TrimSuffix(strings.TrimSpace(line[len(prefix):]), "."), 10, 64)
return v, err == nil
}
if v, ok := num("Pages free:"); ok {
free = v
}
if v, ok := num("Pages inactive:"); ok {
inactive = v
}
if v, ok := num("Pages speculative:"); ok {
speculative = v
}
}
if free < 0 {
return -1
}
return (free + inactive + speculative) * pageSize / (1 << 20)
}
+67
View File
@@ -0,0 +1,67 @@
//go:build windows
package main
// Windows 指标:GetTickCount64(开机时长)+ GlobalMemoryStatusEx + GetDiskFreeSpaceExW。
// 负载/温度在 Windows 上没有等价指标,返回 -1。
import (
"syscall"
"unsafe"
)
type healthInfo struct {
HostUptimeSec int64
Load1, Load5, Load15 float64
MemTotalMB, MemFreeMB int64
DiskTotalGB, DiskFreeGB float64
TempC float64
}
var (
kernel32 = syscall.NewLazyDLL("kernel32.dll")
procTick = kernel32.NewProc("GetTickCount64")
procMem = kernel32.NewProc("GlobalMemoryStatusEx")
procDiskF = kernel32.NewProc("GetDiskFreeSpaceExW")
)
type memStatusEx struct {
Length uint32
MemoryLoad uint32
TotalPhys uint64
AvailPhys uint64
TotalPageFile uint64
AvailPageFile uint64
TotalVirtual uint64
AvailVirtual uint64
AvailExtendedVirtual uint64
}
func hostHealth() healthInfo {
h := healthInfo{
HostUptimeSec: -1, Load1: -1, Load5: -1, Load15: -1,
MemTotalMB: -1, MemFreeMB: -1, DiskTotalGB: -1, DiskFreeGB: -1, TempC: -1,
}
if r, _, _ := procTick.Call(); r != 0 {
h.HostUptimeSec = int64(r / 1000)
}
var m memStatusEx
m.Length = uint32(unsafe.Sizeof(m))
if r, _, _ := procMem.Call(uintptr(unsafe.Pointer(&m))); r != 0 {
h.MemTotalMB = int64(m.TotalPhys >> 20)
h.MemFreeMB = int64(m.AvailPhys >> 20)
}
if p, err := syscall.UTF16PtrFromString("C:\\"); err == nil {
var free, total, totalFree uint64
if r, _, _ := procDiskF.Call(
uintptr(unsafe.Pointer(p)),
uintptr(unsafe.Pointer(&free)),
uintptr(unsafe.Pointer(&total)),
uintptr(unsafe.Pointer(&totalFree)),
); r != 0 {
h.DiskTotalGB = float64(total) / (1 << 30)
h.DiskFreeGB = float64(free) / (1 << 30)
}
}
return h
}
+522
View File
@@ -0,0 +1,522 @@
// agent-device:跑在盒子 / Windows / 任意 Linux 上,主动出站连 core 的 wss,接收并执行命令。
//
// agent-device -server wss://your-host.example/dev/ws -token <TOKEN> -root /var/agent/work
// agent-device # 自动读同目录下的 config.json(token 不进 ps)
//
// 设计约束(对齐 files/print/agent):
// - 只出站,服务器不需要任何入站端口
// - 断线指数退避重连,半开连接靠读超时兜底
// - 单机不依赖 Node / 不装运行时,一个二进制跑起来
package main
import (
"context"
"encoding/json"
"errors"
"flag"
"io"
"log"
"os"
"os/exec"
"path/filepath"
"runtime"
"strings"
"sync"
"sync/atomic"
"time"
"unicode/utf8"
"agent-device/pkg/proto"
"agent-device/pkg/wsnode"
"golang.org/x/text/encoding/simplifiedchinese"
)
const version = "0.1.1"
var (
maxOutBytes = int64(4 << 20) // 单条命令回传上限,超出截断并标记
maxParallel = 4 // 同机并发执行数
)
type proc struct {
cmd *exec.Cmd
mu sync.Mutex
kln string // 终止原因:cancelled / timeout
}
func (p *proc) kill(reason string) {
p.mu.Lock()
if p.kln == "" {
p.kln = reason
}
p.mu.Unlock()
killProc(p.cmd)
}
func (p *proc) killed() string {
p.mu.Lock()
defer p.mu.Unlock()
return p.kln
}
// fileConfig 是 -config 读的 JSON,字段全部可选:没写的落到命令行/默认值。
// 之所以需要它:token 写在命令行会被 ps 看见。
type fileConfig struct {
Server string `json:"server"`
Token string `json:"token"`
Root string `json:"root"`
Name string `json:"name"`
Shell string `json:"shell"`
Insecure *bool `json:"insecure"`
}
var startedAt = time.Now()
type runner struct {
conn *wsnode.Conn
root string
shell string
sem chan struct{}
mu sync.Mutex
procs map[string]*proc
files *fileMgr // 文件通道:core 拉取/推送文件时的在途写入
}
func main() {
server := flag.String("server", "", "core 的接入地址,如 wss://your-host.example/dev/ws")
token := flag.String("token", "", "Bearer token(或环境变量 NODE_TOKEN,或写在 -config 里)")
root := flag.String("root", "", "工作根目录(默认 ~/agent-work),命令的 cwd 必须落在它之内")
shellName := flag.String("shell", "", "sh | cmd | powershell(默认按平台)")
name := flag.String("name", "", "设备名(默认 hostname)")
configPath := flag.String("config", "", "JSON 配置文件;不给时自动找可执行文件同目录的 config.json")
insecure := flag.Bool("insecure", false, "跳过证书校验")
fixClock := flag.Bool("fix-clock", false, "证书失败时用服务器时间校准本机(Linux 需 root)")
flag.Parse()
// 优先级:命令行显式参数 > 环境变量(仅 token)> 配置文件 > 默认值。
// 配置文件的意义是把 token 从命令行拿掉——ps aux 能看见所有参数。
set := map[string]bool{}
flag.Visit(func(f *flag.Flag) { set[f.Name] = true })
// 配置文件默认位置:可执行文件同目录的 config.json。放二进制旁边就不用带参数,
// token 也不会出现在 ps 里。命令行显式给的 -config 优先。
effectiveCfg := *configPath
if effectiveCfg == "" {
if dir := exeDir(); dir != "" {
p := filepath.Join(dir, "config.json")
if _, err := os.Stat(p); err == nil {
effectiveCfg = p
}
}
}
if effectiveCfg != "" {
var fc fileConfig
b, err := os.ReadFile(effectiveCfg)
if err != nil {
log.Fatalf("读配置失败:%v", err)
}
if err := json.Unmarshal(b, &fc); err != nil {
log.Fatalf("配置 %s 不是合法 JSON:%v", effectiveCfg, err)
}
log.Printf("已加载配置 %s", effectiveCfg)
if !set["server"] && fc.Server != "" {
*server = fc.Server
}
if !set["token"] && fc.Token != "" {
*token = fc.Token
}
if !set["root"] && fc.Root != "" {
*root = fc.Root
}
if !set["name"] && fc.Name != "" {
*name = fc.Name
}
if !set["shell"] && fc.Shell != "" {
*shellName = fc.Shell
}
if !set["insecure"] && fc.Insecure != nil {
*insecure = *fc.Insecure
}
}
if *token == "" {
*token = os.Getenv("NODE_TOKEN")
}
if *server == "" {
log.Fatal("缺少 -server(或配置文件里的 server)")
}
if *token == "" {
log.Fatal("缺少 token:用 -token / NODE_TOKEN / 配置文件")
}
r := &runner{
root: *root,
shell: *shellName,
sem: make(chan struct{}, maxParallel),
procs: map[string]*proc{},
files: newFileMgr(),
}
if r.root == "" {
home, _ := os.UserHomeDir()
r.root = filepath.Join(home, "agent-work")
}
r.root = filepath.Clean(r.root)
// 相对路径按可执行文件所在目录解析:双击、服务、命令行启动都得到同一个工作区,
// 不受进程当前目录影响;同时不允许用 ".." 跑到 exe 目录之外。
if !filepath.IsAbs(r.root) {
dir := exeDir()
if dir == "" {
log.Fatalf("工作根 %q 是相对路径,但取不到可执行文件位置", r.root)
}
abs := filepath.Join(dir, r.root)
rel, err := filepath.Rel(dir, abs)
if err != nil || rel == ".." || strings.HasPrefix(rel, ".."+string(filepath.Separator)) {
log.Fatalf("工作根 %q 超出可执行文件目录:%s", r.root, abs)
}
r.root = abs
}
if err := os.MkdirAll(r.root, 0o755); err != nil {
log.Fatalf("工作根不可用:%v", err)
}
// 进程 cwd 失效时(快捷方式的「起始位置」指向已删目录、启动目录被改名等),
// Windows 上 os/exec 给 nil Stdin 打开空设备 "NUL" 是个相对路径调用,会直接报
// 「找不到文件」,任何命令都起不来(含下面的 shellInfo 探测)。工作根刚 MkdirAll 过,
// 钉在这里;失败也不致命,后面 run() 还有一层不依赖 NUL 的兵底。
if err := os.Chdir(r.root); err != nil {
log.Printf("切换工作目录失败(不影响命令执行):%v", err)
}
if r.shell == "" {
r.shell = defaultShell()
}
host, _ := os.Hostname()
if *name != "" {
host = *name
}
log.Printf("agent-device %s 启动:root=%s shell=%s → %s", version, r.root, shellKind(r.shell), *server)
shPath, shVer := shellInfo(r.shell)
log.Printf("shell:%s(%s %s)", r.shell, shPath, shVer)
cfg := wsnode.Config{URL: *server, Token: *token, Insecure: *insecure, FixClock: *fixClock}
err := wsnode.Run(context.Background(), cfg,
func(c *wsnode.Conn) error {
r.conn = c
if err := c.Send(proto.Msg{
T: proto.TKindHello, Ver: version, Name: host,
OS: runtime.GOOS, Arch: runtime.GOARCH,
Shell: shellKind(r.shell), ShellPath: shPath, ShellVer: shVer, Root: r.root,
}); err != nil {
return err
}
log.Printf("已连上 hub(%s/%s shell=%s %s)", runtime.GOOS, runtime.GOARCH, shPath, shVer)
return nil
},
func(c *wsnode.Conn, t string, raw []byte) {
var m proto.Msg
if json.Unmarshal(raw, &m) != nil {
return
}
switch t {
case proto.TKindExec:
go r.run(m)
case proto.TKindKill:
if p := r.lookup(m.ID); p != nil {
p.kill("cancelled")
}
case proto.TKindPing:
_ = c.Send(proto.Msg{T: proto.TKindPong})
case proto.TKindFile:
// write 的建栅必须同步完成:core 紧接着就发 chunk,异步会先到后建、丢块
r.fileStart(c, m)
case proto.TKindFileChunk:
r.fileChunk(c, m)
case proto.TKindFileDone:
r.fileEnd(c, m)
case proto.TKindHealth:
h := hostHealth()
m := proto.Msg{
T: proto.TKindHealth, ID: m.ID,
UptimeSec: int64(time.Since(startedAt).Seconds()), HostUptimeSec: h.HostUptimeSec,
Load1: h.Load1, Load5: h.Load5, Load15: h.Load15,
MemTotalMB: h.MemTotalMB, MemFreeMB: h.MemFreeMB,
DiskTotalGB: h.DiskTotalGB, DiskFreeGB: h.DiskFreeGB, TempC: h.TempC,
OS: runtime.GOOS, Arch: runtime.GOARCH, Name: host,
}
_ = c.Send(m)
}
})
log.Printf("退出:%v", err)
}
func (r *runner) lookup(id string) *proc {
r.mu.Lock()
defer r.mu.Unlock()
return r.procs[id]
}
func (r *runner) send(m proto.Msg) { _ = r.conn.Send(m) }
func (r *runner) exit(id string, code int, killed, errMsg string, truncated bool, ms int64) {
m := proto.Msg{T: proto.TKindExit, ID: id, Code: &code, Killed: killed, Err: errMsg, MS: ms, Truncated: truncated}
r.send(m)
}
// run 执行一条命令:并发闸门 → cwd 校验 → 起进程组 → 流式回传 → 退出码。
func (r *runner) run(m proto.Msg) {
select {
case r.sem <- struct{}{}:
case <-time.After(30 * time.Second):
r.exit(m.ID, -1, "", "节点忙:排队超过 30 秒", false, 0)
return
}
defer func() { <-r.sem }()
dir, err := r.resolveCwd(m.Cwd)
if err != nil {
r.exit(m.ID, -1, "", err.Error(), false, 0)
return
}
tmo := time.Duration(m.TimeoutMS) * time.Millisecond
if tmo <= 0 {
tmo = 5 * time.Minute
}
ctx, cancel := context.WithTimeout(context.Background(), tmo)
defer cancel()
sh, shArgs := shellCmd(r.shell)
cmd := newCmd(ctx, sh, append(shArgs, m.Cmd)...)
cmd.Dir = dir
if len(m.Env) > 0 {
cmd.Env = append(os.Environ(), flatten(m.Env)...)
}
cmd.Cancel = func() error { killProc(cmd); return nil } // 超时/取消时整组杀,不只杀 sh
setupProc(cmd)
outPipe, err1 := cmd.StdoutPipe()
errPipe, err2 := cmd.StderrPipe()
if err1 != nil || err2 != nil {
r.exit(m.ID, 127, "", "取管道失败", false, 0)
return
}
p := &proc{cmd: cmd}
r.mu.Lock()
r.procs[m.ID] = p
r.mu.Unlock()
defer func() {
r.mu.Lock()
delete(r.procs, m.ID)
r.mu.Unlock()
}()
started := time.Now()
if err := cmd.Start(); err != nil {
r.exit(m.ID, 127, "", "启动失败:"+err.Error(), false, 0)
return
}
var sent atomic.Int64
var truncated atomic.Bool
var wg sync.WaitGroup
pump := func(rd io.Reader, stream string) {
defer wg.Done()
buf := make([]byte, 32<<10)
for {
n, rerr := rd.Read(buf)
if n > 0 {
if sent.Load() >= maxOutBytes {
truncated.Store(true)
} else {
chunk := make([]byte, n)
copy(chunk, buf[:n])
sent.Add(int64(n))
r.send(proto.Msg{T: proto.TKindChunk, ID: m.ID, Out: stream, Stream: chunk})
}
}
if rerr != nil {
return
}
}
}
wg.Add(2)
go pump(outPipe, "out")
go pump(errPipe, "err")
wg.Wait()
werr := cmd.Wait()
code := 0
if werr != nil {
var ee *exec.ExitError
if errors.As(werr, &ee) {
code = ee.ExitCode()
} else {
code = 127
}
}
killed := p.killed()
if killed == "" && ctx.Err() == context.DeadlineExceeded {
killed = "timeout"
}
if killed != "" && code == 0 {
code = -1
}
r.exit(m.ID, code, killed, "", truncated.Load(), time.Since(started).Milliseconds())
}
// resolveCwd:hub 已把服务器路径重写成节点路径,这里只保证落在 root 之内并自动建目录。
func (r *runner) resolveCwd(raw string) (string, error) {
if raw == "" {
return r.root, nil
}
if !filepath.IsAbs(raw) {
return "", errors.New("cwd 必须是绝对路径:" + raw)
}
cwd := filepath.Clean(raw)
rel, err := filepath.Rel(r.root, cwd)
if err != nil || rel == ".." || strings.HasPrefix(rel, ".."+string(filepath.Separator)) {
return "", errors.New("cwd 超出工作根:" + cwd)
}
if err := os.MkdirAll(cwd, 0o755); err != nil {
return "", errors.New("建目录失败:" + err.Error())
}
return cwd, nil
}
func flatten(env map[string]string) []string {
out := make([]string, 0, len(env))
for k, v := range env {
out = append(out, k+"="+v)
}
return out
}
// exeDir 返回可执行文件所在目录(解开软链接)。相对的工作根、默认配置都基于它。
func exeDir() string {
exe, err := os.Executable()
if err != nil {
return ""
}
if real, err := filepath.EvalSymlinks(exe); err == nil {
exe = real
}
return filepath.Dir(exe)
}
// defaultShell 选默认解释器。POSIX 上固定 /bin/sh(不读 $SHELL:用户把 shell 设成 fish
// 之后模型写的 POSIX 语法全废);Windows 默认 cmd,想用 git-bash / busybox 就在
// config.json 里写 "shell": "C:\\Program Files\\Git\\bin\\bash.exe"(或 PATH 里的名字)。
func defaultShell() string {
if runtime.GOOS == "windows" {
return "cmd"
}
return "sh"
}
// shellKind 把路径/命令名归成一个短标签给 core 看(hello 的 shell 字段)。
func shellKind(p string) string {
b := strings.ToLower(filepath.Base(p))
switch {
case strings.Contains(b, "busybox"):
return "busybox"
case strings.Contains(b, "bash"):
return "bash"
case b == "sh" || b == "sh.exe" || b == "/bin/sh":
return "sh"
case strings.Contains(b, "powershell"), b == "pwsh", b == "pwsh.exe":
return "powershell"
case b == "cmd" || b == "cmd.exe":
return "cmd"
}
return p
}
// newCmd 统一构造要执行的命令:Stdin 显式给一个空 reader。
// 不给(nil)时 os/exec 会自己 os.Open(os.DevNull),Windows 上那是相对路径的设备名
// "NUL"——有的机器上 CreateFile 直接报 ERROR_FILE_NOT_FOUND,命令还没到 shell 就死了
//(实测 pc-gd:所有 exec 都 exit 127 "open NUL: The system cannot find the file specified")。
// 空 reader 与 NUL 语义一致(子进程读到立即 EOF),且不依赖进程 cwd。
func newCmd(ctx context.Context, name string, args ...string) *exec.Cmd {
c := exec.CommandContext(ctx, name, args...)
c.Stdin = strings.NewReader("")
return c
}
func shellCmd(name string) (string, []string) {
switch name {
case "cmd":
return "cmd", []string{"/c"}
case "powershell", "pwsh":
return name, []string{"-NoProfile", "-NonInteractive", "-Command"}
}
// busybox 的子命令形式:busybox sh -c "…"
if strings.Contains(strings.ToLower(filepath.Base(name)), "busybox") {
return name, []string{"sh", "-c"}
}
// 带路径的(git-bash 绝对路径、/bin/sh)直接当 POSIX shell 用
if strings.ContainsAny(name, `\/`) {
return name, []string{"-c"}
}
if runtime.GOOS == "windows" {
return "cmd", []string{"/c"}
}
if _, err := os.Stat("/bin/sh"); err == nil {
return "/bin/sh", []string{"-c"}
}
return "sh", []string{"-c"}
}
// toUTF8 把 Windows 中文控制台吐出的 GBK 字节转成 UTF-8。
// 先过 utf8.Valid:纯 ASCII / 真 UTF-8(英文版 Windows、开了 UTF-8 的系统)一律原样返回,
// 不会被误转;只有不是合法 UTF-8 时才按 GBK 解,解不出来就保留原样。
func toUTF8(b []byte) []byte {
if utf8.Valid(b) {
return b
}
if d, err := simplifiedchinese.GBK.NewDecoder().Bytes(b); err == nil {
return d
}
return b
}
// shellInfo 探测实际解释器与版本。这是模型写命令的唯一入口,所以路径要解开符号链接
// (/bin/sh 可能是 dash / bash / busybox),版本拿不到就留空(dash、busybox 不支持 --version)。
func shellInfo(name string) (string, string) {
bin, _ := shellCmd(name)
p, err := exec.LookPath(bin)
if err != nil {
return "", ""
}
if real, err := filepath.EvalSymlinks(p); err == nil {
p = real
}
ctx, cancel := context.WithTimeout(context.Background(), 800*time.Millisecond)
defer cancel()
var c *exec.Cmd
switch name {
case "cmd":
c = newCmd(ctx, "cmd", "/c", "ver")
case "powershell", "pwsh":
c = newCmd(ctx, bin, "-NoProfile", "-NonInteractive", "-Command",
"$PSVersionTable.PSVersion.ToString()")
default:
c = newCmd(ctx, p, "--version")
}
out, _ := c.Output()
out = toUTF8(out) // 中文 Windows 的 ver 是 GBK;本来就是 UTF-8 的原样返回
ver := ""
if s := strings.TrimSpace(string(out)); s != "" {
if i := strings.IndexByte(s, '\n'); i > 0 {
s = s[:i]
}
s = strings.TrimSpace(s)
if len(s) > 60 {
s = s[:60] + "…"
}
ver = s
}
return p, ver
}
+21
View File
@@ -0,0 +1,21 @@
//go:build !windows
package main
import (
"os/exec"
"syscall"
)
// setupProc 让命令自成一个进程组,后面才能整组杀(sh 拉起的子进程一起收)。
func setupProc(cmd *exec.Cmd) {
cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
}
// killProc 负号 = 整个进程组。忽略错误:进程可能已自行退出。
func killProc(cmd *exec.Cmd) {
if cmd == nil || cmd.Process == nil {
return
}
_ = syscall.Kill(-cmd.Process.Pid, syscall.SIGKILL)
}
+25
View File
@@ -0,0 +1,25 @@
//go:build windows
package main
import (
"context"
"os/exec"
"strconv"
"syscall"
)
const createNewProcessGroup = 0x00000200
// setupProc 让命令自成一组,taskkill /T 才能连子进程一起收。
func setupProc(cmd *exec.Cmd) {
cmd.SysProcAttr = &syscall.SysProcAttr{CreationFlags: createNewProcessGroup}
}
func killProc(cmd *exec.Cmd) {
if cmd == nil || cmd.Process == nil {
return
}
_ = newCmd(context.Background(), "taskkill", "/T", "/F", "/PID", strconv.Itoa(cmd.Process.Pid)).Run()
_ = cmd.Process.Kill()
}
+7
View File
@@ -0,0 +1,7 @@
module agent-device
go 1.22
require github.com/gorilla/websocket v1.5.3
require golang.org/x/text v0.21.0
+4
View File
@@ -0,0 +1,4 @@
github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
golang.org/x/text v0.21.0 h1:zyQAAkrwaneQ066sspRyJaG9VNi/YJ1NfzcGB3hZ/qo=
golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ=
+68
View File
@@ -0,0 +1,68 @@
// Package proto 定义 hub 与节点之间的消息。一条连接上全是 JSON 文本帧,
// 用 t 字段区分类型;二进制数据(命令输出)走 chunk 字段,encoding/json 自动 base64。
package proto
// 消息类型
const (
TKindHello = "hello" // 节点 → hub:上线自报家门
TKindExec = "exec" // hub → 节点:执行一条命令
TKindKill = "kill" // hub → 节点:终止某条命令
TKindChunk = "chunk" // 节点 → hub:输出片段
TKindExit = "exit" // 节点 → hub:命令结束
TKindPing = "ping" // hub → 节点:保活
TKindPong = "pong" // 节点 → hub:保活回应
TKindHealth = "health" // 双向:hub 要指标 / 节点回指标
TKindFile = "file" // 双向:core 发起一次 read/write
TKindFileChunk = "file.chunk" // 双向:文件数据块(base64)
TKindFileDone = "file.done" // 双向:结束,带 size / sha256 / err
)
// Msg 是双向通用信封:不同 t 只用其中一部分字段,其余 omitempty。
type Msg struct {
T string `json:"t"`
// hello
Ver string `json:"ver,omitempty"`
Name string `json:"name,omitempty"`
OS string `json:"os,omitempty"`
Arch string `json:"arch,omitempty"`
Shell string `json:"shell,omitempty"` // 逻辑名:sh / cmd / powershell
ShellPath string `json:"shell_path,omitempty"` // 实际解释器路径(符号链接已解开)
ShellVer string `json:"shell_ver,omitempty"` // 版本首行(拿不到就留空)
Root string `json:"root,omitempty"`
// exec / kill
ID string `json:"id,omitempty"`
Cmd string `json:"cmd,omitempty"`
Cwd string `json:"cwd,omitempty"`
TimeoutMS int `json:"timeout_ms,omitempty"`
Env map[string]string `json:"env,omitempty"`
// chunk / exit
Stream []byte `json:"chunk,omitempty"` // 原始字节,JSON 里是 base64
Out string `json:"out,omitempty"` // "out" | "err"
Code *int `json:"code,omitempty"`
Killed string `json:"killed_by,omitempty"` // cancelled | timeout
MS int64 `json:"ms,omitempty"`
Err string `json:"err,omitempty"`
Truncated bool `json:"truncated,omitempty"`
// health(hub 请求 / 节点回报共用)
UptimeSec int64 `json:"uptime_sec,omitempty"` // 本进程已运行秒数
HostUptimeSec int64 `json:"host_uptime_sec,omitempty"` // 主机开机秒数(不支持为 -1)
Load1 float64 `json:"load1,omitempty"`
Load5 float64 `json:"load5,omitempty"`
Load15 float64 `json:"load15,omitempty"`
MemTotalMB int64 `json:"mem_total_mb,omitempty"`
MemFreeMB int64 `json:"mem_free_mb,omitempty"`
DiskTotalGB float64 `json:"disk_total_gb,omitempty"`
DiskFreeGB float64 `json:"disk_free_gb,omitempty"`
TempC float64 `json:"temp_c,omitempty"`
// file(read/write 共用一个 信封)
Op string `json:"op,omitempty"` // read | write
Path string `json:"path,omitempty"` // 设备侧绝对路径,必须在 root 内
Size int64 `json:"size,omitempty"` // 文件字节数
SHA string `json:"sha256,omitempty"` // 文件内容的 sha256(传完对账)
Data []byte `json:"data,omitempty"` // 数据块(JSON 里是 base64)
}
+210
View File
@@ -0,0 +1,210 @@
// Package wsnode 是「节点主动出站 + 断线重连 + 心跳保活」的最小 WebSocket 基座。
// 语义与 files/print/agent 一致:节点在 NAT 后面也能被驱动,服务器不需要任何入站端口。
package wsnode
import (
"context"
"crypto/tls"
"crypto/x509"
"encoding/json"
"fmt"
"log"
"net"
"net/http"
"net/url"
"os"
"os/exec"
"runtime"
"time"
"github.com/gorilla/websocket"
)
// ReadTimeout 多久没收到服务器任何消息(含 ping)就认定连接已死。
// hub 每 20s ping 一次,正常情况下永远触发不到;半开连接会在这里超时并触发重连。
const ReadTimeout = 90 * time.Second
type Config struct {
URL string // wss://host/ws
Token string // Authorization: Bearer <token>
Insecure bool // 跳过证书校验(自签环境)
CAFile string // 额外信任的 CA
FixClock bool // 证书校验失败时用服务器 Date 头校时(盒子无 RTC 时有用)
}
type Conn struct {
ws *websocket.Conn
mu chan struct{} // 容量 1 的信号量:gorilla 不允许并发写
cfg Config
}
func (c *Conn) Send(v any) error {
b, err := json.Marshal(v)
if err != nil {
return err
}
c.mu <- struct{}{}
defer func() { <-c.mu }()
return c.ws.WriteMessage(websocket.TextMessage, b)
}
func (c *Conn) Close() { _ = c.ws.Close() }
// Wrap 把已升级的底层连接包成 Conn(hub 服务端用;客户端走 Run/Dial)。
func Wrap(ws *websocket.Conn) *Conn {
ws.SetReadLimit(4 << 20)
return &Conn{ws: ws, mu: make(chan struct{}, 1)}
}
// Run 持续维持连接:拨号 → onOpen → 读循环 → 断开 → 退避重连,直到 ctx 结束。
func Run(ctx context.Context, cfg Config, onOpen func(*Conn) error, onMsg func(*Conn, string, []byte)) error {
backoff := time.Second
for {
start := time.Now()
err := once(ctx, cfg, onOpen, onMsg)
if ctx.Err() != nil {
return ctx.Err()
}
// 稳定连过 60s 才把退避重置,避免「连上就断」时疯狂重试
if time.Since(start) > 60*time.Second {
backoff = time.Second
}
if err != nil {
log.Printf("连接中断:%v;%s 后重连", err, backoff)
}
select {
case <-time.After(backoff):
case <-ctx.Done():
return ctx.Err()
}
if backoff < 30*time.Second {
backoff *= 2
if backoff > 30*time.Second {
backoff = 30 * time.Second
}
}
}
}
func once(ctx context.Context, cfg Config, onOpen func(*Conn) error, onMsg func(*Conn, string, []byte)) error {
d := websocket.Dialer{
HandshakeTimeout: 15 * time.Second,
TLSClientConfig: tlsConf(cfg),
Proxy: http.ProxyFromEnvironment,
NetDial: (&net.Dialer{
Timeout: 15 * time.Second,
KeepAlive: 30 * time.Second,
}).Dial,
}
hdr := http.Header{}
if cfg.Token != "" {
hdr.Set("Authorization", "Bearer "+cfg.Token)
}
ws, resp, err := d.DialContext(ctx, cfg.URL, hdr)
if err != nil {
if resp != nil {
return fmt.Errorf("%s 拒绝连接:%s", cfg.URL, resp.Status)
}
if cfg.FixClock && !cfg.Insecure && isCertErr(err) {
log.Printf("证书校验失败,可能是系统时间不对(%v),尝试用服务器时间校准", err)
syncClock(cfg.URL)
}
return err
}
defer ws.Close()
ws.SetReadLimit(4 << 20)
c := &Conn{ws: ws, mu: make(chan struct{}, 1), cfg: cfg}
if err := onOpen(c); err != nil {
return err
}
for {
_ = ws.SetReadDeadline(time.Now().Add(ReadTimeout))
_, data, err := ws.ReadMessage()
if err != nil {
return err
}
var head struct {
T string `json:"t"`
}
if json.Unmarshal(data, &head) != nil {
continue
}
onMsg(c, head.T, data)
}
}
func isCertErr(err error) bool {
for _, k := range []string{"certificate", "x509", "tls:"} {
if contains(err.Error(), k) {
return true
}
}
return false
}
func contains(s, sub string) bool {
for i := 0; i+len(sub) <= len(s); i++ {
if s[i:i+len(sub)] == sub {
return true
}
}
return false
}
func tlsConf(cfg Config) *tls.Config {
t := &tls.Config{InsecureSkipVerify: cfg.Insecure}
if cfg.CAFile != "" {
if pem, err := os.ReadFile(cfg.CAFile); err == nil {
pool := x509.NewCertPool()
if pool.AppendCertsFromPEM(pem) {
t.RootCAs = pool
}
} else {
log.Printf("读 CA 失败:%v(忽略)", err)
}
}
return t
}
// syncClock 用服务器 Date 头把本机时间拨回来(只对 Linux 的 date 生效,Windows 一般有 RTC 不需要)。
// 证书本身可能是「因为时间错才失败」,所以这里刻意不校验证书。
func syncClock(rawURL string) {
u, err := url.Parse(rawURL)
if err != nil {
return
}
scheme := "http"
if u.Scheme == "wss" || u.Scheme == "https" {
scheme = "https"
}
req, err := http.NewRequest("HEAD", scheme+"://"+u.Host+"/", nil)
if err != nil {
return
}
client := &http.Client{
Timeout: 10 * time.Second,
Transport: &http.Transport{TLSClientConfig: &tls.Config{InsecureSkipVerify: true}},
}
resp, err := client.Do(req)
if err != nil {
log.Printf("校时请求失败:%v", err)
return
}
defer resp.Body.Close()
t, err := http.ParseTime(resp.Header.Get("Date"))
if err != nil {
log.Printf("服务器 Date 头不可解析:%v", err)
return
}
log.Printf("本地时间偏差约 %s(服务器 %s)", time.Since(t).Truncate(time.Second), t.Format(time.RFC3339))
if runtime.GOOS == "windows" {
return
}
out, err := exec.Command("date", "-u", "-s", t.UTC().Format("2006-01-02 15:04:05")).CombinedOutput()
if err != nil {
log.Printf("设置系统时间失败(需要 root):%v %s", err, out)
return
}
log.Printf("已校时到 %s", t.UTC().Format(time.RFC3339))
}
+48
View File
@@ -0,0 +1,48 @@
#!/bin/sh
# 交叉编译设备端二进制到 ./bin(纯本地动作:不联网、不推送、不依赖任何特定服务器)。
#
# sh scripts/build.sh # 编当前平台
# sh scripts/build.sh all # 编 linux-arm64 / linux-amd64 / linux-mips / windows-amd64 / darwin-amd64 / darwin-arm64
#
# 有本机 Go 就用本机;没有但有 docker 就用 golang 镜像;都没有就报错。
set -e
cd "$(dirname "$0")/.."
TARGETS="$(uname -s | tr 'A-Z' 'a-z')/$(uname -m | sed 's/x86_64/amd64/;s/aarch64/arm64/')"
[ "${1:-}" = "all" ] && TARGETS="linux/arm64 linux/amd64 linux/mips windows/amd64 darwin/amd64 darwin/arm64"
build_with_go() {
mkdir -p bin
for t in $TARGETS; do
os=${t%/*}; arch=${t#*/}; ext=""; gomips=""
[ "$os" = windows ] && ext=.exe
# mips 设备(OpenWrt / 老路由)基本都没有 FPU,硬浮点二进制一跑就是非法指令
[ "$arch" = mips ] && gomips=softfloat
echo "build $os/$arch"
GOOS=$os GOARCH=$arch GOMIPS=$gomips CGO_ENABLED=0 go build -trimpath -ldflags "-s -w" \
-o "bin/agent-device-$os-$arch$ext" ./cmd/agent
done
}
if command -v go >/dev/null 2>&1; then
build_with_go
elif command -v docker >/dev/null 2>&1; then
echo "本机没有 Go,改用 golang:1.23-alpine 容器编译"
docker run --rm -v "$PWD":/w -w /w \
-e CGO_ENABLED=0 -e TARGETS="$TARGETS" \
golang:1.23-alpine sh -c '
mkdir -p bin
for t in $TARGETS; do
os=${t%/*}; arch=${t#*/}; ext=""; gomips=""
[ "$os" = windows ] && ext=.exe
[ "$arch" = mips ] && gomips=softfloat
echo "build $os/$arch"
GOOS=$os GOARCH=$arch GOMIPS=$gomips go build -trimpath -ldflags "-s -w" \
-o "bin/agent-device-$os-$arch$ext" ./cmd/agent
done'
else
echo "需要 Go 或 docker 才能编译" >&2
exit 1
fi
ls -lh bin
+9
View File
@@ -3,6 +3,12 @@ services:
build: ./app
container_name: agent-core
restart: unless-stopped
# 日志轮转:默认 json-file 无上限,长期跑会把磁盘吃穿。保留最近 100MB。
logging:
driver: json-file
options:
max-size: "20m"
max-file: "5"
ports:
# 直接把容器 8090 映射到宿主机端口,用 http://<服务器IP>:<AGENT_PORT> 访问。
- "${AGENT_PORT:-8090}:8090"
@@ -28,6 +34,9 @@ services:
# 对外地址:public_link 的默认值(scripts/init.sh 探测公网 IP 后写进 .env)。
# 设置页里填过 public_link.base_url 时以设置页为准。
- PUBLIC_BASE_URL=${PUBLIC_BASE_URL:-}
# 设备接入(可选):设备主动连 wss://<公网前缀>/dev/ws 时的 Bearer token。
# 与 PUBLIC_BASE_URL 同时具备才会挂端点;留空 = 不启用,本地部署就是这种。
- DEVICE_TOKEN=${DEVICE_TOKEN:-}
networks:
- agent-mcp-net
BIN
View File
Binary file not shown.

After

Width:  |  Height:  |  Size: 257 KiB

+4
View File
@@ -72,6 +72,7 @@ cd agent
| Office 文档(docx/xlsx/pptx) | 首次用到时下载一次 officecli 二进制(约 34MB) | `office` 报 `binary missing` 并给出该技能 `AGENTS.md` 的路径,按它下载即可(不需 root、不需重启);预览面板里直接显示同一份安装说明 |
| 网页搜索 | 无 | 装了 Node 就有(内置免费后端) |
| 图片 / 视频生成 | 设置页给对应 MCP 填上游 key | 调用时报明确的缺参错误 |
| 反向隧道 | `tunnel/client.yml`(服务器地址 + token) | `start.sh` 跳过,不占端口;配置说明见 `tunnel/README.md` |
装完 `ffmpeg` 之后**重跑一次 `./local/start.sh`** 即可生效。`python3` 稍特殊:技能清单本来就在,
只要新装的解释器落在 core 启动时 `PATH` 已包含的目录里(如 brew 的 `/opt/homebrew/bin`)就无需重启;
@@ -144,6 +145,9 @@ git pull
另外,`core` 只监听 `127.0.0.1`,同一局域网的人访问不到。
配了隧道后,core 会经隧道 client 暴露到公网域名。访问控制靠隧道 token + 上游 nginx 的 TLS;
入口仍是 `127.0.0.1:8090`,不额外监听端口。
## 已知限制
- **没 ffmpeg 时 core 日志会有一条 `asr 工具发现失败`**:此时 `mcp_asr` 不启动(它转码要靠
+40 -19
View File
@@ -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 '已启动'
}
@@ -795,7 +794,7 @@ kill_tree_hard() {
do_cleanup() {
# 心跳子进程也得收掉,不然退出后它会继续每秒重绘页面。
ui_stop_ticker
rm -f "$RUNTIME/ui/busy" "$RUNTIME/supervisor.pid" "$RUNTIME/preview.port"
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=''
@@ -902,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 是子进程标记,防自己无限重入。
@@ -938,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"
@@ -1091,15 +1103,24 @@ while :; do
if [ -n "${PREVIEW_PORT:-}" ] && ! port_open "$PREVIEW_PORT"; then
warn "预览网关没起来(端口 ${PREVIEW_PORT})——日志:local/.runtime/preview.log"
fi
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
# 隧道 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
+11
View File
@@ -98,6 +98,17 @@ for p in "$PORT" $MCP_PORTS "$pv_port"; do
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
+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");
+8 -3
View File
@@ -4,7 +4,7 @@
# ./scripts/init.sh # 已有 .env / config.yml 均不覆盖
#
# 可选变量:PUBLIC_IP、AGENT_PORT、AUTH_USER / AUTH_PASSWORD(默认 admin / admin)、
# EXECUTOR_TOKEN / WXBOT_TOKEN / AUTH_SECRET(不给则生成并复用)。
# EXECUTOR_TOKEN / WXBOT_TOKEN / DEVICE_TOKEN / AUTH_SECRET(不给则生成并复用)。
set -euo pipefail
REPO_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
@@ -55,6 +55,7 @@ title "生成 $ENV_FILE"
EXECUTOR_TOKEN="${EXECUTOR_TOKEN:-$(env_get EXECUTOR_TOKEN)}"
WXBOT_TOKEN="${WXBOT_TOKEN:-$(env_get WXBOT_TOKEN)}"
DEVICE_TOKEN="${DEVICE_TOKEN:-$(env_get DEVICE_TOKEN)}"
AUTH_SECRET="${AUTH_SECRET:-$(env_get AUTH_SECRET)}"
AGENT_PORT="${PORT_INPUT:-$(env_get AGENT_PORT)}"
AGENT_PORT="${AGENT_PORT:-8090}"
@@ -62,6 +63,9 @@ OLD_URL="$(env_get PUBLIC_BASE_URL)"
EXECUTOR_TOKEN="${EXECUTOR_TOKEN:-$(gen_hex)}"
WXBOT_TOKEN="${WXBOT_TOKEN:-$(gen_hex)}"
# 设备接入(devices.js):设备连 wss://<公网前缀>/dev/ws 时出示的 Bearer token。
# 与 PUBLIC_BASE_URL 同时具备才启用;没公网地址的部署生成了也无害。
DEVICE_TOKEN="${DEVICE_TOKEN:-$(gen_hex)}"
AUTH_SECRET="${AUTH_SECRET:-$(gen_hex)}"
if [ -n "$PUBLIC_IP" ]; then
@@ -84,7 +88,7 @@ fi
EXTRAS=""
if [ -f "$ENV_FILE" ]; then
EXTRAS="$(awk -F= '/^[A-Za-z_][A-Za-z0-9_]*=/ &&
$1 !~ /^(EXECUTOR_TOKEN|WXBOT_TOKEN|AUTH_SECRET|AGENT_PORT|PUBLIC_BASE_URL)$/ { print }' \
$1 !~ /^(EXECUTOR_TOKEN|WXBOT_TOKEN|DEVICE_TOKEN|AUTH_SECRET|AGENT_PORT|PUBLIC_BASE_URL)$/ { print }' \
"$ENV_FILE" || true)"
fi
@@ -92,6 +96,7 @@ fi
echo "# 由 scripts/init.sh 生成;重跑复用已有密钥,并保留其它变量。"
echo "EXECUTOR_TOKEN=$EXECUTOR_TOKEN"
echo "WXBOT_TOKEN=$WXBOT_TOKEN"
echo "DEVICE_TOKEN=$DEVICE_TOKEN"
echo "AUTH_SECRET=$AUTH_SECRET"
echo "AGENT_PORT=$AGENT_PORT"
echo "PUBLIC_BASE_URL=$PUBLIC_BASE_URL"
@@ -101,7 +106,7 @@ fi
fi
} > "$ENV_FILE"
info "EXECUTOR_TOKEN / WXBOT_TOKEN / AUTH_SECRET 已就位"
info "EXECUTOR_TOKEN / WXBOT_TOKEN / DEVICE_TOKEN / AUTH_SECRET 已就位"
# ---------- config.yml(只写初始管理员)----------
title "检查 $CONFIG_YML"
+6 -2
View File
@@ -1,9 +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 --upgrade --target "$AGENT_SKILLS_DEPS" -r "$(dirname "$AGENT_SKILLS_DEPS")/document-photo-to-pdf/requirements.txt"
```
`fitz` 是 `pymupdf` 的 import 名,`pypdfium2` 不用装。没有 `python3` 先装运行时(Windows 上解释器常是 `python` / `py`)。
`fitz` 是 `pymupdf` 的 import 名,`pypdfium2` 不用装;没有 `python3` 先装运行时(Windows 常是 `python` / `py`)。
+8 -2
View File
@@ -1,12 +1,18 @@
# image-process
`ModuleNotFoundError: No module named 'PIL'`:把依赖装进 `$AGENT_SKILLS_DEPS`
以下命令仅为示例,具体以本机平台实际情况为准。
## ModuleNotFoundError: No module named 'PIL'
把依赖装进 `$AGENT_SKILLS_DEPS`。
```sh
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":"<本机中文字体路径>"}
+10 -3
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"
+19 -13
View File
@@ -1,29 +1,35 @@
# x2pdf
`ModuleNotFoundError`(`markdown`):把依赖装进 `$AGENT_SKILLS_DEPS`
以下命令仅为示例,具体以本机平台实际情况为准。
## ModuleNotFoundError: markdown
把依赖装进 `$AGENT_SKILLS_DEPS`。
```sh
python3 -m pip install --upgrade --target "$AGENT_SKILLS_DEPS" -r "$(dirname "$AGENT_SKILLS_DEPS")/x2pdf/requirements.txt"
```
## 后端缺哪个,代价多大
## 没有可用的 PDF 排版能力
| 后端 | 缺了的影响 | 怎么补 |
|---|---|---|
| LibreOffice | **Office 类(docx/xlsx/pptx)完全不能转**,必装 | Linux `apt install libreoffice`;macOS `brew install --cask libreoffice`;Windows `winget install TheDocumentFoundation.LibreOffice` |
| 浏览器 | 文本类落到 LibreOffice,CSS 基本失效 | 通常不用装:已有 Chrome / Chromium / Edge 就自动用 |
| WeasyPrint | 文本类没有页码、`@page` 精确排版失效 | 先装 Python 包(见上),再补系统库 pango/cairo:Linux `apt install libpango-1.0-0 libpangocairo-1.0-0 libcairo2`;macOS `brew install pango`;Windows 补 GTK 运行库,装不上就跳过 |
文本类有三个后端可退,从便宜到贵补,别一次全装:
报「没有可用的 PDF 排版能力」时:文本类有三个后端可退,按上表从便宜到贵补,别一次全装。
输出带着「排版降级」(无页码/边距偏差)不是失败,是后端不全,按需补。
系统级安装(几百 MB,老系统上可能源码编译十几分钟)先跟用户说清代价,由他决定装还是接受降级。
- 浏览器:有 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(见下节)
## 装完必须验证
系统级安装几百 MB,先跟用户说清代价,由他决定装还是接受降级。
`pip install` 成功不代表能用,缺系统库时 import 就炸:
## 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__)"
```
报 `could not import some external libraries` = 系统库(pango/cairo)还没到位,不是 Python 包的问题。
## 输出带「排版降级」
无页码或边距偏差不是失败,是后端不全,按需补。
+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"
}
}

Some files were not shown because too many files have changed in this diff Show More