agent-loft 0.2.97 → 0.2.98
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/channels/web/experts-api.ts +32 -5
- package/src/channels/web/skills-api.ts +42 -27
- package/src/core/builtin-agents.ts +2 -2
- package/src/core/experts.ts +18 -9
- package/src/core/hub.ts +1 -1
- package/src/core/mcp.ts +121 -18
- package/src/core/skill-runtime.ts +5 -4
- package/src/core/skills-bridge.ts +95 -24
- package/src/core/skills.ts +184 -37
- package/src/mcp/tasks-server.ts +1 -1
- package/web/settings/experts.js +63 -10
- package/web/settings/skills.js +38 -13
package/README.md
CHANGED
|
@@ -79,20 +79,20 @@ Logo 就是这个意思:一大两小几颗星(多个 agent)站在同一张
|
|
|
79
79
|
- **授权**:允许一次 / 本会话全部允许 / 总是允许(按钮上写明放行范围)/ 拒绝。权限级别(输入框左下角或 `/permission`):逐次询问 / 自动改文件 / 完全允许,定时任务也可以单独设,完全允许只给管理员。`/autoedit on` 让 Claude Code 在这条会话里改工作目录内的文件不再询问(Bash 仍询问)。超时一律按拒绝处理。
|
|
80
80
|
- **设置都在网页上**,按用途分组:**我的**(账号、飞书和微信绑定、自己的登录设备、记忆、专家、技能、MCP、用量);**Agent**(运行环境置顶,各 agent 卡片分别配置默认模型、思考程度、可选模型、个人默认技能和 MCP,Codex 沙箱、额度查询;工作目录、会话闲置过期、授权卡超时和 Claude 的「总是允许」名单;「/」命令);**连接**(飞书机器人、配对批准、指令面板同步;远程控制;服务器);**管理**(用户标题旁添加用户,用户的「管理 → 登录设备」查看和下线各自设备;系统页管理服务端版本和升级、重启、局域网访问和端口,网络访问下方是系统通知;成员也可在系统页设置自己的通知)。账号页通过「修改名称」「修改密码」按需展开表单;飞书和微信绑定操作位于卡片右上角。设置、新建 / 编辑专家、重命名等编辑弹窗不会因点击外部或按 Esc 关闭;通过关闭、取消或保存 / 完成按钮退出。改了没保存就切页或关掉设置会先提醒。
|
|
81
81
|
- **多用户**(信任型):管理员在 设置 → 用户 里给别人建账号。每个人只看得到自己的对话、授权和通知;个人设置各自管理,服务器设置由管理员修改,见下面「安全」。
|
|
82
|
-
- **专家**:设置 → 专家。专家是一份配置,新建对话、定时任务时选一个,对话从头到尾都是它(中途不能换;飞书里 `/expert 名字`、`/claude`、`/codex` 换专家会开新会话)。**内置专家**:Claude Code、Codex,保留原装提示词和所有工具,默认技能与 MCP 在「设置 → Agent」中按账号、按引擎分别选择。**自定义专家**由创建者管理,可以勾选「共享给所有账号」。共享后,其他人能在网页、绑定账号后的飞书私聊和定时任务中选择它;只有创建者能修改设定。每个人在该专家的「我的工具」里选择自己的技能和 MCP
|
|
82
|
+
- **专家**:设置 → 专家。专家是一份配置,新建对话、定时任务时选一个,对话从头到尾都是它(中途不能换;飞书里 `/expert 名字`、`/claude`、`/codex` 换专家会开新会话)。**内置专家**:Claude Code、Codex,保留原装提示词和所有工具,默认技能与 MCP 在「设置 → Agent」中按账号、按引擎分别选择。**自定义专家**由创建者管理,可以勾选「共享给所有账号」。共享后,其他人能在网页、绑定账号后的飞书私聊和定时任务中选择它;只有创建者能修改设定。每个人在该专家的「我的工具」里选择自己的技能和 MCP,使用各自的变量、凭据、记忆和聊天记录;创建者沿用原有工具选择;其他人没配置过时,沿用创建者选的里面自己能用的(自己装了的技能、创建者共享出来的 MCP),创建者私有的 MCP 和机器 MCP 不会带给别人。取消共享后,其他人的历史对话保留,后续消息不能继续调用该专家,相关定时任务在下次运行时暂停。可以配:
|
|
83
83
|
- 头像(点头像区域的加号上传;未上传时,会话中用引擎的图标)、引擎(Claude / Codex,建好后不能换)、默认模型和思考程度(从模型列表里选);
|
|
84
84
|
- 提示词:人设、规则、输出格式。agent-loft 在后面自动补上这个专家能做什么、今天的日期、记忆。Claude 专家默认只用这段提示词(一句话约 2 千 token),也可以选「追加在 Claude Code 原装提示词后面」(干活更稳,每轮多约 1.6 万);Codex 的基础指令改不了,专家的提示词附在第一条消息后面,约束力弱一些;
|
|
85
85
|
- 权限,勾选:联网搜索、读网页,以及文件权限(一级包含一级):都不勾就是**只能联网**(不碰本机文件、不弹授权,文本附件内容直接放进消息)/**能读文件**/**能改文件**/**能跑命令**(跑命令就等于能改任何文件,需要授权时弹卡)。Claude 按权限给工具;Codex 按权限开 shell、apply_patch,沙箱只读或 workspace-write;
|
|
86
86
|
- 带不带个人记忆,默认工作目录,新对话页上的欢迎语和快捷提问;
|
|
87
87
|
- 技能:只给选中的(Claude 用技能白名单,没选的调不了;没选技能就不挂 Skill 工具,省 token);
|
|
88
|
-
- MCP:从「设置 → MCP
|
|
88
|
+
- MCP:从「设置 → MCP」里勾自己的或别人共享的(管理员还能勾机器上配的);
|
|
89
89
|
- 子智能体(只有 Claude):别的 Claude 专家,主专家用 Agent 工具把子任务派给它。子智能体的权限不能超过主专家(运行时也封顶在主专家的权限)。
|
|
90
90
|
|
|
91
91
|
只勾联网搜索、读网页的 Claude 专家就是以前聊天模式的效果。专家改了,用它的对话下一条消息起生效;专家删了,用它的对话还能看、不能再发消息,用它的定时任务暂停。以前的聊天模式取消了:升级后聊天模式的旧对话不再保留,聊天模式的定时任务暂停,选个专家再启用。
|
|
92
|
-
- **MCP**:设置 → MCP
|
|
92
|
+
- **MCP**:设置 → MCP,每人管自己的:HTTP 地址(+ 请求头),或者本机进程(命令 + 参数 + 环境变量,会在服务器上直接执行命令、不受专家权限约束,所以只有管理员能添加;成员以前建的不再启动)。值可以标成密钥(网页上不回显,只交给 MCP 进程或请求头,不进提示词)。可以设「调用前询问」,不设就直接用。**共享**:勾「共享给所有账号」后,别人能在专家和内置 Agent 里选它;共享的是命令、地址和普通的环境变量 / 请求头,标成密钥的项每人在「填写我的密钥」里填自己的值,作者的不会给出去;用别人共享的 MCP 时,调用工具前一律先弹授权卡;取消共享后别人填的值一起删掉。自定义专家加载各自勾选的服务;内置专家在「设置 → Agent → 对应 Agent 卡片 → 默认加载」里选择,支持个人 MCP、管理员可选的机器 MCP,也可全部取消;不指定时管理员沿用机器配置。
|
|
93
93
|
- **记忆**:像 ChatGPT 的记忆,设置 → 记忆(默认关),按用很多年设计。「关于我」加上一条条记住的事;agent 在聊天里遇到长期有用的信息会自己用 `remember` 记一条(回复里会说),事情变了用 `update_memory`,记错了用 `forget`。**分三层**:长期(身份、家人、长期偏好,一直放进系统提示,不会被后来的挤掉,也可以自己置顶)、活跃(近期的事,按最近动过的时间放进系统提示,放不下的 agent 能用 `search_memory` 搜到)、归档(过时了、到期了、满了被挤出来的,不进系统提示,不删,能搜到能恢复)。**谁能动**:你加的、你在聊天里明确要求记的、你置顶的都受保护,自动整理不能改、不能删、满了也不会被挤,agent 要改得是你在当前对话里明确要求。明显的密钥(API key、`密码是……`)agent 和整理都记不进去。**不怕改错**:删除进回收站保留 30 天;每次改动都有记录(谁、什么时候、改之前是什么),在设置里能查能撤销,改之前的旧内容也搜得到;清空和彻底删除才是真删。**自动整理**:把上次整理之后新说的话连同日期交给模型(不留会话记录的一次性调用),补充、更新、归档过时的记忆。什么时候整理每个人自己定:每天一次(默认凌晨 2 点,把当天的对话合起来一次整理,最省)/每段对话聊完后(停多久可选,改了什么会在对话里说一声)/只在点「现在整理」时/不整理;整理哪些对话也能选:全部/只整理选中专家的对话;用哪个 agent 的哪个模型也能选,默认 Claude Haiku,没有 Claude 就用 Codex 的默认模型、思考程度 low。很长的对话切成几份整理,一句不漏;整理失败的对话不会丢,留着下次再试,连着全失败就退避(最长 6 小时),同一段一直失败的先搁置,点「现在整理」时再试。**摘要**:整理时顺带给每段对话写摘要(不多一次调用),月份过去后合成一份月度摘要(一个月一次调用),agent 回答「那段时间做了什么」「那件事的经过」时用 `memory_timeline` 看,还能按项目目录筛。只有整理范围内的对话才有摘要。**参考以前的聊天**:agent 遇到「上次说的那个……」会用 `search_past_chats` 搜你以前的对话(关键词搜索,能按日期筛,只有你自己的、没被删掉的对话),要看前后文用 `read_past_chat`。搜索走 SQLite FTS5 全文索引(中文按字索引,两个字的词也能搜),几十万句也在一秒内;设置页会显示近 30 天 agent 搜了多少次、多少次没搜到。聊天记录索引不开记忆也会记(侧栏的「搜索」也用它),升级后会把已有对话收录进来一次;没开记忆时记进来的不拿去整理。删对话时它的聊天记录索引和摘要一起删,提炼出来的记忆条目留着(记着来源)。**导出和备份**:记忆能导出成 JSON、导入到别的账号或服务器,聊天记录能导出成 JSONL;整个数据库每天自动备份到 `backups/db/`(校验后压缩,留最近 7 天、4 周、12 个月,`AGENT_LOFT_BACKUP_DIR` 可以换到别的盘)。每个用户一份,Claude 和 Codex、Web 和飞书共用;改了记忆(设置里改的、后台整理的、别的对话里记的),正在跑的会话空闲下来就换上新的。只用在有主人的对话里:你的 Web 对话,以及绑定了飞书账号后和机器人的私聊;飞书群聊不用。别人(包括管理员)看不到你的记忆,管理员只能清空它;删用户时记忆一起删,不转给管理员。
|
|
94
94
|
- **定时任务**:像 ChatGPT 的 Tasks,侧栏的「定时任务」。到点把一段提示词交给 agent,结果发回对话:一次 / 每天 / 工作日 / 每周 / 每月 / 每隔几小时 / 自定义 cron,按服务端时区,两次至少隔 15 分钟。**有需要才提醒**(默认):agent 自己判断这次有没有要告诉你的事(比如「有新版本才告诉我」),没有就在回复第一行写 `[[静默]]`,推送、飞书都不发,对话里折叠成一行;没写暗号一律照常提醒。结果发到**专用对话**(任务自己的一条对话,第一次运行时新建、之后续用,可选专家和目录;可以设成不携带上下文,每次运行都换新会话,之前的结果还留在对话里,只是 agent 看不到),在专用对话右上角的「更多」里可以直接编辑任务、立即运行,或者**原来的对话**。也能直接在对话里说「每天早上 9 点帮我……」:agent 用 `create_task` / `update_task` / `delete_task` / `list_tasks` 工具管理,新建、修改、删除都会先弹授权卡让你确认(只有暂停不用;没有「总是允许」),任务自己运行的那一轮里不能再建、改、删任务。按人隔离:每人只看得到、改得了自己的任务(最多 30 个),删用户时一起删;到点再核对一次对话还是不是他的,对话被删或换了主人就暂停任务。到点对话在忙(正在回复或挂着授权)就等它,最多 30 分钟;服务停着时错过 2 小时以内的启动后补跑一次。工具和记忆一样只给有主人的对话,飞书群聊里没有。结果可以发到专用对话,也可以发到正在聊的对话(新建和编辑时都能选,也能来回切换):发到正在聊的对话时,专家和目录跟随对话,权限就是对话自己的;选「不携带上下文」时任务在独立的临时会话里运行,跑完换回聊天的会话,结果照样显示在这条对话里,下一条消息会带给 agent。
|
|
95
|
-
- **技能(skills)**:设置 → 技能。技能就是 Claude Code / Codex 用的那种 SKILL.md(可以带脚本和资料),由 agent-loft 按人管理,两个 agent 都能用。**来源**:在页面上写、上传技能包(`.zip` / `.skill` / 单个 SKILL.md / 整个文件夹),或者在对话里让 agent「把刚才的做法存成技能」(agent 用 `create_skill` / `update_skill`,先弹授权卡)。**共享**:新建、编辑时选择「仅自己可见」「指定用户」或「所有人可见」,也可在自己技能的「更多 →
|
|
95
|
+
- **技能(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 代发请求(在请求头或地址的查询参数里写 `{{变量名}}`;不能写进请求体和地址的主机、路径,免得借允许的服务本身发出去),只走 https(局域网、本机地址才允许 http)、不跟随跳转、响应里出现的值(含 URL 编码、base64 形式)会被抹掉。发往哪些地址**按技能分别确认**:在哪个技能的变量页里填值,就只同意这个技能(和你自己建的技能)声明的地址,别人技能声明的同名密钥地址要在各自页面另外确认;作者删掉的地址立即失效,新加的要你再确认。一个值按受保护密钥填过就一直受保护:声明它的技能停用、卸载了,别的技能声明同名的普通变量也拿不到明文,要当普通变量用得重新填。`skill_request` 只认当前会话挂着的技能声明过的变量。**机器上原有的技能**(`~/.claude/skills`、`~/.agents/skills`、插件市场和 claude.ai 同步的)只给管理员:成员的会话里看不到、调不了(Claude 用技能白名单,`/技能名` 也会被拦下;Codex 关掉它自己的技能清单),管理员在「设置 → 技能 → 本机技能」里能看到。
|
|
96
96
|
- **工作区面板**:会话右上角「更多 → 文件」打开或折叠,菜单中用绿色新增行数、红色删除行数显示当前分支的改动,在对话旁边(手机上全屏)看和改这条会话工作目录里的文件。「文件」页签是一棵按需展开的文件树,图片、PDF、音视频、Markdown、网页、代码直接预览,CSV / TSV 显示成表格;文本文件(1 MB 以内、UTF-8)可以编辑,Ctrl / ⌘ + S 保存,Markdown 和 CSV 能预览没保存的内容。还能新建、重命名、上传(点按钮或拖到面板上)、删除。保存时如果文件在你编辑期间被 agent 或别人改过,不会覆盖,由你选覆盖还是重新加载;没保存的内容存在本机,换会话、刷新页面都不丢。「改动」页签是 Git 仓库的已暂存 / 未暂存 / 未跟踪文件,点开看 diff,宽度够时可以切并排;顶栏的分支标记显示当前分支和改动数,点面板里的分支行能查看和切换本地、远程分支,也能新建分支。文件行上可以暂存、取消暂存、丢弃改动,写好说明提交已暂存的内容(默认不运行 Git 钩子,要用的话勾上);「历史」页签看提交记录和每个提交的 diff。推送、拉取、合并、变基请交给 agent 或终端。一轮结束、切回窗口时自动刷新。
|
|
97
97
|
- 管理员能用;成员要管理员在 设置 → 用户 里单独「开通工作区面板」。
|
|
98
98
|
- 分支栏下面可以获取、拉取、推送,用的是服务器上配置的 Git 凭据。拉取只做快进,推送从不强制。成员默认没有这个权限,要管理员再单独「开通 Git 远程操作」。
|
package/package.json
CHANGED
|
@@ -23,9 +23,9 @@ import { builtinAgentDefaults, setBuiltinAgentDefaults } from "../../core/builti
|
|
|
23
23
|
import { hub } from "../../core/hub.js";
|
|
24
24
|
import { config } from "../../core/config.js";
|
|
25
25
|
import { shellInfo } from "../../core/servers.js";
|
|
26
|
-
import { claudeMachineMcp, createMcp, deleteMcp, getMcp,
|
|
26
|
+
import { canUseMcp, claudeMachineMcp, createMcp, deleteMcp, getMcp, listUsableMcp, MACHINE_PREFIX, MCP_LIMITS, mcpView, setMcpUserValues, updateMcp, type McpInput, type McpServer } from "../../core/mcp.js";
|
|
27
27
|
import { activeSkills } from "../../core/skills.js";
|
|
28
|
-
import { isAdmin, type User } from "../../core/users.js";
|
|
28
|
+
import { getUser, isAdmin, type User } from "../../core/users.js";
|
|
29
29
|
import { HttpError, readJsonBody, sendJson } from "./http.js";
|
|
30
30
|
|
|
31
31
|
const bad = (err: unknown) => (err instanceof HttpError ? err : new HttpError(400, err instanceof Error ? err.message : String(err)));
|
|
@@ -91,6 +91,17 @@ async function machineMcp(user: User): Promise<{ claude: string[]; codex: string
|
|
|
91
91
|
return { claude: enabled.has("claude") ? Object.keys(claudeMachineMcp()) : [], codex };
|
|
92
92
|
}
|
|
93
93
|
|
|
94
|
+
/** 选工具时列出的 MCP:自己的,加上别人共享的(说明里带上是谁共享的) */
|
|
95
|
+
function mcpChoices(user: User) {
|
|
96
|
+
return listUsableMcp(user.id).map((s: McpServer) => ({
|
|
97
|
+
id: s.id,
|
|
98
|
+
name: s.name,
|
|
99
|
+
description: s.owner === user.id ? s.description : `${getUser(s.owner)?.name ?? "别人"}共享${s.description ? ` · ${s.description}` : ""}`,
|
|
100
|
+
type: s.type,
|
|
101
|
+
...(s.owner === user.id ? {} : { shared: true }),
|
|
102
|
+
}));
|
|
103
|
+
}
|
|
104
|
+
|
|
94
105
|
/** 处理了就返回 true */
|
|
95
106
|
export async function handleExpertsApi(req: IncomingMessage, res: ServerResponse, p: string, user: User): Promise<boolean> {
|
|
96
107
|
const method = req.method ?? "GET";
|
|
@@ -99,7 +110,7 @@ export async function handleExpertsApi(req: IncomingMessage, res: ServerResponse
|
|
|
99
110
|
sendJson(res, 200, {
|
|
100
111
|
agents: Object.fromEntries(Object.entries(builtinAgentDefaults(user.id)).filter(([id]) => canUseExpert(user.id, id))),
|
|
101
112
|
skills: activeSkills(user.id).map((s) => ({ id: s.id, name: s.name, description: s.description })),
|
|
102
|
-
mcp:
|
|
113
|
+
mcp: mcpChoices(user),
|
|
103
114
|
...(await machineMcp(user).then((m) => m ? { machineMcp: m, machinePrefix: MACHINE_PREFIX } : {})),
|
|
104
115
|
});
|
|
105
116
|
return true;
|
|
@@ -124,7 +135,7 @@ export async function handleExpertsApi(req: IncomingMessage, res: ServerResponse
|
|
|
124
135
|
templates: EXPERT_TEMPLATES.map((t) => ({ id: t.id, label: t.label, expert: t.expert })),
|
|
125
136
|
access: ACCESS_LEVELS.map((id) => ({ id, label: ACCESS_LABEL[id] })),
|
|
126
137
|
skills: activeSkills(user.id).map((s) => ({ id: s.id, name: s.name, description: s.description })),
|
|
127
|
-
mcp:
|
|
138
|
+
mcp: mcpChoices(user),
|
|
128
139
|
...(await machineMcp(user).then((m) => (m ? { machineMcp: m, machinePrefix: MACHINE_PREFIX } : {}))),
|
|
129
140
|
limits: EXPERT_LIMITS,
|
|
130
141
|
});
|
|
@@ -207,8 +218,10 @@ export async function handleExpertsApi(req: IncomingMessage, res: ServerResponse
|
|
|
207
218
|
if (p === "/api/mcp" && method === "GET") {
|
|
208
219
|
const experts = availableExperts(user.id);
|
|
209
220
|
sendJson(res, 200, {
|
|
210
|
-
servers:
|
|
221
|
+
servers: listUsableMcp(user.id).map((s) => ({ ...mcpView(s, user.id), usedBy: experts.filter((e) => expertTools(user.id, e).mcp.includes(s.id)).map((e) => e.name) })),
|
|
211
222
|
limits: MCP_LIMITS,
|
|
223
|
+
// 成员不能添加 stdio(会在服务器上执行命令)
|
|
224
|
+
stdio: isAdmin(user),
|
|
212
225
|
});
|
|
213
226
|
return true;
|
|
214
227
|
}
|
|
@@ -223,6 +236,20 @@ export async function handleExpertsApi(req: IncomingMessage, res: ServerResponse
|
|
|
223
236
|
return true;
|
|
224
237
|
}
|
|
225
238
|
|
|
239
|
+
const mv = /^\/api\/mcp\/(m_[a-f0-9]+)\/values$/.exec(p);
|
|
240
|
+
if (mv && method === "PUT") {
|
|
241
|
+
const server = getMcp(mv[1]!);
|
|
242
|
+
if (!server || server.owner === user.id || !canUseMcp(user.id, server)) throw new HttpError(404, "这个 MCP 不存在");
|
|
243
|
+
const body = await readJsonBody<{ values?: unknown }>(req);
|
|
244
|
+
try {
|
|
245
|
+
setMcpUserValues(user.id, server.id, body.values ?? {});
|
|
246
|
+
} catch (err) {
|
|
247
|
+
throw bad(err);
|
|
248
|
+
}
|
|
249
|
+
sendJson(res, 200, mcpView(server, user.id));
|
|
250
|
+
return true;
|
|
251
|
+
}
|
|
252
|
+
|
|
226
253
|
const mm = /^\/api\/mcp\/(m_[a-f0-9]+)$/.exec(p);
|
|
227
254
|
if (mm) {
|
|
228
255
|
const server = getMcp(mm[1]!);
|
|
@@ -1,27 +1,32 @@
|
|
|
1
1
|
// 技能页面的接口:/api/skills。看得到的技能(自己的、公开的、指名给自己的)、安装 / 停用、变量、上传。
|
|
2
|
-
//
|
|
2
|
+
// 只有作者能改;管理员能查看、下架别人公开或分享出来的(包括没指名给他的),但看不到、删不了别人私有的。
|
|
3
3
|
import fs from "node:fs";
|
|
4
4
|
import path from "node:path";
|
|
5
5
|
import type { IncomingMessage, ServerResponse } from "node:http";
|
|
6
6
|
import { machineSkills } from "../../core/skill-runtime.js";
|
|
7
7
|
import {
|
|
8
|
+
acceptSkillUpdate,
|
|
9
|
+
allowedHosts,
|
|
8
10
|
canDelete,
|
|
9
11
|
canSee,
|
|
12
|
+
canView,
|
|
10
13
|
createSkill,
|
|
11
|
-
declaredHosts,
|
|
12
14
|
deleteSkill,
|
|
15
|
+
guardedNames,
|
|
13
16
|
getSkill,
|
|
14
17
|
installCount,
|
|
15
18
|
installSkill,
|
|
16
19
|
listAllSkills,
|
|
17
20
|
listFiles,
|
|
18
21
|
parseSkillMd,
|
|
22
|
+
pendingHosts,
|
|
19
23
|
prepareUpload,
|
|
20
24
|
readSkillFile,
|
|
21
25
|
readSkillMd,
|
|
22
26
|
setSkillEnabled,
|
|
23
27
|
setSkillVars,
|
|
24
28
|
SKILL_LIMITS,
|
|
29
|
+
updatePending,
|
|
25
30
|
updateSkill,
|
|
26
31
|
userPrefs,
|
|
27
32
|
type Skill,
|
|
@@ -34,6 +39,15 @@ import { HttpError, readJsonBody, sendJson } from "./http.js";
|
|
|
34
39
|
function view(s: Skill, user: User) {
|
|
35
40
|
const prefs = userPrefs(user.id);
|
|
36
41
|
const mine = s.owner === user.id;
|
|
42
|
+
const installed = mine || prefs.installed.includes(s.id);
|
|
43
|
+
// 受保护的密钥:这个技能能发往哪些地址(用户确认过、技能还声明着的),哪些是作者新加、还没确认的
|
|
44
|
+
const hosts: Record<string, { allowed: string[]; pending: string[] }> = {};
|
|
45
|
+
if (installed) {
|
|
46
|
+
for (const v of s.vars) {
|
|
47
|
+
if (!v.secret || !v.hosts?.length) continue;
|
|
48
|
+
hosts[v.name] = { allowed: allowedHosts(prefs, [s], v.name), pending: pendingHosts(prefs, s, v.name) };
|
|
49
|
+
}
|
|
50
|
+
}
|
|
37
51
|
return {
|
|
38
52
|
id: s.id,
|
|
39
53
|
name: s.name,
|
|
@@ -45,38 +59,30 @@ function view(s: Skill, user: User) {
|
|
|
45
59
|
// 分享给了谁只有作者看得到
|
|
46
60
|
...(mine ? { sharedWith: s.sharedWith, installs: installCount(s.id) } : {}),
|
|
47
61
|
vars: s.vars,
|
|
62
|
+
hosts,
|
|
48
63
|
source: s.source,
|
|
49
64
|
createdAt: s.createdAt,
|
|
50
65
|
updatedAt: s.updatedAt,
|
|
51
|
-
installed
|
|
66
|
+
installed,
|
|
67
|
+
// 管理员能看到没指名给他的分享(为了审查、下架),但装不了
|
|
68
|
+
canInstall: !mine && canSee(user, s),
|
|
69
|
+
// 作者改了内容,确认新版之前不加载
|
|
70
|
+
updatePending: updatePending(user.id, s, prefs),
|
|
52
71
|
enabled: !prefs.disabled.includes(s.id),
|
|
53
72
|
canDelete: canDelete({ id: user.id, role: user.role }, s),
|
|
54
73
|
};
|
|
55
74
|
}
|
|
56
75
|
|
|
57
76
|
/**
|
|
58
|
-
*
|
|
59
|
-
*
|
|
77
|
+
* 变量:值按名字存;密钥(任何一个看得到的技能把它标成密钥,或者按受保护密钥填的)不回显,只说填没填。
|
|
78
|
+
* 受保护的密钥能发往哪些地址按技能分开,在各技能的 hosts 里。
|
|
60
79
|
*/
|
|
61
80
|
function varsView(user: User, skills: Skill[]) {
|
|
62
|
-
const secret = new Set(skills.flatMap((s) => s.vars.filter((v) => v.secret).map((v) => v.name)));
|
|
81
|
+
const secret = new Set([...skills.flatMap((s) => s.vars.filter((v) => v.secret).map((v) => v.name)), ...guardedNames(user.id)]);
|
|
82
|
+
const guarded = guardedNames(user.id);
|
|
63
83
|
const prefs = userPrefs(user.id);
|
|
64
|
-
const mineOrInstalled = skills.filter((s) => s.owner === user.id || prefs.installed.includes(s.id));
|
|
65
84
|
return Object.fromEntries(
|
|
66
|
-
Object.entries(prefs.vars).map(([k, v]) => {
|
|
67
|
-
const declared = declaredHosts(mineOrInstalled, k);
|
|
68
|
-
const approved = prefs.approved[k] ?? [];
|
|
69
|
-
const pending = declared.filter((h) => !approved.includes(h));
|
|
70
|
-
return [
|
|
71
|
-
k,
|
|
72
|
-
{
|
|
73
|
-
set: true,
|
|
74
|
-
...(secret.has(k) ? {} : { value: v }),
|
|
75
|
-
...(declared.length ? { hosts: approved } : {}),
|
|
76
|
-
...(pending.length ? { pending } : {}),
|
|
77
|
-
},
|
|
78
|
-
];
|
|
79
|
-
}),
|
|
85
|
+
Object.entries(prefs.vars).map(([k, v]) => [k, { set: true, ...(secret.has(k) ? {} : { value: v }), ...(guarded.has(k) ? { guarded: true } : {}) }]),
|
|
80
86
|
);
|
|
81
87
|
}
|
|
82
88
|
|
|
@@ -105,7 +111,7 @@ export async function handleSkillsApi(req: IncomingMessage, res: ServerResponse,
|
|
|
105
111
|
const viewer = { id: user.id, role: user.role };
|
|
106
112
|
|
|
107
113
|
if (p === "/api/skills" && method === "GET") {
|
|
108
|
-
const visible = listAllSkills().filter((s) =>
|
|
114
|
+
const visible = listAllSkills().filter((s) => canView(viewer, s));
|
|
109
115
|
sendJson(res, 200, {
|
|
110
116
|
skills: visible.map((s) => view(s, user)),
|
|
111
117
|
vars: varsView(user, visible),
|
|
@@ -135,13 +141,13 @@ export async function handleSkillsApi(req: IncomingMessage, res: ServerResponse,
|
|
|
135
141
|
}
|
|
136
142
|
|
|
137
143
|
if (p === "/api/skills/vars" && method === "PUT") {
|
|
138
|
-
const body = await readJsonBody<{ values?: Record<string, unknown>; approve?: unknown }>(req);
|
|
144
|
+
const body = await readJsonBody<{ values?: Record<string, unknown>; approve?: unknown; skill?: unknown }>(req);
|
|
139
145
|
try {
|
|
140
|
-
setSkillVars(user.id, body.values ?? {}, Array.isArray(body.approve) ? body.approve.map(String) : []);
|
|
146
|
+
setSkillVars(user.id, body.values ?? {}, Array.isArray(body.approve) ? body.approve.map(String) : [], typeof body.skill === "string" ? body.skill : undefined);
|
|
141
147
|
} catch (err) {
|
|
142
148
|
throw bad(err);
|
|
143
149
|
}
|
|
144
|
-
sendJson(res, 200, { vars: varsView(user, listAllSkills().filter((s) =>
|
|
150
|
+
sendJson(res, 200, { vars: varsView(user, listAllSkills().filter((s) => canView(viewer, s))) });
|
|
145
151
|
return true;
|
|
146
152
|
}
|
|
147
153
|
|
|
@@ -159,10 +165,10 @@ export async function handleSkillsApi(req: IncomingMessage, res: ServerResponse,
|
|
|
159
165
|
return true;
|
|
160
166
|
}
|
|
161
167
|
|
|
162
|
-
const m = /^\/api\/skills\/(s_[a-f0-9]+)(?:\/(install|enable|file))?$/.exec(p);
|
|
168
|
+
const m = /^\/api\/skills\/(s_[a-f0-9]+)(?:\/(install|enable|file|accept))?$/.exec(p);
|
|
163
169
|
if (!m) return false;
|
|
164
170
|
const skill = getSkill(m[1]!);
|
|
165
|
-
if (!skill || !
|
|
171
|
+
if (!skill || !canView(viewer, skill)) throw new HttpError(404, "这个技能不存在");
|
|
166
172
|
|
|
167
173
|
if (!m[2] && method === "GET") {
|
|
168
174
|
const md = parseSkillMd(readSkillMd(skill.id));
|
|
@@ -187,6 +193,15 @@ export async function handleSkillsApi(req: IncomingMessage, res: ServerResponse,
|
|
|
187
193
|
sendJson(res, 200, view(skill, user));
|
|
188
194
|
return true;
|
|
189
195
|
}
|
|
196
|
+
if (m[2] === "accept" && method === "POST") {
|
|
197
|
+
try {
|
|
198
|
+
acceptSkillUpdate(user.id, skill.id);
|
|
199
|
+
} catch (err) {
|
|
200
|
+
throw bad(err);
|
|
201
|
+
}
|
|
202
|
+
sendJson(res, 200, view(skill, user));
|
|
203
|
+
return true;
|
|
204
|
+
}
|
|
190
205
|
if (m[2] === "enable" && method === "POST") {
|
|
191
206
|
const body = await readJsonBody<{ on?: boolean }>(req);
|
|
192
207
|
setSkillEnabled(user.id, skill.id, body.on !== false);
|
|
@@ -3,7 +3,7 @@ import path from "node:path";
|
|
|
3
3
|
import { EventEmitter } from "node:events";
|
|
4
4
|
import { dataDir, readJson, writeJsonAtomic } from "../home.js";
|
|
5
5
|
import { ENGINES, resolveMcp, type Engine } from "./experts.js";
|
|
6
|
-
import { getMcp, isMachineId, machineName } from "./mcp.js";
|
|
6
|
+
import { canUseMcp, getMcp, isMachineId, machineName } from "./mcp.js";
|
|
7
7
|
import { activeSkills } from "./skills.js";
|
|
8
8
|
import { sessionSkills } from "./skill-runtime.js";
|
|
9
9
|
import { getUser } from "./users.js";
|
|
@@ -64,7 +64,7 @@ export function setBuiltinAgentDefaults(owner: string, patch: unknown): Defaults
|
|
|
64
64
|
for (const id of ids ?? []) {
|
|
65
65
|
const server = getMcp(id);
|
|
66
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) : !
|
|
67
|
+
if (isMachineId(id) ? user.role !== "admin" || !name || !/^[A-Za-z0-9_-]{1,100}$/.test(name) : !canUseMcp(owner, server)) throw new Error("只能选择自己的或别人共享的 MCP(机器 MCP 仅管理员可选)");
|
|
68
68
|
if (names.has(name!)) throw new Error(`MCP 服务名重复:${name}`);
|
|
69
69
|
names.add(name!);
|
|
70
70
|
}
|
package/src/core/experts.ts
CHANGED
|
@@ -12,7 +12,7 @@ import fs from "node:fs";
|
|
|
12
12
|
import path from "node:path";
|
|
13
13
|
import { dataDir, readJson, writeJsonAtomic } from "../home.js";
|
|
14
14
|
import { resolveWorkspacePath } from "./config.js";
|
|
15
|
-
import { claudeMachineMcp, getMcp, isMachineId, machineName, specOf, type McpSpec } from "./mcp.js";
|
|
15
|
+
import { canUseMcp, claudeMachineMcp, getMcp, isMachineId, machineName, specOf, type McpSpec } from "./mcp.js";
|
|
16
16
|
import { activeSkills, canSee, getSkill } from "./skills.js";
|
|
17
17
|
import { canUseResource, getUser } from "./users.js";
|
|
18
18
|
|
|
@@ -205,11 +205,18 @@ export function canUseExpert(owner: string | undefined, id: string): boolean {
|
|
|
205
205
|
return e.shared === true && !!creator && !creator.disabled && canUseResource(user, "experts", id);
|
|
206
206
|
}
|
|
207
207
|
|
|
208
|
-
/**
|
|
208
|
+
/**
|
|
209
|
+
* 发布者沿用专家原有的工具选择。其他人自己配过就用自己的;没配过就沿用发布者选的里面他也能用的:
|
|
210
|
+
* 他自己启用着的技能(装了发布者共享的技能才算),发布者共享出来的 MCP(调用前会问,密钥用他自己的)。
|
|
211
|
+
* 发布者私有的 MCP、机器上的 MCP 不会带给别人。
|
|
212
|
+
*/
|
|
209
213
|
export function expertTools(owner: string, expert: Expert): ExpertTools {
|
|
210
214
|
if (!canUseExpert(owner, expert.id)) throw new Error("这个专家不存在或已取消共享");
|
|
211
215
|
if (expert.owner === owner) return { skills: expert.skills, mcp: expert.mcp };
|
|
212
|
-
|
|
216
|
+
const own = readJson<PersonalTools>(toolsPath, {})[owner]?.[expert.id];
|
|
217
|
+
if (own) return own;
|
|
218
|
+
const active = new Set(activeSkills(owner).map((s) => s.id));
|
|
219
|
+
return { skills: expert.skills.filter((id) => active.has(id)), mcp: expert.mcp.filter((id) => !isMachineId(id) && canUseMcp(owner, id)) };
|
|
213
220
|
}
|
|
214
221
|
|
|
215
222
|
export function setExpertTools(owner: string, id: string, input: unknown): ExpertTools {
|
|
@@ -229,7 +236,7 @@ export function setExpertTools(owner: string, id: string, input: unknown): Exper
|
|
|
229
236
|
for (const id of next.mcp) {
|
|
230
237
|
const server = getMcp(id);
|
|
231
238
|
const name = isMachineId(id) ? machineName(id) : server?.name;
|
|
232
|
-
if (isMachineId(id) ? !admin || !name || !/^[A-Za-z0-9_-]{1,100}$/.test(name) : !
|
|
239
|
+
if (isMachineId(id) ? !admin || !name || !/^[A-Za-z0-9_-]{1,100}$/.test(name) : !canUseMcp(owner, server)) throw new Error("只能选择自己的或别人共享的 MCP(机器 MCP 仅管理员可选)");
|
|
233
240
|
if (names.has(name!)) throw new Error(`MCP 服务名重复:${name}`);
|
|
234
241
|
names.add(name!);
|
|
235
242
|
}
|
|
@@ -309,8 +316,8 @@ function validate(owner: string, input: ExpertInput, prev?: Expert, selfId?: str
|
|
|
309
316
|
return !!s && canSee({ id: owner }, s);
|
|
310
317
|
});
|
|
311
318
|
|
|
312
|
-
// MCP
|
|
313
|
-
const mcp = ids(pick("mcp")).filter((id) => (isMachineId(id) ? admin && machineName(id).length > 0 :
|
|
319
|
+
// MCP:自己的和别人共享的;机器上的只有管理员能选
|
|
320
|
+
const mcp = ids(pick("mcp")).filter((id) => (isMachineId(id) ? admin && machineName(id).length > 0 : canUseMcp(owner, id)));
|
|
314
321
|
|
|
315
322
|
// 子智能体:自己的 Claude 专家,权限不能比自己高,不能是自己
|
|
316
323
|
const subRaw = engine === "claude" ? ids(pick("subagents")) : [];
|
|
@@ -473,10 +480,12 @@ export function resolveMcp(expert: Pick<Expert, "owner" | "engine" | "mcp">, adm
|
|
|
473
480
|
else if (claudeMachine[name]) mcp[name] = claudeMachine[name]!;
|
|
474
481
|
continue;
|
|
475
482
|
}
|
|
483
|
+
// expert.owner 在这里是用这个专家的人(见 expertRuntime)
|
|
476
484
|
const s = getMcp(id);
|
|
477
|
-
if (!s ||
|
|
478
|
-
mcp[s.name] = specOf(s);
|
|
479
|
-
|
|
485
|
+
if (!s || !canUseMcp(expert.owner, s)) continue;
|
|
486
|
+
mcp[s.name] = specOf(s, expert.owner);
|
|
487
|
+
// 别人共享的:调用前一律先问
|
|
488
|
+
if (s.ask || s.owner !== expert.owner) ask.push(s.name);
|
|
480
489
|
}
|
|
481
490
|
return { mcp, ask, machine };
|
|
482
491
|
}
|
package/src/core/hub.ts
CHANGED
|
@@ -364,7 +364,7 @@ class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd]; "p
|
|
|
364
364
|
this.dropIfStale(key);
|
|
365
365
|
}
|
|
366
366
|
});
|
|
367
|
-
mcpEvents.on("changed", (
|
|
367
|
+
mcpEvents.on("changed", (users) => this.personalChanged(new Set(users)));
|
|
368
368
|
builtinAgentEvents.on("changed", (owner) => this.personalChanged(new Set([owner])));
|
|
369
369
|
// workspaceRoot 改了:store 会把没显式 /cd 过的会话目录重置,正在跑的旧目录会话要作废
|
|
370
370
|
onConfigChange((next, prev) => {
|
package/src/core/mcp.ts
CHANGED
|
@@ -6,6 +6,13 @@
|
|
|
6
6
|
// 环境变量和请求头可以标成密钥:网页上不回显,只说填没填。值只交给 MCP 进程 / 请求头,不进 agent 的提示词。
|
|
7
7
|
// 和技能一样是「信任型」的:能执行命令的专家读得到 data/ 下的文件,包括这里的值。
|
|
8
8
|
//
|
|
9
|
+
// stdio 会在服务器上直接执行命令,不受专家权限(只联网、只读……)的约束,所以只有管理员能添加;
|
|
10
|
+
// 成员以前建的 stdio 不再启动(可以删)。
|
|
11
|
+
//
|
|
12
|
+
// 共享:作者打开 shared,其他账号就能在专家 / 内置 Agent 里选它。共享的是「定义」(命令、地址、
|
|
13
|
+
// 普通的环境变量和请求头),标成密钥的那几项每个人填自己的值(data/mcp-values.json),作者的不会给出去。
|
|
14
|
+
// 用别人共享的 MCP,调用它的工具前一律先弹授权卡。
|
|
15
|
+
//
|
|
9
16
|
// 机器上原有的 MCP(Claude 的 ~/.claude.json、Codex 的 config.toml)只给管理员选,id 写成 machine:<名字>。
|
|
10
17
|
// 内置的 Claude Code / Codex 专家按 builtin-agents.ts 的个人默认选择加载;管理员默认沿用机器配置。
|
|
11
18
|
//
|
|
@@ -17,6 +24,7 @@ import { EventEmitter } from "node:events";
|
|
|
17
24
|
import { dataDir, readJson, writeJsonAtomic } from "../home.js";
|
|
18
25
|
import { MEMORY_MCP_NAME } from "./memory-mcp.js";
|
|
19
26
|
import { SKILLS_MCP_NAME, TASKS_MCP_NAME } from "./tasks-mcp.js";
|
|
27
|
+
import { getUser, listUsers } from "./users.js";
|
|
20
28
|
|
|
21
29
|
export type McpPair = { name: string; value: string; secret: boolean };
|
|
22
30
|
|
|
@@ -34,8 +42,10 @@ export type McpServer = {
|
|
|
34
42
|
env: McpPair[];
|
|
35
43
|
/** http 的请求头 */
|
|
36
44
|
headers: McpPair[];
|
|
37
|
-
/**
|
|
45
|
+
/** 调用这个服务的工具前先弹授权卡(默认不问:是用户自己给专家挂的)。别人用共享的一律要问 */
|
|
38
46
|
ask: boolean;
|
|
47
|
+
/** 共享给所有账号:别人能选它,密钥项填自己的值 */
|
|
48
|
+
shared?: boolean;
|
|
39
49
|
createdAt: number;
|
|
40
50
|
updatedAt: number;
|
|
41
51
|
};
|
|
@@ -53,9 +63,15 @@ export const MACHINE_PREFIX = "machine:";
|
|
|
53
63
|
export const MCP_LIMITS = { perUser: 50, description: 500, command: 1000, args: 50, arg: 2000, pairs: 30, value: 4000, url: 2000 };
|
|
54
64
|
|
|
55
65
|
const storePath = path.join(dataDir, "mcp.json");
|
|
66
|
+
/** 别人共享的 MCP,每个人自己填的密钥:用户 id → MCP id → 项名 → 值 */
|
|
67
|
+
const valuesPath = path.join(dataDir, "mcp-values.json");
|
|
68
|
+
|
|
69
|
+
/** 有变化。users:受影响的人(作者;共享的就是所有人),他们用着的会话空闲下来要换上新的 */
|
|
70
|
+
export const mcpEvents = new EventEmitter<{ changed: [users: string[], id: string] }>();
|
|
56
71
|
|
|
57
|
-
|
|
58
|
-
|
|
72
|
+
function touched(s: Pick<McpServer, "owner" | "shared">, wasShared = false): string[] {
|
|
73
|
+
return s.shared || wasShared ? [...new Set([s.owner, ...listUsers().map((u) => u.id)])] : [s.owner];
|
|
74
|
+
}
|
|
59
75
|
|
|
60
76
|
let cache: McpServer[] | null = null;
|
|
61
77
|
|
|
@@ -82,6 +98,74 @@ export function getMcp(id: string): McpServer | undefined {
|
|
|
82
98
|
return load().find((s) => s.id === id);
|
|
83
99
|
}
|
|
84
100
|
|
|
101
|
+
/** 这个服务能不能启动:stdio 要作者是管理员(成员以前建的不再启动) */
|
|
102
|
+
export function runnable(s: McpServer): boolean {
|
|
103
|
+
return s.type !== "stdio" || getUser(s.owner)?.role === "admin";
|
|
104
|
+
}
|
|
105
|
+
|
|
106
|
+
/** 这个人能不能用:自己的,或者别人共享出来的(作者账号还在、没被停用) */
|
|
107
|
+
export function canUseMcp(userId: string, s: McpServer | string | undefined): boolean {
|
|
108
|
+
const server = typeof s === "string" ? getMcp(s) : s;
|
|
109
|
+
if (!server || !runnable(server)) return false;
|
|
110
|
+
if (server.owner === userId) return true;
|
|
111
|
+
const author = getUser(server.owner);
|
|
112
|
+
const user = getUser(userId);
|
|
113
|
+
return server.shared === true && !!author && !author.disabled && !!user && !user.disabled;
|
|
114
|
+
}
|
|
115
|
+
|
|
116
|
+
/** 这个人能选的:自己的在前,别人共享的在后 */
|
|
117
|
+
export function listUsableMcp(userId: string): McpServer[] {
|
|
118
|
+
const others = load()
|
|
119
|
+
.filter((s) => s.owner !== userId && canUseMcp(userId, s))
|
|
120
|
+
.sort((a, b) => a.name.localeCompare(b.name));
|
|
121
|
+
return [...listMcp(userId), ...others];
|
|
122
|
+
}
|
|
123
|
+
|
|
124
|
+
function allValues(): Record<string, Record<string, Record<string, string>>> {
|
|
125
|
+
return readJson<Record<string, Record<string, Record<string, string>>>>(valuesPath, {});
|
|
126
|
+
}
|
|
127
|
+
|
|
128
|
+
/** 这个人给别人共享的 MCP 填的密钥 */
|
|
129
|
+
export function mcpUserValues(userId: string, id: string): Record<string, string> {
|
|
130
|
+
return allValues()[userId]?.[id] ?? {};
|
|
131
|
+
}
|
|
132
|
+
|
|
133
|
+
/** 填自己的密钥:只能填作者标成密钥的项;空字符串 / null = 清掉,没给的项不变 */
|
|
134
|
+
export function setMcpUserValues(userId: string, id: string, raw: unknown): void {
|
|
135
|
+
const s = getMcp(id);
|
|
136
|
+
if (!s || s.owner === userId || !canUseMcp(userId, s)) throw new Error("这个 MCP 不存在");
|
|
137
|
+
if (!raw || typeof raw !== "object" || Array.isArray(raw)) throw new Error("格式不对");
|
|
138
|
+
const secretNames = new Set([...s.env, ...s.headers].filter((p) => p.secret).map((p) => p.name));
|
|
139
|
+
const all = allValues();
|
|
140
|
+
const mine = { ...(all[userId]?.[id] ?? {}) };
|
|
141
|
+
for (const [k, v] of Object.entries(raw as Record<string, unknown>)) {
|
|
142
|
+
if (!secretNames.has(k)) throw new Error(`「${k}」不是这个 MCP 要填的密钥`);
|
|
143
|
+
if (v === null || v === undefined || v === "") delete mine[k];
|
|
144
|
+
else {
|
|
145
|
+
const value = String(v);
|
|
146
|
+
if (value.length > MCP_LIMITS.value) throw new Error(`「${k}」的值太长`);
|
|
147
|
+
mine[k] = value;
|
|
148
|
+
}
|
|
149
|
+
}
|
|
150
|
+
(all[userId] ??= {})[id] = mine;
|
|
151
|
+
writeJsonAtomic(valuesPath, all);
|
|
152
|
+
mcpEvents.emit("changed", [userId], id);
|
|
153
|
+
}
|
|
154
|
+
|
|
155
|
+
function dropValues(pred: (userId: string, id: string) => boolean): void {
|
|
156
|
+
const all = allValues();
|
|
157
|
+
let changed = false;
|
|
158
|
+
for (const [u, byId] of Object.entries(all)) {
|
|
159
|
+
for (const id of Object.keys(byId)) {
|
|
160
|
+
if (!pred(u, id)) continue;
|
|
161
|
+
delete byId[id];
|
|
162
|
+
changed = true;
|
|
163
|
+
}
|
|
164
|
+
if (!Object.keys(byId).length) delete all[u];
|
|
165
|
+
}
|
|
166
|
+
if (changed) writeJsonAtomic(valuesPath, all);
|
|
167
|
+
}
|
|
168
|
+
|
|
85
169
|
export type McpInput = {
|
|
86
170
|
name?: unknown;
|
|
87
171
|
description?: unknown;
|
|
@@ -92,6 +176,7 @@ export type McpInput = {
|
|
|
92
176
|
env?: unknown;
|
|
93
177
|
headers?: unknown;
|
|
94
178
|
ask?: unknown;
|
|
179
|
+
shared?: unknown;
|
|
95
180
|
};
|
|
96
181
|
|
|
97
182
|
const str = (v: unknown, max: number, what: string): string => {
|
|
@@ -134,7 +219,9 @@ function validate(owner: string, input: McpInput, prev?: McpServer): Omit<McpSer
|
|
|
134
219
|
if (!type) throw new Error("类型只能是 stdio 或 http");
|
|
135
220
|
const description = input.description === undefined && prev ? prev.description : str(input.description, MCP_LIMITS.description, "说明");
|
|
136
221
|
const ask = input.ask === undefined && prev ? prev.ask : input.ask === true;
|
|
222
|
+
const shared = input.shared === undefined && prev ? prev.shared === true : input.shared === true;
|
|
137
223
|
if (type === "stdio") {
|
|
224
|
+
if (getUser(owner)?.role !== "admin") throw new Error("本机进程(stdio)会在服务器上直接执行命令,只有管理员能添加或修改;可以改用 HTTP 地址");
|
|
138
225
|
const command = input.command === undefined && prev?.command ? prev.command : str(input.command, MCP_LIMITS.command, "命令");
|
|
139
226
|
if (!command) throw new Error("stdio 要填启动命令");
|
|
140
227
|
let args = prev?.args ?? [];
|
|
@@ -144,7 +231,7 @@ function validate(owner: string, input: McpInput, prev?: McpServer): Omit<McpSer
|
|
|
144
231
|
args = input.args.map((a) => String(a ?? ""));
|
|
145
232
|
if (args.some((a) => a.length > MCP_LIMITS.arg)) throw new Error("有个参数太长");
|
|
146
233
|
}
|
|
147
|
-
return { name, description, type, command, args, env: cleanPairs(input.env, prev?.env ?? [], "环境变量"), headers: [], ask };
|
|
234
|
+
return { name, description, type, command, args, env: cleanPairs(input.env, prev?.env ?? [], "环境变量"), headers: [], ask, shared };
|
|
148
235
|
}
|
|
149
236
|
const url = input.url === undefined && prev?.url ? prev.url : str(input.url, MCP_LIMITS.url, "地址");
|
|
150
237
|
let parsed: URL;
|
|
@@ -154,7 +241,7 @@ function validate(owner: string, input: McpInput, prev?: McpServer): Omit<McpSer
|
|
|
154
241
|
throw new Error("地址不对:要写完整的 http:// 或 https:// 地址");
|
|
155
242
|
}
|
|
156
243
|
if (parsed.protocol !== "http:" && parsed.protocol !== "https:") throw new Error("地址只能是 http:// 或 https://");
|
|
157
|
-
return { name, description, type, url, env: [], headers: cleanPairs(input.headers, prev?.headers ?? [], "请求头"), ask };
|
|
244
|
+
return { name, description, type, url, env: [], headers: cleanPairs(input.headers, prev?.headers ?? [], "请求头"), ask, shared };
|
|
158
245
|
}
|
|
159
246
|
|
|
160
247
|
export function createMcp(owner: string, input: McpInput): McpServer {
|
|
@@ -163,7 +250,7 @@ export function createMcp(owner: string, input: McpInput): McpServer {
|
|
|
163
250
|
const server: McpServer = { id: `m_${crypto.randomBytes(6).toString("hex")}`, owner, ...validate(owner, input), createdAt: now, updatedAt: now };
|
|
164
251
|
load().push(server);
|
|
165
252
|
save();
|
|
166
|
-
mcpEvents.emit("changed",
|
|
253
|
+
mcpEvents.emit("changed", touched(server), server.id);
|
|
167
254
|
return server;
|
|
168
255
|
}
|
|
169
256
|
|
|
@@ -175,7 +262,9 @@ export function updateMcp(owner: string, id: string, input: McpInput): McpServer
|
|
|
175
262
|
const next: McpServer = { ...prev, ...validate(owner, input, prev), updatedAt: Date.now() };
|
|
176
263
|
list[idx] = next;
|
|
177
264
|
save();
|
|
178
|
-
|
|
265
|
+
// 取消共享:别人填的密钥也删掉
|
|
266
|
+
if (prev.shared && !next.shared) dropValues((_u, x) => x === id);
|
|
267
|
+
mcpEvents.emit("changed", touched(next, prev.shared), id);
|
|
179
268
|
return next;
|
|
180
269
|
}
|
|
181
270
|
|
|
@@ -183,22 +272,29 @@ export function deleteMcp(owner: string, id: string): void {
|
|
|
183
272
|
const list = load();
|
|
184
273
|
const idx = list.findIndex((s) => s.id === id && s.owner === owner);
|
|
185
274
|
if (idx < 0) throw new Error("这个 MCP 不存在");
|
|
186
|
-
list.splice(idx, 1);
|
|
275
|
+
const [gone] = list.splice(idx, 1);
|
|
187
276
|
save();
|
|
188
|
-
|
|
277
|
+
dropValues((_u, x) => x === id);
|
|
278
|
+
mcpEvents.emit("changed", touched(gone!), id);
|
|
189
279
|
}
|
|
190
280
|
|
|
191
281
|
export function purgeUserMcp(owner: string): void {
|
|
192
282
|
const list = load();
|
|
193
|
-
const
|
|
194
|
-
|
|
195
|
-
|
|
283
|
+
const mine = list.filter((s) => s.owner === owner);
|
|
284
|
+
const ids = new Set(mine.map((s) => s.id));
|
|
285
|
+
dropValues((u, id) => u === owner || ids.has(id));
|
|
286
|
+
if (!mine.length) return;
|
|
287
|
+
cache = list.filter((s) => s.owner !== owner);
|
|
196
288
|
save();
|
|
289
|
+
if (mine.some((s) => s.shared)) mcpEvents.emit("changed", touched({ owner, shared: true }), mine[0]!.id);
|
|
197
290
|
}
|
|
198
291
|
|
|
199
|
-
/**
|
|
200
|
-
export function mcpView(s: McpServer) {
|
|
201
|
-
const
|
|
292
|
+
/** 网页上看的样子:密钥不回显。viewer 不是作者时,密钥项说的是他自己填没填 */
|
|
293
|
+
export function mcpView(s: McpServer, viewer: string = s.owner) {
|
|
294
|
+
const mine = viewer === s.owner;
|
|
295
|
+
const own = mine ? {} : mcpUserValues(viewer, s.id);
|
|
296
|
+
const pairs = (list: McpPair[]) =>
|
|
297
|
+
list.map((p) => (p.secret ? { name: p.name, secret: true, set: mine ? p.value !== "" : !!own[p.name] } : { name: p.name, value: p.value, secret: false }));
|
|
202
298
|
return {
|
|
203
299
|
id: s.id,
|
|
204
300
|
name: s.name,
|
|
@@ -206,15 +302,22 @@ export function mcpView(s: McpServer) {
|
|
|
206
302
|
type: s.type,
|
|
207
303
|
...(s.type === "stdio" ? { command: s.command ?? "", args: s.args ?? [], env: pairs(s.env) } : { url: s.url ?? "", headers: pairs(s.headers) }),
|
|
208
304
|
ask: s.ask,
|
|
305
|
+
shared: s.shared === true,
|
|
306
|
+
mine,
|
|
307
|
+
...(mine ? {} : { ownerName: getUser(s.owner)?.name ?? "(已删除的用户)" }),
|
|
308
|
+
runnable: runnable(s),
|
|
209
309
|
createdAt: s.createdAt,
|
|
210
310
|
updatedAt: s.updatedAt,
|
|
211
311
|
};
|
|
212
312
|
}
|
|
213
313
|
|
|
214
|
-
|
|
314
|
+
/** 交给 agent 的启动参数。user 不是作者(用的是共享的):密钥项换成他自己填的,没填就不带 */
|
|
315
|
+
export function specOf(s: McpServer, user: string = s.owner): McpSpec {
|
|
316
|
+
const own = user === s.owner ? undefined : mcpUserValues(user, s.id);
|
|
317
|
+
const value = (p: McpPair) => (own && p.secret ? (own[p.name] ?? "") : p.value);
|
|
215
318
|
return s.type === "stdio"
|
|
216
|
-
? { type: "stdio", command: s.command ?? "", args: s.args ?? [], env: Object.fromEntries(s.env.map((p) => [p.name, p
|
|
217
|
-
: { type: "http", url: s.url ?? "", headers: Object.fromEntries(s.headers.filter((p) => p
|
|
319
|
+
? { type: "stdio", command: s.command ?? "", args: s.args ?? [], env: Object.fromEntries(s.env.filter((p) => !own || !p.secret || value(p) !== "").map((p) => [p.name, value(p)])) }
|
|
320
|
+
: { type: "http", url: s.url ?? "", headers: Object.fromEntries(s.headers.filter((p) => value(p) !== "").map((p) => [p.name, value(p)])) };
|
|
218
321
|
}
|
|
219
322
|
|
|
220
323
|
// ---------- 机器上原有的 ----------
|