agent-loft 0.2.22 → 0.2.23

package/src/channels/web/auth.ts

@@ -1,8 +1,8 @@
 // Web 登录鉴权。
 //
 // 这个页面能让 agent 在这台机器上执行命令，等同于一个远程 shell，所以：
-//   - 密码用 scrypt 哈希存，不存明文；
-//   - 首次没有密码时，必须拿终端 / 日志里打印的一次性设置码才能设密码
+//   - 密码用 scrypt 哈希存，不存明文（账号见 core/users.ts）；
+//   - 一个用户都没有时，必须拿终端 / 日志里打印的一次性设置码才能建第一个管理员
 //     （否则谁先打开页面谁就成了主人）；
 //   - 登录态是随机 token，服务端只存它的哈希，HttpOnly cookie；
 //   - 同一 IP 连续输错会被锁一段时间。
@@ -11,16 +11,20 @@ import fs from "node:fs";
 import { EventEmitter } from "node:events";
 import path from "node:path";
 import { config, saveConfig } from "../../core/config.js";
+import { createUser, getUser, hasUsers, legacyOwnerId, updateUser, userEvents, type PublicUser, type User } from "../../core/users.js";
 import { dataDir, readJson, writeJsonAtomic } from "../../home.js";
 
 const SESSION_TTL_MS = 30 * 24 * 60 * 60 * 1000;
 
-/** 登录态被撤销（退出、改密码、踢设备）时通知 WebSocket 那边立刻断开对应连接 */
+/** 登录态被撤销（退出、改密码、踢设备、用户被停用 / 删除）时通知 WebSocket 那边立刻断开对应连接 */
 export const authEvents = new EventEmitter<{ revoked: [] }>();
+userEvents.on("changed", () => authEvents.emit("revoked"));
 const sessionsPath = path.join(dataDir, "web-sessions.json");
 const setupTokenPath = path.join(dataDir, "web-setup-token");
 
 export type WebSession = {
+  /** 升级前的登录态没有这个字段：读的时候认给迁移出来的那个管理员（legacyOwnerId） */
+  userId?: string;
   createdAt: number;
   expiresAt: number;
   lastSeen: number;
@@ -47,7 +51,19 @@ function loadSessions(): Record<string, WebSession> {
     loadedMtime = mtime;
   }
   const now = Date.now();
-  for (const [id, s] of Object.entries(sessions)) if (s.expiresAt < now) delete sessions[id];
+  let stamped = false;
+  for (const [id, s] of Object.entries(sessions)) {
+    if (s.expiresAt < now) delete sessions[id];
+    else if (!s.userId) {
+      // 升级前的登录态：认给迁移出来的管理员，并且记下来，之后那个管理员被删了也不会换人
+      const owner = legacyOwnerId();
+      if (owner) {
+        s.userId = owner;
+        stamped = true;
+      }
+    }
+  }
+  if (stamped) saveSessions();
   return sessions;
 }
 
@@ -60,43 +76,34 @@ function sha256(value: string): string {
   return crypto.createHash("sha256").update(value).digest("hex");
 }
 
-// ---------- 密码 ----------
-
-export function hashPassword(password: string): string {
-  const salt = crypto.randomBytes(16);
-  const key = crypto.scryptSync(password, salt, 32, { N: 16384, r: 8, p: 1 });
-  return `scrypt$${salt.toString("hex")}$${key.toString("hex")}`;
+function ownerOf(s: WebSession): string | undefined {
+  return s.userId;
 }
 
-export function verifyPassword(password: string, stored: string): boolean {
-  const [scheme, saltHex, keyHex] = stored.split("$");
-  if (scheme !== "scrypt" || !saltHex || !keyHex) return false;
-  const expected = Buffer.from(keyHex, "hex");
-  const actual = crypto.scryptSync(password, Buffer.from(saltHex, "hex"), expected.length, { N: 16384, r: 8, p: 1 });
-  return crypto.timingSafeEqual(expected, actual);
-}
+// ---------- 首次设置 ----------
 
-export function hasPassword(): boolean {
-  return !!config().web.passwordHash;
+/** 还一个用户都没有：页面上要先建管理员 */
+export function needsSetup(): boolean {
+  return !hasUsers();
 }
 
-export function setPassword(password: string): void {
-  if (password.length < 8) throw new Error("密码至少 8 位");
-  const cfg = structuredClone(config());
-  cfg.web.passwordHash = hashPassword(password);
-  saveConfig(cfg);
-  // 改密码 = 所有已登录设备下线
+/**
+ * 建第一个管理员（页面上用设置码，或终端里 agent-loft passwd）。
+ * 之前残留的登录态全部作废：否则它们没记用户，会被当成升级前的登录态认给这个新管理员。
+ */
+export function setupFirstAdmin(name: string, password: string): PublicUser {
+  if (hasUsers()) throw new Error("已经设置过了");
+  const user = createUser({ name: name.trim() || "admin", password, role: "admin" });
   sessions = {};
   saveSessions();
   fs.rmSync(setupTokenPath, { force: true });
   authEvents.emit("revoked");
+  return user;
 }
 
-// ---------- 首次设置码 ----------
-
-/** 没有密码时生成（或沿用）一次性设置码，打印到日志里。 */
+/** 一个用户都没有时生成（或沿用）一次性设置码，打印到日志里。 */
 export function ensureSetupToken(): string | null {
-  if (hasPassword()) return null;
+  if (hasUsers()) return null;
   try {
     const existing = fs.readFileSync(setupTokenPath, "utf8").trim();
     if (existing) return existing;
@@ -117,26 +124,54 @@ export function checkSetupToken(token: string): boolean {
   return a.length === b.length && crypto.timingSafeEqual(a, b);
 }
 
+// ---------- 密码 ----------
+
+/**
+ * 改某个用户的密码：他所有已登录的设备下线。
+ * 升级前那个全局密码（config.web.passwordHash）也一并清掉，旧密码从此不再有效。
+ */
+export function setUserPassword(userId: string, password: string): void {
+  patchUser(userId, { password });
+}
+
+/**
+ * 改用户（一次写盘，要么全改要么全不改），再处理副作用：
+ * 改了密码或者停用了，他所有设备下线；改了密码，升级前的全局密码也作废。
+ */
+export function patchUser(userId: string, patch: Parameters<typeof updateUser>[1]): PublicUser {
+  const updated = updateUser(userId, patch);
+  if (patch.password !== undefined || patch.disabled === true) revokeUserSessions(userId);
+  if (patch.password !== undefined && config().web.passwordHash) {
+    const cfg = structuredClone(config());
+    cfg.web.passwordHash = "";
+    saveConfig(cfg);
+  }
+  return updated;
+}
+
 // ---------- 登录态 ----------
 
-export function createSession(ip: string, userAgent: string): string {
+export function createSession(userId: string, ip: string, userAgent: string): string {
   const token = crypto.randomBytes(32).toString("base64url");
   const now = Date.now();
-  loadSessions()[sha256(token)] = { createdAt: now, expiresAt: now + SESSION_TTL_MS, lastSeen: now, ip, userAgent };
+  loadSessions()[sha256(token)] = { userId, createdAt: now, expiresAt: now + SESSION_TTL_MS, lastSeen: now, ip, userAgent };
   saveSessions();
   return token;
 }
 
-export function validateSession(token: string | undefined): WebSession | undefined {
-  if (!token || !hasPassword()) return undefined;
+/** 登录态对应的用户。用户被停用、删掉了也算无效 */
+export function sessionUser(token: string | undefined): User | undefined {
+  if (!token || !hasUsers()) return undefined;
   const s = loadSessions()[sha256(token)];
   if (!s) return undefined;
+  const user = getUser(ownerOf(s));
+  if (!user || user.disabled) return undefined;
   const now = Date.now();
   if (now - s.lastSeen > 60_000) {
     s.lastSeen = now;
     saveSessions();
   }
-  return s;
+  return user;
 }
 
 export function destroySession(token: string | undefined): void {
@@ -146,13 +181,24 @@ export function destroySession(token: string | undefined): void {
   authEvents.emit("revoked");
 }
 
-export function listSessions(): (WebSession & { id: string })[] {
-  return Object.entries(loadSessions()).map(([id, s]) => ({ id: id.slice(0, 12), ...s }));
+export type SessionView = WebSession & { id: string; userId?: string; userName?: string };
+
+/** 已登录的设备。给了 userId 就只列这个用户的 */
+export function listSessions(userId?: string): SessionView[] {
+  return Object.entries(loadSessions())
+    .filter(([, s]) => !userId || ownerOf(s) === userId)
+    .map(([id, s]) => {
+      const owner = ownerOf(s);
+      const name = getUser(owner)?.name;
+      return { ...s, id: id.slice(0, 12), ...(owner ? { userId: owner } : {}), ...(name ? { userName: name } : {}) };
+    });
 }
 
-export function revokeSession(idPrefix: string): boolean {
+/** 踢掉一个设备。给了 userId 就只能踢这个用户自己的 */
+export function revokeSession(idPrefix: string, userId?: string): boolean {
+  if (!idPrefix) return false;
   const all = loadSessions();
-  const hit = Object.keys(all).find((id) => id.startsWith(idPrefix));
+  const hit = Object.keys(all).find((id) => id.startsWith(idPrefix) && (!userId || ownerOf(all[id]!) === userId));
   if (!hit) return false;
   delete all[hit];
   saveSessions();
@@ -160,6 +206,14 @@ export function revokeSession(idPrefix: string): boolean {
   return true;
 }
 
+/** 某个用户的所有设备下线 */
+export function revokeUserSessions(userId: string): void {
+  const all = loadSessions();
+  for (const [id, s] of Object.entries(all)) if (ownerOf(s) === userId) delete all[id];
+  saveSessions();
+  authEvents.emit("revoked");
+}
+
 // ---------- 防爆破 ----------
 //
 // 额度在「真要验密码的那一刻」同步扣掉，而不是先查后记：后者中间隔着读请求体的

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);
+}