agent-loft 0.2.21 → 0.2.23

package/src/channels/web/push.ts

@@ -8,6 +8,7 @@
 import crypto from "node:crypto";
 import path from "node:path";
 import { dataDir, readJson, writeJsonAtomic } from "../../home.js";
+import { legacyOwnerId } from "../../core/users.js";
 
 export type PushSubscriptionRecord = {
   endpoint: string;
@@ -16,8 +17,13 @@ export type PushSubscriptionRecord = {
   label: string;
   createdAt: number;
   lastOkAt?: number;
+  /** 哪个用户开的（core/users.ts）。升级前的没有：第一次读到时认给迁移出来的那个管理员并记下 */
+  userId?: string;
 };
 
+/** 按订阅的主人筛选：拿到的是订阅里记的 userId（可能没有） */
+export type OwnerFilter = (userId: string | undefined) => boolean;
+
 export type PushPayload = {
   title: string;
   body: string;
@@ -42,6 +48,12 @@ function load(): Store {
   if (!store) {
     store = readJson<Store>(FILE(), { subscriptions: [] });
     if (!Array.isArray(store.subscriptions)) store.subscriptions = [];
+    // 升级前的订阅：记到迁移出来的管理员名下。只做一次 —— 之后那个管理员被停用、删掉，
+    // 订阅也不会转给别人（那样别人的通知会推到他的手机上）
+    const owner = legacyOwnerId();
+    const legacy = owner ? store.subscriptions.filter((x) => !x.userId) : [];
+    for (const x of legacy) x.userId = owner;
+    if (legacy.length > 0) writeJsonAtomic(FILE(), store);
   }
   return store;
 }
@@ -134,7 +146,8 @@ function describeUa(ua: string): string {
   return browser ? `${device} · ${browser}` : device;
 }
 
-export function addSubscription(sub: unknown, userAgent: string): PushSubscriptionRecord {
+/** 同一个浏览器换了个账号登录再开通知：订阅归新账号 */
+export function addSubscription(sub: unknown, userAgent: string, userId?: string): PushSubscriptionRecord {
   if (!validSubscription(sub)) throw new Error("订阅信息不完整");
   const s = load();
   const record: PushSubscriptionRecord = {
@@ -142,24 +155,25 @@ export function addSubscription(sub: unknown, userAgent: string): PushSubscripti
     keys: { p256dh: sub.keys.p256dh, auth: sub.keys.auth },
     label: describeUa(userAgent),
     createdAt: Date.now(),
+    ...(userId ? { userId } : {}),
   };
   s.subscriptions = [...s.subscriptions.filter((x) => x.endpoint !== sub.endpoint), record];
   persist();
   return record;
 }
 
-export function removeSubscription(endpoint: string): boolean {
+export function removeSubscription(endpoint: string, mine?: OwnerFilter): boolean {
   const s = load();
   const before = s.subscriptions.length;
-  s.subscriptions = s.subscriptions.filter((x) => x.endpoint !== endpoint);
+  s.subscriptions = s.subscriptions.filter((x) => x.endpoint !== endpoint || (mine && !mine(x.userId)));
   if (s.subscriptions.length === before) return false;
   persist();
   return true;
 }
 
 /** 给设置页看的：不带密钥 */
-export function listSubscriptions(): { endpoint: string; label: string; createdAt: number; lastOkAt?: number }[] {
-  return load().subscriptions.map(({ endpoint, label, createdAt, lastOkAt }) => ({
+export function listSubscriptions(mine?: OwnerFilter): { endpoint: string; label: string; createdAt: number; lastOkAt?: number }[] {
+  return load().subscriptions.filter((x) => !mine || mine(x.userId)).map(({ endpoint, label, createdAt, lastOkAt }) => ({
     endpoint,
     label,
     createdAt,
@@ -201,9 +215,17 @@ async function sendOne(sub: PushSubscriptionRecord, payload: PushPayload): Promi
   return true;
 }
 
-/** 推给所有订阅的设备，返回成功的数量。单个设备失败不影响别的 */
-export async function pushToAll(payload: PushPayload): Promise<number> {
-  const subs = [...load().subscriptions];
+/** 某个用户的订阅全部删掉（删用户时） */
+export function removeSubscriptionsOf(mine: OwnerFilter): void {
+  const s = load();
+  const before = s.subscriptions.length;
+  s.subscriptions = s.subscriptions.filter((x) => !mine(x.userId));
+  if (s.subscriptions.length !== before) persist();
+}
+
+/** 推给订阅的设备（给了 to 就只推给它挑出来的主人），返回成功的数量。单个设备失败不影响别的 */
+export async function pushToAll(payload: PushPayload, to?: OwnerFilter): Promise<number> {
+  const subs = load().subscriptions.filter((x) => !to || to(x.userId));
   if (subs.length === 0) return 0;
   const results = await Promise.all(
     subs.map((sub) =>

package/src/channels/web/server.ts

@@ -10,13 +10,15 @@ import { fileURLToPath } from "node:url";
 import { WebSocketServer, type WebSocket } from "ws";
 import { config, onConfigChange } from "../../core/config.js";
 import { parseCommand } from "../../core/commands.js";
-import { hub, type EventEnvelope } from "../../core/hub.js";
+import { GLOBAL_ALWAYS_DENIED, hub, type EventEnvelope } from "../../core/hub.js";
 import { interactions, type Interaction } from "../../core/interactions.js";
 import { getConversation } from "../../core/store.js";
 import { RUNNING_VERSION } from "../../core/upgrade.js";
 import type { Settlement } from "../../core/types.js";
-import { authed, handleApi, takeUploads } from "./api.js";
-import { authEvents, ensureSetupToken, validateSession } from "./auth.js";
+import { getUser, isAdmin, legacyOwnerId, type User } from "../../core/users.js";
+import { currentUser, handleApi, takeUploads } from "./api.js";
+import { authEvents, ensureSetupToken, sessionUser } from "./auth.js";
+import { canSeeKey, sessionVisibleTo } from "./access.js";
 import { cookies } from "./http.js";
 import { COOKIE } from "./api.js";
 import { HttpError, sameOrigin, SECURITY_HEADERS, sendJson } from "./http.js";
@@ -134,6 +136,8 @@ type Client = {
   subs: Set<string>;
   alive: boolean;
   token: string;
+  /** 登录的用户。每次复查登录态时刷新（角色可能被改了） */
+  user: User;
   /** 页面在前台，且正看着哪条会话（前端在切会话、切前后台时上报） */
   visible: boolean;
   viewing: string | null;
@@ -142,12 +146,18 @@ type Client = {
 /** 每次进程启动换一个：客户端发现变了，就知道 seq 已经从头计数，得整页重拉 */
 const EPOCH = Math.random().toString(36).slice(2, 10);
 
-/** 登录态已失效的连接：断开。客户端收到 4401 会回到登录页 */
-function checkClient(client: Client): boolean {
-  if (validateSession(client.token)) return true;
+/** 登录态已失效（退出、被踢、用户被停用 / 删除）的连接：断开。客户端收到 4401 会回到登录页 */
+function checkClient(client: Client): User | undefined {
+  const user = sessionUser(client.token);
+  if (user) {
+    client.user = user;
+    // 角色被改了（管理员降成成员）：已经订阅着的、现在看不到的会话，事件不能再推给他
+    for (const key of client.subs) if (!canSeeKey(user, key)) client.subs.delete(key);
+    return user;
+  }
   client.ws.close(4401, "登录已失效");
   clients.delete(client);
-  return false;
+  return undefined;
 }
 const clients = new Set<Client>();
 
@@ -160,13 +170,14 @@ function broadcastEvent(env: EventEnvelope): void {
   const listChanged = ["user", "meta", "state", "result", "error"].includes(env.ev.type);
   const info = listChanged ? hub.info(env.key) : undefined;
   for (const client of [...clients]) {
+    // 订阅时已经核对过是不是他的会话
     if (client.subs.has(env.key)) send(client, { t: "ev", ...env });
-    if (info) send(client, { t: "conv", info });
+    if (info && canSeeKey(client.user, env.key)) send(client, { t: "conv", info });
   }
 }
 
 function broadcastInteraction(i: Interaction): void {
-  for (const client of clients) send(client, { t: "ix", interaction: i });
+  for (const client of clients) if (canSeeKey(client.user, i.convKey)) send(client, { t: "ix", interaction: i });
 }
 
 // ---------- 系统通知（Web Push） ----------
@@ -210,8 +221,14 @@ type Notice = { title: string; body: string; tag: string };
  */
 function notify(key: string, notice: Notice): void {
   if (!isWebConv(key)) return;
-  for (const client of clients) send(client, { t: "notice", key, ...notice });
-  if (hasSubscriptions() && !watching(key)) void pushToAll({ ...notice, url: `/#${encodeURIComponent(key)}` });
+  for (const client of clients) if (canSeeKey(client.user, key)) send(client, { t: "notice", key, ...notice });
+  if (!hasSubscriptions() || watching(key)) return;
+  // 只推给这条会话的主人（没记主人的订阅算迁移出来的那个管理员的）
+  const legacy = legacyOwnerId();
+  void pushToAll({ ...notice, url: `/#${encodeURIComponent(key)}` }, (owner) => {
+    const u = getUser(owner ?? legacy);
+    return !!u && !u.disabled && canSeeKey(u, key);
+  });
 }
 
 function pushEvent(env: EventEnvelope): void {
@@ -240,7 +257,8 @@ const BY = "已在 Web 处理";
 
 function handleClientMessage(client: Client, raw: string): void {
   // 每条消息都复查登录态：握手时有效不代表现在还有效（改了密码、被踢了）
-  if (!checkClient(client)) return;
+  const user = checkClient(client);
+  if (!user) return;
   let msg: Record<string, unknown>;
   try {
     const parsed: unknown = JSON.parse(raw);
@@ -260,7 +278,7 @@ function handleClientMessage(client: Client, raw: string): void {
         return;
 
       case "sub": {
-        if (!getConversation(key)) return ack(false, { error: "会话不存在" });
+        if (!getConversation(key) || !canSeeKey(user, key)) return ack(false, { error: "会话不存在" });
         client.subs.add(key);
         const since = typeof msg.since === "number" ? msg.since : 0;
         // 客户端的 seq 来自上一个进程（比现在的还大），或者换了实例：补不了，整页重拉
@@ -291,7 +309,7 @@ function handleClientMessage(client: Client, raw: string): void {
         return ack(true);
 
       case "send": {
-        if (!getConversation(key)) return ack(false, { error: "会话不存在" });
+        if (!getConversation(key) || !canSeeKey(user, key)) return ack(false, { error: "会话不存在" });
         const text = typeof msg.text === "string" ? msg.text : "";
         const attachments = takeUploads(key, msg.uploads);
         if (!text.trim() && attachments.length === 0) return ack(false, { error: "空消息" });
@@ -301,7 +319,16 @@ function handleClientMessage(client: Client, raw: string): void {
         if (command && command.kind !== "chat") {
           const allowedAgents = hub.enabledAgents().map((d) => d.id);
           void hub
-            .command(key, command, { allowedAgents, by: "Web 命令" })
+            .command(key, command, {
+              allowedAgents,
+              by: "Web 命令",
+              ...(() => {
+                const sessionVisible = sessionVisibleTo(user);
+                return sessionVisible ? { sessionVisible } : {};
+              })(),
+              convVisible: (k) => canSeeKey(user, k),
+              allowGlobalAlways: isAdmin(user),
+            })
             .then((reply) => ack(true, { reply, info: hub.info(key) }))
             .catch((err) => ack(false, { error: err instanceof Error ? err.message : String(err) }));
           return;
@@ -312,10 +339,15 @@ function handleClientMessage(client: Client, raw: string): void {
 
       case "ix": {
         const id = String(msg.id ?? "");
+        const target = interactions.get(id);
+        if (!target || !canSeeKey(user, target.convKey)) return ack(false, { error: "请求已失效" });
         let ok = false;
         let error: string | undefined;
         switch (msg.op) {
           case "decide":
+            if (msg.decision === "allow-always" && target.spec.kind === "approval" && target.spec.alwaysGlobal && !isAdmin(user)) {
+              return ack(false, { error: GLOBAL_ALWAYS_DENIED });
+            }
             ok = !!interactions.decide(id, String(msg.decision) as Settlement, BY);
             break;
           case "select":
@@ -392,14 +424,15 @@ export async function startWeb(): Promise<void> {
   server.on("upgrade", (req, socket, head) => {
     try {
       const url = new URL(req.url ?? "/", "http://local");
-      if (url.pathname !== "/ws" || !sameOrigin(req) || !authed(req)) {
+      const user = url.pathname === "/ws" && sameOrigin(req) ? currentUser(req) : undefined;
+      if (!user) {
         socket.write("HTTP/1.1 401 Unauthorized\r\n\r\n");
         socket.destroy();
         return;
       }
       const token = cookies(req)[COOKIE] ?? "";
       wss!.handleUpgrade(req, socket, head, (ws) => {
-        const client: Client = { ws, subs: new Set(), alive: true, token, visible: false, viewing: null };
+        const client: Client = { ws, subs: new Set(), alive: true, token, user, visible: false, viewing: null };
         clients.add(client);
         ws.on("pong", () => (client.alive = true));
         ws.on("message", (data) => {

package/src/cli/doctor.ts

@@ -3,6 +3,7 @@ import { spawnSync } from "node:child_process";
 import { config, loadConfig } from "../core/config.js";
 import { FeishuClient } from "../channels/feishu/client.js";
 import { configPath } from "../home.js";
+import { hasUsers, listUsers } from "../core/users.js";
 
 loadConfig();
 const cfg = config();
@@ -36,4 +37,4 @@ for (const bot of cfg.feishu.bots) {
 }
 
 console.log("\nWeb");
-console.log(`  ${cfg.web.enabled ? `http://${cfg.web.host}:${cfg.web.port}` : "未启用"}${cfg.web.passwordHash ? "" : "（还没设密码，首次打开需要启动日志里的设置码）"}`);
+console.log(`  ${cfg.web.enabled ? `http://${cfg.web.host}:${cfg.web.port}` : "未启用"}${hasUsers() ? `（${listUsers().length} 个用户）` : "（还没设密码，首次打开需要启动日志里的设置码）"}`);

package/src/cli/passwd.ts

@@ -1,15 +1,32 @@
-// agent-loft passwd：在终端里重置 Web 登录密码（忘记密码时用）。所有已登录设备会下线。
+// agent-loft passwd [新密码] [--user 用户名]：在终端里重置 Web 登录密码（忘记密码时用）。
+// 不指定用户就是最早的那个管理员；还一个用户都没有时，建一个叫 admin（或 --user 给的名字）的管理员。
+// 被重置的用户所有已登录设备会下线。
 import readline from "node:readline/promises";
 import { loadConfig } from "../core/config.js";
-import { setPassword } from "../channels/web/auth.js";
+import { findUserByName, getUser, hasUsers, legacyOwnerId } from "../core/users.js";
+import { setUserPassword, setupFirstAdmin } from "../channels/web/auth.js";
 
 loadConfig();
-const fromArg = process.argv[2];
-let password = fromArg;
+const args = process.argv.slice(2);
+const at = args.indexOf("--user");
+const name = at >= 0 ? args[at + 1] : undefined;
+if (at >= 0 && !name) throw new Error("--user 后面要跟用户名");
+const positional = args.filter((_, i) => at < 0 || (i !== at && i !== at + 1));
+
+const target = !hasUsers() ? undefined : name ? findUserByName(name) : getUser(legacyOwnerId());
+if (hasUsers() && !target) throw new Error(name ? `没有用户「${name}」。用 agent-loft user list 看看有哪些` : "没有能登录的管理员，用 --user 指定用户");
+
+let password = positional[0];
 if (!password) {
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-  password = await rl.question("新的 Web 登录密码（至少 8 位）：");
+  password = await rl.question(`${target ? `「${target.name}」` : "管理员"}的新 Web 登录密码（至少 8 位）：`);
   rl.close();
 }
-setPassword(password.trim());
-console.log("密码已更新，所有已登录的设备需要重新登录。");
+
+if (target) {
+  setUserPassword(target.id, password.trim());
+  console.log(`「${target.name}」的密码已更新，他已登录的设备需要重新登录。`);
+} else {
+  const user = setupFirstAdmin(name ?? "admin", password.trim());
+  console.log(`已创建管理员「${user.name}」，用这个用户名和密码登录。`);
+}

package/src/cli/user.ts

@@ -0,0 +1,99 @@
+// agent-loft user …：在终端里管理 Web 登录用户（Web 上 设置 → 用户 里也能做）。
+//
+//   list                         列出用户
+//   add <用户名> [--admin] [密码]  新建用户（默认普通成员）
+//   passwd <用户名> [新密码]       重置密码，他的设备全部下线
+//   role <用户名> admin|member     改角色
+//   disable <用户名> / enable <用户名>
+//   remove <用户名>
+import readline from "node:readline/promises";
+import { loadConfig } from "../core/config.js";
+import { createUser, findUserByName, legacyOwnerId, listUsers, removeUser } from "../core/users.js";
+import { patchUser, revokeUserSessions } from "../channels/web/auth.js";
+import { removeSubscriptionsOf } from "../channels/web/push.js";
+
+loadConfig();
+
+const USAGE = `用法：
+  agent-loft user list
+  agent-loft user add <用户名> [--admin] [密码]
+  agent-loft user passwd <用户名> [新密码]
+  agent-loft user role <用户名> admin|member
+  agent-loft user disable <用户名>
+  agent-loft user enable <用户名>
+  agent-loft user remove <用户名>
+
+注意：多用户是「信任型」的 —— 所有 agent 都以同一个系统用户运行，能读到这台机器上的任何东西。
+只把账号给你信任的人。`;
+
+const [sub, ...rest] = process.argv.slice(2);
+const flags = new Set(rest.filter((a) => a.startsWith("--")));
+const args = rest.filter((a) => !a.startsWith("--"));
+
+async function ask(prompt: string): Promise<string> {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const answer = await rl.question(prompt);
+  rl.close();
+  return answer.trim();
+}
+
+function need(name: string | undefined) {
+  if (!name) throw new Error(USAGE);
+  const user = findUserByName(name);
+  if (!user) throw new Error(`没有用户「${name}」`);
+  return user;
+}
+
+switch (sub) {
+  case undefined:
+  case "list": {
+    const users = listUsers();
+    if (users.length === 0) console.log("还没有用户。打开网页用启动日志里的设置码建第一个管理员，或者运行 agent-loft passwd。");
+    for (const u of users) {
+      console.log(`${u.name}\t${u.role === "admin" ? "管理员" : "成员"}${u.disabled ? "\t已停用" : ""}`);
+    }
+    break;
+  }
+  case "add": {
+    const name = args[0];
+    if (!name) throw new Error(USAGE);
+    const password = args[1] ?? (await ask(`「${name}」的登录密码（至少 8 位）：`));
+    const user = createUser({ name, password, role: flags.has("--admin") ? "admin" : "member" });
+    console.log(`已创建${user.role === "admin" ? "管理员" : "成员"}「${user.name}」。`);
+    break;
+  }
+  case "passwd": {
+    const user = need(args[0]);
+    const password = args[1] ?? (await ask(`「${user.name}」的新密码（至少 8 位）：`));
+    patchUser(user.id, { password });
+    console.log(`「${user.name}」的密码已更新，他已登录的设备需要重新登录。`);
+    break;
+  }
+  case "role": {
+    const user = need(args[0]);
+    const role = args[1];
+    if (role !== "admin" && role !== "member") throw new Error(USAGE);
+    patchUser(user.id, { role });
+    console.log(`「${user.name}」现在是${role === "admin" ? "管理员" : "成员"}。`);
+    break;
+  }
+  case "disable":
+  case "enable": {
+    const user = need(args[0]);
+    patchUser(user.id, { disabled: sub === "disable" });
+    console.log(`「${user.name}」已${sub === "disable" ? "停用，设备已全部下线" : "启用"}。`);
+    break;
+  }
+  case "remove": {
+    const user = need(args[0]);
+    // 升级前没记主人的推送订阅算在最早的管理员名下：删人之前先记下是谁
+    const legacy = legacyOwnerId();
+    removeUser(user.id);
+    removeSubscriptionsOf((owner) => (owner ?? legacy) === user.id);
+    revokeUserSessions(user.id);
+    console.log(`已删除「${user.name}」。他的会话还在，归管理员。`);
+    break;
+  }
+  default:
+    throw new Error(USAGE);
+}

package/src/core/command-catalog.ts

@@ -16,25 +16,26 @@ export type BuiltinSpec = {
   feishuOnly?: boolean;
 };
 
+// 按常用程度排：这也是设置 → 命令、「/」列表和 /help 里的默认顺序
 export const BUILTIN_COMMANDS: BuiltinSpec[] = [
   { name: "new", args: "[模型]", description: "开一条新会话" },
-  { name: "status", description: "查看当前会话、模型、目录、剩余额度" },
   { name: "stop", description: "中断当前执行" },
   { name: "model", args: "[名称]", description: "切换模型（不带参数弹选择）" },
   { name: "effort", args: "[程度]", description: "切换思考程度" },
+  { name: "status", description: "查看当前会话、模型、目录、剩余额度" },
   { name: "sessions", args: "[all]", description: "列出历史会话，点按钮恢复；加 all 列所有目录" },
   { name: "resume", args: "<会话ID>", description: "恢复指定会话" },
+  { name: "cd", args: "<相对目录>", description: "切换工作目录（限 workspace 内）" },
+  { name: "pwd", description: "显示当前工作目录" },
   { name: "fork", description: "从当前会话分叉，原会话保留" },
+  { name: "autoedit", args: "[on|off]", description: "本对话自动允许改工作目录内的文件（Bash 仍询问）" },
   { 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: "web", description: "接上一条 Web 会话，在飞书里查看和回复", feishuOnly: true },
   { name: "detach", description: "不再接着 Web 会话，回到这个聊天自己的会话", feishuOnly: true },
-  { name: "approve", args: "<请求ID> allow-once|allow-always|allow-session|deny", description: "审批兜底（卡片失效时用）" },
   { name: "help", description: "显示帮助" },
+  { name: "approve", args: "<请求ID> allow-once|allow-always|allow-session|deny", description: "审批兜底（卡片失效时用）" },
 ];
 
 /** agent 自己报上来的命令 */
@@ -132,7 +133,10 @@ function needsArgs(args: string | undefined): boolean {
  * 合并内置命令和 agent 原生命令，再按用户配置排序。
  * - 只对接得上的 agent 才列 /claude /codex 这类快捷切换；
  * - 和内置命令重名的原生命令丢掉：反正会被 agent-loft 先拦下来，列出来只会误导；
- * - 配置里排过序的在前，按配置的顺序；没排过的（比如新装的 skill）按默认顺序接在后面。
+ * - 配置里排过序的在前，按配置的顺序；没排过的（比如新装的 skill）按默认顺序接在后面；
+ * - 默认顺序：agent-loft 内置命令（按常用程度）→ 自定义命令 → agent 原生命令；
+ * - agent 原生命令默认不显示：只有在设置里保存过（出现在 order 里）且没被隐藏的才显示。
+ *   设置页每次保存都会把整张表的顺序存下来，所以存过的照用户的选择，以后新装的 skill 默认不勾。
  */
 export function buildCatalog(params: {
   allowedAgents: string[];
@@ -202,7 +206,7 @@ export function buildCatalog(params: {
       if (rb !== undefined) return 1;
       return a.i - b.i;
     })
-    .map(({ c }) => ({ ...c, hidden: hidden.has(c.name) }));
+    .map(({ c }) => ({ ...c, hidden: hidden.has(c.name) || (c.source === "agent" && !rank.has(c.name)) }));
 }
 
 /** 「/name args」，给人看的写法 */

package/src/core/commands.ts

@@ -91,7 +91,7 @@ export function helpText(agents: string[], channel?: string): string {
     "",
     "Agent 给选项时会发一张提问卡，点按钮作答；都不合适就直接发消息，那条消息会被当成你的回答。",
     "",
-    "**命令**（需整条消息只有命令；只发一个 `/` 可以列出全部命令，包括 agent 自己的）",
+    "**命令**（需整条消息只有命令；只发一个 `/` 可以列出命令；agent 自己的命令默认不在列表里，可以在设置 → 命令里勾选，没勾的照样可以直接发）",
     "",
     ...BUILTIN_COMMANDS.filter((c) => !c.multiAgentOnly || multi)
       .filter((c) => !c.feishuOnly || channel === "feishu")

package/src/core/hub.ts

@@ -18,6 +18,7 @@ import {
   getConversation,
   isExpired,
   listConversations,
+  recordSessionOwner,
   touchConversation,
   updateAgentBinding,
   updateConversation,
@@ -131,6 +132,9 @@ export type ConversationInfo = {
   canFork?: boolean;
 };
 
+/** 普通成员点了会落盘的「总是允许」 */
+export const GLOBAL_ALWAYS_DENIED = "「总是允许」会对所有人的会话生效，只有管理员能点。可以用「允许一次」或「本会话全部允许」。";
+
 const BUFFER_MAX = 400;
 const CONTEXT_MAX = 500;
 /** 会占住会话操作队列的 agent 查询，最多等这么久 */
@@ -384,6 +388,8 @@ class Hub extends EventEmitter<{ event: [EventEnvelope] }> {
     channelId: string;
     defaultAgent: string;
     title?: string;
+    /** 谁的对话（用户 id）。只有 Web 上新建的有 */
+    owner?: string;
   }): Conversation {
     return ensureConversation({
       key: params.key,
@@ -391,6 +397,7 @@ class Hub extends EventEmitter<{ event: [EventEnvelope] }> {
       channelId: params.channelId,
       agent: params.defaultAgent,
       ...(params.title ? { title: params.title } : {}),
+      ...(params.owner ? { owner: params.owner } : {}),
     });
   }
 
@@ -429,8 +436,10 @@ class Hub extends EventEmitter<{ event: [EventEnvelope] }> {
     };
   }
 
-  list(): ConversationInfo[] {
+  /** visible：只列这些（按用户过滤，见 core/users.ts 的 ownedBy） */
+  list(visible?: (conv: Conversation) => boolean): ConversationInfo[] {
     return listConversations()
+      .filter((c) => !visible || visible(c))
       .map((c) => this.info(c.key)!)
       .sort((a, b) => b.activeAt - a.activeAt);
   }
@@ -546,6 +555,7 @@ class Hub extends EventEmitter<{ event: [EventEnvelope] }> {
           // 分叉中还报的是原会话 id：分叉尚未生效，什么都不改
           if (forkFrom && sessionId === forkFrom) return;
           updateAgentBinding(key, agent, { sessionId, forkFrom: undefined });
+          recordSessionOwner(sessionId, current?.owner);
           this.emitEvent(key, { type: "meta" });
         },
       },
@@ -887,13 +897,21 @@ class Hub extends EventEmitter<{ event: [EventEnvelope] }> {
     return `已恢复会话 ${sessionId}，直接接着说就行。${note}`;
   }
 
-  async sessions(key: string, all: boolean): Promise<Extract<CommandReply, { type: "sessions" }>> {
+  /** visible：这个用户能看到哪些 agent 会话（多用户时按人过滤）。不给就是全部 */
+  async sessions(
+    key: string,
+    all: boolean,
+    visible?: (sessionId: string) => boolean,
+  ): Promise<Extract<CommandReply, { type: "sessions" }>> {
     const conv = getConversation(key)!;
     const driver = this.requireDriver(conv.agent);
+    // 要过滤的话多拿一些，滤完再截到 10 条
+    const list = async (cwd: string | undefined) =>
+      visible ? (await driver.listSessions(cwd, 100)).filter((s) => visible(s.id)).slice(0, 10) : driver.listSessions(cwd, 10);
     // 先按当前目录列，一条都没有就自动退回全局 —— 回一句「没有历史」是误导
-    let sessions = all ? [] : await driver.listSessions(conv.cwd, 10);
+    let sessions = all ? [] : await list(conv.cwd);
     const fellBack = !all && sessions.length === 0;
-    if (all || fellBack) sessions = await driver.listSessions(undefined, 10);
+    if (all || fellBack) sessions = await list(undefined);
     const current = agentBinding(conv).sessionId;
     return {
       type: "sessions",
@@ -1051,7 +1069,8 @@ class Hub extends EventEmitter<{ event: [EventEnvelope] }> {
    * 分叉成一条新的 Web 对话：agent 会话复制一份（给了 anchor 就只到那条回复为止），
    * 原对话完全不动。返回新对话的 key。和 /fork 不同 —— /fork 是在同一条对话里换成分叉出来的会话。
    */
-  async forkConversation(key: string, anchor?: string): Promise<string> {
+  /** owner：新对话归谁（分叉的人）。不给就沿用原对话的 */
+  async forkConversation(key: string, anchor?: string, owner?: string): Promise<string> {
     const conv = getConversation(key);
     if (!conv) throw new Error(`会话不存在：${key}`);
     const driver = this.requireDriver(conv.agent);
@@ -1062,8 +1081,10 @@ class Hub extends EventEmitter<{ event: [EventEnvelope] }> {
     if (!source) throw new Error("这条对话还没有可分叉的会话");
     const sessionId = await withTimeout(driver.forkAt(source, conv.cwd, anchor), "分叉会话");
     copyFooters(source, sessionId);
+    owner ??= conv.owner;
     const newKey = `web:${crypto.randomBytes(6).toString("hex")}`;
-    ensureConversation({ key: newKey, channel: "web", channelId: "web", agent: conv.agent });
+    ensureConversation({ key: newKey, channel: "web", channelId: "web", agent: conv.agent, ...(owner ? { owner } : {}) });
+    recordSessionOwner(sessionId, owner);
     updateConversation(newKey, {
       title: `${conv.title ?? "会话"} · 分叉`.slice(0, 80),
       cwd: conv.cwd,
@@ -1119,7 +1140,17 @@ class Hub extends EventEmitter<{ event: [EventEnvelope] }> {
   async command(
     key: string,
     cmd: ParsedCommand,
-    ctx: { allowedAgents: string[]; by: string; channel?: string },
+    ctx: {
+      allowedAgents: string[];
+      by: string;
+      channel?: string;
+      /** 多用户：发命令的人能看到哪些 agent 会话（/sessions 列哪些、/resume 能恢复哪些） */
+      sessionVisible?: (sessionId: string) => boolean;
+      /** 多用户：/approve 只能处理这些会话里的请求 */
+      convVisible?: (convKey: string) => boolean;
+      /** 多用户：false = 不能点会落盘的「总是允许」（见 InteractionSpec.alwaysGlobal） */
+      allowGlobalAlways?: boolean;
+    },
   ): Promise<CommandReply> {
     const text = (t: string): CommandReply => ({ type: "text", text: t });
     const channel = ctx.channel ?? getConversation(key)?.channel;
@@ -1148,10 +1179,13 @@ class Hub extends EventEmitter<{ event: [EventEnvelope] }> {
       case "fork":
         return text(await this.fork(key));
       case "sessions": {
-        const reply = await this.sessions(key, cmd.all);
+        const reply = await this.sessions(key, cmd.all, ctx.sessionVisible);
         return reply.sessions.length === 0 ? text("还没有任何历史会话。") : reply;
       }
       case "resume":
+        if (ctx.sessionVisible && !ctx.sessionVisible(cmd.sessionId)) {
+          return text(`找不到会话 ${cmd.sessionId}。\n发 /sessions 看看有哪些可恢复的。`);
+        }
         return text(await this.resume(key, cmd.sessionId));
       case "model":
         return cmd.model ? text(await this.setModel(key, cmd.model)) : await this.models(key);
@@ -1173,6 +1207,13 @@ class Hub extends EventEmitter<{ event: [EventEnvelope] }> {
       case "stop":
         return text(await this.stop(key));
       case "approve": {
+        const target = interactions.get(cmd.requestId);
+        if (target && ctx.convVisible && !ctx.convVisible(target.convKey)) {
+          return text(`请求 ${cmd.requestId} 不存在或已处理。`);
+        }
+        if (target?.spec.kind === "approval" && target.spec.alwaysGlobal && cmd.decision === "allow-always" && ctx.allowGlobalAlways === false) {
+          return text(GLOBAL_ALWAYS_DENIED);
+        }
         const settled = interactions.decide(cmd.requestId, cmd.decision as ApprovalDecision, ctx.by);
         if (!settled && interactions.isPending(cmd.requestId)) {
           return text(`请求 ${cmd.requestId} 不支持 ${cmd.decision}。`);