agent-loft 0.2.64 → 0.2.65
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 +4 -4
- package/package.json +1 -1
- package/src/agents/claude/session.ts +6 -6
- package/src/agents/codex/session.ts +9 -3
- package/src/channels/web/api.ts +1 -1
- package/src/channels/web/experts-api.ts +20 -0
- package/src/core/builtin-agents.ts +96 -0
- package/src/core/experts.ts +2 -2
- package/src/core/hub.ts +10 -6
- package/src/core/mcp.ts +1 -1
- package/src/core/personal.ts +2 -0
- package/src/core/skill-runtime.ts +6 -4
- package/src/core/types.ts +5 -1
- package/web/css/settings.css +5 -0
- package/web/settings/agents.js +55 -0
- package/web/settings/experts.js +2 -2
- package/web/settings/index.js +2 -2
package/README.md
CHANGED
|
@@ -72,7 +72,7 @@ Logo 就是这个意思:一大两小几颗星(多个 agent)站在同一张
|
|
|
72
72
|
- **授权**:允许一次 / 本会话全部允许 / 总是允许(按钮上写明放行范围)/ 拒绝。`/autoedit on` 让 Claude Code 在这条会话里改工作目录内的文件不再询问(Bash 仍询问)。超时一律按拒绝处理。
|
|
73
73
|
- **设置都在网页上**,按用途分组:**我的**(账号和密码、飞书绑定、登录设备、通知、记忆、技能、用量,每个人都有);**Agent**(运行环境、各 agent 的默认模型和思考程度、可选模型、Codex 沙箱、额度查询;工作目录、会话闲置过期、授权卡超时和 Claude 的「总是允许」名单;「/」命令);**连接**(飞书机器人、配对批准、指令面板同步;远程控制;服务器);**管理**(用户、所有人的登录设备;服务端版本和升级、重启、局域网访问和端口)。改了没保存就切页或关掉设置会先提醒。
|
|
74
74
|
- **多用户**(信任型):管理员在 设置 → 用户 里给别人建账号。每个人只看得到自己的对话、授权和通知,设置只有管理员能改,见下面「安全」。
|
|
75
|
-
- **专家**:设置 → 专家。专家是一份配置,新建对话、定时任务时选一个,对话从头到尾都是它(中途不能换;飞书里 `/expert 名字`、`/claude`、`/codex` 换专家会开新会话)。**内置专家**:Claude Code、Codex
|
|
75
|
+
- **专家**:设置 → 专家。专家是一份配置,新建对话、定时任务时选一个,对话从头到尾都是它(中途不能换;飞书里 `/expert 名字`、`/claude`、`/codex` 换专家会开新会话)。**内置专家**:Claude Code、Codex,保留原装提示词和所有工具,默认技能与 MCP 在「设置 → Agent」中按账号、按引擎分别选择。**自定义专家**每人管自己的,可以配:
|
|
76
76
|
- 头像(点头像区域的加号上传;未上传时,会话中用引擎的图标)、引擎(Claude / Codex,建好后不能换)、默认模型和思考程度(从模型列表里选);
|
|
77
77
|
- 提示词:人设、规则、输出格式。agent-loft 在后面自动补上这个专家能做什么、今天的日期、记忆。Claude 专家默认只用这段提示词(一句话约 2 千 token),也可以选「追加在 Claude Code 原装提示词后面」(干活更稳,每轮多约 1.6 万);Codex 的基础指令改不了,专家的提示词附在第一条消息后面,约束力弱一些;
|
|
78
78
|
- 权限,勾选:联网搜索、读网页,以及文件权限(一级包含一级):都不勾就是**只能联网**(不碰本机文件、不弹授权,文本附件内容直接放进消息)/**能读文件**/**能改文件**/**能跑命令**(跑命令就等于能改任何文件,需要授权时弹卡)。Claude 按权限给工具;Codex 按权限开 shell、apply_patch,沙箱只读或 workspace-write;
|
|
@@ -82,10 +82,10 @@ Logo 就是这个意思:一大两小几颗星(多个 agent)站在同一张
|
|
|
82
82
|
- 子智能体(只有 Claude):别的 Claude 专家,主专家用 Agent 工具把子任务派给它。子智能体的权限不能超过主专家(运行时也封顶在主专家的权限)。
|
|
83
83
|
|
|
84
84
|
只勾联网搜索、读网页的 Claude 专家就是以前聊天模式的效果。专家改了,用它的对话下一条消息起生效;专家删了,用它的对话还能看、不能再发消息,用它的定时任务暂停。以前的聊天模式取消了:升级后聊天模式的旧对话不再保留,聊天模式的定时任务暂停,选个专家再启用。
|
|
85
|
-
- **MCP**:设置 → MCP,每人管自己的:本机进程(命令 + 参数 + 环境变量)或 HTTP 地址(+ 请求头),值可以标成密钥(网页上不回显,只交给 MCP
|
|
85
|
+
- **MCP**:设置 → MCP,每人管自己的:本机进程(命令 + 参数 + 环境变量)或 HTTP 地址(+ 请求头),值可以标成密钥(网页上不回显,只交给 MCP 进程或请求头,不进提示词)。可以设「调用前询问」,不设就直接用。自定义专家加载各自勾选的服务;内置专家在「设置 → Agent → 内置 Agent 默认加载」里选择,支持个人 MCP、管理员可选的机器 MCP,也可全部取消;不指定时管理员沿用机器配置。
|
|
86
86
|
- **记忆**:像 ChatGPT 的记忆,设置 → 记忆(默认关)。「关于我」加上一条条记住的事,每次对话都带上;agent 在聊天里遇到长期有用的信息会自己用 `remember` 记一条(回复里会说),记错了用 `forget` 删。**自动整理**:把上次整理之后新说的话交给模型(不留会话记录的一次性调用),补充、更新或删掉过时的记忆,用户自己加的条目它不动。什么时候整理每个人自己定:每天一次(默认凌晨 2 点,把当天的对话合起来一次整理,最省)/每段对话聊完后(停多久可选,改了什么会在对话里说一声)/只在点「现在整理」时/不整理;整理哪些对话也能选:全部/只整理选中专家的对话;用哪个 agent 的哪个模型也能选,默认 Claude Haiku,没有 Claude 就用 Codex 的默认模型、思考程度 low。**参考以前的聊天**:agent 遇到「上次说的那个……」会用 `search_past_chats` 搜你以前的对话(关键词搜索,只有你自己的、没被删掉的对话)。聊天记录索引不开记忆也会记(侧栏的「搜索」也用它),升级后会把已有对话收录进来一次;没开记忆时记进来的不拿去整理。两项都能在设置里单独关。每个用户一份,Claude 和 Codex、Web 和飞书共用。只用在有主人的对话里:你的 Web 对话,以及绑定了飞书账号后和机器人的私聊;飞书群聊不用。别人(包括管理员)看不到你的记忆,管理员只能清空它;删用户时记忆一起删,不转给管理员。
|
|
87
87
|
- **定时任务**:像 ChatGPT 的 Tasks,侧栏的「定时任务」。到点把一段提示词交给 agent,结果发回对话:一次 / 每天 / 工作日 / 每周 / 每月 / 每隔几小时 / 自定义 cron,按服务端时区,两次至少隔 15 分钟。**有需要才提醒**(默认):agent 自己判断这次有没有要告诉你的事(比如「有新版本才告诉我」),没有就在回复第一行写 `[[静默]]`,推送、飞书都不发,对话里折叠成一行;没写暗号一律照常提醒。结果发到**专用对话**(任务自己的一条对话,第一次运行时新建、之后续用,可选专家和目录),或者**原来的对话**。也能直接在对话里说「每天早上 9 点帮我……」:agent 用 `create_task` / `update_task` / `delete_task` / `list_tasks` 工具管理,新建、修改、删除都会先弹授权卡让你确认(只有暂停不用;没有「总是允许」),任务自己运行的那一轮里不能再建、改、删任务。按人隔离:每人只看得到、改得了自己的任务(最多 30 个),删用户时一起删;到点再核对一次对话还是不是他的,对话被删或换了主人就暂停任务。到点对话在忙(正在回复或挂着授权)就等它,最多 30 分钟;服务停着时错过 2 小时以内的启动后补跑一次。工具和记忆一样只给有主人的对话,飞书群聊里没有。
|
|
88
|
-
- **技能(skills)**:设置 → 技能。技能就是 Claude Code / Codex 用的那种 SKILL.md(可以带脚本和资料),由 agent-loft 按人管理,两个 agent 都能用。**来源**:在页面上写、上传技能包(`.zip` / `.skill` / 单个 SKILL.md / 整个文件夹),或者在对话里让 agent「把刚才的做法存成技能」(agent 用 `create_skill` / `update_skill
|
|
88
|
+
- **技能(skills)**:设置 → 技能。技能就是 Claude Code / Codex 用的那种 SKILL.md(可以带脚本和资料),由 agent-loft 按人管理,两个 agent 都能用。**来源**:在页面上写、上传技能包(`.zip` / `.skill` / 单个 SKILL.md / 整个文件夹),或者在对话里让 agent「把刚才的做法存成技能」(agent 用 `create_skill` / `update_skill`,先弹授权卡)。每人管自己的,不做分享和技能广场(以前从别人那装过的照常能用,可以卸载)。**使用**:内置专家默认使用你启用的全部技能,也可以在「设置 → Agent」中分别指定 Claude Code / Codex 加载哪些技能;自定义专家只用它选中的;agent 遇到对得上的事自己用。**变量**:技能可以声明要用的环境变量(接口地址、密钥),每个人填自己的值,只注入自己的会话;密钥再写上「只允许发往」的地址就成了**受保护的密钥**——不进环境变量,agent 看不到值,只能用 `skill_request` 工具让 agent-loft 代发请求(在地址、请求头、请求体里写 `{{变量名}}`),只发往你确认过的地址、不跟随跳转、响应里出现的值会被抹掉;作者后来改了地址,要你再确认一次才放行。**机器上原有的技能**(`~/.claude/skills`、`~/.agents/skills`、插件市场和 claude.ai 同步的)只给管理员:成员的会话里看不到、调不了(Claude 用技能白名单,`/技能名` 也会被拦下;Codex 关掉它自己的技能清单),管理员在「设置 → 技能 → 本机技能」里能看到。
|
|
89
89
|
- **资料库**:像 ChatGPT 的资料库,侧栏的「资料库」。对话里发过的附件、agent 回复里给出的、这一轮新写出来的图片 / 文档 / 音视频(复制一份收进来,之后原文件改了删了不影响)都汇总在这里:按图片 / 文档 / 音视频筛、按文件名搜,点开看大图或下载,「在新对话里用」,单个或批量删除(文件从磁盘上删掉)。输入框的「+」也能「从资料库选」。从资料库拿到对话里的文件硬链接进那条对话的上传目录,不占双份空间,agent 照常能读。按人隔离,规则同对话:自己的;没主人的对话(飞书群聊等)的归管理员。上传了一直没发出去的一天后清掉,对话被删的连同文件一起删。
|
|
90
90
|
- **远程控制**:侧栏「定时任务」下面的「远程控制」,直接操作这台机器的**桌面**和**终端**,上面一键切换;切回对话时连接留在后台(侧栏入口上亮个小绿点),再进来接着用。这台机器没有图形桌面(服务器、NAS)时只有终端。
|
|
91
91
|
- 桌面:走 VNC 协议,网页里用 noVNC 显示,鼠标、键盘、剪贴板都能用,进来时不自动连、点「连接桌面」才连,工具栏上选画质:流畅 / 标准(默认)/ 高清由服务端把画面缩小到长边 1280 / 1920 / 2560、只把变了的地方压成 JPEG 发过来(macOS 屏幕共享只给无损的 ZRLE,5K 屏一整屏 30MB,原样转发隔着公网几秒一帧),原画是原样转发、只适合局域网;远程那边接了几块屏时可以只看其中一块(按系统里的显示器名称选,服务端只截那块再缩,比几块屏拼在一起缩小清楚得多;macOS 的各块屏位置要从屏幕共享发来的画面里学,第一次连上要几秒,原画下不能选);可以缩放到窗口或按原始大小看、全屏(手机上也能,iPhone 上是铺满页面)、「只看不控制」、发送 Ctrl+Alt+Del 之类的组合键。手机上有两种手势(右上角切换,「?」看说明):**触控板模式**(默认)屏幕上有个指针,单指滑动移动、轻点单击、双指轻点右键、长按后拖动是按住左键拖、双指滑动滚动;**触摸模式**点哪就点哪。两种模式都能双指捏合在本地放大画面(放大后小按钮也点得准,右下角「还原」),画面下面一排 Esc / Tab / Ctrl / Alt / Win / 方向键,Ctrl、Alt、Win 点一下会粘住,带给下一个按键或点击;键盘按钮弹出软键盘打字,中文输入法也能用。Linux 上 agent-loft 在有人连时用 x11vnc 共享当前的桌面(Xorg 会话;只听 127.0.0.1、随机端口、每次随机密码,需要 `sudo apt install x11vnc`),没人连着 30 分钟后停掉;macOS 上在 设置 → 远程控制 里改用「已有的 VNC 服务」,接系统自带的屏幕共享:填 VNC 密码,或者屏幕共享没开 VNC 密码时填 Mac 的用户名和登录密码(苹果认证,由服务端登录)。
|
|
@@ -181,7 +181,7 @@ agent-loft service install
|
|
|
181
181
|
- agent 子进程拿不到本服务自己的凭据(`FEISHU_*`、`AGENT_LOFT_*` 等环境变量会被剔除)。
|
|
182
182
|
- 技能存在 `data/skills/`:技能本体在 `files/<技能 id>/`,每个人装了哪些、变量的值在 `users/<用户 id>.json`(0600)。普通变量注入到会话环境里,agent 能读到;受保护的密钥 agent 看不到值,但和多用户一样不是安全边界——能读文件的专家(包括内置的 Claude Code / Codex)能直接读这些文件。别人分享的技能会在你的会话里照着执行,装之前在技能页点开看一眼它要做什么、要哪些变量。
|
|
183
183
|
- 记忆和聊天记录索引都存在 `data/agent-loft.db`(SQLite,会话、脚注、用量也在里面)。记给谁由 agent-loft 在拉起记忆工具时定死(工具参数里没有用户),模型想写别人的记忆也写不了;但和多用户一样不是安全边界:能读文件的专家能读到这个数据库文件。只能联网的专家没有读写本机文件的工具,网页里的提示注入也骗不走本机文件。
|
|
184
|
-
- 专家存在 `data/experts.json`,MCP 存在 `data/mcp.json`(0600,含 MCP
|
|
184
|
+
- 专家存在 `data/experts.json`,MCP 存在 `data/mcp.json`(0600,含 MCP 的密钥值),内置 Agent 的个人默认选择存在 `data/builtin-agents.json`。和技能一样不是安全边界:能读文件的专家读得到。
|
|
185
185
|
|
|
186
186
|
## 结构
|
|
187
187
|
|
package/package.json
CHANGED
|
@@ -219,13 +219,13 @@ export function expertOptions(opts: SessionOptions): Partial<Options> {
|
|
|
219
219
|
const skills = opts.skills;
|
|
220
220
|
const expert = opts.expert;
|
|
221
221
|
if (!expert) {
|
|
222
|
-
const mcpServers = loftMcp(opts);
|
|
222
|
+
const mcpServers = { ...opts.builtinMcp?.mcp, ...loftMcp(opts) };
|
|
223
223
|
const append = [RICH_REPLY_LINES.join("\n"), memory?.prompt, skills?.prompt].filter(Boolean).join("\n\n");
|
|
224
224
|
return {
|
|
225
225
|
systemPrompt: { type: "preset", preset: "claude_code", append, snapshot: false },
|
|
226
|
-
...(Object.keys(mcpServers).length ? { mcpServers } : {}),
|
|
226
|
+
...(opts.builtinMcp && !opts.builtinMcp.inheritMachine ? { strictMcpConfig: true, mcpServers } : Object.keys(mcpServers).length ? { mcpServers } : {}),
|
|
227
227
|
...(skills?.pluginDir ? { plugins: [{ type: "local" as const, path: skills.pluginDir, skipMcpDiscovery: true }] } : {}),
|
|
228
|
-
...(skills && !skills.admin ? { skills: memberSkillAllowlist(skills, opts.cwd) } : {}),
|
|
228
|
+
...(skills && (!skills.admin || skills.machineSkills === false) ? { skills: memberSkillAllowlist(skills, opts.cwd) } : {}),
|
|
229
229
|
};
|
|
230
230
|
}
|
|
231
231
|
|
|
@@ -579,10 +579,10 @@ export class ClaudeSession implements AgentSession {
|
|
|
579
579
|
/** 自定义专家:它配了的联网工具、MCP 工具(没标「调用前询问」的)是用户自己给的,不再逐次问 */
|
|
580
580
|
private expertPreApproved(toolName: string): boolean {
|
|
581
581
|
const e = this.opts.expert;
|
|
582
|
-
if (
|
|
583
|
-
|
|
582
|
+
if (e && ((toolName === "WebSearch" && e.webSearch) || (toolName === "WebFetch" && e.webFetch))) return true;
|
|
583
|
+
const config = e ?? this.opts.builtinMcp;
|
|
584
584
|
const m = /^mcp__(.+?)__/.exec(toolName);
|
|
585
|
-
return !!m && m[1]! in
|
|
585
|
+
return !!config && !!m && m[1]! in config.mcp && !config.askMcp.includes(m[1]!);
|
|
586
586
|
}
|
|
587
587
|
|
|
588
588
|
/** 内置专家算能跑命令 */
|
|
@@ -428,7 +428,13 @@ export class CodexSession implements AgentSession {
|
|
|
428
428
|
const off = Object.fromEntries((await userMcpServers()).filter((n) => !keep.has(n)).map((n) => [`mcp_servers.${n}.enabled`, false]));
|
|
429
429
|
return { config: { ...expertConfig(expert), ...off, ...codexMcp(expert.mcp, expert.askMcp), ...mcp, ...this.skillConfig() } };
|
|
430
430
|
}
|
|
431
|
-
const
|
|
431
|
+
const builtin = this.opts.builtinMcp;
|
|
432
|
+
const keep = new Set([...(builtin?.machineMcp ?? []), ...Object.keys(builtin?.mcp ?? {})]);
|
|
433
|
+
const off = builtin && !builtin.inheritMachine
|
|
434
|
+
? Object.fromEntries((await userMcpServers()).filter((n) => !keep.has(n)).map((n) => [`mcp_servers.${n}.enabled`, false]))
|
|
435
|
+
: {};
|
|
436
|
+
const selected = Object.fromEntries((builtin?.machineMcp ?? []).map((n) => [`mcp_servers.${n}.enabled`, true]));
|
|
437
|
+
const work = { ...off, ...selected, ...codexMcp(builtin?.mcp ?? {}, builtin?.askMcp), ...mcp, ...this.skillConfig() };
|
|
432
438
|
return Object.keys(work).length ? { config: work } : {};
|
|
433
439
|
}
|
|
434
440
|
|
|
@@ -442,7 +448,7 @@ export class CodexSession implements AgentSession {
|
|
|
442
448
|
if (!skills) return {};
|
|
443
449
|
return {
|
|
444
450
|
...(this.access === "exec" ? Object.fromEntries(Object.entries(skills.env).map(([k, v]) => [`shell_environment_policy.set.${k}`, v])) : {}),
|
|
445
|
-
...(skills.admin && !this.opts.expert ? {} : { "skills.include_instructions": false, "features.skill_search": false }),
|
|
451
|
+
...(skills.admin && skills.machineSkills !== false && !this.opts.expert ? {} : { "skills.include_instructions": false, "features.skill_search": false }),
|
|
446
452
|
};
|
|
447
453
|
}
|
|
448
454
|
|
|
@@ -710,7 +716,7 @@ export class CodexSession implements AgentSession {
|
|
|
710
716
|
case "mcpServer/elicitation/request": {
|
|
711
717
|
const req = params as { serverName: string; mode?: string; message?: string; _meta?: Record<string, unknown> };
|
|
712
718
|
// Codex 用 elicitation 传工具审批;普通 MCP 表单仍按未支持处理,不能把表单当授权。
|
|
713
|
-
if (req.mode !== "form" || req._meta?.codex_approval_kind !== "mcp_tool_call" || !this.opts.expert?.mcp[req.serverName]) {
|
|
719
|
+
if (req.mode !== "form" || req._meta?.codex_approval_kind !== "mcp_tool_call" || !(this.opts.expert ?? this.opts.builtinMcp)?.mcp[req.serverName]) {
|
|
714
720
|
return refusalFor(method);
|
|
715
721
|
}
|
|
716
722
|
const detail = [req.message, req._meta.tool_params === undefined ? "" : `\`\`\`json\n${JSON.stringify(req._meta.tool_params, null, 2)}\n\`\`\``].filter(Boolean).join("\n\n");
|
package/src/channels/web/api.ts
CHANGED
|
@@ -770,7 +770,7 @@ export async function handleApi(req: IncomingMessage, res: ServerResponse, url:
|
|
|
770
770
|
if (p.startsWith("/api/tasks") && (await handleTasksApi(req, res, p, user))) return;
|
|
771
771
|
if (p.startsWith("/api/library") && (await handleLibraryApi(req, res, p, user))) return;
|
|
772
772
|
if (p.startsWith("/api/skills") && (await handleSkillsApi(req, res, url, user))) return;
|
|
773
|
-
if ((p.startsWith("/api/experts") || p.startsWith("/api/mcp")) && (await handleExpertsApi(req, res, p, user))) return;
|
|
773
|
+
if ((p === "/api/agents/defaults" || p.startsWith("/api/experts") || p.startsWith("/api/mcp")) && (await handleExpertsApi(req, res, p, user))) return;
|
|
774
774
|
if (p.startsWith("/api/terminals") && (await handleTerminalApi(req, res, p, user))) return;
|
|
775
775
|
if ((p === "/api/remote" || p.startsWith("/api/desktop/")) && (await handleDesktopApi(req, res, p, user))) return;
|
|
776
776
|
|
|
@@ -16,6 +16,7 @@ import {
|
|
|
16
16
|
type Expert,
|
|
17
17
|
type ExpertInput,
|
|
18
18
|
} from "../../core/experts.js";
|
|
19
|
+
import { builtinAgentDefaults, setBuiltinAgentDefaults } from "../../core/builtin-agents.js";
|
|
19
20
|
import { hub } from "../../core/hub.js";
|
|
20
21
|
import { claudeMachineMcp, createMcp, deleteMcp, getMcp, listMcp, MACHINE_PREFIX, MCP_LIMITS, mcpView, updateMcp, type McpInput } from "../../core/mcp.js";
|
|
21
22
|
import { activeSkills } from "../../core/skills.js";
|
|
@@ -85,6 +86,25 @@ async function machineMcp(user: User): Promise<{ claude: string[]; codex: string
|
|
|
85
86
|
export async function handleExpertsApi(req: IncomingMessage, res: ServerResponse, p: string, user: User): Promise<boolean> {
|
|
86
87
|
const method = req.method ?? "GET";
|
|
87
88
|
|
|
89
|
+
if (p === "/api/agents/defaults" && method === "GET") {
|
|
90
|
+
sendJson(res, 200, {
|
|
91
|
+
agents: builtinAgentDefaults(user.id),
|
|
92
|
+
skills: activeSkills(user.id).map((s) => ({ id: s.id, name: s.name, description: s.description })),
|
|
93
|
+
mcp: listMcp(user.id).map((s) => ({ id: s.id, name: s.name, description: s.description })),
|
|
94
|
+
...(await machineMcp(user).then((m) => m ? { machineMcp: m, machinePrefix: MACHINE_PREFIX } : {})),
|
|
95
|
+
});
|
|
96
|
+
return true;
|
|
97
|
+
}
|
|
98
|
+
if (p === "/api/agents/defaults" && method === "PUT") {
|
|
99
|
+
const body = await readJsonBody<{ agents?: unknown }>(req);
|
|
100
|
+
try {
|
|
101
|
+
sendJson(res, 200, { agents: setBuiltinAgentDefaults(user.id, body.agents) });
|
|
102
|
+
} catch (err) {
|
|
103
|
+
throw bad(err);
|
|
104
|
+
}
|
|
105
|
+
return true;
|
|
106
|
+
}
|
|
107
|
+
|
|
88
108
|
if (p === "/api/experts" && method === "GET") {
|
|
89
109
|
const enabled = hub.enabledAgents().map((d) => d.id);
|
|
90
110
|
sendJson(res, 200, {
|
|
@@ -0,0 +1,96 @@
|
|
|
1
|
+
// 内置 Agent 的个人默认配置;与管理员管理的运行环境分开,按账号、引擎保存。
|
|
2
|
+
import path from "node:path";
|
|
3
|
+
import { EventEmitter } from "node:events";
|
|
4
|
+
import { dataDir, readJson, writeJsonAtomic } from "../home.js";
|
|
5
|
+
import { ENGINES, resolveMcp, type Engine } from "./experts.js";
|
|
6
|
+
import { getMcp, isMachineId, machineName } from "./mcp.js";
|
|
7
|
+
import { activeSkills } from "./skills.js";
|
|
8
|
+
import { sessionSkills } from "./skill-runtime.js";
|
|
9
|
+
import { getUser } from "./users.js";
|
|
10
|
+
import type { SessionOptions } from "./types.js";
|
|
11
|
+
|
|
12
|
+
export type BuiltinAgentDefaults = {
|
|
13
|
+
/** null = 全部已启用的个人技能;[] = 不加载个人技能 */
|
|
14
|
+
skills: string[] | null;
|
|
15
|
+
machineSkills: boolean;
|
|
16
|
+
/** null = 沿用机器配置;[] = 不加载 MCP(系统工具除外) */
|
|
17
|
+
mcp: string[] | null;
|
|
18
|
+
};
|
|
19
|
+
type Defaults = Record<Engine, BuiltinAgentDefaults>;
|
|
20
|
+
const file = path.join(dataDir, "builtin-agents.json");
|
|
21
|
+
export const builtinAgentEvents = new EventEmitter<{ changed: [owner: string] }>();
|
|
22
|
+
|
|
23
|
+
export function builtinAgentDefaults(owner: string): Defaults {
|
|
24
|
+
const admin = getUser(owner)?.role === "admin";
|
|
25
|
+
const stored = readJson<Record<string, Partial<Defaults>>>(file, {})[owner];
|
|
26
|
+
const defaults = (engine: Engine): BuiltinAgentDefaults => ({
|
|
27
|
+
skills: stored?.[engine]?.skills ?? null,
|
|
28
|
+
machineSkills: admin && stored?.[engine]?.machineSkills !== false,
|
|
29
|
+
mcp: stored?.[engine]?.mcp ?? (admin ? null : []),
|
|
30
|
+
});
|
|
31
|
+
return { claude: defaults("claude"), codex: defaults("codex") };
|
|
32
|
+
}
|
|
33
|
+
|
|
34
|
+
function selection(value: unknown, what: string): string[] | null {
|
|
35
|
+
if (value === null) return null;
|
|
36
|
+
if (!Array.isArray(value) || value.length > 200 || value.some((v) => typeof v !== "string" || v.length > 100)) throw new Error(`${what}必须是列表或 null`);
|
|
37
|
+
return [...new Set(value as string[])];
|
|
38
|
+
}
|
|
39
|
+
|
|
40
|
+
export function setBuiltinAgentDefaults(owner: string, patch: unknown): Defaults {
|
|
41
|
+
if (!patch || typeof patch !== "object" || Array.isArray(patch)) throw new Error("Agent 配置格式不对");
|
|
42
|
+
const user = getUser(owner);
|
|
43
|
+
if (!user) throw new Error("用户不存在");
|
|
44
|
+
const next = builtinAgentDefaults(owner);
|
|
45
|
+
const available = new Set(activeSkills(owner).map((s) => s.id));
|
|
46
|
+
for (const [engine, raw] of Object.entries(patch)) {
|
|
47
|
+
if (!ENGINES.includes(engine as Engine) || !raw || typeof raw !== "object" || Array.isArray(raw)) throw new Error("Agent 配置格式不对");
|
|
48
|
+
const p = raw as Record<string, unknown>;
|
|
49
|
+
const current = next[engine as Engine];
|
|
50
|
+
if (p.skills !== undefined) {
|
|
51
|
+
const ids = selection(p.skills, "技能");
|
|
52
|
+
if (ids?.some((id) => !available.has(id))) throw new Error("只能选择自己已启用的技能");
|
|
53
|
+
current.skills = ids;
|
|
54
|
+
}
|
|
55
|
+
if (p.machineSkills !== undefined) {
|
|
56
|
+
if (typeof p.machineSkills !== "boolean") throw new Error("机器技能开关必须是布尔值");
|
|
57
|
+
if (p.machineSkills && user.role !== "admin") throw new Error("只有管理员能加载机器上的技能");
|
|
58
|
+
current.machineSkills = p.machineSkills;
|
|
59
|
+
}
|
|
60
|
+
if (p.mcp !== undefined) {
|
|
61
|
+
const ids = selection(p.mcp, "MCP");
|
|
62
|
+
if (ids === null && user.role !== "admin") throw new Error("只有管理员能沿用机器 MCP 配置");
|
|
63
|
+
const names = new Set<string>();
|
|
64
|
+
for (const id of ids ?? []) {
|
|
65
|
+
const server = getMcp(id);
|
|
66
|
+
const name = isMachineId(id) ? machineName(id) : server?.name;
|
|
67
|
+
if (isMachineId(id) ? user.role !== "admin" || !name || !/^[A-Za-z0-9_-]{1,100}$/.test(name) : !server || server.owner !== owner) throw new Error("只能选择自己的 MCP(机器 MCP 仅管理员可选)");
|
|
68
|
+
if (names.has(name!)) throw new Error(`MCP 服务名重复:${name}`);
|
|
69
|
+
names.add(name!);
|
|
70
|
+
}
|
|
71
|
+
current.mcp = ids;
|
|
72
|
+
}
|
|
73
|
+
}
|
|
74
|
+
const all = readJson<Record<string, Defaults>>(file, {});
|
|
75
|
+
all[owner] = next;
|
|
76
|
+
writeJsonAtomic(file, all);
|
|
77
|
+
builtinAgentEvents.emit("changed", owner);
|
|
78
|
+
return next;
|
|
79
|
+
}
|
|
80
|
+
|
|
81
|
+
export function builtinAgentSession(owner: string | undefined, engine: Engine): Pick<SessionOptions, "skills" | "builtinMcp"> {
|
|
82
|
+
if (!owner || !getUser(owner)) return {};
|
|
83
|
+
const prefs = builtinAgentDefaults(owner)[engine];
|
|
84
|
+
const resolved = resolveMcp({ owner, engine, mcp: prefs.mcp ?? [] }, getUser(owner)?.role === "admin");
|
|
85
|
+
return {
|
|
86
|
+
skills: sessionSkills(owner, prefs.skills ?? undefined, prefs.machineSkills, `builtin-${engine}`),
|
|
87
|
+
builtinMcp: { mcp: resolved.mcp, askMcp: resolved.ask, machineMcp: resolved.machine, inheritMachine: prefs.mcp === null },
|
|
88
|
+
};
|
|
89
|
+
}
|
|
90
|
+
|
|
91
|
+
export function deleteBuiltinAgentDefaults(owner: string): void {
|
|
92
|
+
const all = readJson<Record<string, Defaults>>(file, {});
|
|
93
|
+
if (!(owner in all)) return;
|
|
94
|
+
delete all[owner];
|
|
95
|
+
writeJsonAtomic(file, all);
|
|
96
|
+
}
|
package/src/core/experts.ts
CHANGED
|
@@ -2,7 +2,7 @@
|
|
|
2
2
|
// 挂哪些技能和 MCP、能把活派给哪些子智能体。新建对话、定时任务时选一个专家,对话从头到尾都是它,
|
|
3
3
|
// 中途不能换(飞书里换专家等于开新会话)。
|
|
4
4
|
//
|
|
5
|
-
// 两个内置专家 claude、codex
|
|
5
|
+
// 两个内置专家 claude、codex 不存成自定义专家:保留原装提示词和工具,技能 / MCP 默认项由 builtin-agents.ts 按人保存。
|
|
6
6
|
// 对话和任务里没写 expert 的,专家就是它的 agent —— 升级前的数据不用迁移。
|
|
7
7
|
//
|
|
8
8
|
// 自定义专家每人管自己的,不分享。存储:data/experts.json,只有主进程读写。
|
|
@@ -389,7 +389,7 @@ export type ExpertRuntime = {
|
|
|
389
389
|
};
|
|
390
390
|
|
|
391
391
|
/** 专家选中的 MCP 解析成启动参数。机器上的:Claude 读 ~/.claude.json,Codex 只要名字(由它自己按 config.toml 起) */
|
|
392
|
-
function resolveMcp(expert: Expert, admin: boolean): { mcp: Record<string, ResolvedMcp>; ask: string[]; machine: string[] } {
|
|
392
|
+
export function resolveMcp(expert: Pick<Expert, "owner" | "engine" | "mcp">, admin: boolean): { mcp: Record<string, ResolvedMcp>; ask: string[]; machine: string[] } {
|
|
393
393
|
const mcp: Record<string, ResolvedMcp> = {};
|
|
394
394
|
const ask: string[] = [];
|
|
395
395
|
const machine: string[] = [];
|
package/src/core/hub.ts
CHANGED
|
@@ -51,6 +51,7 @@ import { helpText, type ParsedCommand } from "./commands.js";
|
|
|
51
51
|
import { listScheduled } from "./scheduled.js";
|
|
52
52
|
import { expertSystemPrompt, searchLabel, stripContext } from "./expert-prompt.js";
|
|
53
53
|
import { avatarUrl, expertEvents, expertRuntime, getExpert, isBuiltin, listExperts, type ExpertRuntime } from "./experts.js";
|
|
54
|
+
import { builtinAgentDefaults, builtinAgentEvents, builtinAgentSession } from "./builtin-agents.js";
|
|
54
55
|
import { mcpEvents } from "./mcp.js";
|
|
55
56
|
import { isMachineCommand, sessionSkills } from "./skill-runtime.js";
|
|
56
57
|
import { skillEvents } from "./skills.js";
|
|
@@ -278,9 +279,10 @@ class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd] }>
|
|
|
278
279
|
interactions.on("created", (i) => this.emitEvent(i.convKey, { type: "ix", id: i.id }));
|
|
279
280
|
// 技能装了、改了、停用了、变量改了:受影响的人空闲的会话换上新的
|
|
280
281
|
skillEvents.on("changed", (users) => this.personalChanged(new Set(users)));
|
|
281
|
-
//
|
|
282
|
+
// 专家修改只影响自定义专家;MCP 和内置默认配置修改也更新该账号的内置会话。
|
|
282
283
|
expertEvents.on("changed", (owner) => this.personalChanged(new Set([owner]), true));
|
|
283
|
-
mcpEvents.on("changed", (owner) => this.personalChanged(new Set([owner])
|
|
284
|
+
mcpEvents.on("changed", (owner) => this.personalChanged(new Set([owner])));
|
|
285
|
+
builtinAgentEvents.on("changed", (owner) => this.personalChanged(new Set([owner])));
|
|
284
286
|
// workspaceRoot 改了:store 会把没显式 /cd 过的会话目录重置,正在跑的旧目录会话要作废
|
|
285
287
|
onConfigChange((next, prev) => {
|
|
286
288
|
// 默认模型可能改了,缓存作废,下次显示时重新读
|
|
@@ -650,7 +652,8 @@ class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd] }>
|
|
|
650
652
|
const taskOwner = memoryOwnerOf(conv);
|
|
651
653
|
// 技能也跟着主人走:他启用的技能、填的变量;成员看不到机器上原有的技能(见 skill-runtime.ts)。
|
|
652
654
|
// 自定义专家只给它选中的
|
|
653
|
-
const
|
|
655
|
+
const builtin = !expert && isBuiltin(agent) ? builtinAgentSession(taskOwner, agent) : {};
|
|
656
|
+
const skills = expert ? sessionSkills(taskOwner, expert.skills) : builtin.skills;
|
|
654
657
|
const session = driver.createSession(
|
|
655
658
|
{
|
|
656
659
|
cwd: conv.cwd,
|
|
@@ -664,6 +667,7 @@ class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd] }>
|
|
|
664
667
|
...(memory ? { memory } : {}),
|
|
665
668
|
...(taskOwner ? { tasks: { userId: taskOwner, convKey: key } } : {}),
|
|
666
669
|
...(skills ? { skills } : {}),
|
|
670
|
+
...(builtin.builtinMcp ? { builtinMcp: builtin.builtinMcp } : {}),
|
|
667
671
|
},
|
|
668
672
|
{
|
|
669
673
|
onUserAnchor: (input, anchor) => {
|
|
@@ -1050,11 +1054,11 @@ class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd] }>
|
|
|
1050
1054
|
// 只有内置的 Claude Code 专家读机器上的技能;自定义专家的技能白名单里只有它选的
|
|
1051
1055
|
if (!conv || conv.agent !== "claude" || conv.expert) return null;
|
|
1052
1056
|
const owner = memoryOwnerOf(conv);
|
|
1053
|
-
if (!owner || getUser(owner)?.role === "admin") return null;
|
|
1057
|
+
if (!owner || (getUser(owner)?.role === "admin" && builtinAgentDefaults(owner).claude.machineSkills)) return null;
|
|
1054
1058
|
const driver = this.enabledAgents().find((d) => d.id === conv.agent);
|
|
1055
1059
|
if (!driver?.commands) return null;
|
|
1056
1060
|
const native = await withTimeout(driver.commands(conv.cwd), "读取命令列表").catch(() => [] as AgentCommand[]);
|
|
1057
|
-
return isMachineCommand(m[1]!, native, conv.cwd) ? `/${m[1]}
|
|
1061
|
+
return isMachineCommand(m[1]!, native, conv.cwd) ? `/${m[1]} 是机器上的技能,当前账号的 Agent 设置未允许加载。` : null;
|
|
1058
1062
|
}
|
|
1059
1063
|
|
|
1060
1064
|
/** 刚点过停止(被打断的那一轮还可能晚到一个出错,见 onError 里的 stopped) */
|
|
@@ -1310,7 +1314,7 @@ class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd] }>
|
|
|
1310
1314
|
|
|
1311
1315
|
/**
|
|
1312
1316
|
* 这些人的记忆、技能、专家或 MCP 变了:他们名下活着的会话空闲下来就重新拉起。
|
|
1313
|
-
* onlyExperts
|
|
1317
|
+
* onlyExperts:只管用自定义专家的会话(修改自定义专家配置时使用)
|
|
1314
1318
|
*/
|
|
1315
1319
|
private personalChanged(users: Set<string>, onlyExperts = false): void {
|
|
1316
1320
|
for (const [key, live] of this.live) {
|
package/src/core/mcp.ts
CHANGED
|
@@ -7,7 +7,7 @@
|
|
|
7
7
|
// 和技能一样是「信任型」的:能执行命令的专家读得到 data/ 下的文件,包括这里的值。
|
|
8
8
|
//
|
|
9
9
|
// 机器上原有的 MCP(Claude 的 ~/.claude.json、Codex 的 config.toml)只给管理员选,id 写成 machine:<名字>。
|
|
10
|
-
// 内置的 Claude Code / Codex
|
|
10
|
+
// 内置的 Claude Code / Codex 专家按 builtin-agents.ts 的个人默认选择加载;管理员默认沿用机器配置。
|
|
11
11
|
//
|
|
12
12
|
// 存储:data/mcp.json,所有人的放在一起,只有主进程读写。
|
|
13
13
|
import crypto from "node:crypto";
|
package/src/core/personal.ts
CHANGED
|
@@ -8,6 +8,7 @@ import { purgeUserExperts } from "./experts.js";
|
|
|
8
8
|
import { purgeUserMcp } from "./mcp.js";
|
|
9
9
|
import type { Conversation } from "./store.js";
|
|
10
10
|
import { getUser, legacyOwnerId } from "./users.js";
|
|
11
|
+
import { deleteBuiltinAgentDefaults } from "./builtin-agents.js";
|
|
11
12
|
import { deleteUiPrefs } from "./ui-prefs.js";
|
|
12
13
|
|
|
13
14
|
/**
|
|
@@ -51,4 +52,5 @@ export function purgeUserData(userId: string): void {
|
|
|
51
52
|
purgeUserExperts(userId);
|
|
52
53
|
purgeUserMcp(userId);
|
|
53
54
|
deleteUiPrefs(userId);
|
|
55
|
+
deleteBuiltinAgentDefaults(userId);
|
|
54
56
|
}
|
|
@@ -115,8 +115,8 @@ export function projectCommandNames(cwd: string): string[] {
|
|
|
115
115
|
* 把这个人启用的技能整理成一个 Claude 插件目录:skills/<name> 链接到技能本体(作者一改,这里就是新的)。
|
|
116
116
|
* 每次开会话时对一遍账:多的删、少的补,正在用这个目录的其他会话不受影响。
|
|
117
117
|
*/
|
|
118
|
-
export function syncPluginDir(userId: string, skills: Skill[]): string {
|
|
119
|
-
const dir = path.join(pluginsRoot, userId);
|
|
118
|
+
export function syncPluginDir(userId: string, skills: Skill[], scope?: string): string {
|
|
119
|
+
const dir = path.join(pluginsRoot, userId, ...(scope ? [scope] : []));
|
|
120
120
|
const skillsDir = path.join(dir, "skills");
|
|
121
121
|
fs.mkdirSync(path.join(dir, ".claude-plugin"), { recursive: true, mode: 0o700 });
|
|
122
122
|
fs.mkdirSync(skillsDir, { recursive: true, mode: 0o700 });
|
|
@@ -188,8 +188,9 @@ function varsPrompt(skills: Skill[], env: Record<string, string>, userId: string
|
|
|
188
188
|
* 没有主人的对话(飞书群聊等,只有管理员能配)照旧:机器上的技能都在,没有 agent-loft 的技能。
|
|
189
189
|
* only:自定义专家选中的技能 id,只给这些(变量的说明也只说这些的)。插件目录照样是这个人启用的全部 ——
|
|
190
190
|
* 正在用这个目录的其他会话不受影响,Claude 那边再用白名单只放选中的。
|
|
191
|
+
* 内置 Agent 使用独立 pluginScope,插件里只挂它选中的技能,避免与自定义专家互相覆盖。
|
|
191
192
|
*/
|
|
192
|
-
export function sessionSkills(owner: string | undefined, only?: string[]): SessionSkills | undefined {
|
|
193
|
+
export function sessionSkills(owner: string | undefined, only?: string[], machineSkills?: boolean, pluginScope?: string): SessionSkills | undefined {
|
|
193
194
|
if (!owner) return undefined;
|
|
194
195
|
const user = getUser(owner);
|
|
195
196
|
if (!user) return undefined;
|
|
@@ -203,7 +204,7 @@ export function sessionSkills(owner: string | undefined, only?: string[]): Sessi
|
|
|
203
204
|
// 子智能体可能选了主专家没有的技能,插件资源要准备完整;各自的白名单由 driver 限定。
|
|
204
205
|
if (all.length) {
|
|
205
206
|
try {
|
|
206
|
-
pluginDir = syncPluginDir(owner, all);
|
|
207
|
+
pluginDir = syncPluginDir(owner, pluginScope ? skills : all, pluginScope);
|
|
207
208
|
} catch (err) {
|
|
208
209
|
console.error("[技能] 整理插件目录失败:", err instanceof Error ? err.message : err);
|
|
209
210
|
}
|
|
@@ -211,6 +212,7 @@ export function sessionSkills(owner: string | undefined, only?: string[]): Sessi
|
|
|
211
212
|
return {
|
|
212
213
|
userId: owner,
|
|
213
214
|
admin,
|
|
215
|
+
...(machineSkills !== undefined ? { machineSkills: admin && machineSkills } : {}),
|
|
214
216
|
...(pluginDir ? { pluginDir } : {}),
|
|
215
217
|
list: skills.map((s) => ({ name: s.name, description: s.description, path: path.join(skillDir(s.id), "SKILL.md") })),
|
|
216
218
|
env,
|
package/src/core/types.ts
CHANGED
|
@@ -200,7 +200,7 @@ export type SessionOptions = {
|
|
|
200
200
|
autoEdit?: boolean;
|
|
201
201
|
/**
|
|
202
202
|
* 自定义专家(core/experts.ts):提示词、权限、技能、MCP、子智能体都按它来。
|
|
203
|
-
*
|
|
203
|
+
* 不给就是内置专家:原装提示词和工具,技能与 MCP 按账号的内置默认配置加载。
|
|
204
204
|
*/
|
|
205
205
|
expert?: ExpertRuntime;
|
|
206
206
|
/** 这条对话主人的记忆:prompt 拼进系统提示,userId 交给记忆工具(记给谁由这里定死) */
|
|
@@ -219,12 +219,16 @@ export type SessionOptions = {
|
|
|
219
219
|
tasks?: { userId: string; convKey: string };
|
|
220
220
|
/** 这条对话主人的技能(core/skill-runtime.ts)。没主人的对话不给:机器上的技能照旧,没有 agent-loft 的技能 */
|
|
221
221
|
skills?: SessionSkills;
|
|
222
|
+
/** 内置 Agent 的个人 MCP 选择;不给时沿用 CLI 原配置。 */
|
|
223
|
+
builtinMcp?: Pick<ExpertRuntime, "mcp" | "askMcp" | "machineMcp"> & { inheritMachine: boolean };
|
|
222
224
|
};
|
|
223
225
|
|
|
224
226
|
export type SessionSkills = {
|
|
225
227
|
userId: string;
|
|
226
228
|
/** 管理员:机器上原有的技能照常能用;成员:只有 agent-loft 的技能和 agent 自带的 */
|
|
227
229
|
admin: boolean;
|
|
230
|
+
/** 内置 Agent 是否加载机器技能;未设置时沿用管理员默认行为 */
|
|
231
|
+
machineSkills?: boolean;
|
|
228
232
|
/** Claude 插件目录(里面是这个人启用的技能),一个都没有就不给 */
|
|
229
233
|
pluginDir?: string;
|
|
230
234
|
/** 启用的技能:名字、说明、SKILL.md 的路径 */
|
package/web/css/settings.css
CHANGED
package/web/settings/agents.js
CHANGED
|
@@ -156,7 +156,62 @@ function installCodexButton(after) {
|
|
|
156
156
|
return h("div", {}, btn);
|
|
157
157
|
}
|
|
158
158
|
|
|
159
|
+
/** 内置 Agent 的个人默认项;普通成员也能设置自己的,不需要服务器管理权限。 */
|
|
160
|
+
function builtinDefaultsSection() {
|
|
161
|
+
const section = h("div", { class: "section", "data-form": "" }, h("h4", {}, "内置 Agent 默认加载"), h("span", { class: "spinner" }));
|
|
162
|
+
const load = async () => {
|
|
163
|
+
let data;
|
|
164
|
+
try {
|
|
165
|
+
data = await api("/api/agents/defaults");
|
|
166
|
+
} catch (err) {
|
|
167
|
+
fill(section, h("h4", {}, "内置 Agent 默认加载"), h("div", { class: "error-text" }, err.message), h("button", { class: "btn small", onclick: load }, "重试"));
|
|
168
|
+
return;
|
|
169
|
+
}
|
|
170
|
+
const choices = {};
|
|
171
|
+
const picker = (label, items, selected, inheritLabel) => {
|
|
172
|
+
const mode = h("select", { "aria-label": label },
|
|
173
|
+
...(inheritLabel ? [h("option", { value: "inherit", selected: selected === null }, inheritLabel)] : []),
|
|
174
|
+
h("option", { value: "pick", selected: selected !== null }, "指定加载(可全部取消)"));
|
|
175
|
+
const known = new Set(items.map((item) => item.id));
|
|
176
|
+
const missing = (selected ?? []).filter((id) => !known.has(id)).map((id) => ({ id, name: `${id}(暂不可用,可取消)` }));
|
|
177
|
+
const inputs = [...items, ...missing].map((item) => ({ id: item.id, input: h("input", { type: "checkbox", checked: (selected ?? []).includes(item.id) }), item }));
|
|
178
|
+
const list = h("div", { class: "check-list" }, inputs.length
|
|
179
|
+
? inputs.map(({ input, item }) => h("label", { class: "check-item", title: item.description ?? "" }, input, h("span", {}, item.name)))
|
|
180
|
+
: h("small", {}, "暂无可选项,请先在设置中添加"));
|
|
181
|
+
const sync = () => { list.hidden = mode.value !== "pick"; };
|
|
182
|
+
mode.addEventListener("change", sync);
|
|
183
|
+
sync();
|
|
184
|
+
return { el: h("div", { class: "field" }, h("span", {}, label), mode, list), value: () => mode.value === "inherit" ? null : inputs.filter((x) => x.input.checked).map((x) => x.id) };
|
|
185
|
+
};
|
|
186
|
+
const panels = ["claude", "codex"].map((engine) => {
|
|
187
|
+
const label = engine === "claude" ? "Claude Code" : "Codex";
|
|
188
|
+
const prefs = data.agents[engine];
|
|
189
|
+
const skills = picker(`${label} 技能`, data.skills, prefs.skills, "全部已启用的个人技能(含以后新增)");
|
|
190
|
+
const machine = (data.machineMcp?.[engine] ?? []).map((name) => ({ id: `${data.machinePrefix}${name}`, name: `${name}(本机)` }));
|
|
191
|
+
const mcp = picker(`${label} MCP`, [...data.mcp, ...machine], prefs.mcp, data.machineMcp ? "沿用机器上的 MCP 配置" : null);
|
|
192
|
+
const machineSkills = h("input", { type: "checkbox", checked: prefs.machineSkills });
|
|
193
|
+
choices[engine] = { skills, mcp, machineSkills };
|
|
194
|
+
return h("div", { class: "builtin-agent-defaults" }, h("h4", {}, label), skills.el,
|
|
195
|
+
data.machineMcp ? h("label", { class: "check-item" }, machineSkills, "同时加载机器上的技能") : null,
|
|
196
|
+
mcp.el);
|
|
197
|
+
});
|
|
198
|
+
fill(section, h("h4", {}, "内置 Agent 默认加载"),
|
|
199
|
+
h("p", { class: "skill-note" }, "仅影响你当前账号使用的内置 Agent;自定义专家继续使用各自的配置。保存后,下次发消息生效,正在执行的任务不受影响。"),
|
|
200
|
+
...panels,
|
|
201
|
+
h("small", {}, "技能和 MCP 可分别全部取消。记忆、定时任务、技能管理等系统工具仍按功能设置提供。"),
|
|
202
|
+
h("div", { class: "row" }, saveButton(async () => {
|
|
203
|
+
const agents = Object.fromEntries(Object.entries(choices).map(([engine, c]) => [engine, { skills: c.skills.value(), machineSkills: c.machineSkills.checked, mcp: c.mcp.value() }]));
|
|
204
|
+
await api("/api/agents/defaults", { method: "PUT", body: { agents } });
|
|
205
|
+
toast("已保存,下次发消息生效");
|
|
206
|
+
}, "保存默认加载设置")));
|
|
207
|
+
};
|
|
208
|
+
void load();
|
|
209
|
+
return section;
|
|
210
|
+
}
|
|
211
|
+
|
|
159
212
|
export function agentsTab(cfg, page) {
|
|
213
|
+
page.append(builtinDefaultsSection());
|
|
214
|
+
if (!cfg) return;
|
|
160
215
|
page.append(agentHealthSection());
|
|
161
216
|
const a = structuredClone(cfg.agents);
|
|
162
217
|
const claudeOn = h("input", { type: "checkbox", checked: a.claude.enabled });
|
package/web/settings/experts.js
CHANGED
|
@@ -48,7 +48,7 @@ function render(box, data, reload) {
|
|
|
48
48
|
h(
|
|
49
49
|
"p",
|
|
50
50
|
{ class: "skill-note" },
|
|
51
|
-
"专家是一份配置:用哪个引擎、什么提示词、能做什么(联网 / 读文件 / 改文件 / 跑命令)、带哪些技能和 MCP、能把活派给哪些子智能体。新建对话、定时任务时选一个专家,对话从头到尾都是它。内置的 Claude Code、Codex
|
|
51
|
+
"专家是一份配置:用哪个引擎、什么提示词、能做什么(联网 / 读文件 / 改文件 / 跑命令)、带哪些技能和 MCP、能把活派给哪些子智能体。新建对话、定时任务时选一个专家,对话从头到尾都是它。内置的 Claude Code、Codex 在「设置 → Agent」里选择默认技能和 MCP。",
|
|
52
52
|
),
|
|
53
53
|
h("div", { class: "skill-head-btns" }, add),
|
|
54
54
|
),
|
|
@@ -60,7 +60,7 @@ function render(box, data, reload) {
|
|
|
60
60
|
"div",
|
|
61
61
|
{ class: "task-card skill-card" },
|
|
62
62
|
h("div", { class: "task-top" }, h("span", { class: "task-title" }, agentIcon(b.engine, "expert-card-icon"), b.name), h("span", { class: "badge" }, "内置")),
|
|
63
|
-
h("div", { class: "task-prompt" }, `${b.name}
|
|
63
|
+
h("div", { class: "task-prompt" }, `${b.name} 原装的样子:原装提示词、所有工具;默认技能和 MCP 在「设置 → Agent」里配置。`),
|
|
64
64
|
),
|
|
65
65
|
),
|
|
66
66
|
data.experts.map((e) => expertCard(data, e, reload)),
|
package/web/settings/index.js
CHANGED
|
@@ -18,7 +18,7 @@ import { hasDirty, markDirty } from "./common.js";
|
|
|
18
18
|
|
|
19
19
|
// ---------- 设置 ----------
|
|
20
20
|
// 按「谁的、管什么」分组:我的(每个人自己的)、Agent、连接(飞书、远程控制)、管理。
|
|
21
|
-
//
|
|
21
|
+
// 普通成员可管理自己的资料和内置 Agent 默认项;管理员另有运行环境和服务器设置。
|
|
22
22
|
|
|
23
23
|
const LAST_TAB = "aim.settingsTab";
|
|
24
24
|
|
|
@@ -38,7 +38,7 @@ function groupsFor(cfg) {
|
|
|
38
38
|
["用量", (p) => usageTab(p)],
|
|
39
39
|
],
|
|
40
40
|
};
|
|
41
|
-
if (!cfg) return [mine];
|
|
41
|
+
if (!cfg) return [mine, { name: "Agent", tabs: [["Agent", (p) => agentsTab(null, p)]] }];
|
|
42
42
|
return [
|
|
43
43
|
mine,
|
|
44
44
|
{
|