agent-loft 0.2.98 → 0.2.99
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 +2 -2
- package/package.json +1 -1
- package/src/agents/claude/session.ts +57 -5
- package/src/agents/codex/app-server.ts +2 -1
- package/src/agents/codex/protocol.ts +2 -1
- package/src/agents/codex/session.ts +65 -1
- package/src/channels/feishu/cards.ts +9 -4
- package/src/channels/web/api.ts +8 -0
- package/src/channels/weixin/bot.ts +2 -1
- package/src/channels/weixin/format.ts +5 -5
- package/src/core/builtin-agents.ts +47 -6
- package/src/core/command-catalog.ts +2 -1
- package/src/core/commands.ts +11 -0
- package/src/core/hub.ts +61 -11
- package/src/core/interactions.ts +1 -1
- package/src/core/permission.ts +20 -2
- package/src/core/store.ts +5 -0
- package/src/core/types.ts +14 -0
- package/web/css/composer.css +15 -0
- package/web/lib/permission.js +23 -4
- package/web/settings/agents.js +15 -5
- package/web/settings/commands.js +1 -1
- package/web/state.js +4 -0
- package/web/views/composer.js +4 -3
- package/web/views/conv-actions.js +24 -4
- package/web/views/interaction.js +9 -5
- package/web/views/sidebar.js +1 -0
- package/web/views/tasks.js +2 -2
- package/web/views/topbar.js +15 -10
package/README.md
CHANGED
|
@@ -76,7 +76,7 @@ Logo 就是这个意思:一大两小几颗星(多个 agent)站在同一张
|
|
|
76
76
|
- **网页多服务器切换**:在 设置 → 服务器 添加其他 agent-loft,再点「授权」到对方页面确认,侧栏左上角通过名称和紧随其后的箭头切换,不显示服务器图标,嵌入桌面端时隐藏此入口;各台分别登录,切走后保持连接,列表显示待处理数和运行状态,刷新后保留选择。几台需使用同一主域名下的 HTTPS 地址(例如 `mac.example.com`、`nas.example.com`)。在外层页面开启系统通知后,各台的提醒都能推到同一个主屏幕 App,点通知自动切到对应服务器和对话。见[使用指南](docs/产品介绍.md#在网页和手机上切换多台服务器)。
|
|
77
77
|
- **系统通知**:Web 会话回复完成、出错、需要授权或提问时推送到手机 / 电脑(设置 → 系统 → 系统通知 → 「在此设备开启通知」,可以发测试通知)。飞书会话由飞书提醒,正在前台看着的会话不推。需要 HTTPS 访问,iPhone 需 iOS 16.4+ 且从主屏幕图标打开。
|
|
78
78
|
- **跨渠道同步**:飞书里的会话在 Web 上也能打开接着聊。同一个授权请求同时出现在飞书卡片和网页上,哪边先点算哪边,另一边自动变成「已处理」。
|
|
79
|
-
- **授权**:允许一次 / 本会话全部允许 / 总是允许(按钮上写明放行范围)/ 拒绝。权限级别(输入框左下角或 `/permission`):逐次询问 / 自动改文件 /
|
|
79
|
+
- **授权**:允许一次 / 本会话全部允许 / 总是允许(按钮上写明放行范围)/ 拒绝。权限级别(输入框左下角或 `/permission`):逐次询问 / 自动改文件 / 自动判断(仅 Claude Code,由 Claude 逐个判断安不安全)/ 完全允许,定时任务也可以单独设,自动判断和完全允许只给管理员;默认级别在 设置 → Agent 里按引擎设。同一个弹窗里还有**计划模式**开关(或 `/planmode on`):agent 先只读、出方案,你点「开始执行」后再按权限级别动手。`/autoedit on` 让 Claude Code 在这条会话里改工作目录内的文件不再询问(Bash 仍询问)。超时一律按拒绝处理。
|
|
80
80
|
- **设置都在网页上**,按用途分组:**我的**(账号、飞书和微信绑定、自己的登录设备、记忆、专家、技能、MCP、用量);**Agent**(运行环境置顶,各 agent 卡片分别配置默认模型、思考程度、可选模型、个人默认技能和 MCP,Codex 沙箱、额度查询;工作目录、会话闲置过期、授权卡超时和 Claude 的「总是允许」名单;「/」命令);**连接**(飞书机器人、配对批准、指令面板同步;远程控制;服务器);**管理**(用户标题旁添加用户,用户的「管理 → 登录设备」查看和下线各自设备;系统页管理服务端版本和升级、重启、局域网访问和端口,网络访问下方是系统通知;成员也可在系统页设置自己的通知)。账号页通过「修改名称」「修改密码」按需展开表单;飞书和微信绑定操作位于卡片右上角。设置、新建 / 编辑专家、重命名等编辑弹窗不会因点击外部或按 Esc 关闭;通过关闭、取消或保存 / 完成按钮退出。改了没保存就切页或关掉设置会先提醒。
|
|
81
81
|
- **多用户**(信任型):管理员在 设置 → 用户 里给别人建账号。每个人只看得到自己的对话、授权和通知;个人设置各自管理,服务器设置由管理员修改,见下面「安全」。
|
|
82
82
|
- **专家**:设置 → 专家。专家是一份配置,新建对话、定时任务时选一个,对话从头到尾都是它(中途不能换;飞书里 `/expert 名字`、`/claude`、`/codex` 换专家会开新会话)。**内置专家**:Claude Code、Codex,保留原装提示词和所有工具,默认技能与 MCP 在「设置 → Agent」中按账号、按引擎分别选择。**自定义专家**由创建者管理,可以勾选「共享给所有账号」。共享后,其他人能在网页、绑定账号后的飞书私聊和定时任务中选择它;只有创建者能修改设定。每个人在该专家的「我的工具」里选择自己的技能和 MCP,使用各自的变量、凭据、记忆和聊天记录;创建者沿用原有工具选择;其他人没配置过时,沿用创建者选的里面自己能用的(自己装了的技能、创建者共享出来的 MCP),创建者私有的 MCP 和机器 MCP 不会带给别人。取消共享后,其他人的历史对话保留,后续消息不能继续调用该专家,相关定时任务在下次运行时暂停。可以配:
|
|
@@ -178,7 +178,7 @@ agent-loft service install
|
|
|
178
178
|
|
|
179
179
|
`aloft` 是 `agent-loft` 的简写。
|
|
180
180
|
|
|
181
|
-
聊天里的命令(飞书和 Web 通用;Web 打开页面时会预加载当前专家和目录的命令,输入框打 `/` 会弹出命令补全,飞书里打 `/` 会弹出机器人的指令面板(agent-loft 自动注册,约 5~8 分钟生效;只发一个 `/` 也会回一张可点击的命令卡片),顺序和显示项在 设置 → 命令 里调整):`/new` `/fork` `/sessions [all]` `/resume <id>` `/model [名称]` `/effort <程度>` `/stop` `/cd <目录>` `/pwd` `/status` `/permission [ask|edit|full|default]`、`/autoedit [on|off]` `/approve <id> allow-once|allow-always|allow-session|deny` `/help`;只在飞书里有的:`/expert [名称]`(或者直接发 `/claude`、`/codex`,换专家会开新会话)`/web` `/detach` `/bind <绑定码>`
|
|
181
|
+
聊天里的命令(飞书和 Web 通用;Web 打开页面时会预加载当前专家和目录的命令,输入框打 `/` 会弹出命令补全,飞书里打 `/` 会弹出机器人的指令面板(agent-loft 自动注册,约 5~8 分钟生效;只发一个 `/` 也会回一张可点击的命令卡片),顺序和显示项在 设置 → 命令 里调整):`/new` `/fork` `/sessions [all]` `/resume <id>` `/model [名称]` `/effort <程度>` `/stop` `/cd <目录>` `/pwd` `/status` `/permission [ask|edit|auto|full|default]`、`/planmode [on|off]`、`/autoedit [on|off]` `/approve <id> allow-once|allow-always|allow-session|deny` `/help`;只在飞书里有的:`/expert [名称]`(或者直接发 `/claude`、`/codex`,换专家会开新会话)`/web` `/detach` `/bind <绑定码>`
|
|
182
182
|
|
|
183
183
|
自定义命令:设置 → 命令 → 「添加命令」,填命令名、说明和一段提示词,之后发 `/命令名 参数` 就会把这段提示词发给 agent(提示词里的 `$ARGUMENTS` 换成参数,没写就把参数接在后面)。按 agent 分开存,可以编辑、删除,也会同步到飞书指令面板。
|
|
184
184
|
|
package/package.json
CHANGED
|
@@ -11,6 +11,7 @@ import {
|
|
|
11
11
|
type McpServerConfigForProcessTransport,
|
|
12
12
|
type ModelUsage,
|
|
13
13
|
type Options,
|
|
14
|
+
type PermissionMode,
|
|
14
15
|
type PermissionResult,
|
|
15
16
|
type Query,
|
|
16
17
|
type SDKMessage,
|
|
@@ -49,6 +50,16 @@ import {
|
|
|
49
50
|
} from "./permissions.js";
|
|
50
51
|
import { feedTodos, readTodos, TodoTracker } from "./todos.js";
|
|
51
52
|
|
|
53
|
+
/**
|
|
54
|
+
* 级别 + 计划模式 → Claude 的 permissionMode。计划模式优先(只读、出方案)。
|
|
55
|
+
* acceptEdits 只放行工作目录(含附件目录)内的改文件;auto 由分类器逐个判断,拿不准的才走 canUseTool;
|
|
56
|
+
* 「完全允许」用 default,在 canUseTool 里全放行(bypassPermissions 会让 canUseTool 变成死代码)
|
|
57
|
+
*/
|
|
58
|
+
function modeOf(level: PermissionLevel | undefined, plan: boolean | undefined): PermissionMode {
|
|
59
|
+
if (plan) return "plan";
|
|
60
|
+
return level === "edit" ? "acceptEdits" : level === "auto" ? "auto" : "default";
|
|
61
|
+
}
|
|
62
|
+
|
|
52
63
|
export function toModelInfo(models: Awaited<ReturnType<Query["supportedModels"]>>): ModelInfo[] {
|
|
53
64
|
return models.map((m) => ({
|
|
54
65
|
id: m.value,
|
|
@@ -363,9 +374,8 @@ export class ClaudeSession implements AgentSession {
|
|
|
363
374
|
...(this.access === "web" ? {} : { CLAUDE_CODE_ENABLE_TODO_TOOLS: "1" }),
|
|
364
375
|
...(this.access === "exec" ? (this.opts.skills?.env ?? {}) : {}),
|
|
365
376
|
},
|
|
366
|
-
//
|
|
367
|
-
|
|
368
|
-
permissionMode: this.opts.permission === "edit" ? "acceptEdits" : "default",
|
|
377
|
+
// 不用 bypassPermissions:它会让 canUseTool 变成死代码(「完全允许」也在 canUseTool 里放行)。见 modeOf
|
|
378
|
+
permissionMode: modeOf(this.opts.permission, this.opts.plan),
|
|
369
379
|
// 逐字输出给 Web 用;飞书渠道直接忽略这些片段
|
|
370
380
|
includePartialMessages: true,
|
|
371
381
|
...(this.opts.model ? { model: this.opts.model } : {}),
|
|
@@ -415,6 +425,12 @@ export class ClaudeSession implements AgentSession {
|
|
|
415
425
|
return;
|
|
416
426
|
}
|
|
417
427
|
|
|
428
|
+
// 模式变了(Claude 自己调 EnterPlanMode 进了计划模式、批准方案后退出):对话上的开关跟着走
|
|
429
|
+
if (message.type === "system" && message.subtype === "status") {
|
|
430
|
+
if (message.permissionMode) this.syncPlan(message.permissionMode === "plan");
|
|
431
|
+
return;
|
|
432
|
+
}
|
|
433
|
+
|
|
418
434
|
// 逐字片段。子 agent 的输出(parent_tool_use_id 非空)不算回复正文
|
|
419
435
|
if (message.type === "stream_event") {
|
|
420
436
|
if (message.parent_tool_use_id) return;
|
|
@@ -546,12 +562,15 @@ export class ClaudeSession implements AgentSession {
|
|
|
546
562
|
const answered = await this.askQuestion(input);
|
|
547
563
|
if (answered) return answered;
|
|
548
564
|
}
|
|
565
|
+
// 批准方案也不是授权:完全允许、本会话全部允许都不能替用户批
|
|
566
|
+
if (toolName === "ExitPlanMode") return this.approvePlan(input);
|
|
549
567
|
|
|
550
568
|
// 提问、批准计划这类不是「安全确认」,而是要用户真的做决定,全部允许也照样问。
|
|
551
569
|
// 标了「调用前询问」的 MCP 是用户特意要每次把关的:全部允许、总是允许都不算数(和 Codex 一致)
|
|
552
570
|
const asksFirst = this.mcpAsksFirst(toolName);
|
|
553
571
|
const sessionable = isRememberable(toolName) && !asksFirst;
|
|
554
|
-
|
|
572
|
+
// 计划模式下不沿用全部放行:只读是计划模式的前提,Bash 写文件不能因为放开过就直接跑
|
|
573
|
+
if (sessionable && this.allowAll && !this.opts.plan) return { behavior: "allow", updatedInput: input };
|
|
555
574
|
|
|
556
575
|
const signature = signatureOf(toolName, input);
|
|
557
576
|
const rememberable = !asksFirst && isRememberableSignature(toolName, signature);
|
|
@@ -602,6 +621,34 @@ export class ClaudeSession implements AgentSession {
|
|
|
602
621
|
return this.opts.expert?.access ?? "exec";
|
|
603
622
|
}
|
|
604
623
|
|
|
624
|
+
/**
|
|
625
|
+
* ExitPlanMode:方案出好了,问用户按不按它做。批准就切回这条对话的权限级别接着干;
|
|
626
|
+
* 不批就留在计划模式,等用户说要怎么改。
|
|
627
|
+
*/
|
|
628
|
+
private async approvePlan(input: Record<string, unknown>): Promise<PermissionResult> {
|
|
629
|
+
const plan = typeof input.plan === "string" && input.plan.trim() ? input.plan : "(Claude 没有附上方案正文)";
|
|
630
|
+
const outcome = await this.host({ kind: "approval", title: "方案出好了,按这个开始做?", detail: plan, allowLabel: "开始执行", denyLabel: "继续改方案" });
|
|
631
|
+
if (outcome.settlement === "allow-once" || outcome.settlement === "allow-always") {
|
|
632
|
+
this.syncPlan(false);
|
|
633
|
+
const mode = modeOf(this.opts.permission, false);
|
|
634
|
+
return { behavior: "allow", updatedInput: input, updatedPermissions: [{ type: "setMode", mode, destination: "session" }] };
|
|
635
|
+
}
|
|
636
|
+
const message =
|
|
637
|
+
outcome.settlement === "timeout"
|
|
638
|
+
? "用户长时间没有回应这个方案(已超时)。留在计划模式,不要动手,等用户回来。"
|
|
639
|
+
: outcome.settlement === "cancelled"
|
|
640
|
+
? "方案确认已被取消(用户中断了这一轮或切换了会话)。留在计划模式,不要动手。"
|
|
641
|
+
: "用户还不想按这个方案做。留在计划模式,不要动手;简短问一句要改哪里,等用户说明。";
|
|
642
|
+
return { behavior: "deny", message };
|
|
643
|
+
}
|
|
644
|
+
|
|
645
|
+
/** 记下是不是在计划模式,变了就告诉核心 */
|
|
646
|
+
private syncPlan(on: boolean): void {
|
|
647
|
+
if (!!this.opts.plan === on) return;
|
|
648
|
+
this.opts.plan = on;
|
|
649
|
+
this.events.onPlanMode?.(on);
|
|
650
|
+
}
|
|
651
|
+
|
|
605
652
|
/**
|
|
606
653
|
* AskUserQuestion:选了什么要顺着 updatedInput.answers 回填(问题原文 → 答案),
|
|
607
654
|
* 少了这一步工具会以「The user did not answer the questions.」收场。
|
|
@@ -684,7 +731,12 @@ export class ClaudeSession implements AgentSession {
|
|
|
684
731
|
this.opts.permission = level;
|
|
685
732
|
this.allowAll = level === "full";
|
|
686
733
|
// 还没起 CLI 就不用管:下次拉起时按 opts 来
|
|
687
|
-
if (this.q) await this.q.setPermissionMode(level
|
|
734
|
+
if (this.q) await this.q.setPermissionMode(modeOf(level, this.opts.plan));
|
|
735
|
+
}
|
|
736
|
+
|
|
737
|
+
async setPlan(on: boolean): Promise<void> {
|
|
738
|
+
this.opts.plan = on;
|
|
739
|
+
if (this.q) await this.q.setPermissionMode(modeOf(this.opts.permission, on));
|
|
688
740
|
}
|
|
689
741
|
|
|
690
742
|
async setModel(model?: string, effort?: string): Promise<void> {
|
|
@@ -125,7 +125,8 @@ export class AppServer {
|
|
|
125
125
|
|
|
126
126
|
const result = (await this.request("initialize", {
|
|
127
127
|
clientInfo: CLIENT_INFO,
|
|
128
|
-
|
|
128
|
+
// 计划模式(turn/start 的 collaborationMode)是实验接口,不声明就收不到
|
|
129
|
+
capabilities: { experimentalApi: true },
|
|
129
130
|
})) as InitializeResult;
|
|
130
131
|
|
|
131
132
|
// 握手的第二拍。少了它,服务端会一直当我们还没准备好。
|
|
@@ -83,7 +83,8 @@ export type Thread = {
|
|
|
83
83
|
updatedAt?: number;
|
|
84
84
|
};
|
|
85
85
|
|
|
86
|
-
|
|
86
|
+
/** collaborationMode 是实验字段(initialize 时开了 experimentalApi 才有):这条 thread 上次停在哪个模式 */
|
|
87
|
+
export type ThreadResponse = { thread: Thread; collaborationMode?: { mode?: string } | null };
|
|
87
88
|
export type ThreadListResponse = { data: Thread[]; nextCursor?: string | null };
|
|
88
89
|
|
|
89
90
|
/** 只列出我们会发的:文字,以及落在本机的图片。 */
|
|
@@ -156,7 +156,8 @@ export function codexMcp(mcp: ExpertRuntime["mcp"], ask: readonly string[] = [])
|
|
|
156
156
|
}
|
|
157
157
|
|
|
158
158
|
const SANDBOX_RANK = ["read-only", "workspace-write", "danger-full-access"];
|
|
159
|
-
|
|
159
|
+
// Codex 没有自动判断,按自动改文件算(hub 交过来之前已经降过级,这里兜底)
|
|
160
|
+
const PERMISSION_SANDBOX: Record<PermissionLevel, string> = { ask: "read-only", edit: "workspace-write", auto: "workspace-write", full: "danger-full-access" };
|
|
160
161
|
|
|
161
162
|
/** 用户自己配的 MCP 服务(config.toml 里的 mcp_servers)。名字因人而异,只能读出来再逐个关 */
|
|
162
163
|
let userMcpCache: { names: string[]; at: number } | null = null;
|
|
@@ -318,6 +319,14 @@ export class CodexSession implements AgentSession {
|
|
|
318
319
|
/** 全部放行:对话选了「完全允许」,或者用户点过「本会话全部允许」(点出来的只在内存里,会话对象一换就重新逐条询问)。 */
|
|
319
320
|
private allowAll = false;
|
|
320
321
|
private replyText = "";
|
|
322
|
+
/** 这一轮是按计划模式跑的;planText 是它出的方案,轮次结束后拿来问用户开不开始做 */
|
|
323
|
+
private turnPlan = false;
|
|
324
|
+
private planText = "";
|
|
325
|
+
/**
|
|
326
|
+
* 这条 thread 当前停在计划模式:collaborationMode 会留在 thread 上,关掉计划模式后要显式切回 default 一次。
|
|
327
|
+
* 恢复 thread 时按响应里的 collaborationMode 定
|
|
328
|
+
*/
|
|
329
|
+
private planOnThread = false;
|
|
321
330
|
/** 本轮所有模型请求的用量,和会话汇总使用相同的输入 / 缓存 / 输出口径。 */
|
|
322
331
|
private turnTokens: number | undefined;
|
|
323
332
|
/** 上次看到的 thread 累计 token 数:变了才说明有新的模型请求(同一次请求可能报好几遍) */
|
|
@@ -549,6 +558,7 @@ export class CodexSession implements AgentSession {
|
|
|
549
558
|
throw new DisposedError();
|
|
550
559
|
}
|
|
551
560
|
this.adopt(res.thread);
|
|
561
|
+
this.planOnThread = res.collaborationMode?.mode === "plan";
|
|
552
562
|
// 到这里分叉才算完成;之前任何一步失败,下次重试都还会走 thread/fork,绝不会续写原会话
|
|
553
563
|
if (fork) this.forked = true;
|
|
554
564
|
return res.thread.id;
|
|
@@ -608,6 +618,8 @@ export class CodexSession implements AgentSession {
|
|
|
608
618
|
private startTurn(input: UserInput): void {
|
|
609
619
|
this.currentInput = input;
|
|
610
620
|
this.replyText = "";
|
|
621
|
+
this.planText = "";
|
|
622
|
+
this.turnPlan = false;
|
|
611
623
|
this.turnTokens = undefined;
|
|
612
624
|
this.turnSeen = false;
|
|
613
625
|
this.phase = "starting";
|
|
@@ -633,6 +645,7 @@ export class CodexSession implements AgentSession {
|
|
|
633
645
|
if (this.disposed) throw new DisposedError();
|
|
634
646
|
if (token !== this.turnSeq) throw new DisposedError(); // 等 thread 期间被停止了
|
|
635
647
|
startedOn = threadId;
|
|
648
|
+
const collaborationMode = this.collaborationMode();
|
|
636
649
|
return appServer.call<{ turn?: { id?: string } }>("turn/start", {
|
|
637
650
|
threadId,
|
|
638
651
|
input: [
|
|
@@ -646,6 +659,7 @@ export class CodexSession implements AgentSession {
|
|
|
646
659
|
sandboxPolicy: sandboxPolicyFor(this.sandboxMode, this.opts.cwd),
|
|
647
660
|
...(this.opts.model ? { model: this.opts.model } : {}),
|
|
648
661
|
...(this.opts.effort ? { effort: this.opts.effort } : {}),
|
|
662
|
+
...(collaborationMode ? { collaborationMode } : {}),
|
|
649
663
|
});
|
|
650
664
|
})
|
|
651
665
|
.then((res) => {
|
|
@@ -683,6 +697,47 @@ export class CodexSession implements AgentSession {
|
|
|
683
697
|
}
|
|
684
698
|
}
|
|
685
699
|
|
|
700
|
+
/**
|
|
701
|
+
* 这一轮要带的 collaborationMode:开着计划模式就是 plan;刚关掉的话切回 default 一次(模式会留在 thread 上)。
|
|
702
|
+
* settings.model 是必填的,按这条会话当前的模型给(thread 打开后一定知道);developer_instructions 给 null 用 Codex 内置的说明
|
|
703
|
+
*/
|
|
704
|
+
private collaborationMode(): Record<string, unknown> | undefined {
|
|
705
|
+
const plan = !!this.opts.plan;
|
|
706
|
+
if (!plan && !this.planOnThread) return undefined;
|
|
707
|
+
const model = this.opts.model ?? this.runtime.model;
|
|
708
|
+
if (!model) return undefined;
|
|
709
|
+
this.turnPlan = plan;
|
|
710
|
+
this.planOnThread = plan;
|
|
711
|
+
return { mode: plan ? "plan" : "default", settings: { model, reasoning_effort: this.opts.effort ?? this.runtime.effort ?? null, developer_instructions: null } };
|
|
712
|
+
}
|
|
713
|
+
|
|
714
|
+
/** 下一轮生效 */
|
|
715
|
+
async setPlan(on: boolean): Promise<void> {
|
|
716
|
+
this.opts.plan = on;
|
|
717
|
+
}
|
|
718
|
+
|
|
719
|
+
/**
|
|
720
|
+
* 计划模式那一轮只出方案就结束了:弹一张不阻塞的卡问开不开始做(和 Codex 自己界面上的「按这个方案实施?」一样)。
|
|
721
|
+
* 批准就关掉计划模式,替用户发一句「开始执行」;用户另外发了消息(比如说要改哪里)卡就撤掉,照旧留在计划模式
|
|
722
|
+
*/
|
|
723
|
+
private askPlanApproval(): void {
|
|
724
|
+
void this.host({
|
|
725
|
+
kind: "approval",
|
|
726
|
+
title: "方案出好了,按这个开始做?",
|
|
727
|
+
detail: "方案见上面的回复。开始执行后关闭计划模式,按这条对话的权限动手;想改的话直接发消息说。",
|
|
728
|
+
allowLabel: "开始执行",
|
|
729
|
+
denyLabel: "继续改方案",
|
|
730
|
+
detached: true,
|
|
731
|
+
})
|
|
732
|
+
.then((outcome) => {
|
|
733
|
+
if (this.disposed || (outcome.settlement !== "allow-once" && outcome.settlement !== "allow-always")) return;
|
|
734
|
+
this.opts.plan = false;
|
|
735
|
+
this.events.onPlanMode?.(false);
|
|
736
|
+
this.events.onFollowUp?.("按这个方案开始执行。");
|
|
737
|
+
})
|
|
738
|
+
.catch((err) => console.warn("[codex] 方案确认卡没能弹出:", err));
|
|
739
|
+
}
|
|
740
|
+
|
|
686
741
|
/** 记下来,下一轮 turn/start 带上即可。 */
|
|
687
742
|
async setModel(model?: string, effort?: string): Promise<void> {
|
|
688
743
|
if (model !== undefined) this.opts.model = model;
|
|
@@ -974,6 +1029,8 @@ export class CodexSession implements AgentSession {
|
|
|
974
1029
|
...(this.turnTokens !== undefined ? { tokens: this.turnTokens } : {}),
|
|
975
1030
|
...(turn.id ? { anchor: turn.id } : {}),
|
|
976
1031
|
});
|
|
1032
|
+
// 用户已经排了下一条(多半就是要改方案)就不问了;计划模式期间又被关掉的也不问
|
|
1033
|
+
if (this.turnPlan && this.planText && this.opts.plan && this.queue.length === 0) this.askPlanApproval();
|
|
977
1034
|
}
|
|
978
1035
|
this.drainQueue();
|
|
979
1036
|
return;
|
|
@@ -1071,6 +1128,13 @@ export class CodexSession implements AgentSession {
|
|
|
1071
1128
|
case "plan": {
|
|
1072
1129
|
if (phase !== "completed") return;
|
|
1073
1130
|
const plan = item as Extract<ThreadItem, { type: "plan" }>;
|
|
1131
|
+
// 计划模式出的方案就是这一轮的回复(实测这一轮往往没有别的正文)
|
|
1132
|
+
if (this.turnPlan && plan.text.trim()) {
|
|
1133
|
+
this.planText = plan.text;
|
|
1134
|
+
this.replyText += (this.replyText ? "\n\n" : "") + plan.text;
|
|
1135
|
+
this.events.onText(plan.text);
|
|
1136
|
+
return;
|
|
1137
|
+
}
|
|
1074
1138
|
this.events.onStep("note", `📋 ${summarize(plan.text, 90)}`);
|
|
1075
1139
|
return;
|
|
1076
1140
|
}
|
|
@@ -62,10 +62,10 @@ export function approvalCard(interaction: Interaction, ctx: CardCtx) {
|
|
|
62
62
|
if (spec.kind !== "approval") throw new Error("不是审批");
|
|
63
63
|
const id = interaction.id;
|
|
64
64
|
const buttons = [
|
|
65
|
-
button("允许一次", { a: "approval", r: id, d: "allow-once" }, ctx, "primary"),
|
|
65
|
+
button(spec.allowLabel ?? "允许一次", { a: "approval", r: id, d: "allow-once" }, ctx, "primary"),
|
|
66
66
|
...(spec.allowSession ? [button("本会话全部允许", { a: "approval", r: id, d: "allow-session" }, ctx)] : []),
|
|
67
67
|
...(spec.alwaysLabel ? [button(spec.alwaysLabel, { a: "approval", r: id, d: "allow-always" }, ctx)] : []),
|
|
68
|
-
button("拒绝", { a: "approval", r: id, d: "deny" }, ctx, "danger"),
|
|
68
|
+
button(spec.denyLabel ?? "拒绝", { a: "approval", r: id, d: "deny" }, ctx, "danger"),
|
|
69
69
|
];
|
|
70
70
|
return card(
|
|
71
71
|
[
|
|
@@ -131,10 +131,15 @@ export function settledCard(interaction: Interaction) {
|
|
|
131
131
|
const by = settled?.by ?? "";
|
|
132
132
|
if (interaction.spec.kind === "approval") {
|
|
133
133
|
const ok = settlement === "allow-once" || settlement === "allow-always" || settlement === "allow-session";
|
|
134
|
+
const spec = interaction.spec;
|
|
134
135
|
const label =
|
|
135
136
|
settlement === "allow-always"
|
|
136
|
-
? `已允许(${
|
|
137
|
-
:
|
|
137
|
+
? `已允许(${spec.alwaysLabel ?? "后续同类自动放行"})`
|
|
138
|
+
: settlement === "allow-once" && spec.allowLabel
|
|
139
|
+
? `已选「${spec.allowLabel}」`
|
|
140
|
+
: settlement === "deny" && spec.denyLabel
|
|
141
|
+
? `已选「${spec.denyLabel}」`
|
|
142
|
+
: SETTLEMENT_LABEL[settlement];
|
|
138
143
|
return card([{ tag: "markdown", content: `请求 \`${interaction.id}\` ${by}` }], {
|
|
139
144
|
title: `${label}:${interaction.spec.title.replace(/^需要授权:/, "")}`,
|
|
140
145
|
template: ok ? "green" : "grey",
|
package/src/channels/web/api.ts
CHANGED
|
@@ -31,6 +31,7 @@ import {
|
|
|
31
31
|
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
|
+
import { builtinAgentDefaults } from "../../core/builtin-agents.js";
|
|
34
35
|
import { appendDirOrder, getDirOrder, getSidebarNav, setDirOrder, setSidebarNav } from "../../core/ui-prefs.js";
|
|
35
36
|
import {
|
|
36
37
|
addMemoryItem,
|
|
@@ -726,6 +727,8 @@ export async function handleApi(req: IncomingMessage, res: ServerResponse, url:
|
|
|
726
727
|
// 项目和飞书分组的混合顺序,跟着账号走;沿用目录排序字段兼容旧数据
|
|
727
728
|
dirOrder: getDirOrder(user.id) ?? null,
|
|
728
729
|
sidebarNav: getSidebarNav(user.id),
|
|
730
|
+
// 新对话没选级别时按哪一级(设置 → Agent),按引擎
|
|
731
|
+
defaultPermission: Object.fromEntries(Object.entries(builtinAgentDefaults(user.id)).map(([engine, d]) => [engine, d.permission])),
|
|
729
732
|
pending,
|
|
730
733
|
user: publicMe(user),
|
|
731
734
|
remote: remoteStatus(user),
|
|
@@ -1226,6 +1229,11 @@ export async function handleApi(req: IncomingMessage, res: ServerResponse, url:
|
|
|
1226
1229
|
text = await hub.setPermission(key, value ? (value as PermissionLevel) : undefined, admin);
|
|
1227
1230
|
break;
|
|
1228
1231
|
}
|
|
1232
|
+
case "plan": {
|
|
1233
|
+
if (value && value !== "on" && value !== "off") throw new HttpError(400, "计划模式只能是 on 或 off");
|
|
1234
|
+
text = await hub.setPlan(key, value ? value === "on" : undefined);
|
|
1235
|
+
break;
|
|
1236
|
+
}
|
|
1229
1237
|
// 换专家(开新会话):只有飞书的对话能换,网页上的 hub 会拒绝
|
|
1230
1238
|
case "agent":
|
|
1231
1239
|
text = await hub.setExpert(key, value, allowedAgentsFor(key));
|
|
@@ -307,7 +307,8 @@ export class WeixinBot {
|
|
|
307
307
|
if (i.spec.kind === "approval") {
|
|
308
308
|
const decision = parseApproval(text, i, this.admin);
|
|
309
309
|
if (decision === undefined) {
|
|
310
|
-
|
|
310
|
+
// 不阻塞的卡(Codex 出完方案问开不开始做):另外发消息就是不用它了,照常发给 agent
|
|
311
|
+
if (!i.spec.detached) this.say(`还有一个授权在等你:回复 1 ${i.spec.allowLabel ?? "允许一次"},回复 0 ${i.spec.denyLabel ?? "拒绝"}。这条消息已排队,处理完授权才会发给 agent。`);
|
|
311
312
|
return false;
|
|
312
313
|
}
|
|
313
314
|
if (tooSoon) {
|
|
@@ -66,12 +66,12 @@ export function approvalPrompt(i: Interaction, isAdmin: boolean, timeoutMin: num
|
|
|
66
66
|
clip(spec.detail, 2500),
|
|
67
67
|
"",
|
|
68
68
|
"回复数字:",
|
|
69
|
-
|
|
69
|
+
`1 ${spec.allowLabel ?? "允许一次"}`,
|
|
70
70
|
...(spec.allowSession ? ["2 本会话全部允许"] : []),
|
|
71
71
|
...(canAlways(spec, isAdmin) ? [`3 ${spec.alwaysLabel}`] : []),
|
|
72
|
-
|
|
72
|
+
`0 ${spec.denyLabel ?? "拒绝"}`,
|
|
73
73
|
"",
|
|
74
|
-
`网页上也能处理。${timeoutMin} 分钟没回应按拒绝。`,
|
|
74
|
+
spec.detached ? "网页上也能处理。直接发消息就是不用这张卡。" : `网页上也能处理。${timeoutMin} 分钟没回应按拒绝。`,
|
|
75
75
|
].join("\n");
|
|
76
76
|
}
|
|
77
77
|
|
|
@@ -80,8 +80,8 @@ export function parseApproval(text: string, i: Interaction, isAdmin: boolean): A
|
|
|
80
80
|
const spec = i.spec;
|
|
81
81
|
if (spec.kind !== "approval") return undefined;
|
|
82
82
|
const t = text.trim();
|
|
83
|
-
if (t === "1" || t === "允许") return "allow-once";
|
|
84
|
-
if (t === "0" || t === "拒绝") return "deny";
|
|
83
|
+
if (t === "1" || t === "允许" || (!!spec.allowLabel && t === spec.allowLabel)) return "allow-once";
|
|
84
|
+
if (t === "0" || t === "拒绝" || (!!spec.denyLabel && t === spec.denyLabel)) return "deny";
|
|
85
85
|
if (t === "2" && spec.allowSession) return "allow-session";
|
|
86
86
|
if (t === "3" && canAlways(spec, isAdmin)) return "allow-always";
|
|
87
87
|
return undefined;
|
|
@@ -8,6 +8,7 @@ import { activeSkills } from "./skills.js";
|
|
|
8
8
|
import { sessionSkills } from "./skill-runtime.js";
|
|
9
9
|
import { getUser } from "./users.js";
|
|
10
10
|
import type { SessionOptions } from "./types.js";
|
|
11
|
+
import { DEFAULT_PERMISSION_LEVELS, engineSupports, type PermissionLevel } from "./permission.js";
|
|
11
12
|
|
|
12
13
|
export type BuiltinAgentDefaults = {
|
|
13
14
|
/** null = 全部已启用的个人技能;[] = 不加载个人技能 */
|
|
@@ -15,18 +16,42 @@ export type BuiltinAgentDefaults = {
|
|
|
15
16
|
machineSkills: boolean;
|
|
16
17
|
/** null = 沿用机器配置;[] = 不加载 MCP(系统工具除外) */
|
|
17
18
|
mcp: string[] | null;
|
|
19
|
+
/**
|
|
20
|
+
* 这个人用这个引擎的对话默认按哪一级权限(没单独选过级别的对话都按它,专家照样按自己的权限封顶)。
|
|
21
|
+
* null = 跟随引擎(Claude 逐次询问,Codex 按设置里的沙箱)。和技能、MCP 不同,自定义专家的对话也按它
|
|
22
|
+
*/
|
|
23
|
+
permission: PermissionLevel | null;
|
|
18
24
|
};
|
|
19
25
|
type Defaults = Record<Engine, BuiltinAgentDefaults>;
|
|
20
26
|
const file = path.join(dataDir, "builtin-agents.json");
|
|
21
27
|
export const builtinAgentEvents = new EventEmitter<{ changed: [owner: string] }>();
|
|
22
28
|
|
|
29
|
+
// 对话列表里每条都要算默认权限,不能每次都读盘。只有本文件写它
|
|
30
|
+
let cache: Record<string, Partial<Defaults>> | null = null;
|
|
31
|
+
function readAll(): Record<string, Partial<Defaults>> {
|
|
32
|
+
return (cache ??= readJson<Record<string, Partial<Defaults>>>(file, {}));
|
|
33
|
+
}
|
|
34
|
+
function writeAll(all: Record<string, Partial<Defaults>>): void {
|
|
35
|
+
writeJsonAtomic(file, all);
|
|
36
|
+
cache = all;
|
|
37
|
+
}
|
|
38
|
+
|
|
39
|
+
function storedPermission(value: unknown, engine: Engine, admin: boolean): PermissionLevel | null {
|
|
40
|
+
if (!(DEFAULT_PERMISSION_LEVELS as readonly unknown[]).includes(value)) return null;
|
|
41
|
+
const level = value as PermissionLevel;
|
|
42
|
+
// 成员最高到自动改文件(见 hub.permissionMax);管理员降级成成员后,以前存的高一级不再算数
|
|
43
|
+
if (!engineSupports(engine, level) || (level === "auto" && !admin)) return null;
|
|
44
|
+
return level;
|
|
45
|
+
}
|
|
46
|
+
|
|
23
47
|
export function builtinAgentDefaults(owner: string): Defaults {
|
|
24
48
|
const admin = getUser(owner)?.role === "admin";
|
|
25
|
-
const stored =
|
|
49
|
+
const stored = readAll()[owner];
|
|
26
50
|
const defaults = (engine: Engine): BuiltinAgentDefaults => ({
|
|
27
51
|
skills: stored?.[engine]?.skills ?? null,
|
|
28
52
|
machineSkills: admin && stored?.[engine]?.machineSkills !== false,
|
|
29
53
|
mcp: stored?.[engine]?.mcp ?? (admin ? null : []),
|
|
54
|
+
permission: storedPermission(stored?.[engine]?.permission, engine, admin),
|
|
30
55
|
});
|
|
31
56
|
return { claude: defaults("claude"), codex: defaults("codex") };
|
|
32
57
|
}
|
|
@@ -70,10 +95,16 @@ export function setBuiltinAgentDefaults(owner: string, patch: unknown): Defaults
|
|
|
70
95
|
}
|
|
71
96
|
current.mcp = ids;
|
|
72
97
|
}
|
|
98
|
+
if (p.permission !== undefined) {
|
|
99
|
+
if (p.permission !== null && !(DEFAULT_PERMISSION_LEVELS as readonly unknown[]).includes(p.permission)) throw new Error("默认权限只能是逐次询问、自动改文件或自动判断");
|
|
100
|
+
const level = p.permission as PermissionLevel | null;
|
|
101
|
+
if (level && !engineSupports(engine, level)) throw new Error("「自动判断」只有 Claude Code 能用");
|
|
102
|
+
if (level === "auto" && user.role !== "admin") throw new Error("只有管理员能把「自动判断」设成默认");
|
|
103
|
+
current.permission = level;
|
|
104
|
+
}
|
|
73
105
|
}
|
|
74
|
-
const all =
|
|
75
|
-
all
|
|
76
|
-
writeJsonAtomic(file, all);
|
|
106
|
+
const all = { ...readAll(), [owner]: next };
|
|
107
|
+
writeAll(all);
|
|
77
108
|
builtinAgentEvents.emit("changed", owner);
|
|
78
109
|
return next;
|
|
79
110
|
}
|
|
@@ -88,9 +119,19 @@ export function builtinAgentSession(owner: string | undefined, engine: Engine):
|
|
|
88
119
|
};
|
|
89
120
|
}
|
|
90
121
|
|
|
122
|
+
/** 对话没单独选过级别时按哪一级(没主人的对话没有默认) */
|
|
123
|
+
export function defaultPermissionOf(owner: string | undefined, engine: string): PermissionLevel | undefined {
|
|
124
|
+
if (!owner || !getUser(owner) || !(ENGINES as readonly string[]).includes(engine)) return undefined;
|
|
125
|
+
return builtinAgentDefaults(owner)[engine as Engine].permission ?? undefined;
|
|
126
|
+
}
|
|
127
|
+
|
|
91
128
|
export function deleteBuiltinAgentDefaults(owner: string): void {
|
|
92
|
-
const all =
|
|
129
|
+
const all = { ...readAll() };
|
|
93
130
|
if (!(owner in all)) return;
|
|
94
131
|
delete all[owner];
|
|
95
|
-
|
|
132
|
+
writeAll(all);
|
|
133
|
+
}
|
|
134
|
+
|
|
135
|
+
export function resetBuiltinAgentCacheForTest(): void {
|
|
136
|
+
cache = null;
|
|
96
137
|
}
|
|
@@ -30,7 +30,8 @@ export const BUILTIN_COMMANDS: BuiltinSpec[] = [
|
|
|
30
30
|
{ name: "cd", args: "<相对目录>", description: "切换工作目录(限 workspace 内)" },
|
|
31
31
|
{ name: "pwd", description: "显示当前工作目录" },
|
|
32
32
|
{ name: "fork", description: "从当前会话分叉,原会话保留" },
|
|
33
|
-
{ name: "permission", args: "[ask|edit|full|default]", description: "查看 /
|
|
33
|
+
{ name: "permission", args: "[ask|edit|auto|full|default]", description: "查看 / 切换本对话的权限级别(逐次询问、自动改文件、自动判断、完全允许)" },
|
|
34
|
+
{ name: "planmode", args: "[on|off]", description: "开关计划模式:先出方案,批准了再动手" },
|
|
34
35
|
{ name: "autoedit", args: "[on|off]", description: "本对话自动允许改工作目录内的文件(等于 /permission edit)" },
|
|
35
36
|
// 网页上的对话中途不能换专家(新建对话时选),这几个只在飞书、微信里有
|
|
36
37
|
{ name: "expert", args: "[名称]", description: "查看 / 换专家(换了会开新会话)", chatOnly: true },
|
package/src/core/commands.ts
CHANGED
|
@@ -19,6 +19,8 @@ export type ParsedCommand =
|
|
|
19
19
|
| { kind: "status" }
|
|
20
20
|
| { kind: "pwd" }
|
|
21
21
|
| { kind: "autoedit"; on?: boolean }
|
|
22
|
+
/** 计划模式;on 不给就是切换 */
|
|
23
|
+
| { kind: "plan"; on?: boolean }
|
|
22
24
|
/** default:恢复默认;不给就是看当前级别 */
|
|
23
25
|
| { kind: "permission"; level?: PermissionLevel | "default" }
|
|
24
26
|
| { kind: "help" }
|
|
@@ -30,6 +32,7 @@ export type ParsedCommand =
|
|
|
30
32
|
const PERMISSION_ARGS: Record<string, PermissionLevel | "default"> = {
|
|
31
33
|
ask: "ask", 询问: "ask", 逐次询问: "ask",
|
|
32
34
|
edit: "edit", 自动改文件: "edit",
|
|
35
|
+
auto: "auto", 自动判断: "auto",
|
|
33
36
|
full: "full", 完全允许: "full",
|
|
34
37
|
default: "default", 默认: "default",
|
|
35
38
|
};
|
|
@@ -81,6 +84,14 @@ export function parseCommand(raw: string): ParsedCommand {
|
|
|
81
84
|
if (["off", "关", "0", "false"].includes(v)) return { kind: "autoedit", on: false };
|
|
82
85
|
return { kind: "chat", text };
|
|
83
86
|
}
|
|
87
|
+
// 不叫 /plan:那是很常见的自定义命令名,内置了会把用户已有的挤掉
|
|
88
|
+
case "planmode": {
|
|
89
|
+
const v = arg.toLowerCase();
|
|
90
|
+
if (!v) return { kind: "plan" };
|
|
91
|
+
if (["on", "开", "1", "true"].includes(v)) return { kind: "plan", on: true };
|
|
92
|
+
if (["off", "关", "0", "false"].includes(v)) return { kind: "plan", on: false };
|
|
93
|
+
return { kind: "chat", text };
|
|
94
|
+
}
|
|
84
95
|
case "permission": {
|
|
85
96
|
if (!arg) return { kind: "permission" };
|
|
86
97
|
const level = Object.hasOwn(PERMISSION_ARGS, arg.toLowerCase()) ? PERMISSION_ARGS[arg.toLowerCase()] : undefined;
|
package/src/core/hub.ts
CHANGED
|
@@ -37,7 +37,7 @@ import {
|
|
|
37
37
|
import { formatDateTime } from "./task-schedule.js";
|
|
38
38
|
import { attachmentInfo, ensureUploadsDir, KIND_LABEL } from "./uploads.js";
|
|
39
39
|
import { memoryOwnerOf, sessionMemory } from "./personal.js";
|
|
40
|
-
import { exceedsPermission, minPermission, PERMISSION_LABEL, permissionCapOfAccess, permissionOfSandbox, type PermissionLevel } from "./permission.js";
|
|
40
|
+
import { engineSupports, exceedsPermission, forEngine, minPermission, PERMISSION_LABEL, permissionCapOfAccess, permissionOfSandbox, type PermissionLevel } from "./permission.js";
|
|
41
41
|
import { readMemory } from "./memory.js";
|
|
42
42
|
import { canUseFiles, getUser, userEvents } from "./users.js";
|
|
43
43
|
import type {
|
|
@@ -61,7 +61,7 @@ import { helpText, type ParsedCommand } from "./commands.js";
|
|
|
61
61
|
import { listScheduled } from "./scheduled.js";
|
|
62
62
|
import { expertSystemPrompt, searchLabel, stripContext, wrapContext } from "./expert-prompt.js";
|
|
63
63
|
import { availableExperts, avatarUrl, canUseExpert, expertEvents, expertToolEvents, expertRuntime, getExpert, isBuiltin, type ExpertRuntime } from "./experts.js";
|
|
64
|
-
import { builtinAgentDefaults, builtinAgentEvents, builtinAgentSession } from "./builtin-agents.js";
|
|
64
|
+
import { builtinAgentDefaults, builtinAgentEvents, builtinAgentSession, defaultPermissionOf } from "./builtin-agents.js";
|
|
65
65
|
import { mcpEvents } from "./mcp.js";
|
|
66
66
|
import { isMachineCommand, sessionSkills } from "./skill-runtime.js";
|
|
67
67
|
import { skillEvents } from "./skills.js";
|
|
@@ -204,6 +204,8 @@ export type ConversationInfo = {
|
|
|
204
204
|
permission: PermissionLevel;
|
|
205
205
|
/** 这条对话最高能选到哪一级 */
|
|
206
206
|
permissionMax: PermissionLevel;
|
|
207
|
+
/** 计划模式开着:先出方案,批准了再动手 */
|
|
208
|
+
plan?: boolean;
|
|
207
209
|
/** 这条对话的专家 */
|
|
208
210
|
expert: ExpertBadge;
|
|
209
211
|
/** 这条对话有主人、会用上主人的记忆(主人自己关了记忆的话实际不会注入,见 personal.ts) */
|
|
@@ -683,6 +685,7 @@ class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd]; "p
|
|
|
683
685
|
...(binding.sessionId || binding.forkFrom || binding.parked || binding.pastSessions?.length ? { canHandoff: true } : {}),
|
|
684
686
|
permission: this.permissionOf(conv),
|
|
685
687
|
permissionMax: this.permissionMax(conv),
|
|
688
|
+
...(conv.plan ? { plan: true } : {}),
|
|
686
689
|
expert: this.expertBadge(conv),
|
|
687
690
|
...(memoryOwnerOf(conv) ? { personal: true } : {}),
|
|
688
691
|
...(conv.taskId ? { taskId: conv.taskId } : {}),
|
|
@@ -788,6 +791,7 @@ class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd]; "p
|
|
|
788
791
|
...(resumeId ? { resumeId } : {}),
|
|
789
792
|
...(fork ? { fork: true } : {}),
|
|
790
793
|
...(permission ? { permission } : {}),
|
|
794
|
+
...(conv.plan ? { plan: true } : {}),
|
|
791
795
|
...(taskOwner && getUser(taskOwner)?.role !== "admin" ? { noSessionGrant: true } : {}),
|
|
792
796
|
...(expert ? { expert } : {}),
|
|
793
797
|
...(memory ? { memory } : {}),
|
|
@@ -809,6 +813,11 @@ class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd]; "p
|
|
|
809
813
|
onTodos: (todos) => alive() && this.emitEvent(key, { type: "todos", todos }),
|
|
810
814
|
onTextDelta: (text) => alive() && this.emitEvent(key, { type: "delta", text }),
|
|
811
815
|
onText: (text) => alive() && this.emitEvent(key, { type: "text", text }),
|
|
816
|
+
onPlanMode: (on) => {
|
|
817
|
+
if (!alive() || !!getConversation(key)?.plan === on) return;
|
|
818
|
+
updateConversation(key, { plan: on || undefined });
|
|
819
|
+
this.emitEvent(key, { type: "meta" });
|
|
820
|
+
},
|
|
812
821
|
onFollowUp: (text) => {
|
|
813
822
|
if (!alive()) return;
|
|
814
823
|
try {
|
|
@@ -1499,7 +1508,7 @@ class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd]; "p
|
|
|
1499
1508
|
channel: "weixin", channelId: conv.channelId,
|
|
1500
1509
|
agent: conv.agent, expert: conv.expert, owner: conv.owner,
|
|
1501
1510
|
cwd: conv.cwd, cwdExplicit: conv.cwdExplicit,
|
|
1502
|
-
...(
|
|
1511
|
+
...carriedPermission(conv),
|
|
1503
1512
|
perAgent: {}, createdAt: now, activeAt: now,
|
|
1504
1513
|
...patch,
|
|
1505
1514
|
};
|
|
@@ -1635,10 +1644,14 @@ class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd]; "p
|
|
|
1635
1644
|
return !admin && conv.agent === "codex" ? minPermission(max, permissionOfSandbox(config().agents.codex.sandbox)) : max;
|
|
1636
1645
|
}
|
|
1637
1646
|
|
|
1638
|
-
/**
|
|
1647
|
+
/**
|
|
1648
|
+
* 交给 session 的级别:选过的按上限封顶,引擎不认的降一级(Codex 没有自动判断);
|
|
1649
|
+
* 没选过就按主人在设置里定的默认,也没有就是 undefined,走引擎默认。
|
|
1650
|
+
* 定时任务的专用对话不用默认:级别只跟着任务走
|
|
1651
|
+
*/
|
|
1639
1652
|
private effectivePermission(conv: Conversation): PermissionLevel | undefined {
|
|
1640
|
-
const wanted = requestedPermission(conv);
|
|
1641
|
-
return wanted ? minPermission(wanted, this.permissionMax(conv)) : undefined;
|
|
1653
|
+
const wanted = requestedPermission(conv) ?? (conv.taskId ? undefined : defaultPermissionOf(memoryOwnerOf(conv), conv.agent));
|
|
1654
|
+
return wanted ? forEngine(conv.agent, minPermission(wanted, this.permissionMax(conv))) : undefined;
|
|
1642
1655
|
}
|
|
1643
1656
|
|
|
1644
1657
|
/** 给人看的级别:没选过就换算引擎默认(Claude 逐次询问,Codex 看设置里的沙箱,不超过专家) */
|
|
@@ -1687,12 +1700,14 @@ class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd]; "p
|
|
|
1687
1700
|
private describePermission(key: string): string {
|
|
1688
1701
|
const conv = getConversation(key)!;
|
|
1689
1702
|
return [
|
|
1690
|
-
`当前权限:${PERMISSION_LABEL[this.permissionOf(conv)]}。`,
|
|
1703
|
+
`当前权限:${PERMISSION_LABEL[this.permissionOf(conv)]}${conv.plan ? ",计划模式开着" : ""}。`,
|
|
1691
1704
|
"",
|
|
1692
1705
|
"- `/permission ask`:逐次询问",
|
|
1693
1706
|
"- `/permission edit`:自动改文件",
|
|
1707
|
+
...(engineSupports(conv.agent, "auto") ? ["- `/permission auto`:自动判断(Claude 逐个判断安不安全,拿不准再问你)"] : []),
|
|
1694
1708
|
"- `/permission full`:完全允许",
|
|
1695
|
-
"- `/permission default
|
|
1709
|
+
"- `/permission default`:恢复默认(设置 → Agent 里定的默认权限)",
|
|
1710
|
+
"- `/planmode on` / `/planmode off`:开关计划模式(先出方案,你批准了再动手)",
|
|
1696
1711
|
"",
|
|
1697
1712
|
`这条对话最高能到「${PERMISSION_LABEL[this.permissionMax(conv)]}」。`,
|
|
1698
1713
|
].join("\n");
|
|
@@ -1705,6 +1720,7 @@ class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd]; "p
|
|
|
1705
1720
|
return `⚠️ 已切换为「完全允许」:agent 的操作不再询问,可以跑任意命令、改任意文件。提问和标了「调用前询问」的 MCP 照常询问;开新会话后恢复默认。${nextTurn}`;
|
|
1706
1721
|
}
|
|
1707
1722
|
if (level === "ask") return `已切换为「逐次询问」:改文件、跑命令都要先问你。${nextTurn}`;
|
|
1723
|
+
if (level === "auto") return "已切换为「自动判断」:Claude 逐个判断操作安不安全,安全的直接做,拿不准的再问你。";
|
|
1708
1724
|
return conv.agent === "codex"
|
|
1709
1725
|
? `已切换为「自动改文件」:工作目录(${conv.cwd})内可以直接改文件、跑命令,超出沙箱的要先问你。${nextTurn}`
|
|
1710
1726
|
: `已切换为「自动改文件」:修改工作目录(${conv.cwd})内的文件不再询问;目录外的文件、Bash 命令照常询问。`;
|
|
@@ -1714,6 +1730,7 @@ class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd]; "p
|
|
|
1714
1730
|
const conv = getConversation(key)!;
|
|
1715
1731
|
if (conv.taskId) return "这是定时任务的专用对话,权限跟着任务走。到定时任务页面编辑这个任务来改。";
|
|
1716
1732
|
if (level === "full" && !allowFull) return "只有管理员本人能选「完全允许」。飞书上要在私聊里、并且绑定了管理员账号。";
|
|
1733
|
+
if (level && !engineSupports(conv.agent, level)) return `「${PERMISSION_LABEL[level]}」只有 Claude Code 能用。`;
|
|
1717
1734
|
const max = this.permissionMax(conv);
|
|
1718
1735
|
if (level && exceedsPermission(level, max)) return `这条对话最高只能到「${PERMISSION_LABEL[max]}」(看对话的主人和专家的权限)。`;
|
|
1719
1736
|
this.applyPermission(key, level);
|
|
@@ -1725,6 +1742,31 @@ class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd]; "p
|
|
|
1725
1742
|
return this.serial(key, async () => this.setPermissionNow(key, level, allowFull));
|
|
1726
1743
|
}
|
|
1727
1744
|
|
|
1745
|
+
/** 计划模式。on 不给就是切换。不动权限级别:批准方案后按原来的级别干活 */
|
|
1746
|
+
private setPlanNow(key: string, on: boolean | undefined): string {
|
|
1747
|
+
const conv = getConversation(key)!;
|
|
1748
|
+
if (conv.taskId) return "定时任务的专用对话到点就要直接干活,不能开计划模式。";
|
|
1749
|
+
const next = on ?? !conv.plan;
|
|
1750
|
+
if (next === !!conv.plan) return next ? "计划模式本来就开着。" : "计划模式本来就关着。";
|
|
1751
|
+
updateConversation(key, { plan: next || undefined });
|
|
1752
|
+
const live = this.live.get(key);
|
|
1753
|
+
live?.session.setPlan?.(next)?.catch((err) => {
|
|
1754
|
+
// 没切过去:不能让它照旧动手(或一直只出方案),空闲下来按新开关重新拉起
|
|
1755
|
+
console.warn(`[${conv.agent}] ${key} 切换计划模式失败:`, err instanceof Error ? err.message : err);
|
|
1756
|
+
this.staleLive.add(live.id);
|
|
1757
|
+
this.dropIfStale(key);
|
|
1758
|
+
});
|
|
1759
|
+
this.emitEvent(key, { type: "meta" });
|
|
1760
|
+
const nextTurn = conv.agent === "codex" ? "下一轮起生效。" : "";
|
|
1761
|
+
return next
|
|
1762
|
+
? `已打开计划模式:先只读、出方案,你批准了再按「${PERMISSION_LABEL[this.permissionOf(conv)]}」动手。${nextTurn}`
|
|
1763
|
+
: `已关闭计划模式。${nextTurn}`;
|
|
1764
|
+
}
|
|
1765
|
+
|
|
1766
|
+
setPlan(key: string, on?: boolean): Promise<string> {
|
|
1767
|
+
return this.serial(key, async () => this.setPlanNow(key, on));
|
|
1768
|
+
}
|
|
1769
|
+
|
|
1728
1770
|
/** /autoedit:on 不给就是切换。「自动改文件」的旧叫法,关掉就是恢复默认 */
|
|
1729
1771
|
private setAutoEditNow(key: string, on: boolean | undefined): string {
|
|
1730
1772
|
const conv = getConversation(key)!;
|
|
@@ -2017,7 +2059,7 @@ class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd]; "p
|
|
|
2017
2059
|
`目录:${conv.cwd}`,
|
|
2018
2060
|
`模型:${runtime.model ?? "默认"}`,
|
|
2019
2061
|
...(runtime.effort ? [`思考程度:${runtime.effort}`] : []),
|
|
2020
|
-
`权限:${PERMISSION_LABEL[this.permissionOf(conv)]}(/permission 切换)`,
|
|
2062
|
+
`权限:${PERMISSION_LABEL[this.permissionOf(conv)]}${conv.plan ? ",计划模式" : ""}(/permission、/planmode 切换)`,
|
|
2021
2063
|
...(extra.length > 0 ? ["", ...extra] : []),
|
|
2022
2064
|
].join("\n");
|
|
2023
2065
|
}
|
|
@@ -2081,7 +2123,7 @@ class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd]; "p
|
|
|
2081
2123
|
cwd: conv.cwd,
|
|
2082
2124
|
...(conv.cwdExplicit ? { cwdExplicit: true } : {}),
|
|
2083
2125
|
// 「完全允许」不跟着分叉过去
|
|
2084
|
-
...(
|
|
2126
|
+
...carriedPermission(conv),
|
|
2085
2127
|
...(conv.expert ? { expert: conv.expert } : {}),
|
|
2086
2128
|
forkOf: key,
|
|
2087
2129
|
perAgent: {
|
|
@@ -2161,7 +2203,7 @@ class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd]; "p
|
|
|
2161
2203
|
cwd: conv.cwd,
|
|
2162
2204
|
...(conv.cwdExplicit ? { cwdExplicit: true } : {}),
|
|
2163
2205
|
// 和分叉一样,「完全允许」不跟过去
|
|
2164
|
-
...(
|
|
2206
|
+
...carriedPermission(conv),
|
|
2165
2207
|
forkOf: key,
|
|
2166
2208
|
handoff: true,
|
|
2167
2209
|
});
|
|
@@ -2250,6 +2292,8 @@ class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd]; "p
|
|
|
2250
2292
|
return text(getConversation(key)!.cwd);
|
|
2251
2293
|
case "autoedit":
|
|
2252
2294
|
return text(await this.setAutoEdit(key, cmd.on));
|
|
2295
|
+
case "plan":
|
|
2296
|
+
return text(await this.setPlan(key, cmd.on));
|
|
2253
2297
|
case "permission":
|
|
2254
2298
|
return text(cmd.level ? await this.setPermission(key, cmd.level === "default" ? undefined : cmd.level, ctx.allowFullAccess === true) : this.describePermission(key));
|
|
2255
2299
|
case "status":
|
|
@@ -2337,3 +2381,9 @@ class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd]; "p
|
|
|
2337
2381
|
}
|
|
2338
2382
|
|
|
2339
2383
|
export const hub = new Hub();
|
|
2384
|
+
|
|
2385
|
+
/** 分叉、交接、微信开新对话时带过去的级别:「完全允许」不跟过去,放手只是对原来那件事说的 */
|
|
2386
|
+
function carriedPermission(conv: Conversation): { permission?: PermissionLevel } {
|
|
2387
|
+
const level = requestedPermission(conv);
|
|
2388
|
+
return level && level !== "full" ? { permission: level } : {};
|
|
2389
|
+
}
|
package/src/core/interactions.ts
CHANGED
|
@@ -232,7 +232,7 @@ function publicView(entry: Entry | Interaction): Interaction {
|
|
|
232
232
|
}
|
|
233
233
|
|
|
234
234
|
export function isDetached(interaction: Interaction): boolean {
|
|
235
|
-
return
|
|
235
|
+
return !!interaction.spec.detached;
|
|
236
236
|
}
|
|
237
237
|
|
|
238
238
|
export function unansweredCount(entry: Interaction): number {
|
package/src/core/permission.ts
CHANGED
|
@@ -2,27 +2,45 @@
|
|
|
2
2
|
//
|
|
3
3
|
// ask 逐次询问 Claude:default; Codex:只读沙箱(写文件要批准)
|
|
4
4
|
// edit 自动改文件 Claude:acceptEdits; Codex:工作区可写沙箱
|
|
5
|
+
// auto 自动判断 Claude:auto(分类器逐个判断,拿不准再问);Codex 没有,按自动改文件算
|
|
5
6
|
// full 完全允许 Claude:default + 全放行;Codex:无沙箱 + 全放行
|
|
6
7
|
//
|
|
7
|
-
// 不选级别(undefined)=
|
|
8
|
+
// 不选级别(undefined)= 按主人在设置里定的默认(见 builtin-agents.ts),没定就是老行为:
|
|
9
|
+
// Claude 逐次询问,Codex 按设置里的沙箱。老对话、老任务都不受影响。
|
|
8
10
|
//
|
|
9
11
|
// 完全允许不用 Claude 的 bypassPermissions:那会让 canUseTool 变成死代码,提问卡和「调用前询问」的 MCP 都走不到。
|
|
10
12
|
// Codex 也不用 approvalPolicy: never:实测 on-request 配无沙箱一样不弹审批,还留着 MCP 审批这条路。
|
|
13
|
+
//
|
|
14
|
+
// 计划模式(先出方案、批准了再动手)不是一个级别,是和级别叠加的开关,见 store.ts 的 Conversation.plan。
|
|
11
15
|
import type { ExpertAccess } from "./experts.js";
|
|
12
16
|
|
|
13
|
-
export const PERMISSION_LEVELS = ["ask", "edit", "full"] as const;
|
|
17
|
+
export const PERMISSION_LEVELS = ["ask", "edit", "auto", "full"] as const;
|
|
14
18
|
export type PermissionLevel = (typeof PERMISSION_LEVELS)[number];
|
|
15
19
|
|
|
16
20
|
export const PERMISSION_LABEL: Record<PermissionLevel, string> = {
|
|
17
21
|
ask: "逐次询问",
|
|
18
22
|
edit: "自动改文件",
|
|
23
|
+
auto: "自动判断",
|
|
19
24
|
full: "完全允许",
|
|
20
25
|
};
|
|
21
26
|
|
|
27
|
+
/** 能当默认权限的级别:完全允许是对一次任务说的,不能默认放开 */
|
|
28
|
+
export const DEFAULT_PERMISSION_LEVELS = ["ask", "edit", "auto"] as const;
|
|
29
|
+
|
|
22
30
|
export function isPermissionLevel(v: unknown): v is PermissionLevel {
|
|
23
31
|
return typeof v === "string" && (PERMISSION_LEVELS as readonly string[]).includes(v);
|
|
24
32
|
}
|
|
25
33
|
|
|
34
|
+
/** 这个引擎认不认这一级:自动判断只有 Claude 有 */
|
|
35
|
+
export function engineSupports(agent: string, level: PermissionLevel): boolean {
|
|
36
|
+
return level !== "auto" || agent === "claude";
|
|
37
|
+
}
|
|
38
|
+
|
|
39
|
+
/** 引擎不认的级别降到它认的最近一级(Codex 的自动判断按自动改文件算) */
|
|
40
|
+
export function forEngine(agent: string, level: PermissionLevel): PermissionLevel {
|
|
41
|
+
return engineSupports(agent, level) ? level : "edit";
|
|
42
|
+
}
|
|
43
|
+
|
|
26
44
|
export function minPermission(a: PermissionLevel, b: PermissionLevel): PermissionLevel {
|
|
27
45
|
return PERMISSION_LEVELS.indexOf(a) <= PERMISSION_LEVELS.indexOf(b) ? a : b;
|
|
28
46
|
}
|
package/src/core/store.ts
CHANGED
|
@@ -64,6 +64,11 @@ export type Conversation = {
|
|
|
64
64
|
* 「自动改文件」跨 /new 保留,「完全允许」开新会话时清掉。实际生效的还要封顶,见 hub.permissionMax。
|
|
65
65
|
*/
|
|
66
66
|
permission?: PermissionLevel;
|
|
67
|
+
/**
|
|
68
|
+
* 计划模式:agent 先出方案,用户批准了才按 permission 动手。和权限级别叠加,属于对话;
|
|
69
|
+
* 方案批准后自动关掉(见 hub 的 onPlanMode)
|
|
70
|
+
*/
|
|
71
|
+
plan?: boolean;
|
|
67
72
|
/** 以前 /autoedit 记的,只读不写(Claude 下等于 permission: "edit");选过级别就清掉 */
|
|
68
73
|
autoEdit?: boolean;
|
|
69
74
|
/** 从哪条对话分叉出来的(对话 key),列表里据此显示关联 */
|
package/src/core/types.ts
CHANGED
|
@@ -60,6 +60,14 @@ export type InteractionSpec =
|
|
|
60
60
|
alwaysGlobal?: boolean;
|
|
61
61
|
/** 给了就显示「本会话全部允许」按钮。只有 agent 能真正兑现时才给 */
|
|
62
62
|
allowSession?: boolean;
|
|
63
|
+
/** 「允许一次」「拒绝」按钮换个说法(批准计划:开始执行 / 继续改方案) */
|
|
64
|
+
allowLabel?: string;
|
|
65
|
+
denyLabel?: string;
|
|
66
|
+
/**
|
|
67
|
+
* 发起方不等这张卡(Codex 出完方案那一轮已经结束了):用户另外发了消息就撤掉,
|
|
68
|
+
* 和不阻塞的提问一样(见 interactions.dismissDetached)
|
|
69
|
+
*/
|
|
70
|
+
detached?: boolean;
|
|
63
71
|
}
|
|
64
72
|
| {
|
|
65
73
|
kind: "question";
|
|
@@ -108,6 +116,8 @@ export type AgentEvents = {
|
|
|
108
116
|
onTextDelta: (delta: string) => void;
|
|
109
117
|
/** 一段完整的回复正文 */
|
|
110
118
|
onText: (text: string) => void;
|
|
119
|
+
/** agent 自己进出了计划模式(用户批准了方案、Claude 自己进了计划模式):核心据此更新对话上的开关 */
|
|
120
|
+
onPlanMode?: (on: boolean) => void;
|
|
111
121
|
/** 用户回答了不阻塞的提问(detached):把答案当下一条用户消息发出 */
|
|
112
122
|
onFollowUp?: (text: string) => void;
|
|
113
123
|
onResult: (result: TurnResult) => void;
|
|
@@ -223,6 +233,8 @@ export type SessionOptions = {
|
|
|
223
233
|
uploadsDir: string;
|
|
224
234
|
/** 权限级别(见 core/permission.ts),已按主人和专家封顶。不给 = 老行为:Claude 逐次询问,Codex 按设置里的沙箱 */
|
|
225
235
|
permission?: PermissionLevel | undefined;
|
|
236
|
+
/** 计划模式:先出方案,用户批准了再按 permission 动手(见 store.ts 的 Conversation.plan) */
|
|
237
|
+
plan?: boolean;
|
|
226
238
|
/** 不给「本会话全部允许」按钮:有主人的对话,主人不是管理员 */
|
|
227
239
|
noSessionGrant?: boolean;
|
|
228
240
|
/**
|
|
@@ -285,6 +297,8 @@ export interface AgentSession {
|
|
|
285
297
|
dispose(): Promise<void>;
|
|
286
298
|
/** 运行中切换权限级别。不追溯已经弹出的授权 */
|
|
287
299
|
setPermission?(level: PermissionLevel | undefined): Promise<void>;
|
|
300
|
+
/** 开关计划模式。Claude 立即生效,Codex 下一轮生效 */
|
|
301
|
+
setPlan?(on: boolean): Promise<void>;
|
|
288
302
|
}
|
|
289
303
|
|
|
290
304
|
export type Diagnosis = {
|
package/web/css/composer.css
CHANGED
|
@@ -520,6 +520,21 @@ textarea.sending {
|
|
|
520
520
|
min-width: 260px;
|
|
521
521
|
}
|
|
522
522
|
|
|
523
|
+
/* 计划模式那一行:开关只显示状态,点的是整行 */
|
|
524
|
+
.perm-pop .perm-plan .switch {
|
|
525
|
+
flex-shrink: 0;
|
|
526
|
+
pointer-events: none;
|
|
527
|
+
}
|
|
528
|
+
|
|
529
|
+
.perm-plan-tag {
|
|
530
|
+
padding: 0 6px;
|
|
531
|
+
border-radius: 999px;
|
|
532
|
+
font-size: 11px;
|
|
533
|
+
line-height: 18px;
|
|
534
|
+
background: color-mix(in srgb, var(--accent) 12%, transparent);
|
|
535
|
+
color: var(--accent);
|
|
536
|
+
}
|
|
537
|
+
|
|
523
538
|
@media (max-width: 480px) {
|
|
524
539
|
/* 窄屏只留盾牌,把地方让给模型按钮;完全允许仍然保留文字 */
|
|
525
540
|
.perm-pill:not(.danger) .perm-name {
|
package/web/lib/permission.js
CHANGED
|
@@ -1,12 +1,18 @@
|
|
|
1
1
|
// 权限级别的显示文案和上限换算(级别的含义见服务端 core/permission.ts)
|
|
2
|
-
export const PERMISSION_ORDER = ["ask", "edit", "full"];
|
|
2
|
+
export const PERMISSION_ORDER = ["ask", "edit", "auto", "full"];
|
|
3
3
|
|
|
4
4
|
export const PERMISSIONS = {
|
|
5
5
|
ask: { label: "逐次询问", short: "询问", desc: "改文件、跑命令都先问你" },
|
|
6
6
|
edit: { label: "自动改文件", short: "自动改文件", desc: "工作目录内改文件不再询问,其余照常问" },
|
|
7
|
+
auto: { label: "自动判断", short: "自动判断", desc: "Claude 逐个判断安不安全,安全的直接做,拿不准再问你" },
|
|
7
8
|
full: { label: "完全允许", short: "完全允许", desc: "不再询问,可以跑任意命令、改任意文件" },
|
|
8
9
|
};
|
|
9
10
|
|
|
11
|
+
/** 能设成默认的级别(完全允许只对一次任务说,不能默认) */
|
|
12
|
+
export const DEFAULT_LEVELS = ["ask", "edit", "auto"];
|
|
13
|
+
|
|
14
|
+
export const PLAN_INFO = { label: "计划模式", desc: "先只读、出方案,你批准了再按上面的权限动手" };
|
|
15
|
+
|
|
10
16
|
/** 专家的权限 → 最高能选到哪一级 */
|
|
11
17
|
export function capOfAccess(access) {
|
|
12
18
|
return !access || access === "exec" ? "full" : access === "edit" ? "edit" : "ask";
|
|
@@ -16,9 +22,22 @@ export function minPermission(a, b) {
|
|
|
16
22
|
return PERMISSION_ORDER[Math.min(PERMISSION_ORDER.indexOf(a), PERMISSION_ORDER.indexOf(b))];
|
|
17
23
|
}
|
|
18
24
|
|
|
19
|
-
/**
|
|
20
|
-
export function
|
|
21
|
-
return
|
|
25
|
+
/** 自动判断只有 Claude 有 */
|
|
26
|
+
export function engineSupports(agent, level) {
|
|
27
|
+
return level !== "auto" || agent === "claude";
|
|
28
|
+
}
|
|
29
|
+
|
|
30
|
+
/** 不超过 max、这个引擎认的级别。agent 不给就不按引擎筛 */
|
|
31
|
+
export function permissionsUpTo(max, agent) {
|
|
32
|
+
return PERMISSION_ORDER.slice(0, PERMISSION_ORDER.indexOf(max) + 1).filter((l) => !agent || engineSupports(agent, l));
|
|
33
|
+
}
|
|
34
|
+
|
|
35
|
+
/** 新对话没选级别时按哪一级:设置里定的默认,封顶后引擎不认就降到自动改文件(和服务端 hub.effectivePermission 一致) */
|
|
36
|
+
export function defaultPermissionFor(agent, max, defaults) {
|
|
37
|
+
const wanted = defaults?.[agent];
|
|
38
|
+
if (!wanted || !PERMISSIONS[wanted]) return null;
|
|
39
|
+
const capped = minPermission(wanted, max);
|
|
40
|
+
return engineSupports(agent, capped) ? capped : "edit";
|
|
22
41
|
}
|
|
23
42
|
|
|
24
43
|
export const FULL_WARNING = {
|
package/web/settings/agents.js
CHANGED
|
@@ -1,8 +1,9 @@
|
|
|
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, S } from "../state.js";
|
|
5
|
-
import { defaultEntryName, usableAgents } from "../views/topbar.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";
|
|
6
7
|
import { renderEmpty } from "../views/messages.js";
|
|
7
8
|
import { field, saveButton, saveConfig } from "./common.js";
|
|
8
9
|
import { modelPicker } from "./commands.js";
|
|
@@ -193,16 +194,25 @@ function builtinDefaultsSections(targets) {
|
|
|
193
194
|
const machine = (data.machineMcp?.[engine] ?? []).map((name) => ({ id: `${data.machinePrefix}${name}`, name: `${name}(本机)` }));
|
|
194
195
|
const mcp = picker(`${label} MCP`, [...data.mcp, ...machine], prefs.mcp, data.machineMcp ? "沿用机器上的 MCP 配置" : null);
|
|
195
196
|
const machineSkills = h("input", { type: "checkbox", checked: prefs.machineSkills });
|
|
196
|
-
|
|
197
|
+
// 成员最高到自动改文件;自动判断只有 Claude 有
|
|
198
|
+
const levels = DEFAULT_LEVELS.filter((l) => engineSupports(engine, l) && (l !== "auto" || isAdmin()));
|
|
199
|
+
const permission = h("select", { "aria-label": `${label} 默认权限` },
|
|
200
|
+
h("option", { value: "", selected: !prefs.permission }, engine === "claude" ? "跟随 Claude Code(逐次询问)" : "跟随沙箱设置"),
|
|
201
|
+
levels.map((l) => h("option", { value: l, selected: l === prefs.permission }, `${PERMISSIONS[l].label}:${PERMISSIONS[l].desc}`)));
|
|
202
|
+
fill(section, h("h4", {}, "默认权限"),
|
|
203
|
+
field("新对话的权限", permission, "没单独选过权限的对话都按这一级(输入框里的盾牌按钮可以随时改)。自定义专家也按它,但不会超过专家自己的权限;定时任务按任务里选的。「完全允许」不能设成默认。"),
|
|
204
|
+
h("h4", {}, "默认加载"),
|
|
197
205
|
h("p", { class: "skill-note" }, "仅影响你当前账号使用的这个内置 Agent,自定义专家使用各自的配置。保存后,下次发消息生效。"),
|
|
198
206
|
skills.el,
|
|
199
207
|
data.machineMcp ? h("label", { class: "check-item" }, machineSkills, "同时加载机器上的技能") : null,
|
|
200
208
|
mcp.el,
|
|
201
209
|
h("small", {}, "技能和 MCP 可分别全部取消。记忆、定时任务、技能管理等系统工具仍按功能设置提供。"),
|
|
202
210
|
h("div", { class: "row" }, saveButton(async () => {
|
|
203
|
-
await api("/api/agents/defaults", { method: "PUT", body: { agents: { [engine]: { skills: skills.value(), machineSkills: machineSkills.checked, mcp: mcp.value() } } } });
|
|
211
|
+
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() } } } });
|
|
212
|
+
S.defaultPermission = { ...S.defaultPermission, [engine]: res.agents?.[engine]?.permission ?? null };
|
|
213
|
+
renderContext();
|
|
204
214
|
toast("已保存,下次发消息生效");
|
|
205
|
-
}, `保存 ${label}
|
|
215
|
+
}, `保存 ${label} 默认设置`)));
|
|
206
216
|
}
|
|
207
217
|
if (!Object.keys(data.agents).length) {
|
|
208
218
|
const section = Object.values(targets)[0];
|
package/web/settings/commands.js
CHANGED
|
@@ -75,7 +75,7 @@ export function modelPicker(agent, model, effort, defaultLabel) {
|
|
|
75
75
|
}
|
|
76
76
|
|
|
77
77
|
/** agent-loft 内置命令名(和服务端 BUILTIN_COMMANDS 一致),自定义命令不能用 */
|
|
78
|
-
const BUILTIN_NAMES = ["new", "status", "stop", "model", "effort", "sessions", "resume", "fork", "agent", "claude", "codex", "cd", "pwd", "permission", "autoedit", "web", "detach", "approve", "help"];
|
|
78
|
+
const BUILTIN_NAMES = ["new", "status", "stop", "model", "effort", "sessions", "resume", "fork", "agent", "claude", "codex", "cd", "pwd", "permission", "planmode", "autoedit", "web", "detach", "approve", "help"];
|
|
79
79
|
|
|
80
80
|
/**
|
|
81
81
|
* 添加 / 编辑一条自定义命令。onSave 返回 true 才关窗;失败(比如服务端校验没过)留着让用户改。
|
package/web/state.js
CHANGED
|
@@ -7,6 +7,10 @@ export const S = {
|
|
|
7
7
|
pending: new Map(),
|
|
8
8
|
/** 侧栏菜单的显示和顺序,随账号保存;null 使用默认配置。 */
|
|
9
9
|
sidebarNav: null,
|
|
10
|
+
/** 设置 → Agent 里定的默认权限,按引擎:{ claude: "edit", codex: null } */
|
|
11
|
+
defaultPermission: null,
|
|
12
|
+
/** 新对话里打开的计划模式(和 draftPermission 一样,建好对话后带过去) */
|
|
13
|
+
draftPlan: false,
|
|
10
14
|
current: null,
|
|
11
15
|
/** 新对话的引擎(claude / codex),跟着选的专家走 */
|
|
12
16
|
draftAgent: localStorage.getItem("aim.agent") || null,
|
package/web/views/composer.js
CHANGED
|
@@ -226,10 +226,11 @@ export async function ensureConversation() {
|
|
|
226
226
|
S.draftCwdPicked = false;
|
|
227
227
|
// 新对话里选过模型 / 思考程度:建好会话后先切过去再发消息
|
|
228
228
|
// 权限只对这一条新对话有效,不留给下一条(不放进按专家记住的 draftPick)
|
|
229
|
-
const pick = { ...draftPick(), permission: S.draftPermission };
|
|
229
|
+
const pick = { ...draftPick(), permission: S.draftPermission, plan: S.draftPlan ? "on" : null };
|
|
230
230
|
S.draftPermission = null;
|
|
231
|
-
|
|
232
|
-
|
|
231
|
+
S.draftPlan = false;
|
|
232
|
+
const FAILED = { model: "切换模型", effort: "切换思考程度", permission: "设置权限", plan: "打开计划模式" };
|
|
233
|
+
for (const [action, value] of [["model", pick.model], ["effort", pick.effort], ["permission", pick.permission], ["plan", pick.plan]]) {
|
|
233
234
|
if (!value) continue;
|
|
234
235
|
try {
|
|
235
236
|
const res = await api(`/api/conversations/${encodeURIComponent(info.key)}/action`, { method: "POST", body: { action, value } });
|
|
@@ -8,7 +8,7 @@ import { closeMenu, confirmDialog, modal, placePopover, showPopover } from "../l
|
|
|
8
8
|
import { newDraft, openConversation, renderEmpty } from "./messages.js";
|
|
9
9
|
import { setDraftExpert } from "./experts.js";
|
|
10
10
|
import { preloadCommands } from "./slash.js";
|
|
11
|
-
import { FULL_WARNING, PERMISSIONS, permissionsUpTo } from "../lib/permission.js";
|
|
11
|
+
import { FULL_WARNING, PERMISSIONS, permissionsUpTo, PLAN_INFO } from "../lib/permission.js";
|
|
12
12
|
|
|
13
13
|
// ---------- 会话操作 ----------
|
|
14
14
|
|
|
@@ -169,8 +169,11 @@ export async function openModelPicker(anchor = ui.modelSlot) {
|
|
|
169
169
|
render();
|
|
170
170
|
}
|
|
171
171
|
|
|
172
|
-
/**
|
|
173
|
-
|
|
172
|
+
/**
|
|
173
|
+
* 权限级别 + 计划模式开关:已有对话直接切,新对话先记下,建好对话后带过去。
|
|
174
|
+
* max、current、agent、plan 由输入框上的按钮算好传进来(自动判断只有 Claude 有)
|
|
175
|
+
*/
|
|
176
|
+
export function openPermissionPicker(anchor, { current, max, agent, plan }) {
|
|
174
177
|
if (ui.menu?.dataset.for === "permission") return closeMenu();
|
|
175
178
|
const pop = showPopover(anchor, { align: "left" });
|
|
176
179
|
pop.dataset.for = "permission";
|
|
@@ -186,10 +189,19 @@ export function openPermissionPicker(anchor, { current, max }) {
|
|
|
186
189
|
renderContext();
|
|
187
190
|
}
|
|
188
191
|
};
|
|
192
|
+
const togglePlan = async (on) => {
|
|
193
|
+
closeMenu();
|
|
194
|
+
if (S.current) {
|
|
195
|
+
await doAction("plan", on ? "on" : "off");
|
|
196
|
+
} else {
|
|
197
|
+
S.draftPlan = on;
|
|
198
|
+
renderContext();
|
|
199
|
+
}
|
|
200
|
+
};
|
|
189
201
|
fill(
|
|
190
202
|
pop,
|
|
191
203
|
h("div", { class: "pop-head" }, "权限"),
|
|
192
|
-
permissionsUpTo(max).map((level) =>
|
|
204
|
+
permissionsUpTo(max, agent).map((level) =>
|
|
193
205
|
h(
|
|
194
206
|
"button",
|
|
195
207
|
{ class: `pop-item${level === current ? " on" : ""}`, onclick: () => void choose(level) },
|
|
@@ -197,6 +209,14 @@ export function openPermissionPicker(anchor, { current, max }) {
|
|
|
197
209
|
level === current ? h("span", { class: "check" }, "✓") : null,
|
|
198
210
|
),
|
|
199
211
|
),
|
|
212
|
+
h("div", { class: "sep" }),
|
|
213
|
+
// 整行是一个按钮,开关只是显示状态
|
|
214
|
+
h(
|
|
215
|
+
"button",
|
|
216
|
+
{ class: "pop-item perm-plan", role: "switch", "aria-checked": String(!!plan), onclick: () => void togglePlan(!plan) },
|
|
217
|
+
h("span", { class: "grow" }, h("span", { class: "t" }, PLAN_INFO.label), h("span", { class: "s" }, PLAN_INFO.desc)),
|
|
218
|
+
h("span", { class: "switch", "aria-hidden": "true" }, h("input", { type: "checkbox", checked: !!plan, tabindex: -1 }), h("span", { class: "slider" })),
|
|
219
|
+
),
|
|
200
220
|
);
|
|
201
221
|
placePopover(pop, anchor);
|
|
202
222
|
}
|
package/web/views/interaction.js
CHANGED
|
@@ -45,7 +45,11 @@ export function insertCard(ix) {
|
|
|
45
45
|
}
|
|
46
46
|
|
|
47
47
|
/** 已处理:「已回答 · 已在 Web 处理」。从会话记录里还原的不知道是谁处理的,只写结果 */
|
|
48
|
-
const settledText = (s
|
|
48
|
+
const settledText = (s, spec) => {
|
|
49
|
+
// 换过按钮文字的卡(批准方案)按按钮上的说法回显
|
|
50
|
+
const custom = s.settlement === "allow-once" ? spec?.allowLabel : s.settlement === "deny" ? spec?.denyLabel : undefined;
|
|
51
|
+
return [custom ? `已选「${custom}」` : (SETTLE_LABEL[s.settlement] ?? s.settlement), s.by].filter(Boolean).join(" · ");
|
|
52
|
+
};
|
|
49
53
|
|
|
50
54
|
function notifyIfHidden(ix) {
|
|
51
55
|
// 桌面端由服务端的 notice 统一弹,这里再弹就重复了
|
|
@@ -87,22 +91,22 @@ export function renderInteraction(item) {
|
|
|
87
91
|
return h(
|
|
88
92
|
"div",
|
|
89
93
|
{ class: `ix-card${settled ? " settled" : ""}` },
|
|
90
|
-
h("div", { class: "ix-title" }, settled ? "" : "⚠️", spec.title),
|
|
94
|
+
h("div", { class: "ix-title" }, settled ? "" : spec.allowLabel ? "📋" : "⚠️", spec.title),
|
|
91
95
|
h("div", { class: "ix-detail" }, renderMarkdown(spec.detail)),
|
|
92
96
|
settled
|
|
93
|
-
? h("div", { class: "ix-meta" }, settledText(settled))
|
|
97
|
+
? h("div", { class: "ix-meta" }, settledText(settled, spec))
|
|
94
98
|
: h(
|
|
95
99
|
"div",
|
|
96
100
|
{ class: "ix-buttons" },
|
|
97
101
|
spec.allowSession
|
|
98
102
|
? h("button", { class: "btn primary", onclick: () => ixOp(ix.id, "decide", { decision: "allow-session" }) }, "本会话全部允许")
|
|
99
103
|
: null,
|
|
100
|
-
h("button", { class: `btn${spec.allowSession ? "" : " accent"}`, onclick: () => ixOp(ix.id, "decide", { decision: "allow-once" }) }, "允许一次"),
|
|
104
|
+
h("button", { class: `btn${spec.allowSession ? "" : " accent"}`, onclick: () => ixOp(ix.id, "decide", { decision: "allow-once" }) }, spec.allowLabel ?? "允许一次"),
|
|
101
105
|
// 会落盘、对所有人生效的「总是允许」只给管理员
|
|
102
106
|
spec.alwaysLabel && (!spec.alwaysGlobal || isAdmin())
|
|
103
107
|
? h("button", { class: "btn", onclick: () => ixOp(ix.id, "decide", { decision: "allow-always" }) }, spec.alwaysLabel)
|
|
104
108
|
: null,
|
|
105
|
-
h("button", { class:
|
|
109
|
+
h("button", { class: `btn${spec.denyLabel ? "" : " danger"}`, onclick: () => ixOp(ix.id, "decide", { decision: "deny" }) }, spec.denyLabel ?? "拒绝"),
|
|
106
110
|
),
|
|
107
111
|
);
|
|
108
112
|
}
|
package/web/views/sidebar.js
CHANGED
|
@@ -446,6 +446,7 @@ export function bootstrapQuery() {
|
|
|
446
446
|
|
|
447
447
|
export function applyBootstrap(data) {
|
|
448
448
|
S.sidebarNav = data.sidebarNav ?? null;
|
|
449
|
+
S.defaultPermission = data.defaultPermission ?? null;
|
|
449
450
|
S.convs = new Map(data.conversations.map((c) => [c.key, c]));
|
|
450
451
|
pages.full = !data.sidebar;
|
|
451
452
|
// bootstrap 只带 IM 分组最近/当前的一条;展开的列表需要重新补齐。
|
package/web/views/tasks.js
CHANGED
|
@@ -456,7 +456,7 @@ export function openTaskForm(task, preset) {
|
|
|
456
456
|
let permissionValue = src.permission ?? "";
|
|
457
457
|
const syncPermission = () => {
|
|
458
458
|
const max = minPermission(isAdmin() ? "full" : "edit", capOfAccess(findExpert(expert.value)?.access));
|
|
459
|
-
const levels = permissionsUpTo(max);
|
|
459
|
+
const levels = permissionsUpTo(max, findExpert(expert.value)?.engine);
|
|
460
460
|
// 已经存着的级别高过现在的上限(被降级了、换了专家):不留着,免得显示的和实际跑的不一样
|
|
461
461
|
if (permissionValue && !levels.includes(permissionValue)) permissionValue = "";
|
|
462
462
|
fill(
|
|
@@ -486,7 +486,7 @@ export function openTaskForm(task, preset) {
|
|
|
486
486
|
const info = target.value === "dedicated" ? null : convTargetInfo(target.value, task);
|
|
487
487
|
if (!info) return fill(convBox);
|
|
488
488
|
const label = PERMISSIONS[info.permission]?.label ?? "默认";
|
|
489
|
-
const levels = info.max ? permissionsUpTo(info.max) : [];
|
|
489
|
+
const levels = info.max ? permissionsUpTo(info.max, info.expert?.engine) : [];
|
|
490
490
|
if (!info.locked && levels.length > 1) {
|
|
491
491
|
convPermission = h("select", { class: "task-conv-permission" }, levels.map((l) => h("option", { value: l, selected: l === info.permission }, `${PERMISSIONS[l].label}:${PERMISSIONS[l].desc}`)));
|
|
492
492
|
}
|
package/web/views/topbar.js
CHANGED
|
@@ -8,7 +8,7 @@ import { closeMenu, modal, placePopover, showMenu, showPopover, submenuButton }
|
|
|
8
8
|
import { openConversation } from "./messages.js";
|
|
9
9
|
import { openSchedule } from "./schedule.js";
|
|
10
10
|
import { changeCwd, deleteConv, doAction, forkConversation, handoffConversation, openModelPicker, openPermissionPicker, renameConv, switchAgent } from "./conv-actions.js";
|
|
11
|
-
import { capOfAccess, minPermission,
|
|
11
|
+
import { capOfAccess, defaultPermissionFor, minPermission, permissionsUpTo, PERMISSIONS } from "../lib/permission.js";
|
|
12
12
|
import { canSeeChanges, syncWorkspace, toggleWorkspace, workspaceButtons, workspaceStats } from "./workspace-entry.js";
|
|
13
13
|
|
|
14
14
|
// ---------- 顶栏 ----------
|
|
@@ -429,26 +429,31 @@ export function renderContext() {
|
|
|
429
429
|
);
|
|
430
430
|
}
|
|
431
431
|
|
|
432
|
-
/**
|
|
432
|
+
/** 输入框里的权限按钮(级别 + 计划模式)。只有一级可选(只能联网、只能读文件的专家)时不显示 */
|
|
433
433
|
function renderPermission(c, expert) {
|
|
434
434
|
if (!ui.permSlot) return;
|
|
435
|
+
const agent = c ? c.agent : S.draftAgent;
|
|
435
436
|
const max = c ? c.permissionMax : minPermission(isAdmin() ? "full" : "edit", capOfAccess(expert?.access));
|
|
436
|
-
//
|
|
437
|
-
if (!c && S.draftPermission &&
|
|
438
|
-
|
|
439
|
-
|
|
437
|
+
// 新对话选好后换了个权限低的专家、或换到了没有这一级的引擎:选的不再算数
|
|
438
|
+
if (!c && S.draftPermission && !permissionsUpTo(max, agent).includes(S.draftPermission)) S.draftPermission = null;
|
|
439
|
+
// 没选过就按设置里的默认权限(已有对话由服务端算好)
|
|
440
|
+
const current = c ? c.permission : (S.draftPermission ?? defaultPermissionFor(agent, max, S.defaultPermission));
|
|
441
|
+
const plan = c ? !!c.plan : !!S.draftPlan;
|
|
442
|
+
if (max === "ask" && (!current || current === "ask") && !plan) return fill(ui.permSlot);
|
|
440
443
|
const locked = !!c?.taskId;
|
|
444
|
+
const name = current ? PERMISSIONS[current].short : "默认权限";
|
|
441
445
|
fill(
|
|
442
446
|
ui.permSlot,
|
|
443
447
|
h(
|
|
444
448
|
"button",
|
|
445
449
|
{
|
|
446
|
-
class: `perm-pill${current === "full" ? " danger" : ""}`,
|
|
447
|
-
title: locked ? "定时任务的专用对话:权限在任务设置里改" : `权限:${current ? PERMISSIONS[current].label : "默认"},点击切换`,
|
|
448
|
-
onclick: (e) => (locked ? toast("这是定时任务的专用对话,权限在任务设置里改") : openPermissionPicker(e.currentTarget, { current, max })),
|
|
450
|
+
class: `perm-pill${current === "full" ? " danger" : ""}${plan ? " plan" : ""}`,
|
|
451
|
+
title: locked ? "定时任务的专用对话:权限在任务设置里改" : `权限:${current ? PERMISSIONS[current].label : "默认"}${plan ? ",计划模式开着" : ""},点击切换`,
|
|
452
|
+
onclick: (e) => (locked ? toast("这是定时任务的专用对话,权限在任务设置里改") : openPermissionPicker(e.currentTarget, { current, max, agent, plan })),
|
|
449
453
|
},
|
|
450
454
|
icon("shield"),
|
|
451
|
-
h("span", { class: "perm-name" },
|
|
455
|
+
h("span", { class: "perm-name" }, name),
|
|
456
|
+
plan ? h("span", { class: "perm-plan-tag" }, "计划") : null,
|
|
452
457
|
locked ? null : icon("down"),
|
|
453
458
|
),
|
|
454
459
|
);
|