agent-loft 0.2.64 → 0.2.66

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.
@@ -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,
@@ -7,7 +7,7 @@
7
7
  // 更不能被当成对挂着的提问的回答。
8
8
  import crypto from "node:crypto";
9
9
  import { resolveWorkspacePath } from "./config.js";
10
- import { getExpert } from "./experts.js";
10
+ import { canUseExpert, getExpert } from "./experts.js";
11
11
  import { hub, type TaskTurnEnd } from "./hub.js";
12
12
  import { interactions } from "./interactions.js";
13
13
  import { memoryOwnerOf } from "./personal.js";
@@ -50,8 +50,8 @@ type Resolved = { key: string } | { pause: string } | { error: string };
50
50
 
51
51
  /** 这次该发到哪条对话;专用对话还没有(或者被删了)就新建一条 */
52
52
  function resolveConv(task: Task): Resolved {
53
- const missingExpert = (id: string | undefined) => !!id && getExpert(id)?.owner !== task.owner;
54
- const deletedExpert = { pause: "任务用的专家已经删除了,任务已暂停。编辑任务换一个专家再启用。" };
53
+ const missingExpert = (id: string | undefined) => !!id && !canUseExpert(task.owner, id);
54
+ const deletedExpert = { pause: "任务用的专家已经删除或取消共享了,任务已暂停。编辑任务换一个专家再启用。" };
55
55
  if (task.target.kind === "conv") {
56
56
  const conv = getConversation(task.target.key);
57
57
  if (!conv || conv.hidden) return { pause: "回复的那条对话已经被删除,任务已暂停。可以改成「专用对话」后再启用。" };
package/src/core/tasks.ts CHANGED
@@ -157,7 +157,7 @@ function cleanPrompt(v: unknown): string {
157
157
  return p;
158
158
  }
159
159
 
160
- /** 选的专家 → 引擎 + 自定义专家 id。只能选内置的或自己的 */
160
+ /** 选的专家 → 引擎 + 自定义专家 id。可选内置、自己的或共享的专家 */
161
161
  function cleanExpert(owner: string, v: unknown): { agent: string; expert?: string } {
162
162
  const id = str(v) || "claude";
163
163
  if (!canUseExpert(owner, id)) throw new Error("这个专家不存在");
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
- * 不给就是内置专家 —— agent 原装的样子(原装提示词、机器上的技能和 MCP、所有工具)。
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 的路径 */
@@ -600,3 +600,8 @@
600
600
  grid-template-columns: 1fr 1fr;
601
601
  }
602
602
  }
603
+ .builtin-agent-defaults + .builtin-agent-defaults {
604
+ border-top: 1px solid var(--border);
605
+ padding-top: 16px;
606
+ margin-top: 16px;
607
+ }
package/web/lib/ws.js CHANGED
@@ -11,6 +11,7 @@ import { setBusy } from "../views/composer.js";
11
11
  import { SH, shownHere } from "./shell.js";
12
12
  import { currentPushSub } from "./push.js";
13
13
  import { renderScheduled } from "../views/schedule.js";
14
+ import { reloadExperts } from "../views/experts.js";
14
15
 
15
16
  // ---------- WebSocket ----------
16
17
 
@@ -281,6 +282,9 @@ function onWsMessage(msg) {
281
282
  // 自己的终端开了 / 关了,或者远程控制的权限、设置变了:重新问一下(views/layout.js)
282
283
  document.dispatchEvent(new Event("aim:remote"));
283
284
  return;
285
+ case "experts":
286
+ void reloadExperts();
287
+ return;
284
288
  case "skills":
285
289
  // 技能变了:设置里的技能页开着就重新拉,@ 补全的缓存作废
286
290
  document.dispatchEvent(new Event("aim:skills"));
@@ -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 });
@@ -20,6 +20,8 @@ const PERMS = [
20
20
  { id: "exec", label: "跑命令", hint: "执行命令,等于能改任何文件;需要授权时会弹卡" },
21
21
  ];
22
22
  const FILE_LEVELS = ["read", "edit", "exec"];
23
+ let refreshExpertsPage = () => {};
24
+ document.addEventListener("aim:experts", () => refreshExpertsPage());
23
25
 
24
26
  export async function expertsTab(panel) {
25
27
  const box = h("div", { class: "experts-page" }, h("span", { class: "spinner" }));
@@ -35,6 +37,7 @@ export async function expertsTab(panel) {
35
37
  if (!box.isConnected) return;
36
38
  render(box, data, load);
37
39
  };
40
+ refreshExpertsPage = () => { if (box.isConnected) void load(); };
38
41
  await load();
39
42
  }
40
43
 
@@ -48,7 +51,7 @@ function render(box, data, reload) {
48
51
  h(
49
52
  "p",
50
53
  { class: "skill-note" },
51
- "专家是一份配置:用哪个引擎、什么提示词、能做什么(联网 / 读文件 / 改文件 / 跑命令)、带哪些技能和 MCP、能把活派给哪些子智能体。新建对话、定时任务时选一个专家,对话从头到尾都是它。内置的 Claude Code、Codex 就是原装的样子。",
54
+ "专家决定引擎、提示词和能力。共享给所有账号后,设定由创建者维护,每个人的记忆、技能和 MCP 仍各自独立;点「我的工具」选择自己要用的工具。内置的 Claude Code、Codex 在「设置 → Agent」里选择默认技能和 MCP。",
52
55
  ),
53
56
  h("div", { class: "skill-head-btns" }, add),
54
57
  ),
@@ -60,7 +63,7 @@ function render(box, data, reload) {
60
63
  "div",
61
64
  { class: "task-card skill-card" },
62
65
  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} 原装的样子:原装提示词、机器上的技能和 MCP(成员只有自己的技能)、所有工具。`),
66
+ h("div", { class: "task-prompt" }, `${b.name} 原装的样子:原装提示词、所有工具;默认技能和 MCP 在「设置 → Agent」里配置。`),
64
67
  ),
65
68
  ),
66
69
  data.experts.map((e) => expertCard(data, e, reload)),
@@ -70,14 +73,15 @@ function render(box, data, reload) {
70
73
  }
71
74
 
72
75
  function expertCard(data, e, reload) {
76
+ const editable = e.editable !== false;
77
+ const open = () => editable ? openEditor(data, e, reload) : viewSharedExpert(e);
73
78
  const access = data.access.find((a) => a.id === e.access)?.label ?? e.access;
74
79
  const more = h("button", { class: "icon-btn", title: "更多" }, icon("more"));
75
80
  more.onclick = () =>
76
81
  showMenu(more, [
77
- { label: "编辑…", onclick: () => openEditor(data, e, reload) },
78
- { label: "复制一份…", onclick: () => openEditor(data, null, reload, { ...e, name: `${e.name} 副本` }) },
79
- "sep",
80
- { label: "删除", danger: true, onclick: () => removeExpert(e, reload) },
82
+ { label: editable ? "编辑…" : "查看设定…", onclick: open },
83
+ { label: "复制一份…", onclick: () => openEditor(data, null, reload, { ...e, shared: false, subagents: editable ? e.subagents : [], name: `${e.name} 副本` }) },
84
+ ...(editable ? ["sep", { label: "删除", danger: true, onclick: () => removeExpert(e, reload) }] : []),
81
85
  ]);
82
86
  const extras = [
83
87
  e.skills.length ? `${e.skills.length} 个技能` : null,
@@ -91,7 +95,9 @@ function expertCard(data, e, reload) {
91
95
  h(
92
96
  "div",
93
97
  { class: "task-top" },
94
- h("button", { class: "task-title skill-name", title: "编辑", onclick: () => openEditor(data, e, reload) }, expertIcon(e, "expert-card-icon"), e.name),
98
+ h("button", { class: "task-title skill-name", title: editable ? "编辑" : "查看设定", onclick: open }, expertIcon(e, "expert-card-icon"), e.name),
99
+ e.shared ? h("span", { class: "badge" }, editable ? "已共享" : "共享") : null,
100
+ e.shared ? h("button", { class: "btn", onclick: () => openTools(data, e, reload) }, "我的工具") : null,
95
101
  more,
96
102
  ),
97
103
  h("div", { class: "task-meta" }, h("span", {}, ENGINE_LABEL[e.engine]), h("span", {}, access), e.model ? h("span", {}, e.model) : null, extras.map((x) => h("span", {}, x))),
@@ -99,6 +105,40 @@ function expertCard(data, e, reload) {
99
105
  );
100
106
  }
101
107
 
108
+ function viewSharedExpert(e) {
109
+ const prompt = h("textarea", { rows: 12, readonly: true, "aria-label": "提示词" });
110
+ prompt.value = e.prompt;
111
+ modal({ title: e.name, wide: true, body: h("div", { class: "modal-body" },
112
+ h("p", { class: "muted" }, "这是共享专家,设定由创建者维护。你的记忆和工具独立,工具可在「我的工具」里配置。"),
113
+ field("说明", h("p", {}, e.description || "暂无说明")),
114
+ field("引擎", h("p", {}, ENGINE_LABEL[e.engine])),
115
+ field("提示词", prompt),
116
+ ) });
117
+ }
118
+
119
+ function openTools(data, e, reload) {
120
+ const skills = checkList(data.skills.map((s) => ({ id: s.id, label: s.name, hint: s.description })), e.skills, "还没有启用的技能(设置 → 技能)");
121
+ const machine = (data.machineMcp?.[e.engine] ?? []).map((name) => ({ id: `${data.machinePrefix}${name}`, label: `${name}(本机)` }));
122
+ const mcp = checkList([...data.mcp.map((s) => ({ id: s.id, label: s.name, hint: s.description })), ...machine], e.mcp, "还没有 MCP(设置 → MCP)");
123
+ const save = h("button", { class: "btn primary" }, "保存我的工具");
124
+ const close = modal({ title: `${e.name} · 我的工具`, body: h("div", { class: "modal-body" },
125
+ h("p", { class: "muted" }, "只影响你使用这个专家时加载的工具,网页和绑定账号后的飞书私聊共用。未选择时不加载技能或 MCP;记忆使用你自己的设置。子智能体的工具需在对应专家中单独配置。"),
126
+ field("我的技能", skills.el), field("我的 MCP", mcp.el),
127
+ ), foot: h("div", { class: "modal-foot" }, save) });
128
+ save.onclick = async () => {
129
+ save.disabled = true;
130
+ try {
131
+ await api(`/api/experts/${e.id}/tools`, { method: "PUT", body: { skills: skills.value(), mcp: mcp.value() } });
132
+ close();
133
+ toast("已保存,你的对话下一条消息起使用新的工具");
134
+ void reload();
135
+ } catch (err) {
136
+ save.disabled = false;
137
+ toast(err.message);
138
+ }
139
+ };
140
+ }
141
+
102
142
  async function removeExpert(e, reload) {
103
143
  const sure = await confirmDialog({
104
144
  title: `删除专家「${e.name}」?`,
@@ -170,6 +210,7 @@ function openEditor(data, e, reload, preset) {
170
210
  },
171
211
  });
172
212
  const memory = h("input", { type: "checkbox", checked: src.memory !== false });
213
+ const shared = h("input", { type: "checkbox", checked: src.shared === true });
173
214
  const welcome = h("input", { value: src.welcome ?? "", maxlength: "500", placeholder: "新对话页上的那句话,比如:想了解哪只股票?" });
174
215
  const quick = h("textarea", { rows: 4, placeholder: "一行一个,新对话页上点一下就填进输入框。可以写成「标题|提示词」,提示词里的 ___ 是要用户填的空" });
175
216
  quick.value = (src.quickPrompts ?? []).map((q) => (q.title && q.title !== q.prompt.slice(0, 20) ? `${q.title}|${q.prompt}` : q.prompt)).join("\n");
@@ -196,7 +237,7 @@ function openEditor(data, e, reload, preset) {
196
237
  const keepSubs = subs.value();
197
238
  // 子智能体只有 Claude:自己的 Claude 专家,不能是自己
198
239
  subs = checkList(
199
- data.experts.filter((x) => x.engine === "claude" && x.id !== e?.id).map((x) => ({ id: x.id, label: !x.avatar && x.icon ? `${x.icon} ${x.name}` : x.name, hint: x.description })),
240
+ data.experts.filter((x) => x.editable !== false && x.engine === "claude" && x.id !== e?.id).map((x) => ({ id: x.id, label: !x.avatar && x.icon ? `${x.icon} ${x.name}` : x.name, hint: x.description })),
200
241
  keepSubs,
201
242
  "还没有别的 Claude 专家可以当子智能体",
202
243
  );
@@ -218,15 +259,16 @@ function openEditor(data, e, reload, preset) {
218
259
  { class: "modal-body task-form expert-form" },
219
260
  h("div", { class: "row-fields avatar-row" }, field("头像", avatar.el), field("名字", name)),
220
261
  field("说明", desc),
262
+ field("共享", h("label", { class: "check-item" }, shared, h("span", {}, "共享给所有账号")), "其他账号可在网页、飞书私聊和定时任务中使用;只有你能修改设定。取消共享后,其他人的旧对话保留但不能继续调用。子智能体也需要先共享。"),
221
263
  h("div", { class: "row-fields" }, field("引擎", engine, e ? "建好后不能换" : null), field("模型", models.model), field("思考程度", models.effort)),
222
264
  field("提示词", prompt, "agent-loft 会在后面自动补上:这个专家能做什么、不能做什么,今天的日期,记忆"),
223
265
  baseField,
224
266
  field("权限", perms.el, "改文件包含读文件,跑命令包含改文件。什么都不勾就是只能聊天"),
225
267
  cwdField,
226
- field("技能", skills.el, "只给选中的技能;没选就不挂技能(省 token)"),
227
- field("MCP", mcpBox, "选中的 MCP 的工具直接可用(MCP 设了「调用前询问」的会弹授权)"),
268
+ field("我的技能", skills.el, "只影响你的工具选择;共享后其他账号单独选择自己的技能"),
269
+ field("我的 MCP", mcpBox, "只使用你的 MCP;共享后不会把你的 MCP 或凭据交给其他账号"),
228
270
  subField,
229
- field("记忆", h("label", { class: "check-item" }, memory, h("span", {}, "带上我的个人记忆(设置 → 记忆)"))),
271
+ field("记忆", h("label", { class: "check-item" }, memory, h("span", {}, "使用聊天者自己的个人记忆(需在设置 → 记忆开启)"))),
230
272
  field("欢迎语", welcome),
231
273
  field("快捷提问", quick),
232
274
  );
@@ -246,6 +288,7 @@ function openEditor(data, e, reload, preset) {
246
288
  });
247
289
  const payload = {
248
290
  name: name.value,
291
+ shared: shared.checked,
249
292
  ...avatar.payload(),
250
293
  description: desc.value,
251
294
  engine: engine.value,
@@ -9,7 +9,17 @@ import { field, markDirty, saveButton, saveConfig } from "./common.js";
9
9
  * 设置 → 飞书:机器人、谁能用(配对请求、已配对的人)、指令面板同步,都是飞书这一侧的事,放在一页。
10
10
  * 每个机器人一张表单各自保存;存了一个,其它机器人没保存的改动原样留着(表单按机器人缓存,不重建)。
11
11
  */
12
- export function feishuTab(cfg, page) {
12
+ export async function feishuTab(cfg, page) {
13
+ let shared;
14
+ try {
15
+ shared = (await api("/api/experts/brief")).experts.filter((e) => e.shared);
16
+ } catch (err) {
17
+ page.append(h("div", { class: "error-text" }, `无法加载共享专家:${err.message}`));
18
+ return;
19
+ }
20
+ const choices = [...S.agents.map((a) => ({ id: a.id, label: a.label, engine: a.id })), ...shared.map((e) => ({ id: e.id, label: `${e.name}(共享)`, engine: e.engine }))];
21
+ // 复选框各有自己的 label,外层使用分组,避免把第一项关联到整组说明。
22
+ const expertField = (content, hint) => h("div", { class: "field", role: "group", "aria-label": "可用专家" }, h("span", {}, "可用专家"), content, h("small", {}, hint));
13
23
  /** 已经存进配置的机器人(以服务端为准) + 手动添加、还没保存的 */
14
24
  let saved = structuredClone(cfg.feishu.bots);
15
25
  let drafts = [];
@@ -42,7 +52,7 @@ export function feishuTab(cfg, page) {
42
52
  "div",
43
53
  { class: "section" },
44
54
  h("h4", {}, "飞书机器人"),
45
- h("div", { class: "muted" }, "一个机器人可以对应一个 agent,也可以在会话里用 /agent 切换。扫码创建会自动建好飞书应用;Lark 国际版请用「手动添加」,填开发者后台里的 App ID 和 App Secret。"),
55
+ h("div", { class: "muted" }, "勾选这个机器人可用的内置或共享专家,并选择默认专家。共享专家在每个人绑定账号后的私聊中使用各自的记忆和工具。扫码创建会自动建好飞书应用;Lark 国际版请用「手动添加」。"),
46
56
  h(
47
57
  "div",
48
58
  { class: "row" },
@@ -79,11 +89,21 @@ export function feishuTab(cfg, page) {
79
89
  const allow = h("textarea", { rows: 2, placeholder: "ou_xxx,一行一个" });
80
90
  allow.value = b.allowFrom.join("\n");
81
91
  const enabled = h("input", { type: "checkbox", checked: b.enabled });
82
- const agentChecks = S.agents.map((a) => {
83
- const box = h("input", { type: "checkbox", checked: b.agents.includes(a.id), value: a.id });
84
- return { id: a.id, box, el: h("label", { class: "check" }, box, a.label) };
92
+ const selected = b.experts ?? b.agents;
93
+ const missing = selected.filter((id) => !choices.some((e) => e.id === id)).map((id) => ({ id, label: `${id}(已删除或未共享,请取消勾选)` }));
94
+ const expertChecks = [...choices, ...missing].map((e) => {
95
+ const box = h("input", { type: "checkbox", checked: selected.includes(e.id), value: e.id });
96
+ return { id: e.id, box, el: h("label", { class: "check" }, box, e.label) };
85
97
  });
86
- const def = h("select", {}, S.agents.map((a) => h("option", { value: a.id, selected: a.id === b.defaultAgent }, a.label)));
98
+ const def = h("select", { "aria-label": "默认专家" });
99
+ const syncDefault = () => {
100
+ const preferred = def.value || b.defaultExpert || b.defaultAgent;
101
+ const enabled = choices.filter((e) => expertChecks.some((c) => c.id === e.id && c.box.checked));
102
+ fill(def, enabled.map((e) => h("option", { value: e.id }, e.label)));
103
+ if (enabled.some((e) => e.id === preferred)) def.value = preferred;
104
+ };
105
+ for (const c of expertChecks) c.box.addEventListener("change", syncDefault);
106
+ syncDefault();
87
107
  const status = h("span", { class: "status-tag" }, b.enabled ? "…" : "未启用");
88
108
  if (!isDraft) statusTags.set(b.id, status);
89
109
  const collect = () => {
@@ -96,14 +116,16 @@ export function feishuTab(cfg, page) {
96
116
  domain: domain.value,
97
117
  allowFrom: allow.value.split(/[\s,]+/).filter(Boolean),
98
118
  enabled: enabled.checked,
99
- agents: agentChecks.filter((c) => c.box.checked).map((c) => c.id),
100
- defaultAgent: def.value,
119
+ experts: expertChecks.filter((c) => c.box.checked).map((c) => c.id),
120
+ defaultExpert: def.value,
121
+ agents: [...new Set(choices.filter((e) => expertChecks.some((c) => c.id === e.id && c.box.checked)).map((e) => e.engine))],
122
+ defaultAgent: choices.find((e) => e.id === def.value)?.engine ?? b.defaultAgent,
101
123
  };
102
124
  };
103
125
  const save = async () => {
104
126
  const v = collect();
105
- if (!v.agents.length) {
106
- toast("至少勾选一个 agent");
127
+ if (!v.experts.length) {
128
+ toast("至少勾选一个专家");
107
129
  return false;
108
130
  }
109
131
  // 只存这一个:其它机器人按服务端现在的样子原样带上,别的草稿不跟着存
@@ -125,8 +147,8 @@ export function feishuTab(cfg, page) {
125
147
  field("名称", name),
126
148
  h("div", { class: "row" }, h("div", { style: { flex: 1 } }, field("App ID", appId)), h("div", { style: { flex: 1 } }, field("App Secret", secret))),
127
149
  field("域名", domain),
128
- field("可用的 Agent", h("div", { class: "row" }, agentChecks.map((c) => c.el)), "勾一个 = 一个机器人对应一个 agent;勾多个可在会话里用 /agent 切换"),
129
- field("默认 Agent", def),
150
+ expertField(h("div", { class: "row" }, expertChecks.map((c) => c.el)), "只勾一个共享专家即可专用;无需再勾选底层 Agent。勾多个可用 /expert 切换。保存后按这里的名单限制可选专家"),
151
+ field("默认专家", def, "新聊天和绑定账号后使用;已有聊天在当前专家仍可用时继续使用原专家"),
130
152
  field("Owner 白名单(open_id)", allow, "陌生人发消息会拿到配对码,在下面「配对请求」里批准即可,不必手填"),
131
153
  h(
132
154
  "div",
@@ -174,22 +196,24 @@ export function feishuTab(cfg, page) {
174
196
 
175
197
  const registerBot = async () => {
176
198
  const nameInput = h("input", { value: "Agent 助手" });
177
- const checks = S.agents.filter((a) => a.enabled).map((a) => ({ id: a.id, box: h("input", { type: "checkbox", checked: true }), label: a.label }));
199
+ const checks = choices.map((e) => ({ id: e.id, box: h("input", { type: "checkbox", checked: false }), label: e.label }));
178
200
  const body = h(
179
201
  "div",
180
202
  { class: "modal-body" },
181
203
  h("div", { class: "muted" }, "用飞书扫码,会自动创建一个飞书应用(机器人),并把扫码的你设为 owner。"),
182
204
  field("机器人名称", nameInput),
183
- field("可用的 Agent", h("div", { class: "row" }, checks.map((c) => h("label", { class: "check" }, c.box, c.label)))),
205
+ expertField(h("div", { class: "row" }, checks.map((c) => h("label", { class: "check" }, c.box, c.label))), "可直接选择共享专家;选多个时默认使用第一个,创建后可以再调整默认专家"),
184
206
  );
185
207
  const go = h("button", { class: "btn primary" }, "生成二维码");
186
208
  const closeReg = modal({ title: "扫码创建飞书机器人", body, foot: h("div", { class: "modal-foot" }, go) });
187
209
  go.onclick = async () => {
210
+ const selected = checks.filter((c) => c.box.checked).map((c) => c.id);
211
+ if (!selected.length) return toast("至少勾选一个专家");
188
212
  go.disabled = true;
189
213
  try {
190
214
  const reg = await api("/api/feishu/register", {
191
215
  method: "POST",
192
- body: { name: nameInput.value, agents: checks.filter((c) => c.box.checked).map((c) => c.id) },
216
+ body: { name: nameInput.value, experts: selected, defaultExpert: selected[0] },
193
217
  });
194
218
  const state = h("div", { class: "muted", style: { textAlign: "center" } }, "等待扫码确认…");
195
219
  fill(
@@ -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
  {
@@ -14,7 +14,7 @@ function usableEngines() {
14
14
  return (usable.length ? usable : enabled).map((a) => a.id);
15
15
  }
16
16
 
17
- /** 能选的专家:内置的在前,再是自己的(引擎能用的) */
17
+ /** 能选的专家:内置的在前,再是自己的和共享的(引擎能用的) */
18
18
  export function expertChoices() {
19
19
  const engines = usableEngines();
20
20
  return [