im-agent 0.1.1 → 0.2.0

package/src/channels/feishu/slash-sync.ts

@@ -0,0 +1,192 @@
+// 把命令表同步成飞书的「斜杠指令」：用户在飞书输入框里打「/」就能看到并选择。
+//
+// 接口：/open-apis/application/v7/app_slash_commands（增删改查）。扫码创建的应用自带读写权限。
+// 实测出来的规矩（文档没写全，别凭感觉改）：
+//   - 指令名必须匹配 ^[a-z][a-z0-9_-]{0,31}$ —— 带冒号的 plugin skill、大写、超长的都注册不了，跳过；
+//   - 说明最长 100 字；每个应用最多 100 条；
+//   - 列表按创建时间倒序返回（后建的在前），没有排序字段。所以想要某个顺序，就得
+//     按目标顺序倒着建，每条之间隔开 1 秒以上（create_time 精确到秒，同一秒内顺序不定）；
+//   - 改动约 5 分钟生效，客户端还有约 3 分钟缓存。
+//
+// 这个应用是 im-agent 专用的：同步时会删掉不在命令表里的指令，包括手动加的。
+import type * as Lark from "@larksuiteoapi/node-sdk";
+import type { CommandEntry } from "../../core/command-catalog.js";
+
+const API = "/open-apis/application/v7/app_slash_commands";
+const NAME = /^[a-z][a-z0-9_-]{0,31}$/;
+const MAX_COMMANDS = 100;
+const MAX_DESCRIPTION = 100;
+/** create_time 精确到秒，间隔要超过 1 秒顺序才稳定 */
+const CREATE_GAP_MS = 1100;
+
+export type FeishuSlashCommand = { command: string; description: string };
+export type RemoteSlashCommand = { command_id: string; command: string; description?: { default_value?: string } };
+
+export type SlashSyncStatus = {
+  state: "idle" | "syncing" | "done" | "error";
+  /** 最近一次完成（或失败）的时间 */
+  at?: number;
+  /** 飞书上现在注册了多少条 */
+  registered?: number;
+  /** 名字不合飞书规矩、或者超出 100 条而没注册的命令 */
+  skipped?: string[];
+  /** 最近一次是否真的改了东西（没改就是已经一致） */
+  changed?: boolean;
+  error?: string;
+};
+
+function clipChars(text: string, max: number): string {
+  const chars = Array.from(text);
+  return chars.length <= max ? text : `${chars.slice(0, max - 1).join("")}…`;
+}
+
+/** 命令表 → 飞书指令。参数提示并进说明里，飞书那边没有单独的参数字段。 */
+export function toFeishuCommands(entries: CommandEntry[]): { commands: FeishuSlashCommand[]; skipped: string[] } {
+  const commands: FeishuSlashCommand[] = [];
+  const skipped: string[] = [];
+  const seen = new Set<string>();
+  for (const c of entries) {
+    if (c.hidden || seen.has(c.name)) continue;
+    seen.add(c.name);
+    if (!NAME.test(c.name) || commands.length >= MAX_COMMANDS) {
+      skipped.push(c.name);
+      continue;
+    }
+    const text = `${c.args ? `${c.args} ` : ""}${c.description}`.replace(/\s+/g, " ").trim() || c.name;
+    commands.push({ command: c.name, description: clipChars(text, MAX_DESCRIPTION) });
+  }
+  return { commands, skipped };
+}
+
+export type SyncPlan =
+  | { action: "none" }
+  | { action: "patch"; updates: { id: string; description: string }[] }
+  | { action: "rebuild" };
+
+/**
+ * remote 是飞书返回的顺序（后建的在前），desired 是想要的显示顺序（第一条在最前）。
+ * 名字和顺序都对得上，最多改改说明；否则整体重建 —— 飞书没有排序字段，只能靠重建来排。
+ */
+export function planSync(remote: RemoteSlashCommand[], desired: FeishuSlashCommand[]): SyncPlan {
+  const sameOrder =
+    remote.length === desired.length && remote.every((r, i) => r.command === desired[i]!.command);
+  if (!sameOrder) return { action: "rebuild" };
+  const updates = remote
+    .map((r, i) => ({ r, d: desired[i]! }))
+    .filter(({ r, d }) => (r.description?.default_value ?? "") !== d.description)
+    .map(({ r, d }) => ({ id: r.command_id, description: d.description }));
+  return updates.length > 0 ? { action: "patch", updates } : { action: "none" };
+}
+
+type ApiResponse<T> = { code?: number; msg?: string; data?: T };
+
+const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
+
+/**
+ * 一个机器人一个。request() 可以随便多次调用：会合并成一次，正在同步时再要求就等这次完了再跑一遍。
+ */
+export class SlashSync {
+  status: SlashSyncStatus = { state: "idle" };
+  private running = false;
+  private again = false;
+  private stopped = false;
+  private debounce: NodeJS.Timeout | null = null;
+
+  constructor(
+    private readonly lark: Lark.Client,
+    /** 现在应该注册哪些命令（已排好序） */
+    private readonly desired: () => Promise<CommandEntry[]>,
+    private readonly tag: string,
+  ) {}
+
+  /** delayMs：设置里连着点几次保存，只同步一次 */
+  request(delayMs = 3000): void {
+    if (this.stopped) return;
+    if (this.debounce) clearTimeout(this.debounce);
+    this.debounce = setTimeout(() => {
+      this.debounce = null;
+      void this.run();
+    }, delayMs);
+    this.debounce.unref?.();
+  }
+
+  stop(): void {
+    this.stopped = true;
+    if (this.debounce) clearTimeout(this.debounce);
+  }
+
+  private async run(): Promise<void> {
+    if (this.running) {
+      this.again = true;
+      return;
+    }
+    this.running = true;
+    this.status = { ...this.status, state: "syncing" };
+    try {
+      const { commands, skipped } = toFeishuCommands(await this.desired());
+      const remote = await this.list();
+      const plan = planSync(remote, commands);
+      if (plan.action === "patch") {
+        for (const u of plan.updates) {
+          await this.call("PATCH", `${API}/${u.id}`, { description: { default_value: u.description } });
+        }
+      } else if (plan.action === "rebuild") {
+        for (const r of remote) {
+          if (this.stopped) return;
+          await this.call("DELETE", `${API}/${r.command_id}`);
+        }
+        // 倒着建：最后建的显示在最前
+        for (const [i, c] of [...commands].reverse().entries()) {
+          if (this.stopped) return;
+          if (i > 0) await sleep(CREATE_GAP_MS);
+          await this.call("POST", API, { command: c.command, description: { default_value: c.description } });
+        }
+      }
+      this.status = {
+        state: "done",
+        at: Date.now(),
+        registered: commands.length,
+        skipped,
+        changed: plan.action !== "none",
+      };
+      if (plan.action !== "none") {
+        console.log(`${this.tag} 斜杠指令已同步：${commands.length} 条（${plan.action === "rebuild" ? "重建" : "更新说明"}），约 5～8 分钟后在飞书里生效`);
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      this.status = { ...this.status, state: "error", at: Date.now(), error: message };
+      console.error(`${this.tag} 斜杠指令同步失败：${message}`);
+    } finally {
+      this.running = false;
+      if (this.again && !this.stopped) {
+        this.again = false;
+        void this.run();
+      }
+    }
+  }
+
+  private async list(): Promise<RemoteSlashCommand[]> {
+    const data = await this.call<{ items?: RemoteSlashCommand[] }>("GET", API);
+    return data?.items ?? [];
+  }
+
+  private async call<T>(method: "GET" | "POST" | "PATCH" | "DELETE", url: string, data?: unknown): Promise<T | undefined> {
+    let res: ApiResponse<T>;
+    try {
+      res = await this.lark.request<ApiResponse<T>>({ method, url, ...(data !== undefined ? { data } : {}) });
+    } catch (err) {
+      const body = (err as { response?: { data?: ApiResponse<T> } })?.response?.data;
+      if (body?.code) throw new Error(explain(body.code, body.msg));
+      throw err;
+    }
+    if (res?.code) throw new Error(explain(res.code, res.msg));
+    return res?.data;
+  }
+}
+
+function explain(code: number, msg?: string): string {
+  if (code === 99991640 || code === 99991672) {
+    return `应用没有斜杠指令权限（${code}）。到飞书开发者后台给这个应用开通 application:app_slash_command:write / read，并发布新版本`;
+  }
+  return `code=${code} ${msg ?? ""}`.trim();
+}

package/src/channels/web/api.ts

@@ -134,6 +134,19 @@ function applyConfig(input: Partial<AppConfig>): void {
     const { passwordHash: _ignored, ...web } = input.web as AppConfig["web"];
     next.web = { ...next.web, ...web, passwordHash: current.web.passwordHash };
   }
+  if (input.commands) {
+    // 只收字符串数组，别的一律当没传
+    const names = (v: unknown) =>
+      Array.isArray(v) ? [...new Set(v.filter((s): s is string => typeof s === "string" && s.length > 0 && s.length < 128))] : null;
+    for (const id of AGENT_IDS) {
+      const prefs = (input.commands as Record<string, { order?: unknown; hidden?: unknown } | undefined>)[id];
+      if (!prefs) continue;
+      next.commands[id] = {
+        order: names(prefs.order) ?? next.commands[id].order,
+        hidden: names(prefs.hidden) ?? next.commands[id].hidden,
+      };
+    }
+  }
   if (input.feishu) {
     if (typeof input.feishu.watchdogMs === "number") next.feishu.watchdogMs = input.feishu.watchdogMs;
     if (Array.isArray(input.feishu.bots)) {
@@ -413,6 +426,38 @@ export async function handleApi(req: IncomingMessage, res: ServerResponse, url:
     sendJson(res, 200, publicConfig());
     return;
   }
+  {
+    // 设置页的模型下拉框：不需要会话。
+    // 未启用的 agent 不去问 —— Codex 的 app-server 一问就会被拉起来常驻，违背「未启用」
+    const m = /^\/api\/agents\/([a-z0-9_-]+)\/models$/.exec(p);
+    if (m && method === "GET") {
+      const driver = hub.enabledAgents().find((d) => d.id === m[1]);
+      if (!driver) {
+        sendJson(res, 409, { error: "未启用，启用并保存后可下拉选择" });
+        return;
+      }
+      sendJson(res, 200, { models: await driver.catalog() });
+      return;
+    }
+  }
+  {
+    // 命令表（含隐藏项）。带 key 时按那条会话的目录读（项目里可能有自己的命令），
+    // Web 输入框补全用；不带 key 是设置页排序用。
+    const m = /^\/api\/agents\/([a-z0-9_-]+)\/commands$/.exec(p);
+    if (m && method === "GET") {
+      if (!(AGENT_IDS as readonly string[]).includes(m[1]!)) {
+        sendJson(res, 404, { error: `没有 agent「${m[1]}」` });
+        return;
+      }
+      const conv = getConversation(url.searchParams.get("key") ?? "");
+      const commands = await hub.commandCatalog(m[1]!, {
+        ...(conv ? { cwd: conv.cwd } : {}),
+        allowedAgents: hub.enabledAgents().map((d) => d.id),
+      });
+      sendJson(res, 200, { commands });
+      return;
+    }
+  }
   if (p === "/api/password" && method === "POST") {
     const body = await readJsonBody<{ old?: string; password?: string }>(req);
     const left = takeAttempt(ip);
@@ -459,6 +504,15 @@ export async function handleApi(req: IncomingMessage, res: ServerResponse, url:
     sendJson(res, 200, listAllowlist());
     return;
   }
+  if (p === "/api/feishu/slash" && method === "GET") {
+    sendJson(res, 200, { bots: feishuBots().map((b) => ({ id: b.id, name: b.cfg.name, status: b.slash.status })) });
+    return;
+  }
+  if (p === "/api/feishu/slash/sync" && method === "POST") {
+    for (const b of feishuBots()) b.slash.request(0);
+    sendJson(res, 200, { ok: true });
+    return;
+  }
   if (p === "/api/feishu/status" && method === "GET") {
     sendJson(res, 200, feishuBots().map((b) => ({ id: b.id, name: b.cfg.name, ...b.status })));
     return;

package/src/channels/web/server.ts

@@ -9,6 +9,7 @@ import { createRequire } from "node:module";
 import { fileURLToPath } from "node:url";
 import { WebSocketServer, type WebSocket } from "ws";
 import { config } from "../../core/config.js";
+import { parseCommand } from "../../core/commands.js";
 import { hub, type EventEnvelope } from "../../core/hub.js";
 import { interactions, type Interaction } from "../../core/interactions.js";
 import { getConversation } from "../../core/store.js";
@@ -198,6 +199,17 @@ function handleClientMessage(client: Client, raw: string): void {
         const text = typeof msg.text === "string" ? msg.text : "";
         const attachments = takeUploads(key, msg.uploads);
         if (!text.trim() && attachments.length === 0) return ack(false, { error: "空消息" });
+        // 和飞书一致：整条消息是 im-agent 命令就由 hub 执行，结果随 ack 回给发命令的这个页面，
+        // 不进会话记录。带附件的一律当聊天。
+        const command = attachments.length > 0 ? null : parseCommand(text);
+        if (command && command.kind !== "chat") {
+          const allowedAgents = hub.enabledAgents().map((d) => d.id);
+          void hub
+            .command(key, command, { allowedAgents, by: "Web 命令" })
+            .then((reply) => ack(true, { reply, info: hub.info(key) }))
+            .catch((err) => ack(false, { error: err instanceof Error ? err.message : String(err) }));
+          return;
+        }
         hub.send(key, { text, attachments }, { channel: "web", channelId: "web", name: "Web" });
         return ack(true);
       }

package/src/core/command-catalog.ts

@@ -0,0 +1,112 @@
+// 命令目录：输入「/」时给用户看的那张表。
+//
+// 两种来源：
+//   - im-agent 自己的命令（/new /status …），由 hub 拦下来执行，所有 agent 通用；
+//   - agent 原生命令（Claude 的 skills、/compact 之类），im-agent 不认识，原样转给 agent。
+// 顺序和隐藏按 agent 分开存在配置里（设置 → 命令），用户自己排。
+
+/** im-agent 内置命令。name 不带斜杠；args 里尖括号是必填、方括号是可选 */
+export type BuiltinSpec = { name: string; args?: string; description: string; multiAgentOnly?: boolean };
+
+export const BUILTIN_COMMANDS: BuiltinSpec[] = [
+  { name: "new", args: "[模型]", description: "开一条新会话" },
+  { name: "status", description: "查看当前会话、模型、目录、剩余额度" },
+  { name: "stop", description: "中断当前执行" },
+  { name: "model", args: "[名称]", description: "切换模型（不带参数弹选择）" },
+  { name: "effort", args: "[程度]", description: "切换思考程度" },
+  { name: "sessions", args: "[all]", description: "列出历史会话，点按钮恢复；加 all 列所有目录" },
+  { name: "resume", args: "<会话ID>", description: "恢复指定会话" },
+  { name: "fork", description: "从当前会话分叉，原会话保留" },
+  { name: "agent", args: "[名称]", description: "查看 / 切换 agent", multiAgentOnly: true },
+  { name: "claude", description: "切换到 Claude Code", multiAgentOnly: true },
+  { name: "codex", description: "切换到 Codex", multiAgentOnly: true },
+  { name: "cd", args: "<相对目录>", description: "切换工作目录（限 workspace 内）" },
+  { name: "pwd", description: "显示当前工作目录" },
+  { name: "autoedit", args: "[on|off]", description: "本对话自动允许改工作目录内的文件（Bash 仍询问）" },
+  { name: "approve", args: "<请求ID> allow-once|allow-always|deny", description: "审批兜底（卡片失效时用）" },
+  { name: "help", description: "显示帮助" },
+];
+
+/** agent 自己报上来的命令 */
+export type AgentCommand = { name: string; description: string; args?: string };
+
+export type CommandEntry = {
+  name: string;
+  args?: string;
+  description: string;
+  source: "im-agent" | "agent";
+  /** 不带参数就能直接执行（飞书卡片上给按钮、Web 里回车直接发） */
+  runnable: boolean;
+  hidden: boolean;
+};
+
+export type CommandPrefs = { order: string[]; hidden: string[] };
+
+/** 参数里有必填项（尖括号）就不能一键执行 */
+function needsArgs(args: string | undefined): boolean {
+  return !!args && args.includes("<");
+}
+
+/**
+ * 合并内置命令和 agent 原生命令，再按用户配置排序。
+ * - 只对接得上的 agent 才列 /claude /codex 这类快捷切换；
+ * - 和内置命令重名的原生命令丢掉：反正会被 im-agent 先拦下来，列出来只会误导；
+ * - 配置里排过序的在前，按配置的顺序；没排过的（比如新装的 skill）按默认顺序接在后面。
+ */
+export function buildCatalog(params: {
+  allowedAgents: string[];
+  native: AgentCommand[];
+  prefs: CommandPrefs | undefined;
+}): CommandEntry[] {
+  const multi = params.allowedAgents.length > 1;
+  const builtin: CommandEntry[] = BUILTIN_COMMANDS.filter(
+    (c) =>
+      (!c.multiAgentOnly || multi) &&
+      // /claude /codex 只在这个渠道能用对应 agent 时才有意义
+      (!["claude", "codex"].includes(c.name) || params.allowedAgents.includes(c.name)),
+  ).map((c) => ({
+    name: c.name,
+    ...(c.args ? { args: c.args } : {}),
+    description: c.description,
+    source: "im-agent" as const,
+    runnable: !needsArgs(c.args),
+    hidden: false,
+  }));
+  const taken = new Set(BUILTIN_COMMANDS.map((c) => c.name));
+  const seen = new Set<string>();
+  const native: CommandEntry[] = [];
+  for (const c of params.native) {
+    const name = c.name.replace(/^\//, "");
+    if (!name || taken.has(name) || seen.has(name)) continue;
+    seen.add(name);
+    native.push({
+      name,
+      ...(c.args ? { args: c.args } : {}),
+      description: c.description,
+      source: "agent",
+      runnable: !needsArgs(c.args),
+      hidden: false,
+    });
+  }
+
+  const all = [...builtin, ...native];
+  const order = params.prefs?.order ?? [];
+  const hidden = new Set(params.prefs?.hidden ?? []);
+  const rank = new Map(order.map((name, i) => [name, i]));
+  return all
+    .map((c, i) => ({ c, i }))
+    .sort((a, b) => {
+      const ra = rank.get(a.c.name);
+      const rb = rank.get(b.c.name);
+      if (ra !== undefined && rb !== undefined) return ra - rb;
+      if (ra !== undefined) return -1;
+      if (rb !== undefined) return 1;
+      return a.i - b.i;
+    })
+    .map(({ c }) => ({ ...c, hidden: hidden.has(c.name) }));
+}
+
+/** 「/name args」，给人看的写法 */
+export function usageOf(c: { name: string; args?: string }): string {
+  return `/${c.name}${c.args ? ` ${c.args}` : ""}`;
+}

package/src/core/commands.ts

@@ -2,6 +2,7 @@
 //
 // 只有「整条消息就是一个命令」时才当命令处理，参数对不上就退化成普通聊天 ——
 // 避免把正常对话误当指令执行。
+import { BUILTIN_COMMANDS, usageOf } from "./command-catalog.js";
 import type { ApprovalDecision } from "./types.js";
 
 export type ParsedCommand =
@@ -16,7 +17,10 @@ export type ParsedCommand =
   | { kind: "cd"; dir: string }
   | { kind: "status" }
   | { kind: "pwd" }
+  | { kind: "autoedit"; on?: boolean }
   | { kind: "help" }
+  /** 只发了一个「/」：列出可用命令 */
+  | { kind: "commands" }
   | { kind: "approve"; requestId: string; decision: ApprovalDecision }
   | { kind: "chat"; text: string };
 
@@ -24,6 +28,8 @@ const DECISIONS: ApprovalDecision[] = ["allow-once", "allow-always", "deny"];
 
 export function parseCommand(raw: string): ParsedCommand {
   const text = raw.trim();
+  // 全角斜杠也认：中文输入法下很容易打成「／」
+  if (text === "/" || text === "／") return { kind: "commands" };
   if (!text.startsWith("/") || text.includes("\n")) return { kind: "chat", text };
 
   const [head = "", ...rest] = text.slice(1).split(/\s+/);
@@ -56,6 +62,13 @@ export function parseCommand(raw: string): ParsedCommand {
       return { kind: "status" };
     case "pwd":
       return { kind: "pwd" };
+    case "autoedit": {
+      const v = arg.toLowerCase();
+      if (!v) return { kind: "autoedit" };
+      if (["on", "开", "1", "true"].includes(v)) return { kind: "autoedit", on: true };
+      if (["off", "关", "0", "false"].includes(v)) return { kind: "autoedit", on: false };
+      return { kind: "chat", text };
+    }
     case "help":
       return { kind: "help" };
     case "approve": {
@@ -78,22 +91,14 @@ export function helpText(agents: string[]): string {
     "",
     "Agent 给选项时会发一张提问卡，点按钮作答；都不合适就直接发消息，那条消息会被当成你的回答。",
     "",
-    "**命令**（需整条消息只有命令）",
+    "**命令**（需整条消息只有命令；只发一个 `/` 可以列出全部命令，包括 agent 自己的）",
     "",
-    ...(multi
-      ? [`\`/agent [名称]\` 查看 / 切换 agent（可选：${agents.join("、")}），也可以直接发 ${agents.map((a) => `\`/${a}\``).join(" ")}`]
-      : []),
-    "`/new [模型]` 开一条新会话",
-    "`/fork` 从当前会话分叉，原会话保留",
-    "`/sessions [all]` 列出历史会话，点按钮恢复；加 all 列所有目录",
-    "`/resume <会话ID>` 恢复指定会话",
-    "`/model [名称]` 切换模型（不带参数弹选择卡片）",
-    "`/effort <程度>` 切换思考程度",
-    "`/stop` 中断当前执行",
-    "`/cd <相对目录>` 切换工作目录（限 workspace 内）",
-    "`/pwd` 显示当前工作目录",
-    "`/status` 查看当前会话、模型、目录",
-    "`/approve <请求ID> allow-once|allow-always|deny` 审批兜底",
-    "`/help` 显示本帮助",
+    ...BUILTIN_COMMANDS.filter((c) => !c.multiAgentOnly || multi)
+      .filter((c) => !["claude", "codex"].includes(c.name))
+      .map((c) =>
+        c.name === "agent"
+          ? `\`${usageOf(c)}\` ${c.description}（可选：${agents.join("、")}），也可以直接发 ${agents.map((a) => `\`/${a}\``).join(" ")}`
+          : `\`${usageOf(c)}\` ${c.description}`,
+      ),
   ].join("\n");
 }

package/src/core/config.ts

@@ -6,6 +6,8 @@ import fs from "node:fs";
 import path from "node:path";
 import crypto from "node:crypto";
 import { configPath, ensureDirs, readJson, writeJsonAtomic } from "../home.js";
+import type { CommandPrefs } from "./command-catalog.js";
+
 
 export type SandboxMode = "read-only" | "workspace-write" | "danger-full-access";
 
@@ -56,6 +58,8 @@ export type AppConfig = {
      */
     trustedProxies: string[];
   };
+  /** 输入「/」时命令列表的顺序和隐藏项，按 agent 分开（设置 → 命令） */
+  commands: { claude: CommandPrefs; codex: CommandPrefs };
   feishu: {
     /** 长连接掉线多久就重建，0 关闭 */
     watchdogMs: number;
@@ -82,6 +86,7 @@ export function defaultConfig(): AppConfig {
       },
     },
     web: { enabled: true, host: "0.0.0.0", port: 8800, passwordHash: "", trustedProxies: ["127.0.0.1", "::1"] },
+    commands: { claude: { order: [], hidden: [] }, codex: { order: [], hidden: [] } },
     feishu: { watchdogMs: 10 * 60 * 1000, bots: [] },
   };
 }

package/src/core/hub.ts

@@ -34,6 +34,7 @@ import type {
   StepKind,
   UserInput,
 } from "./types.js";
+import { buildCatalog, type AgentCommand, type CommandEntry, type CommandPrefs } from "./command-catalog.js";
 import { helpText, type ParsedCommand } from "./commands.js";
 
 // ---------- 事件 ----------
@@ -95,6 +96,8 @@ export type CommandReply =
       effortSupported: boolean;
     }
   | { type: "agents"; agents: { id: string; label: string }[]; current: string }
+  /** 只发了「/」：可用命令（已按用户配置排序、去掉隐藏的） */
+  | { type: "commands"; agent: string; commands: CommandEntry[] }
   | { type: "none" };
 
 export type ConversationInfo = {
@@ -368,6 +371,7 @@ class Hub extends EventEmitter<{ event: [EventEnvelope] }> {
         ...(effort ? { effort } : {}),
         ...(resumeId ? { resumeId } : {}),
         ...(fork ? { fork: true } : {}),
+        ...(conv.autoEdit ? { autoEdit: true } : {}),
       },
       {
         onTurnStart: () => alive() && this.emitEvent(key, { type: "turn_start" }),
@@ -756,6 +760,28 @@ class Hub extends EventEmitter<{ event: [EventEnvelope] }> {
     return `思考程度已切换为 ${effort}。`;
   }
 
+  /** /autoedit：on 不给就是切换。只影响正在跑的会话和以后新建的，不追溯已经弹出的授权。 */
+  private async setAutoEditNow(key: string, on: boolean | undefined): Promise<string> {
+    const conv = getConversation(key)!;
+    const next = on ?? !conv.autoEdit;
+    const live = this.live.get(key);
+    if (live?.session.setAutoEdit) await withTimeout(live.session.setAutoEdit(next), "切换自动改文件");
+    updateConversation(key, { autoEdit: next });
+    this.emitEvent(key, { type: "meta" });
+    const driver = this.requireDriver(conv.agent);
+    const note =
+      conv.agent === "codex"
+        ? `\n\n注意：${driver.label} 改文件由沙箱控制（设置 → Agent → 沙箱），这个开关只对 Claude 生效。`
+        : "";
+    return next
+      ? `已开启：这条对话里 Claude 修改工作目录（${conv.cwd}）内的文件不再询问；目录外的文件、Bash 命令照常询问。发 /autoedit off 关闭。${note}`
+      : `已关闭：改文件恢复逐次询问。${note}`;
+  }
+
+  setAutoEdit(key: string, on?: boolean): Promise<string> {
+    return this.serial(key, () => this.setAutoEditNow(key, on));
+  }
+
   /** 切 agent：各 agent 的会话各自保留，切回来接着聊。 */
   private async setAgentNow(key: string, agent: string, allowed: string[], op: SwitchOp): Promise<string> {
     const conv = getConversation(key)!;
@@ -809,6 +835,7 @@ class Hub extends EventEmitter<{ event: [EventEnvelope] }> {
       `目录：${conv.cwd}`,
       `模型：${runtime.model ?? "默认"}`,
       ...(runtime.effort ? [`思考程度：${runtime.effort}`] : []),
+      ...(conv.autoEdit ? ["自动允许改文件：开（/autoedit off 关闭）"] : []),
       ...(extra.length > 0 ? ["", ...extra] : []),
     ].join("\n");
   }
@@ -879,8 +906,15 @@ class Hub extends EventEmitter<{ event: [EventEnvelope] }> {
     switch (cmd.kind) {
       case "help":
         return text(helpText(ctx.allowedAgents));
+      case "commands": {
+        const conv = getConversation(key)!;
+        const all = await this.commandCatalog(conv.agent, { cwd: conv.cwd, allowedAgents: ctx.allowedAgents });
+        return { type: "commands", agent: conv.agent, commands: all.filter((c) => !c.hidden) };
+      }
       case "pwd":
         return text(getConversation(key)!.cwd);
+      case "autoedit":
+        return text(await this.setAutoEdit(key, cmd.on));
       case "status":
         return text(await this.status(key));
       case "cd":
@@ -924,6 +958,27 @@ class Hub extends EventEmitter<{ event: [EventEnvelope] }> {
     }
   }
 
+  /**
+   * 某个 agent 的完整命令表（含隐藏项，带 hidden 标记），已按配置排序。
+   * 原生命令读不到、或者超时，就只给 im-agent 自己的 —— 列表少几项，总比「/」没反应强。
+   * 未启用的 agent 不去问：问一次就可能拉起它的进程。
+   */
+  async commandCatalog(
+    agent: string,
+    opts: { cwd?: string; allowedAgents: string[] },
+  ): Promise<CommandEntry[]> {
+    const driver = this.enabledAgents().find((d) => d.id === agent);
+    let native: AgentCommand[] = [];
+    if (driver?.commands) {
+      native = await withTimeout(driver.commands(opts.cwd), "读取命令列表").catch((err) => {
+        console.error(`[${agent}] 读取命令列表失败:`, err instanceof Error ? err.message : err);
+        return [];
+      });
+    }
+    const prefs = (config().commands as Record<string, CommandPrefs | undefined>)[agent];
+    return buildCatalog({ allowedAgents: opts.allowedAgents, native, prefs });
+  }
+
   async shutdown(): Promise<void> {
     for (const key of [...this.live.keys()]) await this.drop(key, "服务正在重启");
     for (const driver of this.drivers.values()) await driver.stop().catch(() => {});

package/src/core/store.ts

@@ -38,6 +38,8 @@ export type Conversation = {
   createdAt: number;
   /** Web 列表里隐藏（Web 上删除的会话只是隐藏，agent 侧的历史还在） */
   hidden?: boolean;
+  /** /autoedit：这条对话里 agent 在工作目录内改文件不再询问（跨 /new 保留，属于对话不属于某个会话） */
+  autoEdit?: boolean;
 };
 
 type StoreShape = Record<string, Conversation>;

package/src/core/types.ts

@@ -1,5 +1,6 @@
 // 核心类型：渠道（飞书 / Web / 以后的 Telegram）与 agent（Claude / Codex / 以后的 ACP）
 // 之间只通过这里的类型说话。渠道不认识 Claude，agent 不认识飞书。
+import type { AgentCommand } from "./command-catalog.js";
 
 // ---------- 用户输入 ----------
 
@@ -118,6 +119,8 @@ export type SessionOptions = {
   fork?: boolean;
   /** 附件所在目录，agent 需要能直接读 */
   uploadsDir: string;
+  /** 工作目录内改文件不再询问（/autoedit）。Bash 等照常询问 */
+  autoEdit?: boolean;
 };
 
 export interface AgentSession {
@@ -127,6 +130,8 @@ export interface AgentSession {
   setModel(model?: string, effort?: string): Promise<void>;
   describeRuntime(): Promise<RuntimeInfo>;
   dispose(): Promise<void>;
+  /** 运行中切换「自动允许改文件」；不支持的 agent 不实现 */
+  setAutoEdit?(on: boolean): Promise<void>;
 }
 
 export type Diagnosis = {
@@ -151,6 +156,10 @@ export interface AgentDriver {
   readHistory(id: string, cwd: string): Promise<HistoryMessage[]>;
   /** 有的 agent（Claude）要借一个活着的会话才能问到模型列表 */
   listModels(session: AgentSession): Promise<ModelInfo[]>;
+  /** 不依赖会话的模型列表，设置页的下拉框用 */
+  catalog(): Promise<ModelInfo[]>;
+  /** agent 自己的斜杠命令（skills 之类），没有就不实现。cwd 影响项目级命令 */
+  commands?(cwd?: string): Promise<AgentCommand[]>;
   /** 不建会话也能知道的默认模型 / 思考程度 */
   defaults(): Promise<RuntimeInfo>;
   /** /status 里额外的几行（比如 Codex 的额度） */