agent-loft 0.2.107 → 0.2.109

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/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "agent-loft",
3
- "version": "0.2.107",
3
+ "version": "0.2.109",
4
4
  "type": "module",
5
5
  "description": "多个 agent 的工作台:把本机 Claude Code / Codex 放到一处统一管理,用飞书和 Web 页面随时驱动——会话、审批、模型切换都共用",
6
6
  "keywords": [
@@ -32,7 +32,7 @@ import type { AttachmentInfo, SavedAttachment } from "../../core/types.js";
32
32
  import { dailyUsage } from "../../core/usage.js";
33
33
  import { localUsage } from "../../core/local-usage.js";
34
34
  import { builtinAgentDefaults } from "../../core/builtin-agents.js";
35
- import { appendDirOrder, getDirOrder, getSidebarNav, setDirOrder, setSidebarNav } from "../../core/ui-prefs.js";
35
+ import { appendDirOrder, getDirOrder, getExpertOrder, getSidebarNav, setDirOrder, setSidebarNav } from "../../core/ui-prefs.js";
36
36
  import {
37
37
  addMemoryItem,
38
38
  clearMemory,
@@ -93,7 +93,7 @@ import {
93
93
  takeAttempt,
94
94
  } from "./auth.js";
95
95
  import { canSeeConv, pushOwnedBy, sessionVisibleTo } from "./access.js";
96
- import { clampLimit, dirsOf, inDir, inRecent, pageOf, parseCursor, searchConvs } from "./conv-pages.js";
96
+ import { clampLimit, dirsOf, inDir, pageOf, parseCursor, recentPageOf, searchConvs } from "./conv-pages.js";
97
97
  import { clientIp, cookies, HttpError, isHttps, readBody, readJsonBody, SECURITY_HEADERS, sendJson, setServerTiming } from "./http.js";
98
98
  import { handleTasksApi } from "./tasks-api.js";
99
99
  import { handleLibraryApi } from "./library-api.js";
@@ -665,12 +665,12 @@ export async function handleApi(req: IncomingMessage, res: ServerResponse, url:
665
665
 
666
666
  // ----- 总览 -----
667
667
  if (p === "/api/bootstrap" && method === "GET") {
668
- // 会话只给侧栏第一屏要的(见 conv-pages.ts):「最近」的前 recent 棵树、展开着的目录各自的前几棵,
668
+ // 会话只给侧栏第一屏要的(见 conv-pages.ts):「最近」的前 recent 条、展开着的目录各自的前几棵树,
669
669
  // 每个 IM 分组最近的一条(微信另含当前会话),再加上正在跑的、等你处理的。其余展开后分页拉取。
670
670
  const startedAt = performance.now();
671
671
  const all = hub.list(visible).filter((c) => !c.hidden);
672
672
  const pending = interactions.listPending().filter((i) => visible(getConversation(i.convKey)));
673
- const recent = pageOf(all.filter(inRecent), null, clampLimit(url.searchParams.get("recent"), 10));
673
+ const recent = recentPageOf(all, null, clampLimit(url.searchParams.get("recent"), 5));
674
674
  let open: [string, number][] = [];
675
675
  try {
676
676
  const raw: unknown = JSON.parse(url.searchParams.get("open") ?? "[]");
@@ -734,6 +734,7 @@ export async function handleApi(req: IncomingMessage, res: ServerResponse, url:
734
734
  bots: admin ? config().feishu.bots.map((b) => ({ id: b.id, name: b.name, agents: b.agents, enabled: b.enabled })) : [],
735
735
  // 自己的和共享的专家(新对话、定时任务里选)。内置的 Claude Code / Codex 就是上面的 agents
736
736
  experts: availableExperts(user.id).map(expertBrief),
737
+ expertOrder: getExpertOrder(user.id),
737
738
  workspaceRoot: config().workspaceRoot,
738
739
  quotaRefreshMin: config().web.quotaRefreshMin,
739
740
  quotaEnabled: config().web.quotaEnabled,
@@ -900,7 +901,7 @@ export async function handleApi(req: IncomingMessage, res: ServerResponse, url:
900
901
  }
901
902
 
902
903
  // ----- 会话 -----
903
- // 侧栏按页拉:recent / dir / bot / weixin 按树分页。
904
+ // 侧栏按页拉:recent 逐条分页,dir / bot / weixin 按树分页。
904
905
  if (p === "/api/conversations/page" && method === "GET") {
905
906
  const all = hub.list(visible).filter((c) => !c.hidden);
906
907
  const scope = url.searchParams.get("scope");
@@ -921,9 +922,10 @@ export async function handleApi(req: IncomingMessage, res: ServerResponse, url:
921
922
  return;
922
923
  }
923
924
  if (scope !== "recent" && scope !== "dir") throw new HttpError(400, "scope 只能是 recent / dir / bot / weixin");
924
- const list = scope === "recent" ? all.filter(inRecent) : all.filter(inDir(url.searchParams.get("dir") ?? ""));
925
+ const list = scope === "recent" ? all : all.filter(inDir(url.searchParams.get("dir") ?? ""));
925
926
  const before = parseCursor(url.searchParams.get("at"), url.searchParams.get("key"));
926
- sendJson(res, 200, pageOf(list, before, clampLimit(url.searchParams.get("limit"), 10)));
927
+ const paginate = scope === "recent" ? recentPageOf : pageOf;
928
+ sendJson(res, 200, paginate(list, before, clampLimit(url.searchParams.get("limit"), scope === "recent" ? 5 : 10)));
927
929
  return;
928
930
  }
929
931
  // 搜索会话(侧栏「搜索」弹窗):标题、目录名,再搜聊天内容(聊天记录索引,见 chat-history.ts)。
@@ -1,16 +1,17 @@
1
1
  // 侧栏会话列表分页:打开页面只拿第一页,点「展开显示」再按页拉。
2
2
  //
3
- // 一页按「树」算:主对话连同从它分叉出来的对话算一条(和前端 sidebar.js 的 forkForest 一样),
3
+ // 项目和 IM 一页按「树」算:主对话连同从它分叉出来的对话算一条(和前端 sidebar.js 的 forkForest 一样),
4
4
  // 按整棵树里最近的活跃时间从新到旧排。翻页用游标(上一页最后一棵树的活跃时间 + 根的 key),
5
5
  // 期间有会话变活跃、被删,也不会漏掉或重复一页的边界。
6
+ // 「最近」逐条按各自的活跃时间分页。
6
7
  import type { ConversationInfo } from "../../core/hub.js";
7
8
 
8
9
  export type Cursor = { at: number; key: string };
9
10
  export type Page = { conversations: ConversationInfo[]; next: Cursor | null };
10
11
  type Tree = { root: ConversationInfo; convs: ConversationInfo[]; at: number };
11
12
 
12
- /** 最近:飞书、微信以外的会话(IM 渠道在侧栏单独分组) */
13
- export const inRecent = (c: ConversationInfo): boolean => c.channel !== "feishu" && c.channel !== "weixin";
13
+ /** 最近:所有 Web 会话(IM 渠道在侧栏单独分组) */
14
+ export const inRecent = (c: ConversationInfo): boolean => c.channel === "web";
14
15
  /** 项目:Web 会话按工作目录分组 */
15
16
  export const inDir = (dir: string) => (c: ConversationInfo): boolean => c.channel === "web" && c.cwd === dir;
16
17
 
@@ -50,6 +51,15 @@ export function pageOf(list: ConversationInfo[], before: Cursor | null, limit: n
50
51
  };
51
52
  }
52
53
 
54
+ /** 最近逐条分页,分叉独立按自己的活跃时间排序。 */
55
+ export function recentPageOf(list: ConversationInfo[], before: Cursor | null, limit: number): Page {
56
+ const sorted = list.filter(inRecent).sort((a, b) => b.activeAt - a.activeAt || (a.key < b.key ? 1 : -1));
57
+ const remaining = before ? sorted.filter((c) => c.activeAt < before.at || (c.activeAt === before.at && c.key < before.key)) : sorted;
58
+ const conversations = remaining.slice(0, limit);
59
+ const last = conversations.at(-1);
60
+ return { conversations, next: last && remaining.length > conversations.length ? { at: last.activeAt, key: last.key } : null };
61
+ }
62
+
53
63
  /** 项目目录:每个目录最近的活跃时间(目录行本身要全部显示,会话再按需拉) */
54
64
  export function dirsOf(list: ConversationInfo[]): { dir: string; at: number }[] {
55
65
  const at = new Map<string, number>();
@@ -27,6 +27,7 @@ import { shellInfo } from "../../core/servers.js";
27
27
  import { canUseMcp, claudeMachineMcp, createMcp, deleteMcp, getMcp, listUsableMcp, MACHINE_PREFIX, MCP_LIMITS, mcpView, setMcpUserValues, updateMcp, type McpInput, type McpServer } from "../../core/mcp.js";
28
28
  import { activeSkills } from "../../core/skills.js";
29
29
  import { getUser, isAdmin, type User } from "../../core/users.js";
30
+ import { getExpertOrder, setExpertOrder } from "../../core/ui-prefs.js";
30
31
  import { HttpError, readJsonBody, sendJson } from "./http.js";
31
32
 
32
33
  const bad = (err: unknown) => (err instanceof HttpError ? err : new HttpError(400, err instanceof Error ? err.message : String(err)));
@@ -130,6 +131,7 @@ export async function handleExpertsApi(req: IncomingMessage, res: ServerResponse
130
131
  if (p === "/api/experts" && method === "GET") {
131
132
  const enabled = hub.enabledAgents().map((d) => d.id);
132
133
  sendJson(res, 200, {
134
+ expertOrder: getExpertOrder(user.id),
133
135
  experts: availableExperts(user.id).map((e) => expertView(e, user.id)),
134
136
  builtin: enabled.filter((id) => canUseExpert(user.id, id)).map((id) => ({ id, name: hub.label(id), engine: id })),
135
137
  // 能建自定义专家的引擎(WorkBuddy、pi 只有内置专家)
@@ -146,6 +148,7 @@ export async function handleExpertsApi(req: IncomingMessage, res: ServerResponse
146
148
 
147
149
  if (p === "/api/experts/brief" && method === "GET") {
148
150
  sendJson(res, 200, {
151
+ expertOrder: getExpertOrder(user.id),
149
152
  experts: availableExperts(user.id).map(expertBrief),
150
153
  builtin: hub.enabledAgents().filter((d) => canUseExpert(user.id, d.id)).map((d) => d.id),
151
154
  user: { id: user.id, name: user.name, role: user.role },
@@ -154,6 +157,16 @@ export async function handleExpertsApi(req: IncomingMessage, res: ServerResponse
154
157
  return true;
155
158
  }
156
159
 
160
+ if (p === "/api/experts/order" && method === "PUT") {
161
+ const body = await readJsonBody<{ order?: unknown }>(req);
162
+ try {
163
+ sendJson(res, 200, { order: setExpertOrder(user.id, body.order) });
164
+ } catch (err) {
165
+ throw bad(err);
166
+ }
167
+ return true;
168
+ }
169
+
157
170
  if (p === "/api/experts" && method === "POST") {
158
171
  const body = await readJsonBody<ExpertInput>(req, 1024 * 1024);
159
172
  try {
package/src/core/hub.ts CHANGED
@@ -117,7 +117,16 @@ export type ConvEvent =
117
117
  * fresh:这一轮不带之前的上下文,发出去之前先换新会话(专用对话,换了就不回头)。
118
118
  * isolated:同样不带上下文,但这条对话还有人在聊:借一个临时会话跑,跑完换回聊天的会话。
119
119
  */
120
- export type TaskTurn = { taskId: string; runId: string; title: string; smart: boolean; fresh?: boolean; isolated?: boolean };
120
+ export type TaskTurn = {
121
+ taskId: string;
122
+ runId: string;
123
+ title: string;
124
+ smart: boolean;
125
+ fresh?: boolean;
126
+ isolated?: boolean;
127
+ /** 专用对话:模型 / 思考程度以任务为准(空 = 默认),每次运行前对齐一遍 */
128
+ runtime?: { model?: string; effort?: string };
129
+ };
121
130
 
122
131
  /** 每条对话最多接着显示这么多条旧会话:每次打开对话都要全读一遍,不能无限长 */
123
132
  const PAST_SESSIONS_KEPT = 50;
@@ -1261,6 +1270,10 @@ class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd]; "p
1261
1270
  if (waiting.cancelled) return;
1262
1271
  if (cancelled()) return gone("没有发出(停止了或者会话被切换了)");
1263
1272
  }
1273
+ if (task?.runtime && !this.isBusy(key) && (await this.applyTaskRuntime(key, task.runtime))) {
1274
+ if (waiting.cancelled) return;
1275
+ if (cancelled()) return gone("没有发出(停止了或者会话被切换了)");
1276
+ }
1264
1277
  if (task?.isolated) {
1265
1278
  if (this.isBusy(key)) return gone("对话正在回复,这次没有运行");
1266
1279
  await this.drop(key, "定时任务开始独立运行");
@@ -1705,6 +1718,21 @@ class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd]; "p
1705
1718
  * 定时任务的专用对话:级别以任务为准(到点时、改了任务、任务不再用这条对话时调)。
1706
1719
  * 返回封顶后实际生效的级别。
1707
1720
  */
1721
+ /**
1722
+ * 专用对话的模型 / 思考程度对齐到任务的设置(编辑任务时改了,下次运行生效)。
1723
+ * 变了的话关掉活着的进程,下一轮按新设置接着原会话拉起。返回有没有改
1724
+ */
1725
+ private async applyTaskRuntime(key: string, rt: { model?: string; effort?: string }): Promise<boolean> {
1726
+ const conv = getConversation(key);
1727
+ if (!conv) return false;
1728
+ const binding = agentBinding(conv);
1729
+ if ((binding.model || undefined) === rt.model && (binding.effort || undefined) === rt.effort) return false;
1730
+ updateAgentBinding(key, conv.agent, { model: rt.model, effort: rt.effort });
1731
+ if (this.live.has(key)) await this.drop(key, "定时任务换了模型");
1732
+ this.emitEvent(key, { type: "meta" });
1733
+ return true;
1734
+ }
1735
+
1708
1736
  applyTaskPermission(key: string, level: PermissionLevel | undefined): PermissionLevel | undefined {
1709
1737
  const conv = getConversation(key);
1710
1738
  if (!conv) return undefined;
@@ -1721,7 +1749,7 @@ class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd]; "p
1721
1749
  "- `/permission edit`:自动改文件",
1722
1750
  ...(engineSupports(conv.agent, "auto") ? ["- `/permission auto`:自动判断(Claude 逐个判断安不安全,拿不准再问你)"] : []),
1723
1751
  "- `/permission full`:完全允许",
1724
- "- `/permission default`:恢复默认(设置 → Agent 里定的默认权限)",
1752
+ "- `/permission default`:恢复默认(设置 → 专家 → 内置 Agent 的「设置」里定的默认权限)",
1725
1753
  "- `/planmode on` / `/planmode off`:开关计划模式(先出方案,你批准了再动手)",
1726
1754
  "",
1727
1755
  `这条对话最高能到「${PERMISSION_LABEL[this.permissionMax(conv)]}」。`,
@@ -151,6 +151,7 @@ function fire(task: Task, manual: boolean, now = Date.now()): string | undefined
151
151
  const fresh = !!task.freshContext;
152
152
  // 专用对话直接换新会话;发到已有对话的还有人在聊,借临时会话跑,跑完换回去
153
153
  const contextTag = !fresh ? {} : task.target.kind === "dedicated" ? { fresh } : { isolated: true };
154
+ const runtime = task.target.kind === "dedicated" ? { runtime: { ...(task.model ? { model: task.model } : {}), ...(task.effort ? { effort: task.effort } : {}) } } : {};
154
155
  const run = pushRun(task, { id: runId(), at: now, status: "running", convKey: key, ...(note ? { note } : {}) });
155
156
  running.set(task.id, { runId: run.id, key, at: now });
156
157
  console.log(`[定时任务] ${task.id}「${task.title}」${manual ? "手动运行" : "到点运行"},发到 ${key}`);
@@ -159,7 +160,7 @@ function fire(task: Task, manual: boolean, now = Date.now()): string | undefined
159
160
  { text: taskMessage(task, { now, manual, version: RUNNING_VERSION, fresh }), attachments: [] },
160
161
  { channel: "task", channelId: task.id, name: `定时任务「${task.title}」` },
161
162
  undefined,
162
- { task: { taskId: task.id, runId: run.id, title: task.title, smart: task.notify === "smart", ...contextTag } },
163
+ { task: { taskId: task.id, runId: run.id, title: task.title, smart: task.notify === "smart", ...contextTag, ...runtime } },
163
164
  );
164
165
  return undefined;
165
166
  }
@@ -5,7 +5,7 @@ import { dataDir, readJson, writeJsonAtomic } from "../home.js";
5
5
 
6
6
  export type SidebarNavItem = { id: string; visible: boolean };
7
7
  const NAV_IDS = ["search", "tasks", "library", "remote", "settings"];
8
- type Prefs = { dirOrder?: string[]; sidebarNav?: SidebarNavItem[] };
8
+ type Prefs = { dirOrder?: string[]; sidebarNav?: SidebarNavItem[]; expertOrder?: string[] };
9
9
 
10
10
  const prefsPath = path.join(dataDir, "ui-prefs.json");
11
11
  let cache: Record<string, Prefs> | null = null;
@@ -49,7 +49,8 @@ export function appendDirOrder(userId: string, dirs: unknown): string[] {
49
49
  const cur = all[userId]?.dirOrder ?? [];
50
50
  const add = cleanDirs(dirs).filter((d) => !cur.includes(d));
51
51
  if (add.length === 0 && all[userId]?.dirOrder) return cur;
52
- const dirOrder = [...cur, ...add].slice(0, MAX_DIRS);
52
+ // 「最近」首次出现时默认置顶;已有位置时保留用户排序。
53
+ const dirOrder = [...add.filter((id) => id === "recent"), ...cur, ...add.filter((id) => id !== "recent")].slice(0, MAX_DIRS);
53
54
  all[userId] = { ...all[userId], dirOrder };
54
55
  save();
55
56
  return dirOrder;
@@ -80,6 +81,20 @@ export function setSidebarNav(userId: string, value: unknown): SidebarNavItem[]
80
81
  return sidebarNav;
81
82
  }
82
83
 
84
+ /** 内置、自建和共享专家的混合顺序,只影响当前账号的展示。 */
85
+ export function getExpertOrder(userId: string): string[] {
86
+ return load()[userId]?.expertOrder ?? [];
87
+ }
88
+
89
+ export function setExpertOrder(userId: string, value: unknown): string[] {
90
+ if (!Array.isArray(value) || value.length > 2000 || value.some((id) => typeof id !== "string" || !id || id.length > 100)) throw new Error("专家顺序必须是专家 ID 列表");
91
+ const expertOrder = [...new Set(value as string[])];
92
+ const all = load();
93
+ all[userId] = { ...all[userId], expertOrder };
94
+ save();
95
+ return expertOrder;
96
+ }
97
+
83
98
  export function deleteUiPrefs(userId: string): void {
84
99
  const all = load();
85
100
  if (!(userId in all)) return;
@@ -23,6 +23,39 @@
23
23
  min-width: 0;
24
24
  }
25
25
 
26
+ .expert-sort-card {
27
+ position: relative;
28
+ padding-left: 44px;
29
+ }
30
+
31
+ .expert-sort-card.dragging {
32
+ opacity: 0.55;
33
+ outline: 1px solid var(--border);
34
+ }
35
+
36
+ .expert-sort-grip {
37
+ position: absolute;
38
+ top: 10px;
39
+ left: 6px;
40
+ width: 30px;
41
+ height: 34px;
42
+ color: var(--fg-faint);
43
+ cursor: grab;
44
+ touch-action: none;
45
+ user-select: none;
46
+ border-radius: 6px;
47
+ }
48
+
49
+ .expert-sort-grip:hover,
50
+ .expert-sort-grip:focus-visible {
51
+ color: var(--fg);
52
+ background: var(--bg-hover);
53
+ }
54
+
55
+ .expert-sort-grip:active {
56
+ cursor: grabbing;
57
+ }
58
+
26
59
  .tool-check-item > input,
27
60
  .perm-list > .check-item > input {
28
61
  flex-shrink: 0;
@@ -692,9 +692,19 @@ body:has(.settings) > :is(.overlay, .menu) {
692
692
  min-width: 0;
693
693
  }
694
694
 
695
- .agent-config + .builtin-agent-defaults {
696
- border-top: 1px solid var(--border);
697
- padding-top: 14px;
695
+ /* 内置 Agent 默认设置弹窗:模型 + 思考程度一行 */
696
+ .builtin-agent-defaults .row-fields {
697
+ display: flex;
698
+ gap: 12px;
699
+ }
700
+
701
+ .builtin-agent-defaults .row-fields > .field {
702
+ flex: 1;
703
+ min-width: 0;
704
+ }
705
+
706
+ .builtin-agent-defaults h4 {
707
+ margin: 4px 0 0;
698
708
  }
699
709
 
700
710
  /* 记忆页:点开才读的区块(归档、回收站、改动记录、摘要) */
@@ -286,7 +286,16 @@ button.conv-group:hover {
286
286
  color: var(--fg);
287
287
  }
288
288
 
289
+ .recent-row:hover .conv-item.proj {
290
+ padding-right: 10px;
291
+ }
292
+
289
293
  @media (pointer: coarse) {
294
+ /* 触屏的新建按钮常驻,首次打开侧栏时也要为它让出状态图标的位置。 */
295
+ .proj-row[data-dir] .conv-item.proj {
296
+ padding-right: 36px;
297
+ }
298
+
290
299
  .proj-new {
291
300
  display: grid;
292
301
  }
package/web/css/tasks.css CHANGED
@@ -351,6 +351,17 @@ button.task-run:hover {
351
351
  gap: 12px;
352
352
  }
353
353
 
354
+ /* 模型 + 思考程度放一行 */
355
+ .task-form .row-fields {
356
+ display: flex;
357
+ gap: 12px;
358
+ }
359
+
360
+ .task-form .row-fields > .field {
361
+ flex: 1;
362
+ min-width: 0;
363
+ }
364
+
354
365
  /* 执行时间:选择星期和当天的时间 */
355
366
  .task-freq {
356
367
  display: flex;
@@ -0,0 +1,137 @@
1
+ import { fill, h, toast } from "../lib/dom.js";
2
+ import { api } from "../lib/api.js";
3
+ import { modal, confirmDialog } from "../lib/overlay.js";
4
+ import { isAdmin, S } from "../state.js";
5
+ import { renderContext } from "../views/topbar.js";
6
+ import { DEFAULT_LEVELS, engineSupports, PERMISSIONS } from "../lib/permission.js";
7
+ import { field, hasDirty, markDirty, saveButton, saveConfig } from "./common.js";
8
+ import { modelPicker } from "./commands.js";
9
+
10
+ // ---------- 内置 Agent 的默认设置(设置 → 专家 → 内置卡片上的「设置」) ----------
11
+ // 默认模型 / 思考程度:整台服务器的(config),只有管理员能改;
12
+ // 默认权限、默认加载的技能和 MCP:每个人自己的(/api/agents/defaults),单独保存,互不覆盖。
13
+
14
+ /** 设置里的默认权限「跟随」时实际是什么 */
15
+ const FOLLOW_LABEL = { claude: "跟随 Claude Code(逐次询问)", codex: "跟随沙箱设置", workbuddy: "跟随 WorkBuddy(逐次询问)", pi: "跟随 pi(逐次询问)" };
16
+ const DEFAULT_MODEL_LABEL = { claude: "跟随 Claude Code 默认", codex: "跟随 config.toml", workbuddy: "跟随 WorkBuddy 默认", pi: "pi 自动挑一个能用的" };
17
+
18
+ /** 技能 / MCP:「跟随」或者「指定加载」+ 勾选 */
19
+ function loadPicker(label, items, selected, inheritLabel) {
20
+ const mode = h(
21
+ "select",
22
+ { "aria-label": label },
23
+ ...(inheritLabel ? [h("option", { value: "inherit", selected: selected === null }, inheritLabel)] : []),
24
+ h("option", { value: "pick", selected: selected !== null }, "指定加载(可全部取消)"),
25
+ );
26
+ const known = new Set(items.map((item) => item.id));
27
+ const missing = (selected ?? []).filter((id) => !known.has(id)).map((id) => ({ id, name: `${id}(暂不可用,可取消)` }));
28
+ const inputs = [...items, ...missing].map((item) => ({ id: item.id, input: h("input", { type: "checkbox", checked: (selected ?? []).includes(item.id) }), item }));
29
+ const list = h(
30
+ "div",
31
+ { class: "check-list" },
32
+ inputs.length
33
+ ? inputs.map(({ input, item }) => h("label", { class: "check-item tool-check-item", title: item.description ?? item.name }, input, h("span", {}, item.name)))
34
+ : h("small", {}, "暂无可选项,请先在设置中添加"),
35
+ );
36
+ const sync = () => {
37
+ list.hidden = mode.value !== "pick";
38
+ };
39
+ mode.addEventListener("change", sync);
40
+ sync();
41
+ return {
42
+ el: h("div", { class: "field" }, h("span", {}, label), mode, list),
43
+ value: () => (mode.value === "inherit" ? null : inputs.filter((x) => x.input.checked).map((x) => x.id)),
44
+ };
45
+ }
46
+
47
+ export function openAgentDefaults(engine, label) {
48
+ const form = h("div", { class: "modal-body builtin-agent-defaults" }, h("span", { class: "spinner" }));
49
+ const foot = h("div", { class: "modal-foot" });
50
+ // 改了没保存就关:问一句(和设置页切标签一样)
51
+ const close = modal({
52
+ title: `${label} 默认设置`,
53
+ body: form,
54
+ foot,
55
+ beforeClose: () =>
56
+ !hasDirty(root.parentElement) ||
57
+ confirmDialog({ title: "有修改还没保存", message: "现在关掉,刚才改的内容不会保存。", confirmText: "不保存", danger: true }),
58
+ });
59
+ // 保存按钮在底栏、不在 body 里:整个弹窗当成一张表单
60
+ const root = form.closest(".modal");
61
+ root.dataset.form = "";
62
+ const onEdit = (e) => {
63
+ if (!e.target.closest("[data-nodirty]")) markDirty(root);
64
+ };
65
+ form.addEventListener("input", onEdit);
66
+ form.addEventListener("change", onEdit);
67
+
68
+ const load = async () => {
69
+ let data;
70
+ let cfg = null;
71
+ try {
72
+ [data, cfg] = await Promise.all([api("/api/agents/defaults"), isAdmin() ? api("/api/config") : null]);
73
+ } catch (err) {
74
+ fill(form, h("div", { class: "error-text" }, err.message), h("button", { class: "btn small", onclick: load }, "重试"));
75
+ return;
76
+ }
77
+ const prefs = data.agents[engine];
78
+ if (!prefs) {
79
+ fill(form, h("p", { class: "muted" }, `没有 ${label} 的使用权限,请联系管理员。`));
80
+ return;
81
+ }
82
+ const server = cfg?.agents?.[engine];
83
+ const pick = server ? modelPicker(engine, server.defaultModel ?? "", server.defaultEffort ?? "", DEFAULT_MODEL_LABEL[engine] ?? "跟随默认") : null;
84
+
85
+ const skills = loadPicker(`${label} 技能`, data.skills, prefs.skills, "全部已启用的个人技能(含以后新增)");
86
+ const machine = (data.machineMcp?.[engine] ?? []).map((name) => ({ id: `${data.machinePrefix}${name}`, name: `${name}(本机)` }));
87
+ const mcp = loadPicker(`${label} MCP`, [...data.mcp, ...machine], prefs.mcp, data.machineMcp ? "沿用机器上的 MCP 配置" : null);
88
+ const machineSkills = h("input", { type: "checkbox", checked: prefs.machineSkills });
89
+ // 成员最高到自动改文件;自动判断只有 Claude 有
90
+ const levels = DEFAULT_LEVELS.filter((l) => engineSupports(engine, l) && (l !== "auto" || isAdmin()));
91
+ const permission = h(
92
+ "select",
93
+ { "aria-label": `${label} 默认权限` },
94
+ h("option", { value: "", selected: !prefs.permission }, FOLLOW_LABEL[engine] ?? "跟随默认"),
95
+ levels.map((l) => h("option", { value: l, selected: l === prefs.permission }, `${PERMISSIONS[l].label}:${PERMISSIONS[l].desc}`)),
96
+ );
97
+
98
+ fill(
99
+ form,
100
+ pick
101
+ ? [
102
+ h("h4", {}, "默认模型"),
103
+ h("p", { class: "skill-note" }, "整台服务器的默认值,对所有成员生效;对话里可以随时换。自定义专家自己选了模型的按专家的来。"),
104
+ h("div", { class: "row-fields" }, field("模型", pick.modelEl), engine === "workbuddy" ? null : field("思考程度", pick.effortEl)),
105
+ ]
106
+ : null,
107
+ h("h4", {}, "默认权限"),
108
+ field(
109
+ "新对话的权限",
110
+ permission,
111
+ "没单独选过权限的对话都按这一级(输入框里的盾牌按钮可以随时改)。自定义专家也按它,但不会超过专家自己的权限;定时任务的专用对话按任务里设的。",
112
+ ),
113
+ h("h4", {}, "默认加载"),
114
+ h("p", { class: "skill-note" }, "只影响你自己的账号用这个内置 Agent 时,自定义专家用各自的配置。"),
115
+ skills.el,
116
+ data.machineMcp ? h("label", { class: "check-item" }, machineSkills, "同时加载机器上的技能") : null,
117
+ mcp.el,
118
+ h("small", {}, "技能和 MCP 可分别全部取消。记忆、定时任务、技能管理等系统工具仍按功能设置提供。"),
119
+ );
120
+ fill(
121
+ foot,
122
+ saveButton(async () => {
123
+ const res = await api("/api/agents/defaults", {
124
+ method: "PUT",
125
+ body: { agents: { [engine]: { permission: permission.value || null, skills: skills.value(), machineSkills: machineSkills.checked, mcp: mcp.value() } } },
126
+ });
127
+ S.defaultPermission = { ...S.defaultPermission, [engine]: res.agents?.[engine]?.permission ?? null };
128
+ const changed = pick && (pick.model() !== (server.defaultModel ?? "") || pick.effort() !== (server.defaultEffort ?? ""));
129
+ if (changed && !(await saveConfig(cfg, { agents: { [engine]: { defaultModel: pick.model(), defaultEffort: pick.effort() } } }))) return false;
130
+ renderContext();
131
+ toast("已保存,下次发消息生效");
132
+ close();
133
+ }, `保存 ${label} 默认设置`),
134
+ );
135
+ };
136
+ void load();
137
+ }
@@ -1,17 +1,14 @@
1
1
  import { fill, h, icon, toast } from "../lib/dom.js";
2
2
  import { api } from "../lib/api.js";
3
3
  import { copyText } from "../lib/markdown.js";
4
- import { desktopQuota, isAdmin, S } from "../state.js";
5
- import { defaultEntryName, renderContext, usableAgents } from "../views/topbar.js";
6
- import { DEFAULT_LEVELS, engineSupports, PERMISSIONS } from "../lib/permission.js";
4
+ import { desktopQuota, S } from "../state.js";
5
+ import { defaultEntryName, usableAgents } from "../views/topbar.js";
7
6
  import { renderEmpty } from "../views/messages.js";
8
7
  import { field, saveButton, saveConfig } from "./common.js";
9
8
  import { modelPicker } from "./commands.js";
10
9
 
11
10
  const ENGINE_LABEL = { claude: "Claude Code", codex: "Codex", workbuddy: "WorkBuddy", pi: "pi" };
12
11
  const ENGINES = Object.keys(ENGINE_LABEL);
13
- /** 设置里的默认权限「跟随」时实际是什么 */
14
- const FOLLOW_LABEL = { claude: "跟随 Claude Code(逐次询问)", codex: "跟随沙箱设置", workbuddy: "跟随 WorkBuddy(逐次询问)", pi: "跟随 pi(逐次询问)" };
15
12
  const WORKBUDDY_SITES = [
16
13
  ["workbuddy", "WorkBuddy(www.workbuddy.cn,用本机的 WorkBuddy 桌面版)"],
17
14
  ["internal", "CodeBuddy 国内版(copilot.tencent.com)"],
@@ -222,82 +219,8 @@ function workbuddyLoginButton(after) {
222
219
  return h("div", {}, btn, status);
223
220
  }
224
221
 
225
- /** 个人默认工具单独保存,避免改服务器配置时覆盖尚未保存的个人选择。 */
226
- function builtinDefaultsSections(targets) {
227
- const load = async () => {
228
- let data;
229
- try {
230
- data = await api("/api/agents/defaults");
231
- } catch (err) {
232
- for (const section of Object.values(targets)) fill(section, h("div", { class: "error-text" }, err.message), h("button", { class: "btn small", onclick: load }, "重试"));
233
- return;
234
- }
235
- const picker = (label, items, selected, inheritLabel) => {
236
- const mode = h("select", { "aria-label": label },
237
- ...(inheritLabel ? [h("option", { value: "inherit", selected: selected === null }, inheritLabel)] : []),
238
- h("option", { value: "pick", selected: selected !== null }, "指定加载(可全部取消)"));
239
- const known = new Set(items.map((item) => item.id));
240
- const missing = (selected ?? []).filter((id) => !known.has(id)).map((id) => ({ id, name: `${id}(暂不可用,可取消)` }));
241
- const inputs = [...items, ...missing].map((item) => ({ id: item.id, input: h("input", { type: "checkbox", checked: (selected ?? []).includes(item.id) }), item }));
242
- const list = h("div", { class: "check-list" }, inputs.length
243
- ? inputs.map(({ input, item }) => h("label", { class: "check-item tool-check-item", title: item.description ?? item.name }, input, h("span", {}, item.name)))
244
- : h("small", {}, "暂无可选项,请先在设置中添加"));
245
- const sync = () => { list.hidden = mode.value !== "pick"; };
246
- mode.addEventListener("change", sync);
247
- sync();
248
- 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) };
249
- };
250
- for (const [engine, section] of Object.entries(targets)) {
251
- const prefs = data.agents[engine];
252
- if (!prefs) {
253
- section.hidden = true;
254
- if (section.parentElement?.dataset.personal) section.parentElement.hidden = true;
255
- continue;
256
- }
257
- const label = ENGINE_LABEL[engine] ?? engine;
258
- const skills = picker(`${label} 技能`, data.skills, prefs.skills, "全部已启用的个人技能(含以后新增)");
259
- const machine = (data.machineMcp?.[engine] ?? []).map((name) => ({ id: `${data.machinePrefix}${name}`, name: `${name}(本机)` }));
260
- const mcp = picker(`${label} MCP`, [...data.mcp, ...machine], prefs.mcp, data.machineMcp ? "沿用机器上的 MCP 配置" : null);
261
- const machineSkills = h("input", { type: "checkbox", checked: prefs.machineSkills });
262
- // 成员最高到自动改文件;自动判断只有 Claude 有
263
- const levels = DEFAULT_LEVELS.filter((l) => engineSupports(engine, l) && (l !== "auto" || isAdmin()));
264
- const permission = h("select", { "aria-label": `${label} 默认权限` },
265
- h("option", { value: "", selected: !prefs.permission }, FOLLOW_LABEL[engine] ?? "跟随默认"),
266
- levels.map((l) => h("option", { value: l, selected: l === prefs.permission }, `${PERMISSIONS[l].label}:${PERMISSIONS[l].desc}`)));
267
- fill(section, h("h4", {}, "默认权限"),
268
- field("新对话的权限", permission, "没单独选过权限的对话都按这一级(输入框里的盾牌按钮可以随时改)。自定义专家也按它,但不会超过专家自己的权限;定时任务按任务里选的。「完全允许」不能设成默认。"),
269
- h("h4", {}, "默认加载"),
270
- h("p", { class: "skill-note" }, "仅影响你当前账号使用的这个内置 Agent,自定义专家使用各自的配置。保存后,下次发消息生效。"),
271
- skills.el,
272
- data.machineMcp ? h("label", { class: "check-item" }, machineSkills, "同时加载机器上的技能") : null,
273
- mcp.el,
274
- h("small", {}, "技能和 MCP 可分别全部取消。记忆、定时任务、技能管理等系统工具仍按功能设置提供。"),
275
- h("div", { class: "row" }, saveButton(async () => {
276
- const res = await api("/api/agents/defaults", { method: "PUT", body: { agents: { [engine]: { permission: permission.value || null, skills: skills.value(), machineSkills: machineSkills.checked, mcp: mcp.value() } } } });
277
- S.defaultPermission = { ...S.defaultPermission, [engine]: res.agents?.[engine]?.permission ?? null };
278
- renderContext();
279
- toast("已保存,下次发消息生效");
280
- }, `保存 ${label} 默认设置`)));
281
- }
282
- if (!Object.keys(data.agents).length) {
283
- const section = Object.values(targets)[0];
284
- section.hidden = false;
285
- section.parentElement.hidden = false;
286
- const message = h("p", { class: "muted" }, "没有获授权的内置 Agent,请联系管理员配置使用权限。");
287
- if (section.parentElement.dataset.personal) fill(section.parentElement, h("h4", {}, "内置 Agent"), message);
288
- else fill(section, message);
289
- }
290
- };
291
- void load();
292
- }
293
-
222
+ /** 设置 → Agent(管理员):运行环境、启用、引擎自己的配置、输入框可选模型。默认模型 / 权限 / 加载在「专家」里各内置 Agent 的「设置」 */
294
223
  export function agentsTab(cfg, page) {
295
- const targets = Object.fromEntries(ENGINES.map((engine) => [engine, h("div", { class: "builtin-agent-defaults", "data-form": "" }, h("span", { class: "spinner" }))]));
296
- if (!cfg) {
297
- for (const [engine, target] of Object.entries(targets)) page.append(h("div", { class: "section", "data-personal": "true", "data-agent": engine }, h("h4", {}, ENGINE_LABEL[engine]), target));
298
- builtinDefaultsSections(targets);
299
- return;
300
- }
301
224
  page.append(agentHealthSection());
302
225
  const a = structuredClone(cfg.agents);
303
226
  for (const engine of ENGINES) {
@@ -305,7 +228,6 @@ export function agentsTab(cfg, page) {
305
228
  const settings = a[engine];
306
229
  if (!settings) continue;
307
230
  const on = h("input", { type: "checkbox", checked: settings.enabled });
308
- const pick = modelPicker(engine, settings.defaultModel, settings.defaultEffort, engine === "claude" ? "跟随 Claude Code 默认" : engine === "workbuddy" ? "跟随 WorkBuddy 默认" : engine === "pi" ? "pi 自动挑一个能用的" : "跟随 config.toml");
309
231
  const models = modelChecklist(engine, settings.models ?? []);
310
232
  const config = h("div", { class: "agent-config", "data-form": "" },
311
233
  h("h4", {}, label, h("span", { class: "grow" }), h("label", { class: "check" }, on, "启用")));
@@ -345,8 +267,7 @@ export function agentsTab(cfg, page) {
345
267
  piCustomSection(),
346
268
  );
347
269
  }
348
- config.append(field("默认模型", pick.modelEl));
349
- if (engine !== "workbuddy") config.append(field("默认思考程度", pick.effortEl));
270
+ config.append(h("small", { class: "muted" }, "默认模型、思考程度、权限和默认加载的技能 / MCP,在「设置 → 专家」里这个 Agent 的「设置」中修改。"));
350
271
  config.append(h("div", { class: "field" }, h("span", {}, "输入框可选模型"), models.el));
351
272
  if (codex) config.append(h("div", { class: "row title-row" }, h("label", { class: "check" }, codex.titleOn, "自动生成会话名称"), codex.titleModel));
352
273
  config.append(h("div", { class: "row" }, saveButton(() => {
@@ -356,15 +277,14 @@ export function agentsTab(cfg, page) {
356
277
  return false;
357
278
  }
358
279
  return saveConfig(cfg, { agents: { [engine]: {
359
- enabled: on.checked, defaultModel: pick.model(), defaultEffort: pick.effort(), models: selected,
280
+ enabled: on.checked, models: selected,
360
281
  ...(site ? { environment: site.value, cliPath: cliPath.value.trim() } : {}),
361
282
  ...(codex ? { path: codex.path.value.trim() || "codex", home: codex.home.value.trim(), sandbox: codex.sandbox.value, autoTitle: codex.titleOn.checked, titleModel: codex.titlePick.model() } : {}),
362
283
  } } });
363
284
  }, `保存 ${label} 设置`)));
364
- page.append(h("div", { class: "section", "data-agent": engine }, config, targets[engine]));
285
+ page.append(h("div", { class: "section", "data-agent": engine }, config));
365
286
  }
366
287
  page.append(quotaSection(cfg));
367
- builtinDefaultsSections(targets);
368
288
  }
369
289
 
370
290
  /** 常用的排前面:国内能直接用的几家、再是 OpenRouter 和海外几家 */
@@ -1,9 +1,11 @@
1
1
  import { agentIcon, fill, h, icon, toast } from "../lib/dom.js";
2
2
  import { api } from "../lib/api.js";
3
3
  import { confirmDialog, modal, showMenu } from "../lib/overlay.js";
4
- import { S } from "../state.js";
5
- import { expertIcon, reloadExperts } from "../views/experts.js";
6
- import { agentCatalog, baseName } from "../views/topbar.js";
4
+ import { isAdmin, S } from "../state.js";
5
+ import { openAgentDefaults } from "./agent-defaults.js";
6
+ import { expertIcon, reloadExperts, sortExperts } from "../views/experts.js";
7
+ import { baseName } from "../views/topbar.js";
8
+ import { modelPicker } from "../views/model-picker.js";
7
9
  import { changeCwd } from "../views/conv-actions.js";
8
10
 
9
11
  // ---------- 专家(设置里的一页) ----------
@@ -35,6 +37,7 @@ export async function expertsTab(panel) {
35
37
  return;
36
38
  }
37
39
  if (!box.isConnected) return;
40
+ S.expertOrder = data.expertOrder ?? [];
38
41
  render(box, data, load);
39
42
  };
40
43
  refreshExpertsPage = () => { if (box.isConnected) void load(); };
@@ -43,6 +46,90 @@ export async function expertsTab(panel) {
43
46
 
44
47
  function render(box, data, reload) {
45
48
  const add = h("button", { class: "btn primary", onclick: () => openEditor(data, null, reload) }, icon("plus"), "新建");
49
+ const choices = sortExperts([...data.builtin.map((b) => ({ ...b, builtin: true })), ...data.experts], data.expertOrder ?? []);
50
+ const list = h("div", { class: "task-list expert-sort-list", role: "list", "aria-label": "专家顺序" });
51
+ const rows = new Map();
52
+ let saving = false;
53
+ const ids = () => [...list.children].map((el) => el.dataset.expert);
54
+ const restore = (order) => order.forEach((id) => list.append(rows.get(id)));
55
+ const save = async (before) => {
56
+ const order = [...ids(), ...(data.expertOrder ?? []).filter((id) => !rows.has(id))];
57
+ if (ids().join("\n") === before.join("\n")) return;
58
+ saving = true;
59
+ for (const handle of list.querySelectorAll(".expert-sort-grip")) handle.disabled = true;
60
+ try {
61
+ const next = await api("/api/experts/order", { method: "PUT", body: { order } });
62
+ data.expertOrder = next.order;
63
+ S.expertOrder = next.order;
64
+ } catch (err) {
65
+ restore(before);
66
+ toast(`保存专家顺序失败:${err.message}`);
67
+ } finally {
68
+ saving = false;
69
+ for (const handle of list.querySelectorAll(".expert-sort-grip")) handle.disabled = false;
70
+ }
71
+ };
72
+ const move = (row, to) => {
73
+ const others = [...list.children].filter((el) => el !== row);
74
+ list.insertBefore(row, others[Math.max(0, to)] ?? null);
75
+ };
76
+ for (const e of choices) {
77
+ const row = e.builtin ? h("div", { class: "task-card skill-card" },
78
+ h(
79
+ "div",
80
+ { class: "task-top" },
81
+ h("span", { class: "task-title" }, agentIcon(e.engine, "expert-card-icon"), e.name),
82
+ h("span", { class: "badge" }, "内置"),
83
+ h("button", { class: "btn", "aria-label": `${e.name} 默认设置`, onclick: () => openAgentDefaults(e.engine, e.name) }, "设置"),
84
+ ),
85
+ h("div", { class: "task-prompt" }, `${e.name} 原装的样子:原装提示词、所有工具。默认${isAdmin() ? "模型、" : ""}权限和加载的技能、MCP 在「设置」里配置。`),
86
+ ) : expertCard(data, e, reload);
87
+ row.dataset.expert = e.id;
88
+ row.setAttribute("role", "listitem");
89
+ row.classList.add("expert-sort-card");
90
+ let drag = null;
91
+ const end = (ev) => {
92
+ if (!drag) return;
93
+ const { before, pointer } = drag;
94
+ drag = null;
95
+ row.classList.remove("dragging");
96
+ if (handle.hasPointerCapture(pointer)) handle.releasePointerCapture(pointer);
97
+ if (ev.type === "pointercancel") restore(before);
98
+ else void save(before);
99
+ };
100
+ const handle = h("button", {
101
+ class: "expert-sort-grip", type: "button", title: "拖动排序,也可用上下方向键调整",
102
+ "aria-label": `调整${e.name}顺序`,
103
+ onpointerdown: (ev) => {
104
+ if (ev.button !== 0 || saving) return;
105
+ ev.preventDefault();
106
+ drag = { before: ids(), y: ev.clientY, pointer: ev.pointerId };
107
+ handle.setPointerCapture(ev.pointerId);
108
+ },
109
+ onpointermove: (ev) => {
110
+ if (!drag || Math.abs(ev.clientY - drag.y) < 4) return;
111
+ row.classList.add("dragging");
112
+ const others = [...list.children].filter((el) => el !== row);
113
+ const to = others.filter((el) => { const r = el.getBoundingClientRect(); return ev.clientY > r.top + r.height / 2; }).length;
114
+ move(row, to);
115
+ handle.setPointerCapture(ev.pointerId);
116
+ },
117
+ onpointerup: end, onpointercancel: end,
118
+ onkeydown: (ev) => {
119
+ if (saving || !["ArrowUp", "ArrowDown"].includes(ev.key)) return;
120
+ ev.preventDefault();
121
+ const before = ids();
122
+ const to = before.indexOf(e.id) + (ev.key === "ArrowUp" ? -1 : 1);
123
+ if (to < 0 || to >= before.length) return;
124
+ move(row, to);
125
+ handle.focus();
126
+ void save(before);
127
+ },
128
+ }, "⋮⋮");
129
+ row.prepend(handle);
130
+ rows.set(e.id, row);
131
+ list.append(row);
132
+ }
46
133
  fill(
47
134
  box,
48
135
  h(
@@ -51,23 +138,11 @@ function render(box, data, reload) {
51
138
  h(
52
139
  "p",
53
140
  { class: "skill-note" },
54
- "专家决定引擎、提示词和能力。共享给所有账号后,设定由创建者维护,每个人的记忆、技能和 MCP 仍各自独立;点「我的工具」选择自己要用的工具。内置的 Claude Code、Codex 在「设置 → Agent」各自卡片的「默认加载」中选择技能和 MCP。",
141
+ "拖动卡片左侧手柄调整顺序,自动保存并用于选择智能体。专家决定引擎、提示词和能力。共享给所有账号后,设定由创建者维护,每个人的记忆、技能和 MCP 仍各自独立;点「我的工具」选择自己要用的工具。内置的 Claude Code、Codex 在「设置 → Agent」各自卡片的「默认加载」中选择技能和 MCP。",
55
142
  ),
56
143
  h("div", { class: "skill-head-btns" }, add),
57
144
  ),
58
- h(
59
- "div",
60
- { class: "task-list" },
61
- data.builtin.map((b) =>
62
- h(
63
- "div",
64
- { class: "task-card skill-card" },
65
- h("div", { class: "task-top" }, h("span", { class: "task-title" }, agentIcon(b.engine, "expert-card-icon"), b.name), h("span", { class: "badge" }, "内置")),
66
- h("div", { class: "task-prompt" }, `${b.name} 原装的样子:原装提示词、所有工具;默认技能和 MCP 在「设置 → Agent」里配置。`),
67
- ),
68
- ),
69
- data.experts.map((e) => expertCard(data, e, reload)),
70
- ),
145
+ list,
71
146
  data.experts.length ? null : h("div", { class: "tasks-empty" }, h("div", { class: "t" }, "还没有自己的专家"), h("div", { class: "s" }, "点「新建」建一个。")),
72
147
  );
73
148
  }
@@ -442,74 +517,6 @@ async function squareImage(f, size) {
442
517
  }
443
518
  }
444
519
 
445
- /**
446
- * 模型、思考程度:下拉选,选项是引擎的模型列表(和输入框里选模型的一样)。
447
- * 第一项「默认」= 不指定;已经存的值不在列表里(模型下线、手写的)也留着一项,不会被悄悄改掉
448
- */
449
- function modelPicker(src) {
450
- const model = h("select", {});
451
- const effort = h("select", {});
452
- let modelVal = src.model ?? "";
453
- let effortVal = src.effort ?? "";
454
- let list = [];
455
- let engineLoaded = null;
456
- const opt = (value, label, selected) => h("option", { value, selected }, label);
457
- const renderEffort = () => {
458
- const picked = list.find((m) => m.id === modelVal) ?? list.find((m) => m.isDefault) ?? list.find((m) => m.efforts?.length);
459
- const efforts = picked?.efforts ?? [];
460
- const extra = effortVal && !efforts.includes(effortVal) ? effortVal : null;
461
- fill(
462
- effort,
463
- opt("", "默认", !effortVal),
464
- efforts.map((x) => opt(x, x, x === effortVal)),
465
- extra ? opt(extra, list.length ? `${extra}(不在列表里)` : extra, true) : null,
466
- );
467
- effort.disabled = !efforts.length && !extra;
468
- };
469
- const render = () => {
470
- const shown = list.filter((m) => m.id !== "default");
471
- const def = list.find((m) => m.isDefault) ?? list.find((m) => m.id === "default");
472
- const known = !modelVal || shown.some((m) => m.id === modelVal);
473
- fill(
474
- model,
475
- opt("", def ? `默认(${def.label || def.id})` : "默认", !modelVal),
476
- shown.map((m) => opt(m.id, m.label && m.label !== m.id ? `${m.label}(${m.id})` : m.id, m.id === modelVal)),
477
- known ? null : opt(modelVal, `${modelVal}(不在列表里)`, true),
478
- );
479
- renderEffort();
480
- };
481
- model.onchange = () => {
482
- modelVal = model.value;
483
- // 换了模型:原来的思考程度这个模型不支持就回到默认
484
- const picked = list.find((m) => m.id === modelVal) ?? list.find((m) => m.isDefault);
485
- if (effortVal && !(picked?.efforts ?? []).includes(effortVal)) effortVal = "";
486
- renderEffort();
487
- };
488
- effort.onchange = () => (effortVal = effort.value);
489
- return {
490
- model,
491
- effort,
492
- async load(engine) {
493
- if (engine === engineLoaded) return;
494
- // 换了引擎(只有新建时能换):原来选的对不上了
495
- if (engineLoaded) modelVal = effortVal = "";
496
- engineLoaded = engine;
497
- list = [];
498
- fill(model, opt(modelVal, "加载中…", true));
499
- model.disabled = true;
500
- renderEffort();
501
- try {
502
- list = await agentCatalog(engine);
503
- } catch {
504
- // 拿不到列表:只能选默认(已经存的值也留着)
505
- }
506
- if (engineLoaded !== engine) return;
507
- model.disabled = false;
508
- render();
509
- },
510
- };
511
- }
512
-
513
520
  // ---------- MCP(设置里的一页) ----------
514
521
 
515
522
  export async function mcpTab(panel) {
@@ -17,12 +17,14 @@ import { hasDirty, markDirty } from "./common.js";
17
17
 
18
18
  // ---------- 设置 ----------
19
19
  // 按「谁的、管什么」分组:我的(每个人自己的)、Agent、连接(飞书、远程控制)、管理。
20
- // 普通成员可管理自己的资料和内置 Agent 默认项;管理员另有运行环境和服务器设置。
20
+ // 普通成员可管理自己的资料和内置 Agent 默认项(在「专家」里);管理员另有运行环境和服务器设置。
21
21
 
22
22
  const LAST_TAB = "aim.settingsTab";
23
23
 
24
24
  /** 以前的标签名:外面(地址、别处的按钮)传进来的旧名字照样能打开对应的页 */
25
25
  const RENAMED = { 通用: "对话", 授权: "对话", 飞书机器人: "飞书", 我的账号: "账号", 通知: "系统" };
26
+ /** 成员没有 Agent 页了:以前记住的 / 外面传进来的「Agent」打开专家页 */
27
+ const MEMBER_RENAMED = { Agent: "专家" };
26
28
 
27
29
  function groupsFor(cfg) {
28
30
  const mine = {
@@ -36,7 +38,8 @@ function groupsFor(cfg) {
36
38
  ["用量", (p) => usageTab(p)],
37
39
  ],
38
40
  };
39
- if (!cfg) return [mine, { name: "Agent", tabs: [["Agent", (p) => agentsTab(null, p)]] }, { name: "系统", tabs: [["系统", (p) => systemTab(null, p)]] }];
41
+ // 成员的内置 Agent 默认设置在「专家」里(内置卡片上的「设置」),这里没有 Agent 页
42
+ if (!cfg) return [mine, { name: "系统", tabs: [["系统", (p) => systemTab(null, p)]] }];
40
43
  return [
41
44
  mine,
42
45
  {
@@ -128,6 +131,6 @@ export async function openSettings(tab) {
128
131
  }
129
132
  }
130
133
  const requested = tab || localStorage.getItem(LAST_TAB);
131
- const want = RENAMED[requested] ?? requested;
134
+ const want = (cfg ? undefined : MEMBER_RENAMED[requested]) ?? RENAMED[requested] ?? requested;
132
135
  void select(Math.max(0, tabs.findIndex(([name]) => name === want)));
133
136
  }
package/web/state.js CHANGED
@@ -7,7 +7,7 @@ export const S = {
7
7
  pending: new Map(),
8
8
  /** 侧栏菜单的显示和顺序,随账号保存;null 使用默认配置。 */
9
9
  sidebarNav: null,
10
- /** 设置 → Agent 里定的默认权限,按引擎:{ claude: "edit", codex: null } */
10
+ /** 设置 → 专家 → 内置 Agent「设置」里定的默认权限,按引擎:{ claude: "edit", codex: null } */
11
11
  defaultPermission: null,
12
12
  /** 新对话里打开的计划模式(和 draftPermission 一样,建好对话后带过去) */
13
13
  draftPlan: false,
@@ -18,6 +18,8 @@ export const S = {
18
18
  draftExpert: localStorage.getItem("aim.expert") || null,
19
19
  /** 自己的专家(bootstrap 里给,设置里改了重新拉) */
20
20
  experts: [],
21
+ /** 内置、自建和共享专家的展示顺序,随账号保存。 */
22
+ expertOrder: [],
21
23
  /** 新对话(还没发消息)选的工作目录,null 表示工作区根目录。顶部新建时继承最近会话的目录 */
22
24
  draftCwd: null,
23
25
  /** 这个新对话的目录是自己选的:换专家时不再改成专家的默认目录。建好会话后清掉 */
@@ -15,13 +15,19 @@ function usableEngines() {
15
15
  return (usable.length ? usable : enabled).map((a) => a.id);
16
16
  }
17
17
 
18
- /** 能选的专家:内置的在前,再是自己的和共享的(引擎能用的) */
18
+ /** 按账号设置的混合顺序展示,新出现的专家接在末尾。 */
19
+ export function sortExperts(experts, order = S.expertOrder) {
20
+ const rank = new Map((order ?? []).map((id, i) => [id, i]));
21
+ return [...experts].sort((a, b) => (rank.get(a.id) ?? Infinity) - (rank.get(b.id) ?? Infinity));
22
+ }
23
+
24
+ /** 能选的专家:引擎能用且有权限,按「设置 → 专家」中的顺序。 */
19
25
  export function expertChoices() {
20
26
  const engines = usableEngines();
21
- return [
27
+ return sortExperts([
22
28
  ...engines.filter((id) => S.agents.find((a) => a.id === id)?.allowed !== false).map((id) => ({ id, name: agentLabel(id), engine: id, builtin: true })),
23
29
  ...S.experts.filter((e) => engines.includes(e.engine)),
24
- ];
30
+ ]);
25
31
  }
26
32
 
27
33
  export function findExpert(id) {
@@ -67,6 +73,7 @@ export async function reloadExperts() {
67
73
  try {
68
74
  const d = await api("/api/experts/brief");
69
75
  S.experts = d.experts ?? [];
76
+ S.expertOrder = d.expertOrder ?? [];
70
77
  if (Array.isArray(d.builtin)) for (const a of S.agents) a.allowed = d.builtin.includes(a.id);
71
78
  if (d.user) S.user = d.user;
72
79
  if ("servers" in d) applyShellInfo(d.servers);
@@ -157,6 +157,7 @@ export async function boot() {
157
157
  applyBootstrap(data);
158
158
  S.pending = new Map(data.pending.map((i) => [i.id, i]));
159
159
  S.experts = data.experts ?? [];
160
+ S.expertOrder = data.expertOrder ?? [];
160
161
  syncDraftExpert();
161
162
  renderLayout();
162
163
  reportDesktop();
@@ -0,0 +1,79 @@
1
+ import { fill, h } from "../lib/dom.js";
2
+ import { agentCatalog } from "./topbar.js";
3
+
4
+ /**
5
+ * 模型、思考程度:下拉选,选项是引擎的模型列表(和输入框里选模型的一样)。
6
+ * 第一项「默认」= 不指定;已经存的值不在列表里(模型下线、手写的)也留着一项,不会被悄悄改掉
7
+ */
8
+ export function modelPicker(src) {
9
+ const model = h("select", {});
10
+ const effort = h("select", {});
11
+ let modelVal = src.model ?? "";
12
+ let effortVal = src.effort ?? "";
13
+ let list = [];
14
+ let engineLoaded = null;
15
+ /** 不指定时实际用的模型(自定义专家自己定了模型):「默认」后面显示它,而不是引擎的默认 */
16
+ let fallback = "";
17
+ const opt = (value, label, selected) => h("option", { value, selected }, label);
18
+ const renderEffort = () => {
19
+ const picked = list.find((m) => m.id === modelVal) ?? list.find((m) => m.isDefault) ?? list.find((m) => m.efforts?.length);
20
+ const efforts = picked?.efforts ?? [];
21
+ const extra = effortVal && !efforts.includes(effortVal) ? effortVal : null;
22
+ fill(
23
+ effort,
24
+ opt("", "默认", !effortVal),
25
+ efforts.map((x) => opt(x, x, x === effortVal)),
26
+ extra ? opt(extra, list.length ? `${extra}(不在列表里)` : extra, true) : null,
27
+ );
28
+ effort.disabled = !efforts.length && !extra;
29
+ };
30
+ const render = () => {
31
+ const shown = list.filter((m) => m.id !== "default");
32
+ const def = list.find((m) => m.isDefault) ?? list.find((m) => m.id === "default");
33
+ const known = !modelVal || shown.some((m) => m.id === modelVal);
34
+ fill(
35
+ model,
36
+ opt("", fallback ? `默认(${fallback})` : def ? `默认(${def.label || def.id})` : "默认", !modelVal),
37
+ shown.map((m) => opt(m.id, m.label && m.label !== m.id ? `${m.label}(${m.id})` : m.id, m.id === modelVal)),
38
+ known ? null : opt(modelVal, `${modelVal}(不在列表里)`, true),
39
+ );
40
+ renderEffort();
41
+ };
42
+ model.onchange = () => {
43
+ modelVal = model.value;
44
+ // 换了模型:原来的思考程度这个模型不支持就回到默认
45
+ const picked = list.find((m) => m.id === modelVal) ?? list.find((m) => m.isDefault);
46
+ if (effortVal && !(picked?.efforts ?? []).includes(effortVal)) effortVal = "";
47
+ renderEffort();
48
+ };
49
+ effort.onchange = () => (effortVal = effort.value);
50
+ return {
51
+ model,
52
+ effort,
53
+ async load(engine, defaultModel = "") {
54
+ if (engine === engineLoaded) {
55
+ if (fallback !== defaultModel) {
56
+ fallback = defaultModel;
57
+ if (!model.disabled) render();
58
+ }
59
+ return;
60
+ }
61
+ fallback = defaultModel;
62
+ // 换了引擎(只有新建时能换):原来选的对不上了
63
+ if (engineLoaded) modelVal = effortVal = "";
64
+ engineLoaded = engine;
65
+ list = [];
66
+ fill(model, opt(modelVal, "加载中…", true));
67
+ model.disabled = true;
68
+ renderEffort();
69
+ try {
70
+ list = await agentCatalog(engine);
71
+ } catch {
72
+ // 拿不到列表:只能选默认(已经存的值也留着)
73
+ }
74
+ if (engineLoaded !== engine) return;
75
+ model.disabled = false;
76
+ render();
77
+ },
78
+ };
79
+ }
@@ -253,12 +253,15 @@ function orderSidebarGroups(dirs) {
253
253
  const rank = new Map(sideState.order.map((d, i) => [d, i]));
254
254
  const ranked = dirs.filter((d) => rank.has(d)).sort((a, b) => rank.get(a) - rank.get(b));
255
255
  const fresh = dirs.filter((d) => !rank.has(d));
256
+ // 首次恢复「最近」时放到顶部;之后沿用用户排好的位置。
257
+ const top = fresh.includes("recent") ? ["recent"] : [];
258
+ const tail = fresh.filter((d) => d !== "recent");
256
259
  if (fresh.length && orderSynced) {
257
- sideState.order = [...sideState.order, ...fresh];
260
+ sideState.order = [...top, ...sideState.order, ...tail];
258
261
  saveSideState();
259
262
  void putDirOrder({ append: fresh });
260
263
  }
261
- return [...ranked, ...fresh];
264
+ return [...top, ...ranked, ...tail];
262
265
  }
263
266
 
264
267
  /** 拿到服务端存的顺序之前不往上写,免得这台设备本地的旧顺序盖掉别处排好的 */
@@ -377,13 +380,13 @@ function toggleSide(list, id) {
377
380
  }
378
381
 
379
382
  let autoOpenedFor = null;
380
- const RECENT_LIMIT = 10;
383
+ const RECENT_LIMIT = 5;
381
384
  const PROJECT_LIMIT = 5;
382
385
  /** 「展开显示」一次多显示几条 */
383
386
  const MORE_STEP = 10;
384
387
 
385
388
  // ---------- 分页(服务端见 channels/web/conv-pages.ts) ----------
386
- // 打开页面只拿「最近」的前 10 条、展开着的目录各自的前 5 条(一条 = 主对话连同它的分叉),
389
+ // 打开页面只拿「最近」的前 5 条会话、展开着的目录各自的前 5 棵分叉树,
387
390
  // 正在跑的、等你处理的、每个飞书机器人最近的一条也都在;点「展开显示」多显示 10 条,本地不够再按页拉。
388
391
  // 新出现的、变活跃的会话经 WebSocket 的 conv 消息补进 S.convs。
389
392
  // next:下一页的游标;null = 没有更多了;undefined = 这个目录还没拉过。
@@ -676,9 +679,28 @@ export function renderSidebar() {
676
679
  botRows.push({ id, at: convs[0].activeAt, rows });
677
680
  }
678
681
 
679
- // ---- Web 会话直接按工作目录分组,目录按用户排的顺序(见 orderSidebarGroups) ----
682
+ // 「最近」逐条按活跃时间排序,分叉也独立占一条;项目中仍按分叉树展示。
683
+ const webConvs = visible.filter((c) => c.channel === "web").sort((a, b) => b.activeAt - a.activeAt || (a.key < b.key ? 1 : -1));
684
+ const recentExpanded = !sideState.folded.includes("recent");
685
+ const recentRows = [h("div", { class: "proj-row recent-row", ...groupDragAttrs("recent") },
686
+ h("button", {
687
+ class: "conv-item proj", title: "最近\n拖动可调整顺序,右键更多操作",
688
+ "aria-expanded": String(recentExpanded), onclick: () => toggleSide("folded", "recent"),
689
+ }, h("span", { class: "title" }, "最近"), caret(!recentExpanded), recentExpanded ? null : status(webConvs.map((c) => c.key))),
690
+ )];
691
+ if (recentExpanded) {
692
+ const st = pages.recent;
693
+ const list = st.next ? webConvs.filter((c) => c.activeAt > st.next.at || (c.activeAt === st.next.at && c.key >= st.next.key)) : webConvs;
694
+ const load = (limit) => fetchPage(st, { scope: "recent", limit: String(limit) });
695
+ for (const c of list.slice(0, st.show)) recentRows.push(convRow(c, " sub recent", `${agentLabel(c.agent)} · ${c.cwd}`, !!c.forkOf));
696
+ if (!list.length && !st.loading) recentRows.push(h("div", { class: "conv-empty sub" }, "还没有会话"));
697
+ const btn = moreButton(st, list.length, RECENT_LIMIT, load);
698
+ if (btn) recentRows.push(h("div", { class: "sub-more recent-more" }, btn));
699
+ }
700
+
701
+ // ---- Web 会话按工作目录分组,目录按用户排的顺序(见 orderSidebarGroups) ----
680
702
  const byDir = new Map();
681
- for (const c of visible.filter((c) => c.channel === "web")) {
703
+ for (const c of webConvs) {
682
704
  if (!byDir.has(c.cwd)) byDir.set(c.cwd, []);
683
705
  byDir.get(c.cwd).push(c);
684
706
  }
@@ -695,9 +717,10 @@ export function renderSidebar() {
695
717
  for (const [dir, convs] of byDir) dirAt.set(dir, Math.max(dirAt.get(dir) ?? 0, convs[0].activeAt));
696
718
  const dirsByActivity = [...dirAt.keys()].sort((a, b) => dirAt.get(b) - dirAt.get(a));
697
719
  const groupRows = new Map(botRows.map((group) => [group.id, group.rows]));
720
+ groupRows.set("recent", recentRows);
698
721
  const groupAt = new Map([...dirAt, ...botRows.map((group) => [group.id, group.at])]);
699
- groupsByActivity = [...groupAt.keys()].sort((a, b) => groupAt.get(b) - groupAt.get(a));
700
- sidebarGroups = orderSidebarGroups([...dirsByActivity, ...botRows.sort((a, b) => b.at - a.at).map((group) => group.id)]);
722
+ groupsByActivity = ["recent", ...[...groupAt.keys()].sort((a, b) => groupAt.get(b) - groupAt.get(a))];
723
+ sidebarGroups = orderSidebarGroups(["recent", ...dirsByActivity, ...botRows.sort((a, b) => b.at - a.at).map((group) => group.id)]);
701
724
  if (dirAt.size) {
702
725
  for (const dir of dirsByActivity) {
703
726
  const convs = byDir.get(dir) ?? [];
@@ -9,6 +9,7 @@ import { baseName, renderTopbar } from "./topbar.js";
9
9
  import { openConversation } from "./messages.js";
10
10
  import { changeCwd } from "./conv-actions.js";
11
11
  import { convExpert, expertChoices, findExpert } from "./experts.js";
12
+ import { modelPicker } from "./model-picker.js";
12
13
  import { capOfAccess, FULL_WARNING, minPermission, PERMISSIONS, permissionsUpTo } from "../lib/permission.js";
13
14
 
14
15
  // ---------- 定时任务页 ----------
@@ -449,6 +450,13 @@ export function openTaskForm(task, preset) {
449
450
  },
450
451
  });
451
452
  const cwdField = field("工作目录", cwdBtn, "专家在这个目录里干活。没选就用专家默认的目录。");
453
+ // ---- 模型、思考程度(专用对话的在任务上,每次运行前对齐;发到已有对话的跟着那条对话)----
454
+ const models = modelPicker(src);
455
+ const modelRow = h("div", { class: "row-fields" }, field("模型", models.model), field("思考程度", models.effort));
456
+ const loadModels = () => {
457
+ const e = findExpert(expert.value);
458
+ if (e) void models.load(e.engine, e.model || "");
459
+ };
452
460
  // ---- 权限(专用对话的在任务上;发到已有对话的就是那条对话的,见下面的 convBox)----
453
461
  const permission = h("select", {});
454
462
  const permissionHint = h("small", {});
@@ -477,7 +485,7 @@ export function openTaskForm(task, preset) {
477
485
  const context = h("select", { class: "task-context" }, keepOption, h("option", { value: "fresh", selected: !!src.freshContext }, "不携带(每次都从头开始)"));
478
486
  const contextHint = h("small", {});
479
487
  const contextField = h("div", { class: "field" }, h("span", {}, "上下文"), context, contextHint);
480
- const dedicatedBox = h("div", { class: "task-dedicated" }, field("专家", expert, "到点由这个专家来做。要联网、读文件还是跑命令,看专家的权限(设置 → 专家)。"), cwdField, permissionField);
488
+ const dedicatedBox = h("div", { class: "task-dedicated" }, field("专家", expert, "到点由这个专家来做。要联网、读文件还是跑命令,看专家的权限(设置 → 专家)。"), modelRow, cwdField, permissionField);
481
489
  // 发到已有对话:专家、目录属于对话,中途换不了,只显示;权限可以改,改的是对话自己的
482
490
  const convBox = h("div", { class: "task-dedicated task-conv" });
483
491
  let convPermission = null;
@@ -515,6 +523,7 @@ export function openTaskForm(task, preset) {
515
523
  cwdField.hidden = access === "web";
516
524
  syncPermission();
517
525
  permissionField.hidden = capOfAccess(access) === "ask";
526
+ if (dedicated) loadModels();
518
527
  };
519
528
  expert.onchange = syncVisibility;
520
529
  target.onchange = syncVisibility;
@@ -587,7 +596,7 @@ export function openTaskForm(task, preset) {
587
596
  notify: notify.value,
588
597
  target: dedicated ? { kind: "dedicated" } : { kind: "conv", key: target.value },
589
598
  freshContext: fresh,
590
- ...(dedicated ? { expert: expert.value, cwd: findExpert(expert.value)?.access === "web" ? "" : cwd, permission: level } : {}),
599
+ ...(dedicated ? { expert: expert.value, cwd: findExpert(expert.value)?.access === "web" ? "" : cwd, permission: level, model: models.model.value, effort: models.effort.value } : {}),
591
600
  ...(convLevelChanged ? { convPermission: convLevel } : {}),
592
601
  };
593
602
  save.disabled = true;