agent-loft 0.2.111 → 0.2.113
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +6 -3
- package/package.json +1 -1
- package/src/agents/codex/protocol.ts +10 -0
- package/src/agents/codex/session.ts +201 -5
- package/src/agents/dsh/acp.ts +193 -0
- package/src/agents/dsh/driver.ts +126 -0
- package/src/agents/dsh/errors.ts +43 -0
- package/src/agents/dsh/history.ts +346 -0
- package/src/agents/dsh/sdk.ts +191 -0
- package/src/agents/dsh/session.ts +454 -0
- package/src/agents/dsh/steps.ts +22 -0
- package/src/agents/dsh/which.ts +23 -0
- package/src/agents/health.ts +51 -2
- package/src/channels/feishu/bot.ts +1 -1
- package/src/channels/web/api.ts +14 -0
- package/src/channels/web/experts-api.ts +1 -0
- package/src/channels/web/server.ts +28 -1
- package/src/core/builtin-agents.ts +1 -1
- package/src/core/command-catalog.ts +2 -1
- package/src/core/commands.ts +2 -1
- package/src/core/config.ts +23 -3
- package/src/core/expert-prompt.ts +15 -0
- package/src/core/experts.ts +22 -3
- package/src/core/hub.ts +60 -3
- package/src/core/memory-curator.ts +2 -2
- package/src/core/memory.ts +2 -2
- package/src/core/permission.ts +1 -1
- package/src/core/types.ts +19 -0
- package/src/core/users.ts +1 -1
- package/src/main.ts +5 -1
- package/web/css/composer.css +164 -0
- package/web/css/experts.css +66 -0
- package/web/lib/dom.js +2 -0
- package/web/lib/ws.js +4 -0
- package/web/settings/agent-defaults.js +2 -2
- package/web/settings/agents.js +15 -1
- package/web/settings/commands.js +1 -1
- package/web/settings/experts.js +86 -17
- package/web/settings/memory.js +2 -1
- package/web/views/composer.js +3 -1
- package/web/views/messages.js +1 -1
- package/web/views/sidebar.js +1 -1
- package/web/views/topbar.js +3 -1
- package/web/views/voice-call.js +293 -0
package/README.md
CHANGED
|
@@ -30,15 +30,16 @@ Logo 就是这个意思:一大两小几颗星(多个 agent)站在同一张
|
|
|
30
30
|
| 🔀 | **飞书机器人灵活绑定 agent** | 机器人数量不限,每个机器人可以直接勾选内置或共享专家,并选择默认专家(可在会话里切换)。网页上扫码就能创建,改完立即生效;由服务端主动连向飞书,家里没有公网 IP 也能在外面用 |
|
|
31
31
|
| 🔗 | **飞书续接 Web 任务** | 飞书里发 `/web` 接上一条 Web 会话,或者在网页聊天右上角「更多」或侧栏会话右键菜单里选「在飞书继续」。之后回复、授权、提问都发到飞书,发 `/detach` 回来 |
|
|
32
32
|
| 💬 | **微信 ClawBot** | 设置 → 账号里用微信扫码,就能在微信里和 agent 聊天、回数字处理授权和提问,网页上是同一条对话。每个人连自己的微信。微信限制较多,适合发起任务和接收回复,详见下面的说明 |
|
|
33
|
-
| 🖥️ | **完整的 Web 工作台** |
|
|
33
|
+
| 🖥️ | **完整的 Web 工作台** | 流式回复、附件、语音输入、Codex 语音对话、模型和思考程度切换、上下文占用、从任意回复分叉、按项目分组的侧栏、搜索会话、全部设置,电脑和手机(PWA)都能用 |
|
|
34
34
|
| 🔔 | **飞书 + 苹果系统推送** | 除了飞书消息,Web 会话还能推送到 iPhone、iPad 锁屏和 Mac 通知中心(标准 Web Push,不需要开发者账号),图标上显示未读数 |
|
|
35
35
|
| 🗂️ | **桌面端同时接入多台设备** | 桌面端(macOS / Windows / Linux)同时连多台服务器,菜单栏 / 托盘一眼看完各台的额度、待处理和运行中的会话 |
|
|
36
36
|
|
|
37
37
|
## 能做什么
|
|
38
38
|
|
|
39
|
-
- **多个 agent**:Claude Code、Codex、WorkBuddy、pi。几个 agent 共用工作目录,能看到对方改过的文件,但聊天记录各自独立。
|
|
39
|
+
- **多个 agent**:Claude Code、Codex、WorkBuddy、pi、dsh。几个 agent 共用工作目录,能看到对方改过的文件,但聊天记录各自独立。
|
|
40
40
|
- **WorkBuddy(腾讯)**:默认不启用。调用这台服务器上 **WorkBuddy 桌面版自带的 CLI**(官方 Agent SDK `@tencent-ai/agent-sdk` 驱动,账号站点 www.workbuddy.cn),也可以改用 CodeBuddy 国内版 / 国际版 / 腾讯 iOA 的账号(用 SDK 自带的 CLI,不用装桌面版)。到 设置 → Agent → WorkBuddy 勾上「启用」、选账号站点后保存,再在「运行环境」里点「登录 WorkBuddy」:在你自己的浏览器里打开登录页,**1 分钟内**登录完(CLI 只等这么久,超时重新点),整台服务器登一次就行,所有人共用。桌面版里登录过也要在这里再登一次(同一个账号):桌面版的登录由它自己保管,不交给单独跑的 CLI;这边的令牌存在 `data/workbuddy-auth.json`(0600),不碰桌面版的数据。也可以给服务设 `CODEBUDDY_API_KEY`。支持流式回复、授权卡(逐次询问 / 自动改文件 / 完全允许)、提问卡、计划模式、中途换模型、图片附件、`/sessions` 恢复以前的会话、记忆和定时任务工具、个人技能和 MCP;管理员的会话读机器上的 `~/.codebuddy` 配置,成员只读项目里的。暂不支持自定义专家、分叉 / 回退、思考程度和额度显示;令牌过期后要回设置页重新登录。
|
|
41
41
|
- **pi**:默认不启用。开源编程 agent [pi](https://pi.dev),用官方 TypeScript SDK(`@earendil-works/pi-coding-agent`)在 agent-loft 进程里运行(需要 Node 22.19 以上)。按**模型服务商**配凭据,整台服务器共用:到 设置 → Agent → pi 勾上「启用」,在「模型服务商」里选一家(DeepSeek、智谱 Coding Plan、Kimi、通义 Token Plan、MiniMax、OpenRouter、Anthropic、OpenAI……)粘贴 API Key 保存;或者点「登录」用**订阅账号**(Claude Pro/Max、ChatGPT Plus/Pro、GitHub Copilot、Kimi Code、xAI……),在你自己的浏览器里完成,设备码直接显示在页面上,浏览器登录完跳到打不开的 127.0.0.1 地址时把地址栏整个粘贴回来即可(订阅能否用在第三方工具里以各家条款为准);也可以给服务设对应的环境变量(如 `DEEPSEEK_API_KEY`)。本地模型和 OpenAI 兼容网关在「自定义服务商」里加(Ollama、LM Studio、vLLM、llama.cpp、one-api……,填地址、接口类型、Key,能「从服务读取模型列表」),写在 `data/pi/models.json`(0600,Key 按字面值保存,不会被当成环境变量或命令)。凭据、会话记录都存在 `data/pi/` 下(`auth.json` 0600、`sessions/`),不读也不写机器上的 `~/.pi`;项目里的 `.pi/` 扩展不加载。pi 自己没有权限系统,授权卡(逐次询问 / 自动改文件 / 完全允许)、计划模式、提问卡由 agent-loft 补上,「自动改文件」只放行工作目录和附件目录里的文件;跑命令(bash)没有沙箱。支持流式回复、中途换模型和思考程度、图片附件(模型支持时)、`/compact` 压缩上下文、`/sessions` 恢复、分叉 / 回退、费用显示、记忆和定时任务工具、个人技能和 MCP,记忆整理也可选 pi。可以建 pi 引擎的自定义专家(见下面「专家」)。
|
|
42
|
+
- **dsh(DeepSeek Harness)**:默认不启用。DeepSeek 官方的编程 agent,先在服务器上 `npm install -g @deepseek-ai/dsh`(升级也是这条),再到 设置 → Agent → dsh 勾上「启用」。agent-loft 通过标准 ACP 协议(`dsh --profile acp`)接入,每个会话一个 dsh 进程(第一条消息要等 4~5 秒拉起,闲置后回收)。凭据和会话记录用 dsh 自己的 `~/.dsh`(DeepSeek API Key 在 `dsh web` 的网页里填,或给服务设 `DEEPSEEK_API_KEY`),dsh 网页里建的会话这里也能接着聊(用 DeepSeek 官方模型的)。权限走 dsh 的沙箱:逐次询问 = 只读、自动改文件 = 工作区可写、完全允许 = 不设沙箱,越界时弹授权卡,可「本会话全部允许」;计划模式用只读沙箱 + 提示词实现,方案写在回复里,关掉计划模式后再动手。支持中途换模型和思考程度(off / low / high / max)、恢复会话、任务清单、上下文占用和 token 用量、记忆和定时任务工具、个人技能和 MCP,记忆整理也可选 dsh。不支持自定义专家、分叉 / 回退、提问卡、逐字流式和图片直传(附件给路径让它自己读);设成「调用前询问」的 MCP 不会挂上(dsh 拦不住 MCP 调用)。ACP 模式默认只有官方 DeepSeek 模型,要接别家模型可以在设置里填一个「额外的 patch 文件」。
|
|
42
43
|
- **多个飞书机器人**:设置 → 飞书 →「可用专家」直接勾选内置或共享专家,并选择「默认专家」。只勾一个共享专家即可专用,不用再勾选底层 Agent;每个人绑定自己的账号后,直接私聊就是这个专家,使用各自的记忆和工具。机器人能在 Web 上扫码创建(Lark 国际版用「手动添加」),改完配置立即生效,不用重启。
|
|
43
44
|
- 群聊里要 @ 机器人;不同话题是各自独立的会话;支持文字、富文本、图片、文件、语音和视频。
|
|
44
45
|
- 思考和工具调用显示在实时刷新的过程卡片里,最终回复是普通消息。
|
|
@@ -53,6 +54,7 @@ Logo 就是这个意思:一大两小几颗星(多个 agent)站在同一张
|
|
|
53
54
|
- **回复里的相册**:agent 用 ```` ```album ```` JSON 描述多张本地照片,网页以大图轮播展示,可左右滑动、点击箭头或底部缩略图切换,按需加载照片;点开预览后支持左右切换、缩放、拖动、方向键和 Esc。可附名称、拍摄日期、说明和查询总数,每个相册最多 200 张;飞书显示简短摘要。写法自动附在所有专家的提示词里,图片沿用会话文件权限。
|
|
54
55
|
- 聊天右上角「更多」和侧栏会话右键菜单共用分叉、重命名、在飞书继续、删除操作,按会话类型和可用机器人显示。
|
|
55
56
|
- 语音输入:用浏览器自带的语音识别(Chrome / Edge / Safari,需要 HTTPS)。
|
|
57
|
+
- 语音对话(只有 Codex,包括 Codex 引擎的自定义专家):输入框里点声波按钮,和 Codex 桌面端的语音模式一样边说边聊,可以随时打断。输入框换成通话条(音量动画、状态、实时字幕、静音、结束);要动手的事语音模型会转交给这条对话里的 Codex,那一轮像发了一条消息一样出现在对话里(前面带 🎙️),授权卡照常弹。走 Codex 的实时语音(v3、WebRTC),声音在浏览器和 OpenAI 之间直连,不经过服务器;用的是 Codex 登录的 ChatGPT 账号。开通话前会把这条对话当前的权限和沙箱同步给 Codex,转交出来的轮次一样受限;机器上最近会话的启动背景只给内置 Codex 的管理员。需要 HTTPS 和麦克风权限;桌面端(Electron)里暂不提供。闲聊的字幕不存进聊天记录,切走对话或关掉页面会挂断。
|
|
56
58
|
- 新对话页:点大标题里的目录名,在固定高度的目录弹窗里逐层选工作目录,也能新建文件夹;输入框上方选专家,鼠标停在专家上看简介,右下角选模型和思考程度。对话从头到尾一个专家,要换专家就新建对话;模型和思考程度随时可换。
|
|
57
59
|
- 输入框里的小圆环显示上下文窗口占用;模型按钮显示实际的模型和思考程度(如「Opus 5.5 high」)。
|
|
58
60
|
- 滚动和 ChatGPT 一样:发出的问题顶到最上面、下面留白,回复长到屏幕底部才跟着往下滚;回复过程中自己滚动了就不再自动滚,下次发消息再恢复。
|
|
@@ -81,7 +83,7 @@ Logo 就是这个意思:一大两小几颗星(多个 agent)站在同一张
|
|
|
81
83
|
- **授权**:允许一次 / 本会话全部允许 / 总是允许(按钮上写明放行范围)/ 拒绝。权限级别(输入框左下角或 `/permission`):逐次询问 / 自动改文件 / 自动判断(仅 Claude Code,由 Claude 逐个判断安不安全)/ 完全允许,定时任务也可以单独设,自动判断和完全允许只给管理员;默认级别在 设置 → Agent 里按引擎设。同一个弹窗里还有**计划模式**开关(或 `/planmode on`):agent 先只读、出方案,你点「开始执行」后再按权限级别动手。`/autoedit on` 让 Claude Code 在这条会话里改工作目录内的文件不再询问(Bash 仍询问)。超时一律按拒绝处理。
|
|
82
84
|
- **设置都在网页上**,按用途分组:**我的**(账号、飞书和微信绑定、自己的登录设备、记忆、专家、技能、MCP、用量);**Agent**(运行环境置顶,各 agent 卡片分别配置默认模型、思考程度、可选模型、个人默认技能和 MCP,Codex 沙箱、额度查询;工作目录、会话闲置过期、授权卡超时和 Claude 的「总是允许」名单;「/」命令);**连接**(飞书机器人、配对批准、指令面板同步;远程控制;服务器);**管理**(用户标题旁添加用户,用户的「管理 → 登录设备」查看和下线各自设备;系统页管理服务端版本和升级、重启、局域网访问和端口,网络访问下方是系统通知;成员也可在系统页设置自己的通知)。账号页通过「修改名称」「修改密码」按需展开表单;飞书和微信绑定操作位于卡片右上角。设置、新建 / 编辑专家、重命名等编辑弹窗不会因点击外部或按 Esc 关闭;通过关闭、取消或保存 / 完成按钮退出。改了没保存就切页或关掉设置会先提醒。
|
|
83
85
|
- **多用户**(信任型):管理员在 设置 → 用户 里给别人建账号。每个人只看得到自己的对话、授权和通知;个人设置各自管理,服务器设置由管理员修改,见下面「安全」。
|
|
84
|
-
- **专家**:设置 → 专家。专家是一份配置,新建对话、定时任务时选一个,对话从头到尾都是它(中途不能换;飞书里 `/expert 名字`、`/claude`、`/codex`、`/workbuddy`、`/pi` 换专家会开新会话)。**内置专家**:Claude Code、Codex,保留原装提示词和所有工具,默认技能与 MCP 在「设置 → Agent」中按账号、按引擎分别选择。**自定义专家**由创建者管理,可以勾选「共享给所有账号」。共享后,其他人能在网页、绑定账号后的飞书私聊和定时任务中选择它;只有创建者能修改设定。每个人在该专家的「我的工具」里选择自己的技能和 MCP,使用各自的变量、凭据、记忆和聊天记录;创建者沿用原有工具选择;其他人没配置过时,沿用创建者选的里面自己能用的(自己装了的技能、创建者共享出来的 MCP),创建者私有的 MCP 和机器 MCP 不会带给别人。取消共享后,其他人的历史对话保留,后续消息不能继续调用该专家,相关定时任务在下次运行时暂停。可以配:
|
|
86
|
+
- **专家**:设置 → 专家。专家是一份配置,新建对话、定时任务时选一个,对话从头到尾都是它(中途不能换;飞书里 `/expert 名字`、`/claude`、`/codex`、`/workbuddy`、`/pi`、`/dsh` 换专家会开新会话)。**内置专家**:Claude Code、Codex,保留原装提示词和所有工具,默认技能与 MCP 在「设置 → Agent」中按账号、按引擎分别选择。**自定义专家**由创建者管理,可以勾选「共享给所有账号」。共享后,其他人能在网页、绑定账号后的飞书私聊和定时任务中选择它;只有创建者能修改设定。每个人在该专家的「我的工具」里选择自己的技能和 MCP,使用各自的变量、凭据、记忆和聊天记录;创建者沿用原有工具选择;其他人没配置过时,沿用创建者选的里面自己能用的(自己装了的技能、创建者共享出来的 MCP),创建者私有的 MCP 和机器 MCP 不会带给别人。取消共享后,其他人的历史对话保留,后续消息不能继续调用该专家,相关定时任务在下次运行时暂停。可以配:
|
|
85
87
|
- 头像(点头像区域的加号上传;未上传时,会话中用引擎的图标)、引擎(Claude / Codex / pi,建好后不能换;pi 专家没有自带的联网搜索和读网页,要联网就给它挂搜索 MCP,也没有子智能体)、默认模型和思考程度(从模型列表里选);
|
|
86
88
|
- 提示词:人设、规则、输出格式。agent-loft 在后面自动补上这个专家能做什么、今天的日期、记忆。Claude 专家默认只用这段提示词(一句话约 2 千 token),也可以选「追加在 Claude Code 原装提示词后面」(干活更稳,每轮多约 1.6 万);pi 专家同样默认只用这段,也可以追加在 pi 原装提示词后面(每轮多约 600 token);Codex 的基础指令改不了,专家的提示词附在第一条消息后面,约束力弱一些;
|
|
87
89
|
- 权限,勾选:联网搜索、读网页,以及文件权限(一级包含一级):都不勾就是**只能联网**(不碰本机文件、不弹授权,文本附件内容直接放进消息)/**能读文件**/**能改文件**/**能跑命令**(跑命令就等于能改任何文件,需要授权时弹卡)。Claude 按权限给工具;Codex 按权限开 shell、apply_patch,沙箱只读或 workspace-write;
|
|
@@ -89,6 +91,7 @@ Logo 就是这个意思:一大两小几颗星(多个 agent)站在同一张
|
|
|
89
91
|
- 技能:只给选中的(Claude 用技能白名单,没选的调不了;没选技能就不挂 Skill 工具,省 token);
|
|
90
92
|
- MCP:从「设置 → MCP」里勾自己的或别人共享的(管理员还能勾机器上配的);
|
|
91
93
|
- 子智能体(只有 Claude):别的 Claude 专家,主专家用 Agent 工具把子任务派给它。子智能体的权限不能超过主专家(运行时也封顶在主专家的权限)。
|
|
94
|
+
- Codex 扩展能力(只有 Codex):Codex 自带、专家默认关掉的能力(关着省 token),勾了才开:生图(图片显示在回复里,占 ChatGPT 订阅额度)、子智能体(Codex 自己的)、操作浏览器、操作桌面、插件和应用(Codex 登录的 ChatGPT 账号连接的应用)。后三项用的是这台机器上的浏览器、桌面和账号,只有管理员能勾,共享出去后别人用时也不开。内置的 Codex 专家不受这些限制,按 Codex 自己的配置来。
|
|
92
95
|
|
|
93
96
|
只勾联网搜索、读网页的 Claude 专家就是以前聊天模式的效果。专家改了,用它的对话下一条消息起生效;专家删了,用它的对话还能看、不能再发消息,用它的定时任务暂停。以前的聊天模式取消了:升级后聊天模式的旧对话不再保留,聊天模式的定时任务暂停,选个专家再启用。
|
|
94
97
|
- **MCP**:设置 → MCP,每人管自己的:HTTP 地址(+ 请求头),或者本机进程(命令 + 参数 + 环境变量,会在服务器上直接执行命令、不受专家权限约束,所以只有管理员能添加;成员以前建的不再启动)。值可以标成密钥(网页上不回显,只交给 MCP 进程或请求头,不进提示词)。可以设「调用前询问」,不设就直接用。**共享**:勾「共享给所有账号」后,别人能在专家和内置 Agent 里选它;共享的是命令、地址和普通的环境变量 / 请求头,标成密钥的项每人在「填写我的密钥」里填自己的值,作者的不会给出去;用别人共享的 MCP 时,调用工具前一律先弹授权卡;取消共享后别人填的值一起删掉。自定义专家加载各自勾选的服务;内置专家在「设置 → Agent → 对应 Agent 卡片 → 默认加载」里选择,支持个人 MCP、管理员可选的机器 MCP,也可全部取消;不指定时管理员沿用机器配置。
|
package/package.json
CHANGED
|
@@ -249,6 +249,16 @@ export type ThreadItem =
|
|
|
249
249
|
status: "inProgress" | "completed" | "failed";
|
|
250
250
|
}
|
|
251
251
|
| { type: "webSearch"; id: string; query?: string }
|
|
252
|
+
| {
|
|
253
|
+
type: "imageGeneration";
|
|
254
|
+
id: string;
|
|
255
|
+
status: string;
|
|
256
|
+
revisedPrompt: string | null;
|
|
257
|
+
failure: { type: string } | null;
|
|
258
|
+
/** Codex 存下来的图片(默认在 CODEX_HOME/generated_images 下) */
|
|
259
|
+
savedPath?: string;
|
|
260
|
+
}
|
|
261
|
+
| { type: "collabAgentToolCall"; id: string; tool: string; status: string; prompt: string | null }
|
|
252
262
|
| { type: "error"; id: string; message: string }
|
|
253
263
|
| { type: string; id: string };
|
|
254
264
|
|
|
@@ -5,8 +5,8 @@
|
|
|
5
5
|
import { appServer } from "./app-server.js";
|
|
6
6
|
import { refusalFor, UnsupportedRequest } from "./refusals.js";
|
|
7
7
|
import { config } from "../../core/config.js";
|
|
8
|
-
import { contextBlock } from "../../core/expert-prompt.js";
|
|
9
|
-
import { ACCESS_LEVELS, type ExpertAccess, type ExpertRuntime } from "../../core/experts.js";
|
|
8
|
+
import { contextBlock, stripContext, VOICE_MARK } from "../../core/expert-prompt.js";
|
|
9
|
+
import { ACCESS_LEVELS, type CodexTool, type ExpertAccess, type ExpertRuntime } from "../../core/experts.js";
|
|
10
10
|
import { MEMORY_MCP_NAME, memoryMcpSpawn } from "../../core/memory-mcp.js";
|
|
11
11
|
import { SKILLS_MCP_NAME, skillsMcpSpawn, TASK_TOOL_TIMEOUT_SEC, TASKS_MCP_NAME, tasksMcpSpawn } from "../../core/tasks-mcp.js";
|
|
12
12
|
import type { PermissionLevel } from "../../core/permission.js";
|
|
@@ -123,11 +123,19 @@ export const CHAT_CONFIG: Record<string, unknown> = {
|
|
|
123
123
|
"workspace_dependencies",
|
|
124
124
|
"in_app_browser",
|
|
125
125
|
"in_app_local_automation",
|
|
126
|
-
"realtime_conversation",
|
|
127
126
|
].map((f) => [`features.${f}`, false]),
|
|
128
127
|
),
|
|
129
128
|
};
|
|
130
129
|
|
|
130
|
+
/** 专家勾了的 Codex 自带能力在 CHAT_CONFIG 上打开哪些(core/experts.ts 的 CODEX_TOOLS) */
|
|
131
|
+
const CODEX_TOOL_CONFIG: Record<CodexTool, Record<string, unknown>> = {
|
|
132
|
+
image_generation: { "features.image_generation": true },
|
|
133
|
+
multi_agent: { "features.multi_agent": true },
|
|
134
|
+
browser: { "features.browser_use": true, "features.in_app_browser": true },
|
|
135
|
+
computer_use: { "features.computer_use": true },
|
|
136
|
+
apps: { "features.plugins": true, "features.apps": true, include_apps_instructions: true },
|
|
137
|
+
};
|
|
138
|
+
|
|
131
139
|
/**
|
|
132
140
|
* 按权限在 CHAT_CONFIG 上打开的东西。能读文件就要 shell(Codex 读文件也是跑命令,沙箱只读管着它改不了);
|
|
133
141
|
* 能改文件再给 apply_patch。
|
|
@@ -141,6 +149,7 @@ export function expertConfig(e: ExpertRuntime): Record<string, unknown> {
|
|
|
141
149
|
? { include_permissions_instructions: true, "features.shell_tool": true, "features.unified_exec": true, "features.view_image": true }
|
|
142
150
|
: {}),
|
|
143
151
|
...(rank >= 2 ? { include_apply_patch_tool: true } : {}),
|
|
152
|
+
...Object.assign({}, ...(e.codexTools ?? []).map((t) => CODEX_TOOL_CONFIG[t] ?? {})),
|
|
144
153
|
};
|
|
145
154
|
}
|
|
146
155
|
|
|
@@ -340,6 +349,10 @@ export class CodexSession implements AgentSession {
|
|
|
340
349
|
private disposed = false;
|
|
341
350
|
/** 轮次还在 starting 时点了停止:拿到轮次 id 立刻中断 */
|
|
342
351
|
private stopRequested = false;
|
|
352
|
+
/** 实时语音对话:在通话中;answer / fail 是 start 还在等对端 SDP */
|
|
353
|
+
private rt: { answer?: (sdp: string) => void; fail?: (err: Error) => void } | undefined;
|
|
354
|
+
/** 这一轮不是这边开的(语音对话转交给 Codex 的):还没把用户说的话报上去 */
|
|
355
|
+
private externalPending = false;
|
|
343
356
|
|
|
344
357
|
constructor(
|
|
345
358
|
private readonly opts: SessionOptions,
|
|
@@ -780,6 +793,10 @@ export class CodexSession implements AgentSession {
|
|
|
780
793
|
}
|
|
781
794
|
|
|
782
795
|
async dispose(): Promise<void> {
|
|
796
|
+
if (this.rt) {
|
|
797
|
+
await this.stopRealtime();
|
|
798
|
+
this.events.onRealtime?.({ type: "closed", reason: "会话已切换" });
|
|
799
|
+
}
|
|
783
800
|
this.disposed = true;
|
|
784
801
|
this.queue = [];
|
|
785
802
|
await this.interrupt();
|
|
@@ -796,6 +813,128 @@ export class CodexSession implements AgentSession {
|
|
|
796
813
|
this.endTurn();
|
|
797
814
|
}
|
|
798
815
|
|
|
816
|
+
// ---------- 实时语音对话(thread/realtime/*,实验接口) ----------
|
|
817
|
+
|
|
818
|
+
/**
|
|
819
|
+
* 浏览器建好 RTCPeerConnection(麦克风 + oai-events 数据通道)把 offer 给过来,app-server 去 OpenAI 建通话,
|
|
820
|
+
* 对端 answer 从 thread/realtime/sdp 通知回来。声音在浏览器和 OpenAI 之间直连,不经过这里。
|
|
821
|
+
* 实测:ChatGPT 账号登录只能走 WebRTC(WebSocket 要 API key),协议版本要 v3。
|
|
822
|
+
* 语音模型把要干的活转交给这条 thread,app-server 自己开一轮(见 turn/started 里的 externalPending)。
|
|
823
|
+
*/
|
|
824
|
+
async startRealtime(offer: string): Promise<string> {
|
|
825
|
+
if (this.disposed) throw new Error("会话已关闭");
|
|
826
|
+
if (this.rt) await this.stopRealtime();
|
|
827
|
+
const threadId = await this.open();
|
|
828
|
+
// 转交出来的轮次不经过 turn/start:先把这条对话现在的工作目录、沙箱、模型写到 thread 上,权限才对得上
|
|
829
|
+
await appServer.call("thread/settings/update", {
|
|
830
|
+
threadId,
|
|
831
|
+
cwd: this.opts.cwd,
|
|
832
|
+
approvalPolicy: "on-request",
|
|
833
|
+
sandboxPolicy: sandboxPolicyFor(this.sandboxMode, this.opts.cwd),
|
|
834
|
+
...(this.opts.model ? { model: this.opts.model } : {}),
|
|
835
|
+
...(this.opts.effort ? { effort: this.opts.effort } : {}),
|
|
836
|
+
});
|
|
837
|
+
if (this.disposed) throw new DisposedError();
|
|
838
|
+
// 专家、记忆、技能清单:打字的第一轮会附在消息后面;语音先开口的话,在这里交给背后的 Codex
|
|
839
|
+
const expert = this.opts.expert;
|
|
840
|
+
const context = this.contextPending
|
|
841
|
+
? contextBlock(expert ? { prompt: expert, cwd: this.opts.cwd } : undefined, this.opts.memory?.prompt, codexSkillLines(this.opts.skills))
|
|
842
|
+
: "";
|
|
843
|
+
const answer = new Promise<string>((resolve, reject) => {
|
|
844
|
+
this.rt = { answer: resolve, fail: reject };
|
|
845
|
+
});
|
|
846
|
+
const timer = setTimeout(() => this.rt?.fail?.(new Error("连接语音服务超时")), 20_000);
|
|
847
|
+
try {
|
|
848
|
+
await appServer.call("thread/realtime/start", {
|
|
849
|
+
threadId,
|
|
850
|
+
outputModality: "audio",
|
|
851
|
+
version: "v3",
|
|
852
|
+
transport: { type: "webrtc", sdp: offer },
|
|
853
|
+
// 启动背景里有这台机器上最近的会话和目录结构:只给内置专家的管理员
|
|
854
|
+
includeStartupContext: !expert && this.opts.skills?.admin === true,
|
|
855
|
+
...(context ? { realtimeStartInstructions: context } : {}),
|
|
856
|
+
});
|
|
857
|
+
return await answer;
|
|
858
|
+
} catch (err) {
|
|
859
|
+
this.rt = undefined;
|
|
860
|
+
void appServer.call("thread/realtime/stop", { threadId }).catch(() => {});
|
|
861
|
+
throw err;
|
|
862
|
+
} finally {
|
|
863
|
+
clearTimeout(timer);
|
|
864
|
+
if (this.rt) this.rt = {};
|
|
865
|
+
}
|
|
866
|
+
}
|
|
867
|
+
|
|
868
|
+
async stopRealtime(): Promise<void> {
|
|
869
|
+
if (!this.rt) return;
|
|
870
|
+
this.rt.fail?.(new Error("已挂断"));
|
|
871
|
+
this.rt = undefined;
|
|
872
|
+
if (!this.threadId) return;
|
|
873
|
+
try {
|
|
874
|
+
await appServer.call("thread/realtime/stop", { threadId: this.threadId });
|
|
875
|
+
} catch (err) {
|
|
876
|
+
console.warn("[codex] 挂断语音对话失败:", err instanceof Error ? err.message : err);
|
|
877
|
+
}
|
|
878
|
+
}
|
|
879
|
+
|
|
880
|
+
/** 实时语音的通知:字幕、建连、结束。返回 false = 不是这类通知 */
|
|
881
|
+
private onRealtime(method: string, params: unknown): boolean {
|
|
882
|
+
if (!method.startsWith("thread/realtime/")) return false;
|
|
883
|
+
const p = params as { sdp?: string; role?: string; delta?: string; text?: string; message?: string; reason?: string | null };
|
|
884
|
+
const role = p.role === "user" ? "user" : "assistant";
|
|
885
|
+
switch (method) {
|
|
886
|
+
case "thread/realtime/sdp":
|
|
887
|
+
if (p.sdp) this.rt?.answer?.(p.sdp);
|
|
888
|
+
return true;
|
|
889
|
+
case "thread/realtime/started":
|
|
890
|
+
this.events.onRealtime?.({ type: "started" });
|
|
891
|
+
return true;
|
|
892
|
+
case "thread/realtime/transcript/delta":
|
|
893
|
+
if (p.delta) this.events.onRealtime?.({ type: "transcript", role, delta: p.delta });
|
|
894
|
+
return true;
|
|
895
|
+
case "thread/realtime/transcript/done":
|
|
896
|
+
if (p.text) this.events.onRealtime?.({ type: "transcript_done", role, text: p.text });
|
|
897
|
+
return true;
|
|
898
|
+
case "thread/realtime/error": {
|
|
899
|
+
const message = realtimeError(p.message);
|
|
900
|
+
if (this.rt?.fail) this.rt.fail(new Error(message));
|
|
901
|
+
else this.events.onRealtime?.({ type: "error", message });
|
|
902
|
+
return true;
|
|
903
|
+
}
|
|
904
|
+
case "thread/realtime/closed":
|
|
905
|
+
if (this.rt) {
|
|
906
|
+
this.rt = undefined;
|
|
907
|
+
this.events.onRealtime?.({ type: "closed", ...(p.reason ? { reason: p.reason } : {}) });
|
|
908
|
+
}
|
|
909
|
+
return true;
|
|
910
|
+
default:
|
|
911
|
+
return true;
|
|
912
|
+
}
|
|
913
|
+
}
|
|
914
|
+
|
|
915
|
+
/** 语音转交出来的一轮开始了:当成这边的一轮接住(回复、审批、用量照常),用户说的话等 userMessage 到了再报 */
|
|
916
|
+
private adoptExternalTurn(id: string): void {
|
|
917
|
+
this.currentInput = undefined;
|
|
918
|
+
this.replyText = "";
|
|
919
|
+
this.planText = "";
|
|
920
|
+
this.turnPlan = false;
|
|
921
|
+
this.turnTokens = undefined;
|
|
922
|
+
this.turnSeq += 1;
|
|
923
|
+
this.phase = "running";
|
|
924
|
+
this.turnId = id;
|
|
925
|
+
this.stopRequested = false;
|
|
926
|
+
this.commentaryItems.clear();
|
|
927
|
+
this.turnSeen = true;
|
|
928
|
+
this.externalPending = true;
|
|
929
|
+
}
|
|
930
|
+
|
|
931
|
+
private announceExternal(text: string): void {
|
|
932
|
+
if (!this.externalPending) return;
|
|
933
|
+
this.externalPending = false;
|
|
934
|
+
this.events.onExternalTurn?.(text, this.turnId);
|
|
935
|
+
this.events.onTurnStart?.();
|
|
936
|
+
}
|
|
937
|
+
|
|
799
938
|
// ---------- 反向请求:审批与提问 ----------
|
|
800
939
|
|
|
801
940
|
/** 审批都走这里:带上「本会话全部允许」按钮,点了就记住。 */
|
|
@@ -934,13 +1073,19 @@ export class CodexSession implements AgentSession {
|
|
|
934
1073
|
// ---------- 通知 ----------
|
|
935
1074
|
|
|
936
1075
|
handleNotification(method: string, params: unknown): void {
|
|
1076
|
+
if (this.onRealtime(method, params)) return;
|
|
937
1077
|
|
|
938
1078
|
switch (method) {
|
|
939
1079
|
case "turn/started": {
|
|
940
1080
|
// 轮次 id 在 params.turn.id,不在顶层
|
|
941
1081
|
const id = (params as { turn?: { id?: string } }).turn?.id;
|
|
942
|
-
|
|
943
|
-
|
|
1082
|
+
if (id && this.endedTurns.has(id)) return;
|
|
1083
|
+
// 空闲时冒出来的一轮不是这边开的:语音对话把事情转交给了 Codex(这个 app-server 里只有这边订阅着这条 thread)
|
|
1084
|
+
if (this.phase === "idle") {
|
|
1085
|
+
if (id && !this.disposed) this.adoptExternalTurn(id);
|
|
1086
|
+
return;
|
|
1087
|
+
}
|
|
1088
|
+
// 只认「正在等它开始」的那一轮
|
|
944
1089
|
if (id) this.onTurnId(id);
|
|
945
1090
|
this.commentaryItems.clear();
|
|
946
1091
|
this.turnSeen = true;
|
|
@@ -1011,6 +1156,7 @@ export class CodexSession implements AgentSession {
|
|
|
1011
1156
|
// 已经收过尾的、或者不是当前这一轮的,不处理
|
|
1012
1157
|
if (this.phase === "idle" || (turn.id && this.endedTurns.has(turn.id))) return;
|
|
1013
1158
|
if (this.turnId && turn.id && turn.id !== this.turnId) return;
|
|
1159
|
+
this.announceExternal(VOICE_FALLBACK);
|
|
1014
1160
|
const text = this.replyText;
|
|
1015
1161
|
this.replyText = "";
|
|
1016
1162
|
this.endTurn();
|
|
@@ -1043,6 +1189,7 @@ export class CodexSession implements AgentSession {
|
|
|
1043
1189
|
return;
|
|
1044
1190
|
}
|
|
1045
1191
|
if (this.phase === "idle") return;
|
|
1192
|
+
this.announceExternal(VOICE_FALLBACK);
|
|
1046
1193
|
this.endTurn();
|
|
1047
1194
|
this.events.onError(new Error(error?.message ?? "未知错误"));
|
|
1048
1195
|
this.drainQueue();
|
|
@@ -1066,7 +1213,15 @@ export class CodexSession implements AgentSession {
|
|
|
1066
1213
|
}
|
|
1067
1214
|
|
|
1068
1215
|
private onItem(item: ThreadItem, phase: "started" | "completed"): void {
|
|
1216
|
+
if (this.externalPending && item.type !== "userMessage") this.announceExternal(VOICE_FALLBACK);
|
|
1069
1217
|
switch (item.type) {
|
|
1218
|
+
case "userMessage": {
|
|
1219
|
+
if (!this.externalPending || phase !== "completed") return;
|
|
1220
|
+
const content = (item as { content?: { type?: string; text?: string }[] }).content ?? [];
|
|
1221
|
+
const raw = content.map((c) => (c.type === "text" ? (c.text ?? "") : "")).join("\n");
|
|
1222
|
+
this.announceExternal(stripContext(raw).trim() || VOICE_FALLBACK);
|
|
1223
|
+
return;
|
|
1224
|
+
}
|
|
1070
1225
|
case "agentMessage": {
|
|
1071
1226
|
const message = item as Extract<ThreadItem, { type: "agentMessage" }>;
|
|
1072
1227
|
if (message.phase === "commentary") this.commentaryItems.add(message.id);
|
|
@@ -1138,6 +1293,32 @@ export class CodexSession implements AgentSession {
|
|
|
1138
1293
|
this.events.onStep("note", `📋 ${summarize(plan.text, 90)}`);
|
|
1139
1294
|
return;
|
|
1140
1295
|
}
|
|
1296
|
+
case "imageGeneration": {
|
|
1297
|
+
if (phase === "started") {
|
|
1298
|
+
this.events.onStep("tool", "🎨 生成图片");
|
|
1299
|
+
return;
|
|
1300
|
+
}
|
|
1301
|
+
const image = item as Extract<ThreadItem, { type: "imageGeneration" }>;
|
|
1302
|
+
if (image.failure?.type === "usageLimitExceeded") {
|
|
1303
|
+
this.events.onStep("warning", "⚠️ 生图额度用完了");
|
|
1304
|
+
return;
|
|
1305
|
+
}
|
|
1306
|
+
// 图片 Codex 自己存好了(savedPath),写进回复里网页才显示得出来(只认回复里写过的路径)
|
|
1307
|
+
if (!image.savedPath) return;
|
|
1308
|
+
const alt = summarize(image.revisedPrompt ?? "", 40).replace(/[[\]\n]/g, " ").trim() || "生成的图片";
|
|
1309
|
+
// 尖括号包住:路径里有空格也能认;回复原文里是原样的路径,服务端按它放行
|
|
1310
|
+
const md = ``;
|
|
1311
|
+
this.replyText += (this.replyText ? "\n\n" : "") + md;
|
|
1312
|
+
this.events.onText(md);
|
|
1313
|
+
return;
|
|
1314
|
+
}
|
|
1315
|
+
case "collabAgentToolCall": {
|
|
1316
|
+
if (phase !== "started") return;
|
|
1317
|
+
const call = item as Extract<ThreadItem, { type: "collabAgentToolCall" }>;
|
|
1318
|
+
const what = call.tool === "spawnAgent" ? `派出子智能体${call.prompt ? `:${summarize(call.prompt, 60)}` : ""}` : `子智能体 ${call.tool}`;
|
|
1319
|
+
this.events.onStep("tool", `🤝 ${what}`);
|
|
1320
|
+
return;
|
|
1321
|
+
}
|
|
1141
1322
|
case "error": {
|
|
1142
1323
|
if (phase !== "completed") return;
|
|
1143
1324
|
const err = item as Extract<ThreadItem, { type: "error" }>;
|
|
@@ -1155,6 +1336,21 @@ function kindMark(kind: unknown): string {
|
|
|
1155
1336
|
return k === "add" ? "+" : k === "delete" ? "-" : "~";
|
|
1156
1337
|
}
|
|
1157
1338
|
|
|
1339
|
+
/** 语音转交的一轮没拿到用户说的话时显示的占位 */
|
|
1340
|
+
const VOICE_FALLBACK = `${VOICE_MARK}(语音)`;
|
|
1341
|
+
|
|
1342
|
+
/** OpenAI 的报错常常是一整段 JSON:取里面的 message */
|
|
1343
|
+
function realtimeError(raw: string | undefined): string {
|
|
1344
|
+
if (!raw) return "语音对话出错了";
|
|
1345
|
+
try {
|
|
1346
|
+
const msg = (JSON.parse(raw) as { error?: { message?: unknown } }).error?.message;
|
|
1347
|
+
if (typeof msg === "string" && msg) return msg;
|
|
1348
|
+
} catch {
|
|
1349
|
+
// 不是 JSON,原样给
|
|
1350
|
+
}
|
|
1351
|
+
return raw;
|
|
1352
|
+
}
|
|
1353
|
+
|
|
1158
1354
|
export function summarize(text: string, max = 80): string {
|
|
1159
1355
|
const line = text.replace(/\s+/g, " ").trim();
|
|
1160
1356
|
return line.length > max ? `${line.slice(0, max)}…` : line;
|
|
@@ -0,0 +1,193 @@
|
|
|
1
|
+
// 和 `dsh --profile acp` 的连接:标准 ACP(Agent Client Protocol)v1,stdio 上按行分隔的 JSON-RPC。
|
|
2
|
+
//
|
|
3
|
+
// 为什么不用 SDK profile(--profile sdk):它没有中断当前回复、也没有关闭会话的方法(官方 README 写明),
|
|
4
|
+
// 停止按钮做不了。ACP 有 session/cancel,模型 / 思考程度、MCP、授权请求、会话列表 / 恢复也都齐。
|
|
5
|
+
//
|
|
6
|
+
// 一个 agent-loft 会话一个 dsh 进程:权限(沙箱档位)、追加的系统提示都只能在启动时给(环境变量和 --patch),
|
|
7
|
+
// 一个进程带多条会话就没法各配各的。代价是拉起要 4~5 秒,所以进程常驻、按需重拉。
|
|
8
|
+
import { spawn, type ChildProcessWithoutNullStreams } from "node:child_process";
|
|
9
|
+
import readline from "node:readline";
|
|
10
|
+
|
|
11
|
+
export type McpServer =
|
|
12
|
+
| { name: string; command: string; args: string[]; env: { name: string; value: string }[] }
|
|
13
|
+
| { type: "http"; name: string; url: string; headers: { name: string; value: string }[] };
|
|
14
|
+
|
|
15
|
+
export type ConfigOption = {
|
|
16
|
+
id: string;
|
|
17
|
+
name?: string;
|
|
18
|
+
category?: string;
|
|
19
|
+
type?: string;
|
|
20
|
+
currentValue?: string;
|
|
21
|
+
options?: ({ value: string; name?: string; description?: string } | { group?: string; name?: string; options: { value: string; name?: string; description?: string }[] })[];
|
|
22
|
+
};
|
|
23
|
+
|
|
24
|
+
export type SessionUpdate = { sessionUpdate: string; [k: string]: unknown };
|
|
25
|
+
|
|
26
|
+
export type PermissionRequest = {
|
|
27
|
+
sessionId: string;
|
|
28
|
+
toolCall: { toolCallId: string; title?: string; rawInput?: unknown; kind?: string };
|
|
29
|
+
options: { optionId: string; name?: string; kind: string }[];
|
|
30
|
+
};
|
|
31
|
+
|
|
32
|
+
export type PermissionOutcome = { outcome: "selected"; optionId: string } | { outcome: "cancelled" };
|
|
33
|
+
|
|
34
|
+
export class AcpError extends Error {
|
|
35
|
+
constructor(
|
|
36
|
+
message: string,
|
|
37
|
+
readonly code?: number,
|
|
38
|
+
readonly data?: unknown,
|
|
39
|
+
) {
|
|
40
|
+
super(message);
|
|
41
|
+
this.name = "AcpError";
|
|
42
|
+
}
|
|
43
|
+
}
|
|
44
|
+
|
|
45
|
+
/** stderr 只留最后这些行,给报错当线索 */
|
|
46
|
+
const STDERR_KEEP = 30;
|
|
47
|
+
|
|
48
|
+
export type AcpSpawn = { command: string; args: string[]; cwd: string; env: NodeJS.ProcessEnv };
|
|
49
|
+
|
|
50
|
+
export class AcpConnection {
|
|
51
|
+
private child: ChildProcessWithoutNullStreams;
|
|
52
|
+
private nextId = 1;
|
|
53
|
+
private pending = new Map<number, { resolve: (v: unknown) => void; reject: (e: Error) => void }>();
|
|
54
|
+
private stderr: string[] = [];
|
|
55
|
+
private closedWith: Error | null = null;
|
|
56
|
+
/** 会话更新:按会话 id 分发 */
|
|
57
|
+
onUpdate: (sessionId: string, update: SessionUpdate) => void = () => {};
|
|
58
|
+
/** dsh 要授权:返回选了哪个选项 */
|
|
59
|
+
onPermission: (req: PermissionRequest) => Promise<PermissionOutcome> = async () => ({ outcome: "cancelled" });
|
|
60
|
+
/** 进程退了(被杀、崩了、自己退出) */
|
|
61
|
+
onExit: (err: Error) => void = () => {};
|
|
62
|
+
|
|
63
|
+
constructor(spec: AcpSpawn) {
|
|
64
|
+
this.child = spawn(spec.command, spec.args, { cwd: spec.cwd, env: spec.env, stdio: ["pipe", "pipe", "pipe"] });
|
|
65
|
+
readline.createInterface({ input: this.child.stdout }).on("line", (line) => this.onLine(line));
|
|
66
|
+
readline.createInterface({ input: this.child.stderr }).on("line", (line) => {
|
|
67
|
+
this.stderr.push(line);
|
|
68
|
+
if (this.stderr.length > STDERR_KEEP) this.stderr.shift();
|
|
69
|
+
});
|
|
70
|
+
this.child.stdin.on("error", () => {});
|
|
71
|
+
this.child.on("error", (err) => this.close(err));
|
|
72
|
+
this.child.on("exit", (code, signal) => {
|
|
73
|
+
const tail = this.stderrTail();
|
|
74
|
+
this.close(new Error(`dsh 进程退出了(${signal ?? `退出码 ${code}`})${tail ? `:${tail}` : ""}`));
|
|
75
|
+
});
|
|
76
|
+
}
|
|
77
|
+
|
|
78
|
+
get alive(): boolean {
|
|
79
|
+
return !this.closedWith;
|
|
80
|
+
}
|
|
81
|
+
|
|
82
|
+
stderrTail(lines = 5): string {
|
|
83
|
+
return this.stderr
|
|
84
|
+
.filter((l) => l.trim())
|
|
85
|
+
.slice(-lines)
|
|
86
|
+
.join("\n");
|
|
87
|
+
}
|
|
88
|
+
|
|
89
|
+
private close(err: Error): void {
|
|
90
|
+
if (this.closedWith) return;
|
|
91
|
+
this.closedWith = err;
|
|
92
|
+
for (const p of this.pending.values()) p.reject(err);
|
|
93
|
+
this.pending.clear();
|
|
94
|
+
this.onExit(err);
|
|
95
|
+
}
|
|
96
|
+
|
|
97
|
+
private write(msg: object): void {
|
|
98
|
+
if (this.closedWith) return;
|
|
99
|
+
this.child.stdin.write(`${JSON.stringify(msg)}\n`);
|
|
100
|
+
}
|
|
101
|
+
|
|
102
|
+
request<T = unknown>(method: string, params: unknown): Promise<T> {
|
|
103
|
+
if (this.closedWith) return Promise.reject(this.closedWith);
|
|
104
|
+
const id = this.nextId++;
|
|
105
|
+
return new Promise<T>((resolve, reject) => {
|
|
106
|
+
this.pending.set(id, { resolve: resolve as (v: unknown) => void, reject });
|
|
107
|
+
this.write({ jsonrpc: "2.0", id, method, params });
|
|
108
|
+
});
|
|
109
|
+
}
|
|
110
|
+
|
|
111
|
+
notify(method: string, params: unknown): void {
|
|
112
|
+
this.write({ jsonrpc: "2.0", method, params });
|
|
113
|
+
}
|
|
114
|
+
|
|
115
|
+
private onLine(line: string): void {
|
|
116
|
+
if (!line.trim()) return;
|
|
117
|
+
let msg: { id?: number | string; method?: string; params?: unknown; result?: unknown; error?: { code?: number; message?: string; data?: unknown } };
|
|
118
|
+
try {
|
|
119
|
+
msg = JSON.parse(line);
|
|
120
|
+
} catch {
|
|
121
|
+
// stdout 只该有协议帧;混进来的别的输出(插件打日志)当 stderr 记下
|
|
122
|
+
this.stderr.push(line);
|
|
123
|
+
return;
|
|
124
|
+
}
|
|
125
|
+
if (msg.method && msg.id !== undefined) {
|
|
126
|
+
void this.onServerRequest(msg.id, msg.method, msg.params);
|
|
127
|
+
return;
|
|
128
|
+
}
|
|
129
|
+
if (msg.method) {
|
|
130
|
+
if (msg.method === "session/update") {
|
|
131
|
+
const p = msg.params as { sessionId?: string; update?: SessionUpdate } | undefined;
|
|
132
|
+
if (p?.sessionId && p.update) this.onUpdate(p.sessionId, p.update);
|
|
133
|
+
}
|
|
134
|
+
return;
|
|
135
|
+
}
|
|
136
|
+
if (typeof msg.id !== "number") return;
|
|
137
|
+
const pending = this.pending.get(msg.id);
|
|
138
|
+
if (!pending) return;
|
|
139
|
+
this.pending.delete(msg.id);
|
|
140
|
+
if (msg.error) {
|
|
141
|
+
const details = (msg.error.data as { details?: unknown } | undefined)?.details;
|
|
142
|
+
const text = [msg.error.message, typeof details === "string" ? details : ""].filter(Boolean).join(":");
|
|
143
|
+
pending.reject(new AcpError(text || "dsh 返回了错误", msg.error.code, msg.error.data));
|
|
144
|
+
} else {
|
|
145
|
+
pending.resolve(msg.result);
|
|
146
|
+
}
|
|
147
|
+
}
|
|
148
|
+
|
|
149
|
+
private async onServerRequest(id: number | string, method: string, params: unknown): Promise<void> {
|
|
150
|
+
try {
|
|
151
|
+
if (method === "session/request_permission") {
|
|
152
|
+
const outcome = await this.onPermission(params as PermissionRequest);
|
|
153
|
+
this.write({ jsonrpc: "2.0", id, result: { outcome } });
|
|
154
|
+
return;
|
|
155
|
+
}
|
|
156
|
+
// 没声明客户端文件系统 / 终端能力,正常不会来
|
|
157
|
+
this.write({ jsonrpc: "2.0", id, error: { code: -32601, message: `agent-loft 不支持 ${method}` } });
|
|
158
|
+
} catch (err) {
|
|
159
|
+
this.write({ jsonrpc: "2.0", id, error: { code: -32603, message: err instanceof Error ? err.message : String(err) } });
|
|
160
|
+
}
|
|
161
|
+
}
|
|
162
|
+
|
|
163
|
+
/** 先关 stdin 让它自己收尾(会 flush 会话记录),几秒不退再杀 */
|
|
164
|
+
async shutdown(graceMs = 5000): Promise<void> {
|
|
165
|
+
if (this.closedWith) return;
|
|
166
|
+
const exited = new Promise<void>((resolve) => this.child.once("exit", () => resolve()));
|
|
167
|
+
try {
|
|
168
|
+
this.child.stdin.end();
|
|
169
|
+
} catch {
|
|
170
|
+
// 已经关了
|
|
171
|
+
}
|
|
172
|
+
const timer = setTimeout(() => this.child.kill("SIGTERM"), graceMs);
|
|
173
|
+
const hard = setTimeout(() => this.child.kill("SIGKILL"), graceMs + 3000);
|
|
174
|
+
await exited;
|
|
175
|
+
clearTimeout(timer);
|
|
176
|
+
clearTimeout(hard);
|
|
177
|
+
}
|
|
178
|
+
}
|
|
179
|
+
|
|
180
|
+
/** ACP 的 initialize:只声明最小能力(不接管文件系统和终端,让 dsh 自己的沙箱管) */
|
|
181
|
+
export async function initialize(conn: AcpConnection): Promise<void> {
|
|
182
|
+
await conn.request("initialize", {
|
|
183
|
+
protocolVersion: 1,
|
|
184
|
+
clientCapabilities: { fs: { readTextFile: false, writeTextFile: false }, terminal: false },
|
|
185
|
+
clientInfo: { name: "agent-loft", version: "1" },
|
|
186
|
+
});
|
|
187
|
+
}
|
|
188
|
+
|
|
189
|
+
/** 把配置选项(可能分组)摊平 */
|
|
190
|
+
export function flatOptions(opt: ConfigOption | undefined): { value: string; name?: string; description?: string }[] {
|
|
191
|
+
if (!opt?.options) return [];
|
|
192
|
+
return opt.options.flatMap((o) => ("options" in o && Array.isArray(o.options) ? o.options : [o as { value: string; name?: string; description?: string }]));
|
|
193
|
+
}
|