agent-loft 0.2.22 → 0.2.24

package/README.md

@@ -46,13 +46,14 @@ Logo 就是这个意思：一大两小几颗星（多个 agent）站在同一张
   - 语音输入：用浏览器自带的语音识别（Chrome / Edge / Safari，需要 HTTPS）。
   - 新对话页：点大标题里的目录名，在目录树里逐层选工作目录；输入框上方选 agent，右下角选模型和思考程度。会话进行中用 `/agent` 切换 agent，模型和思考程度随时可换。
   - 输入框里的小圆环显示上下文窗口占用；模型按钮显示实际的模型和思考程度（如「Opus 5.5 high」）。
-  - 侧栏分「最近」和「项目」两组：Web 会话按工作目录归类，飞书机器人各占一行（右键看历史会话）；分叉出来的会话用虚线挂在原会话下面；会话标题由 agent 自动生成，双击重命名。
+  - 侧栏分「最近」和「项目」两组：Web 会话按工作目录归类（目录可以拖动排序，右键可置顶），飞书机器人各占一行（右键看历史会话）；分叉出来的会话用虚线挂在原会话下面；会话标题由 agent 自动生成，双击重命名。
   - 侧栏底部显示 Claude / Codex 的订阅额度（5 小时 / 7 天窗口，以及多久后重置）。
   - 「添加到主屏幕」后当 App 用；切到后台再回来会自动重连，补上错过的内容。
 - **系统通知**：Web 会话回复完成、出错、需要授权或提问时推送到手机 / 电脑（设置 → 通知 → 「在此设备开启通知」，可以发测试通知）。飞书会话由飞书提醒，正在前台看着的会话不推。需要 HTTPS 访问，iPhone 需 iOS 16.4+ 且从主屏幕图标打开。
 - **跨渠道同步**：飞书里的会话在 Web 上也能打开接着聊。同一个授权请求同时出现在飞书卡片和网页上，哪边先点算哪边，另一边自动变成「已处理」。
 - **授权**：允许一次 / 本会话全部允许 / 总是允许（按钮上写明放行范围）/ 拒绝。`/autoedit on` 让 Claude Code 在这条会话里改工作目录内的文件不再询问（Bash 仍询问）。超时一律按拒绝处理。
-- **设置都在网页上**：工作目录、会话闲置过期时间、局域网访问和端口、各 agent 的默认模型和思考程度、可选模型、Codex 沙箱、飞书机器人、配对批准、Claude 的「总是允许」名单、通知设备、登录设备管理、服务端升级。
+- **设置都在网页上**：工作目录、会话闲置过期时间、局域网访问和端口、各 agent 的默认模型和思考程度、可选模型、Codex 沙箱、飞书机器人、配对批准、Claude 的「总是允许」名单、通知设备、登录设备管理、用户管理、服务端升级。
+- **多用户**（信任型）：管理员在 设置 → 用户 里给别人建账号。每个人只看得到自己的对话、授权和通知，设置只有管理员能改，见下面「安全」。
 
 ## 安装
 
@@ -64,7 +65,7 @@ agent-loft start                  # 前台运行，日志里会打印首次登
 agent-loft service install        # 注册为开机自启服务（systemd / launchd），日志在 ~/.agent-loft/logs/
 ```
 
-打开 `http://<机器 IP>:8800`（本机用 `http://localhost:8800`）：第一次需要输入日志里的设置码，然后设一个登录密码。设置码找不到的话，直接运行 `agent-loft passwd` 设密码。
+打开 `http://<机器 IP>:8800`（本机用 `http://localhost:8800`）：第一次需要输入日志里的设置码，然后建一个管理员账号（用户名默认 `admin`）。设置码找不到的话，直接运行 `agent-loft passwd` 设密码。
 
 到 设置 → Agent 检查 Claude Code、Codex 装好、登录了没有：Claude Code 随 agent-loft 一起安装，只需在服务端终端里登录；Codex 可以点「直接在服务器上安装」。设置 → 系统 里能看到服务端版本，有新版本时点「升级」即可（`npm install -g agent-loft@latest`，以系统服务运行时会自动重启，打开的页面会自动刷新）。
 
@@ -106,7 +107,8 @@ agent-loft service install
 | `agent-loft start` | 启动 |
 | `agent-loft import [--only claude\|codex] [--disabled] [--dry-run]` | 从旧桥接器导入 |
 | `agent-loft pair list \| approve <码> \| revoke <机器人id> <open_id>` | 配对管理（Web 设置页里也能做） |
-| `agent-loft passwd [新密码]` | 重置 Web 登录密码，所有设备下线 |
+| `agent-loft passwd [新密码] [--user 用户名]` | 重置 Web 登录密码（默认是最早的管理员），他的设备全部下线 |
+| `agent-loft user list \| add <用户名> [--admin] \| passwd <用户名> \| role <用户名> admin\|member \| disable \| enable \| remove` | 管理 Web 登录用户（设置 → 用户 里也能做） |
 | `agent-loft service install \| uninstall \| restart \| status` | 开机自启 |
 | `agent-loft doctor` | 体检 |
 
@@ -120,7 +122,9 @@ agent-loft service install
 
 这个服务能让 agent 在你的机器上执行命令，等于一个远程 shell。
 
-- Web 登录密码用 scrypt 哈希保存。首次设置必须用启动日志里的一次性设置码，防止「谁先打开页面谁就成了主人」。
+- Web 登录密码用 scrypt 哈希保存。首次建管理员必须用启动日志里的一次性设置码，防止「谁先打开页面谁就成了主人」。
+- 多用户只隔开**界面上**的东西：会话列表、授权 / 提问卡、通知、`/sessions` 能列出和恢复的 agent 会话；设置、飞书机器人和飞书会话只给管理员；会落盘、对所有人生效的「总是允许」（Claude 的总是允许名单、Codex 的 execpolicy）只有管理员能点。**它不是安全边界**：所有 agent 都以同一个系统用户运行，任何用户都能让 agent 读到这台机器上的文件（别人的对话记录、配置里的密钥），用的也是同一个 Claude / Codex 订阅。只给信任的人开账号；要真正隔离，就每人用自己的系统用户各跑一份 agent-loft。
+- 从老版本升级：原来的登录密码自动变成管理员 `admin`，已登录的设备不用重新登录。
 - 登录态通过 HttpOnly cookie 保存，服务端只存它的哈希。同一 IP 连续输错 5 次锁 15 分钟。所有写请求和 WebSocket 都校验 Origin。页面开启了严格的 CSP。
 - 暴露到公网时，只通过 HTTPS 反向代理（比如 Lucky）或 Cloudflare Tunnel 访问，并把不在本机的反代 IP 加进 `web.trustedProxies`（只有从这些地址来的连接才采信 `X-Forwarded-*`）。不要直接把 8800 端口映射出去。局域网访问可以在 设置 → 系统 → 网络访问 里关掉。
 - 审批超时一律按拒绝处理。Codex 默认沙箱为 `workspace-write`，不会因为 `~/.codex/config.toml` 里配了 `never` 或 `danger-full-access` 就绕过审批。
@@ -135,6 +139,7 @@ src/
     interactions.ts 审批与提问：一个请求，多个渠道都能处理
     store.ts       会话持久化（每个 agent 的会话 id 各自保存）
     config.ts      配置（Web 可改，改完热加载）
+    users.ts       Web 登录用户和归属规则（谁能看到哪条会话）
     pairing.ts uploads.ts commands.ts …
   agents/
     claude/        Claude Agent SDK 驱动

package/bin/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// 统一入口：agent-loft <start|import|pair|passwd|service|doctor>
+// 统一入口：agent-loft <start|import|pair|passwd|user|service|doctor>
 //
 // 源码是 TypeScript，用 tsx 的 ESM loader 直接加载，装完即可运行，不需要先 build。
 import { register } from "tsx/esm/api";
@@ -9,6 +9,7 @@ const COMMANDS = {
   import: "../src/cli/import.ts",
   pair: "../src/cli/pair.ts",
   passwd: "../src/cli/passwd.ts",
+  user: "../src/cli/user.ts",
   service: "../src/cli/service.ts",
   doctor: "../src/cli/doctor.ts",
 };
@@ -19,7 +20,8 @@ const USAGE = `agent-loft —— 用飞书 / Web 驱动本机的 Claude Code 和
   agent-loft start            启动（默认命令）
   agent-loft import           从旧的 feishu-claude-bridge / feishu-codex-bridge 导入配置和会话
   agent-loft pair ...         配对管理：list | approve <配对码> | revoke <机器人id> <open_id>
-  agent-loft passwd           重置 Web 登录密码
+  agent-loft passwd           重置 Web 登录密码（--user 名字 指定用户，默认是管理员）
+  agent-loft user ...         Web 登录用户：list | add <名字> [--admin] | passwd | role | disable | enable | remove
   agent-loft service ...      开机自启：install | uninstall | restart | status
   agent-loft doctor           体检：配置 / agent / 飞书连通性
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-loft",
-  "version": "0.2.22",
+  "version": "0.2.24",
   "type": "module",
   "description": "多个 agent 的工作台：把本机 Claude Code / Codex 放到一处统一管理，用飞书和 Web 页面随时驱动——会话、审批、模型切换都共用",
   "keywords": [

package/src/agents/claude/session.ts

@@ -309,7 +309,7 @@ export class ClaudeSession implements AgentSession {
       kind: "approval",
       title: `需要授权：${toolName}`,
       detail: describeToolCall(toolName, input),
-      ...(isRememberableSignature(toolName, signature) ? { alwaysLabel: alwaysLabelOf(toolName, signature) } : {}),
+      ...(isRememberableSignature(toolName, signature) ? { alwaysLabel: alwaysLabelOf(toolName, signature), alwaysGlobal: true } : {}),
       ...(sessionable ? { allowSession: true } : {}),
     });
     if (outcome.settlement === "allow-always" && isRememberableSignature(toolName, signature)) rememberAlways(signature);

package/src/agents/codex/session.ts

@@ -508,6 +508,7 @@ export class CodexSession implements AgentSession {
           detail: describeCommand(req),
           // 「总是允许」到底记多宽取决于 Codex 有没有给 execpolicy 补丁，差别很大，得写在按钮上
           alwaysLabel: amendment ? "以后同类不再问" : "本会话内不再问",
+          ...(amendment ? { alwaysGlobal: true } : {}),
         });
         const s = outcome.settlement;
         if (s === "allow-once") return { decision: "accept" };

package/src/channels/feishu/bot.ts

@@ -13,7 +13,8 @@ import { interactions, type Interaction } from "../../core/interactions.js";
 import { parseCommand } from "../../core/commands.js";
 import { Dedup } from "../../core/dedup.js";
 import { isPaired, requestPairing } from "../../core/pairing.js";
-import { getConversation, listConversations, updateConversation } from "../../core/store.js";
+import { getConversation, listConversations, sessionOwner, updateConversation } from "../../core/store.js";
+import { adminVisible, hasMembers } from "../../core/users.js";
 import { adoptFile, KIND_LABEL } from "../../core/uploads.js";
 import type { SavedAttachment } from "../../core/types.js";
 import { FeishuClient } from "./client.js";
@@ -140,14 +141,20 @@ export class FeishuBot {
     const target = attachedTarget(feishuKey);
     if (!target) return undefined;
     const conv = getConversation(target);
-    return conv && !conv.hidden ? target : undefined;
+    // 主人后来被降成了普通成员：这条会话不再是飞书能碰的，当它没了（下条消息时自动退回来）
+    return conv && !conv.hidden && adminVisible(conv.owner) ? target : undefined;
+  }
+
+  /** 挂在 Web 会话 key 上的本机器人聊天。会话已经不归管理员了就一个都不算 */
+  private watchers(key: string): string[] {
+    return adminVisible(getConversation(key)?.owner) ? watchersOf(key, this.prefix) : [];
   }
 
   /** 这条会话的事件该画到哪些飞书聊天里：自己的那个聊天，加上挂着它的聊天 */
   chatsOf(key: string): string[] {
     const out = new Set<string>();
     if (this.mine(key)) out.add(this.chatIdOf(key));
-    for (const k of watchersOf(key, this.prefix)) out.add(this.chatIdOf(k));
+    for (const k of this.watchers(key)) out.add(this.chatIdOf(k));
     return [...out];
   }
 
@@ -155,7 +162,7 @@ export class FeishuBot {
   private controls(key: string, chatId: string | undefined): boolean {
     if (!chatId) return false;
     if (this.mine(key)) return this.chatIdOf(key) === chatId;
-    return watchersOf(key, this.prefix).some((k) => this.chatIdOf(k) === chatId);
+    return this.watchers(key).some((k) => this.chatIdOf(k) === chatId);
   }
 
   private webEntry(key: string): WebConvEntry | undefined {
@@ -206,7 +213,8 @@ export class FeishuBot {
    */
   async attachTo(feishuKey: string, webKey: string, operatorOpenId?: string): Promise<string> {
     const conv = getConversation(webKey);
-    if (!conv || conv.channel !== "web" || conv.hidden) throw new Error("这条 Web 会话已不存在");
+    // 飞书是管理员的地盘：普通成员的 Web 会话不能被接到飞书上
+    if (!conv || conv.channel !== "web" || conv.hidden || !adminVisible(conv.owner)) throw new Error("这条 Web 会话已不存在");
     const chatId = this.chatIdOf(feishuKey);
     // 本聊天自己的会话也得有：之后 /detach 回来、侧栏里显示机器人都要它
     const allowed = this.allowedAgents();
@@ -253,8 +261,7 @@ export class FeishuBot {
   private async sendWebList(feishuKey: string, chatId: string): Promise<void> {
     const current = this.attachedWeb(feishuKey);
     const convs = hub
-      .list()
-      .filter((c) => c.channel === "web" && !c.hidden)
+      .list((c) => c.channel === "web" && !c.hidden && adminVisible(c.owner))
       .slice(0, 10)
       .map((c) => this.webEntry(c.key)!)
       .filter(Boolean);
@@ -613,7 +620,14 @@ export class FeishuBot {
     const command = attachments.length > 0 ? ({ kind: "chat", text } as const) : parseCommand(text);
     if (command.kind !== "chat") {
       try {
-        const reply = await hub.command(key, command, { allowedAgents: this.allowedFor(key), by: "飞书命令", channel: "feishu" });
+        const reply = await hub.command(key, command, {
+          allowedAgents: this.allowedFor(key),
+          by: "飞书命令",
+          channel: "feishu",
+          // 普通成员在 Web 上开的 agent 会话、挂着的请求，飞书里都碰不到
+          ...(hasMembers() ? { sessionVisible: (id: string) => adminVisible(sessionOwner(id)) } : {}),
+          convVisible: (k) => adminVisible(getConversation(k)?.owner),
+        });
         await this.renderReply(key, chatId, reply);
       } catch (err) {
         await this.client.sendText(chatId, `出错了：${err instanceof Error ? err.message : String(err)}`);

package/src/channels/web/access.ts

@@ -0,0 +1,26 @@
+// Web 上「这个用户能碰哪些东西」。规则本身在 core/users.ts 的 ownedBy。
+import { getConversation, sessionOwner, type Conversation } from "../../core/store.js";
+import { legacyOwnerId, listUsers, ownedBy, type User } from "../../core/users.js";
+import type { OwnerFilter } from "./push.js";
+
+export function canSeeConv(user: User, conv: Conversation | undefined): conv is Conversation {
+  return !!conv && ownedBy(user, conv.owner);
+}
+
+export function canSeeKey(user: User, key: string): boolean {
+  return canSeeConv(user, getConversation(key));
+}
+
+/**
+ * 这个用户能看到、能恢复哪些 agent 会话。
+ * 只有他一个用户时什么都不会被滤掉，返回 undefined —— 列会话时就不用为了过滤多读一大批
+ */
+export function sessionVisibleTo(user: User): ((sessionId: string) => boolean) | undefined {
+  if (listUsers().every((u) => u.id === user.id)) return undefined;
+  return (sessionId) => ownedBy(user, sessionOwner(sessionId));
+}
+
+/** 推送订阅是不是这个用户的。升级前的订阅没记主人，算迁移出来的那个管理员的 */
+export function pushOwnedBy(userId: string): OwnerFilter {
+  return (owner) => (owner ?? legacyOwnerId()) === userId;
+}

package/src/channels/web/api.ts

@@ -9,7 +9,19 @@ import { hub } from "../../core/hub.js";
 import { interactions } from "../../core/interactions.js";
 import { approve, listApproved, listPending, revoke } from "../../core/pairing.js";
 import { getConversation, updateConversation } from "../../core/store.js";
-import { resolveUploadFile, saveBuffer, sniff } from "../../core/uploads.js";
+import { resolveUploadFile, saveBuffer, sniff, uploadKeyOf } from "../../core/uploads.js";
+import {
+  createUser,
+  getUser,
+  isAdmin,
+  legacyOwnerId,
+  listUsers,
+  removeUser,
+  verifyLogin,
+  verifyPassword,
+  type Role,
+  type User,
+} from "../../core/users.js";
 import type { SavedAttachment } from "../../core/types.js";
 import { listAllowlist, setAllowlist } from "../../agents/claude/permissions.js";
 import { agentAvailability, agentHealth, invalidateHealth } from "../../agents/health.js";
@@ -23,16 +35,19 @@ import {
   clearAttempts,
   createSession,
   destroySession,
-  hasPassword,
   listSessions as listWebSessions,
-  takeAttempt,
+  needsSetup,
   revokeSession,
-  setPassword,
-  validateSession,
-  verifyPassword,
+  revokeUserSessions,
+  sessionUser,
+  patchUser,
+  setUserPassword,
+  setupFirstAdmin,
+  takeAttempt,
 } from "./auth.js";
+import { canSeeConv, pushOwnedBy, sessionVisibleTo } from "./access.js";
 import { clientIp, cookies, HttpError, isHttps, readBody, readJsonBody, SECURITY_HEADERS, sendJson } from "./http.js";
-import { addSubscription, listSubscriptions, pushToAll, removeSubscription, vapidPublicKey } from "./push.js";
+import { addSubscription, listSubscriptions, pushToAll, removeSubscription, removeSubscriptionsOf, vapidPublicKey } from "./push.js";
 
 export const COOKIE = "aim_session";
 const startedAt = Date.now();
@@ -67,9 +82,13 @@ setInterval(() => {
  */
 const INLINE_IMAGE = new Set(["image/png", "image/jpeg", "image/gif", "image/webp"]);
 
-function serveUpload(res: ServerResponse, requested: string, download: boolean): void {
+function serveUpload(res: ServerResponse, user: User, requested: string, download: boolean): void {
   const file = requested ? resolveUploadFile(requested) : undefined;
-  if (!file) throw new HttpError(404, "文件不存在（可能会话重置时已清理）");
+  // 只能看自己会话里的附件。会话已经没了的，只有管理员能看
+  const key = file ? uploadKeyOf(file) : undefined;
+  const conv = key ? getConversation(key) : undefined;
+  const allowed = conv ? canSeeConv(user, conv) : isAdmin(user);
+  if (!file || !allowed) throw new HttpError(404, "文件不存在（可能会话重置时已清理）");
   const head = Buffer.alloc(12);
   const fd = fs.openSync(file, "r");
   try {
@@ -153,7 +172,7 @@ function publicConfig(): unknown {
   const cfg = structuredClone(config()) as AppConfig & { web: { passwordHash?: string } };
   return {
     ...cfg,
-    web: { ...cfg.web, passwordHash: undefined, hasPassword: !!config().web.passwordHash },
+    web: { ...cfg.web, passwordHash: undefined },
     feishu: { ...cfg.feishu, bots: cfg.feishu.bots.map((b) => ({ ...b, appSecret: maskSecret(b.appSecret) })) },
   };
 }
@@ -268,7 +287,46 @@ function setCookie(req: IncomingMessage, res: ServerResponse, token: string, max
 }
 
 export function authed(req: IncomingMessage): boolean {
-  return !!validateSession(cookies(req)[COOKIE]);
+  return !!currentUser(req);
+}
+
+/** 这个请求是哪个用户的（没登录 / 登录态失效返回 undefined） */
+export function currentUser(req: IncomingMessage): User | undefined {
+  return sessionUser(cookies(req)[COOKIE]);
+}
+
+function newSession(req: IncomingMessage, res: ServerResponse, userId: string): void {
+  setCookie(req, res, createSession(userId, clientIp(req), String(req.headers["user-agent"] ?? "")), 30 * 24 * 3600);
+}
+
+/**
+ * 只有管理员能用的接口：所有设置（Agent、飞书、配对、总是允许名单、网络、升级、重启）和用户管理。
+ * 写在一处，方便核对。普通成员只能用自己的会话、通知、密码和登录设备。
+ */
+function adminOnly(p: string): boolean {
+  return (
+    p === "/api/config" ||
+    p === "/api/server/upgrade" ||
+    p === "/api/agents/codex/install" ||
+    p.startsWith("/api/pairing") ||
+    p.startsWith("/api/claude/") ||
+    p.startsWith("/api/feishu/") ||
+    p.startsWith("/api/system") ||
+    p.startsWith("/api/users")
+  );
+}
+
+function publicMe(user: User) {
+  return { id: user.id, name: user.name, role: user.role };
+}
+
+/** users.ts 抛的是给人看的错误，转成 400 */
+function userOp<T>(fn: () => T): T {
+  try {
+    return fn();
+  } catch (err) {
+    throw new HttpError(400, err instanceof Error ? err.message : String(err));
+  }
 }
 
 // ---------- 路由 ----------
@@ -297,32 +355,38 @@ export async function handleApi(req: IncomingMessage, res: ServerResponse, url:
 
   // ----- 无需登录 -----
   if (p === "/api/me" && method === "GET") {
-    sendJson(res, 200, { authed: authed(req), needsSetup: !hasPassword() });
+    const user = currentUser(req);
+    sendJson(res, 200, {
+      authed: !!user,
+      needsSetup: needsSetup(),
+      // 不止一个人能登录：登录页要填用户名
+      multiUser: listUsers().filter((u) => !u.disabled).length > 1,
+      ...(user ? { user: publicMe(user) } : {}),
+    });
     return;
   }
   if (p === "/api/setup" && method === "POST") {
-    if (hasPassword()) throw new HttpError(400, "已经设置过密码了");
-    const body = await readJsonBody<{ token?: string; password?: string }>(req);
+    if (!needsSetup()) throw new HttpError(400, "已经设置过了，直接登录");
+    const body = await readJsonBody<{ token?: string; name?: string; password?: string }>(req);
     const left = takeAttempt(ip);
     if (left) throw new HttpError(429, `尝试次数太多，请 ${Math.ceil(left / 60000)} 分钟后再试`);
     if (!checkSetupToken(String(body.token ?? ""))) {
       throw new HttpError(403, "设置码不对。它打印在 agent-loft 的启动日志里");
     }
-    setPassword(String(body.password ?? ""));
+    const user = userOp(() => setupFirstAdmin(String(body.name ?? ""), String(body.password ?? "")));
     clearAttempts(ip);
-    setCookie(req, res, createSession(ip, String(req.headers["user-agent"] ?? "")), 30 * 24 * 3600);
+    newSession(req, res, user.id);
     sendJson(res, 200, { ok: true });
     return;
   }
   if (p === "/api/login" && method === "POST") {
-    const body = await readJsonBody<{ password?: string }>(req);
+    const body = await readJsonBody<{ name?: string; password?: string }>(req);
     const left = takeAttempt(ip);
     if (left) throw new HttpError(429, `尝试次数太多，请 ${Math.ceil(left / 60000)} 分钟后再试`);
-    if (!hasPassword() || !verifyPassword(String(body.password ?? ""), config().web.passwordHash)) {
-      throw new HttpError(403, "密码不对");
-    }
+    const user = verifyLogin(typeof body.name === "string" ? body.name : undefined, String(body.password ?? ""));
+    if (!user) throw new HttpError(403, listUsers().filter((u) => !u.disabled).length > 1 ? "用户名或密码不对" : "密码不对");
     clearAttempts(ip);
-    setCookie(req, res, createSession(ip, String(req.headers["user-agent"] ?? "")), 30 * 24 * 3600);
+    newSession(req, res, user.id);
     sendJson(res, 200, { ok: true });
     return;
   }
@@ -333,11 +397,15 @@ export async function handleApi(req: IncomingMessage, res: ServerResponse, url:
     return;
   }
 
-  if (!authed(req)) throw new HttpError(401, "请先登录");
+  const user = currentUser(req);
+  if (!user) throw new HttpError(401, "请先登录");
+  if (adminOnly(p) && !isAdmin(user)) throw new HttpError(403, "只有管理员能做这个操作");
+  const admin = isAdmin(user);
+  const visible = (c: Parameters<typeof canSeeConv>[1]) => canSeeConv(user, c);
 
   // ----- 附件预览 / 下载：只给上传目录里的文件 -----
   if (p === "/api/file" && method === "GET") {
-    serveUpload(res, url.searchParams.get("path") ?? "", url.searchParams.get("download") === "1");
+    serveUpload(res, user, url.searchParams.get("path") ?? "", url.searchParams.get("download") === "1");
     return;
   }
 
@@ -357,11 +425,13 @@ export async function handleApi(req: IncomingMessage, res: ServerResponse, url:
           ...(agentAvailability(id) ?? {}),
         };
       }),
-      bots: config().feishu.bots.map((b) => ({ id: b.id, name: b.name, agents: b.agents, enabled: b.enabled })),
+      // 飞书机器人是管理员配的，飞书会话也只给管理员看
+      bots: admin ? config().feishu.bots.map((b) => ({ id: b.id, name: b.name, agents: b.agents, enabled: b.enabled })) : [],
       workspaceRoot: config().workspaceRoot,
       quotaRefreshMin: config().web.quotaRefreshMin,
-      conversations: hub.list(),
-      pending: interactions.listPending(),
+      conversations: hub.list(visible),
+      pending: interactions.listPending().filter((i) => visible(getConversation(i.convKey))),
+      user: publicMe(user),
       serverTime: Date.now(),
     });
     return;
@@ -369,13 +439,13 @@ export async function handleApi(req: IncomingMessage, res: ServerResponse, url:
 
   // ----- 系统通知（Web Push） -----
   if (p === "/api/push" && method === "GET") {
-    sendJson(res, 200, { publicKey: vapidPublicKey(), subscriptions: listSubscriptions() });
+    sendJson(res, 200, { publicKey: vapidPublicKey(), subscriptions: listSubscriptions(pushOwnedBy(user.id)) });
     return;
   }
   if (p === "/api/push/subscribe" && method === "POST") {
     const body = await readJsonBody<{ subscription?: unknown }>(req);
     try {
-      const record = addSubscription(body.subscription, String(req.headers["user-agent"] ?? ""));
+      const record = addSubscription(body.subscription, String(req.headers["user-agent"] ?? ""), user.id);
       sendJson(res, 200, { ok: true, label: record.label });
     } catch (err) {
       throw new HttpError(400, err instanceof Error ? err.message : String(err));
@@ -384,11 +454,14 @@ export async function handleApi(req: IncomingMessage, res: ServerResponse, url:
   }
   if (p === "/api/push/unsubscribe" && method === "POST") {
     const body = await readJsonBody<{ endpoint?: string }>(req);
-    sendJson(res, 200, { ok: removeSubscription(String(body.endpoint ?? "")) });
+    sendJson(res, 200, { ok: removeSubscription(String(body.endpoint ?? ""), pushOwnedBy(user.id)) });
     return;
   }
   if (p === "/api/push/test" && method === "POST") {
-    const sent = await pushToAll({ title: "Agent Loft", body: "测试通知：能看到这条，说明通知已经通了。", tag: "test", url: "/" });
+    const sent = await pushToAll(
+      { title: "Agent Loft", body: "测试通知：能看到这条，说明通知已经通了。", tag: "test", url: "/" },
+      pushOwnedBy(user.id),
+    );
     if (sent === 0) throw new HttpError(502, "没有推送成功：还没有设备开启通知，或推送服务拒绝了（看服务日志）");
     sendJson(res, 200, { sent });
     return;
@@ -404,7 +477,7 @@ export async function handleApi(req: IncomingMessage, res: ServerResponse, url:
 
   // ----- 会话 -----
   if (p === "/api/conversations" && method === "GET") {
-    sendJson(res, 200, hub.list());
+    sendJson(res, 200, hub.list(visible));
     return;
   }
   if (p === "/api/conversations" && method === "POST") {
@@ -419,7 +492,7 @@ export async function handleApi(req: IncomingMessage, res: ServerResponse, url:
       if (!cwd) throw new HttpError(400, `目录必须存在，且在 ${config().workspaceRoot} 之内`);
     }
     const key = `web:${crypto.randomBytes(6).toString("hex")}`;
-    hub.ensure({ key, channel: "web", channelId: "web", defaultAgent: agent });
+    hub.ensure({ key, channel: "web", channelId: "web", defaultAgent: agent, owner: user.id });
     if (cwd && cwd !== config().workspaceRoot) updateConversation(key, { cwd, cwdExplicit: true });
     sendJson(res, 200, hub.info(key));
     return;
@@ -430,6 +503,8 @@ export async function handleApi(req: IncomingMessage, res: ServerResponse, url:
     const key = decodeURIComponent(convMatch[1]!);
     const sub = convMatch[2];
     const conv = conversationOr404(key);
+    // 别人的会话：当它不存在
+    if (!visible(conv)) throw new HttpError(404, "会话不存在");
 
     if (!sub && method === "PATCH") {
       const body = await readJsonBody<{ title?: string; hidden?: boolean }>(req);
@@ -514,12 +589,13 @@ export async function handleApi(req: IncomingMessage, res: ServerResponse, url:
     if (sub === "fork" && method === "POST") {
       const body = await readJsonBody<{ anchor?: string }>(req);
       const anchor = typeof body.anchor === "string" && body.anchor ? body.anchor : undefined;
-      const newKey = await hub.forkConversation(key, anchor);
+      const newKey = await hub.forkConversation(key, anchor, user.id);
       sendJson(res, 200, { info: hub.info(newKey) });
       return;
     }
     if (sub === "feishu" && method === "POST") {
-      // 在飞书继续：把选中的飞书聊天挂到这条 Web 会话上
+      // 在飞书继续：把选中的飞书聊天挂到这条 Web 会话上。飞书机器人是管理员的
+      if (!admin) throw new HttpError(403, "只有管理员能用飞书机器人");
       if (conv.channel !== "web" || conv.hidden) throw new HttpError(400, "只有 Web 会话能到飞书继续");
       const body = await readJsonBody<{ botId?: string; chatId?: string }>(req);
       const bot = feishuBots().find((b) => b.id === body.botId);
@@ -533,7 +609,7 @@ export async function handleApi(req: IncomingMessage, res: ServerResponse, url:
       return;
     }
     if (sub === "sessions" && method === "GET") {
-      sendJson(res, 200, await hub.sessions(key, url.searchParams.get("all") === "1"));
+      sendJson(res, 200, await hub.sessions(key, url.searchParams.get("all") === "1", sessionVisibleTo(user)));
       return;
     }
     if (sub === "models" && method === "GET") {
@@ -556,7 +632,9 @@ export async function handleApi(req: IncomingMessage, res: ServerResponse, url:
           text = await hub.fork(key);
           break;
         case "resume":
-          text = await hub.resume(key, value, body.cwd);
+          text = (sessionVisibleTo(user)?.(value) ?? true)
+            ? await hub.resume(key, value, body.cwd)
+            : `找不到会话 ${value}。\n发 /sessions 看看有哪些可恢复的。`;
           break;
         case "model":
           text = await hub.setModel(key, value);
@@ -662,7 +740,8 @@ export async function handleApi(req: IncomingMessage, res: ServerResponse, url:
         sendJson(res, 404, { error: `没有 agent「${m[1]}」` });
         return;
       }
-      const conv = getConversation(url.searchParams.get("key") ?? "");
+      const found = getConversation(url.searchParams.get("key") ?? "");
+      const conv = found && visible(found) ? found : undefined;
       const commands = await hub.commandCatalog(m[1]!, {
         ...(conv ? { cwd: conv.cwd } : {}),
         allowedAgents: hub.enabledAgents().map((d) => d.id),
@@ -674,25 +753,80 @@ export async function handleApi(req: IncomingMessage, res: ServerResponse, url:
     }
   }
   if (p === "/api/password" && method === "POST") {
+    // 改自己的密码：自己所有设备下线，当前这台换一个新的登录态
     const body = await readJsonBody<{ old?: string; password?: string }>(req);
     const left = takeAttempt(ip);
     if (left) throw new HttpError(429, `尝试次数太多，请 ${Math.ceil(left / 60000)} 分钟后再试`);
-    if (!verifyPassword(String(body.old ?? ""), config().web.passwordHash)) throw new HttpError(403, "原密码不对");
+    if (!verifyPassword(String(body.old ?? ""), user.passwordHash)) throw new HttpError(403, "原密码不对");
     clearAttempts(ip);
-    setPassword(String(body.password ?? ""));
-    setCookie(req, res, createSession(ip, String(req.headers["user-agent"] ?? "")), 30 * 24 * 3600);
+    userOp(() => setUserPassword(user.id, String(body.password ?? "")));
+    newSession(req, res, user.id);
     sendJson(res, 200, { ok: true });
     return;
   }
   if (p === "/api/web-sessions" && method === "GET") {
-    sendJson(res, 200, listWebSessions());
+    // 管理员看所有人的设备，成员只看自己的
+    sendJson(res, 200, listWebSessions(admin ? undefined : user.id));
     return;
   }
   if (p === "/api/web-sessions/revoke" && method === "POST") {
     const body = await readJsonBody<{ id?: string }>(req);
-    sendJson(res, 200, { ok: revokeSession(String(body.id ?? "")) });
+    sendJson(res, 200, { ok: revokeSession(String(body.id ?? ""), admin ? undefined : user.id) });
+    return;
+  }
+
+  // ----- 用户管理（管理员） -----
+  if (p === "/api/users" && method === "GET") {
+    const devices = listWebSessions();
+    sendJson(res, 200, {
+      users: listUsers().map((u) => ({ ...u, devices: devices.filter((d) => d.userId === u.id).length })),
+      me: user.id,
+    });
     return;
   }
+  if (p === "/api/users" && method === "POST") {
+    const body = await readJsonBody<{ name?: string; password?: string; role?: Role }>(req);
+    sendJson(
+      res,
+      200,
+      userOp(() => createUser({ name: String(body.name ?? ""), password: String(body.password ?? ""), role: body.role === "admin" ? "admin" : "member" })),
+    );
+    return;
+  }
+  const userMatch = /^\/api\/users\/([A-Za-z0-9_]+)$/.exec(p);
+  if (userMatch) {
+    const id = userMatch[1]!;
+    if (!getUser(id)) throw new HttpError(404, "用户不存在");
+    if (method === "PATCH") {
+      const body = await readJsonBody<{ name?: string; role?: Role; disabled?: boolean; password?: string }>(req);
+      if (id === user.id && (body.disabled === true || (body.role !== undefined && body.role !== "admin"))) {
+        throw new HttpError(400, "不能停用自己，也不能取消自己的管理员");
+      }
+      // 一次改完：密码不合格时别的也不改。重置密码 / 停用会让他的设备全部下线
+      const updated = userOp(() =>
+        patchUser(id, {
+          ...(typeof body.name === "string" ? { name: body.name } : {}),
+          ...(body.role === "admin" || body.role === "member" ? { role: body.role } : {}),
+          ...(typeof body.disabled === "boolean" ? { disabled: body.disabled } : {}),
+          ...(typeof body.password === "string" ? { password: body.password } : {}),
+        }),
+      );
+      // 管理员在用户列表里重置了自己的密码：当前这台换个新登录态，别把自己踢出去
+      if (id === user.id && typeof body.password === "string") newSession(req, res, user.id);
+      sendJson(res, 200, updated);
+      return;
+    }
+    if (method === "DELETE") {
+      if (id === user.id) throw new HttpError(400, "不能删除自己");
+      // 升级前没记主人的推送订阅算在最早的管理员名下：删人之前先记下是谁
+      const legacy = legacyOwnerId();
+      const removed = userOp(() => removeUser(id));
+      removeSubscriptionsOf((owner) => (owner ?? legacy) === id);
+      revokeUserSessions(id);
+      sendJson(res, 200, removed);
+      return;
+    }
+  }
   if (p === "/api/pairing" && method === "GET") {
     sendJson(res, 200, { pending: listPending(), approved: listApproved() });
     return;