agent-loft 0.2.22 → 0.2.24

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}。`);

package/src/core/store.ts

@@ -47,6 +47,11 @@ export type Conversation = {
   autoEdit?: boolean;
   /** 从哪条对话分叉出来的（对话 key），列表里据此显示关联 */
   forkOf?: string;
+  /**
+   * 谁的对话（用户 id，见 core/users.ts）。Web 上新建 / 分叉时记下；
+   * 飞书会话和升级前就有的 Web 会话没有，归管理员。
+   */
+  owner?: string;
 };
 
 type StoreShape = Record<string, Conversation>;
@@ -112,6 +117,7 @@ export function ensureConversation(params: {
   channelId: string;
   agent: string;
   title?: string;
+  owner?: string;
 }): Conversation {
   const existing = getConversation(params.key);
   if (existing) return existing;
@@ -126,6 +132,7 @@ export function ensureConversation(params: {
     activeAt: now,
     createdAt: now,
     ...(params.title ? { title: params.title } : {}),
+    ...(params.owner ? { owner: params.owner } : {}),
   };
   load()[params.key] = conv;
   persist(true);
@@ -181,3 +188,29 @@ export function putConversation(conv: Conversation): void {
   load()[conv.key] = conv;
   persist(true);
 }
+
+// ---------- agent 会话的归属 ----------
+//
+// /sessions、/resume 列的是 agent 自己存的全部历史（磁盘上谁开的都有），多用户时要按人过滤：
+// 记下每个 agent 会话 id 是哪个用户的对话里开出来的。没记过的（飞书、终端里开的、升级前的）归管理员。
+
+const sessionOwnersPath = path.join(dataDir, "session-owners.json");
+let sessionOwners: Record<string, string> | null = null;
+
+function owners(): Record<string, string> {
+  sessionOwners ??= readJson<Record<string, string>>(sessionOwnersPath, {});
+  return sessionOwners;
+}
+
+/** 第一次见到这个会话 id 时记下主人；已经有主了不改 */
+export function recordSessionOwner(sessionId: string | undefined, userId: string | undefined): void {
+  if (!sessionId || !userId) return;
+  const all = owners();
+  if (all[sessionId]) return;
+  all[sessionId] = userId;
+  writeJsonAtomic(sessionOwnersPath, all);
+}
+
+export function sessionOwner(sessionId: string): string | undefined {
+  return owners()[sessionId];
+}

package/src/core/types.ts

@@ -51,6 +51,11 @@ export type InteractionSpec =
       detail: string;
       /** 「总是允许」按钮的文字；不给就没有这个按钮 */
       alwaysLabel?: string;
+      /**
+       * 「总是允许」会落盘、对所有会话生效（Claude 的总是允许名单、Codex 的 execpolicy）。
+       * 多用户时只有管理员能点 —— 否则一个成员就能替所有人放行。
+       */
+      alwaysGlobal?: boolean;
       /** 给了就显示「本会话全部允许」按钮。只有 agent 能真正兑现时才给 */
       allowSession?: boolean;
     }

package/src/core/uploads.ts

@@ -230,6 +230,18 @@ export function resolveUploadFile(p: string): string | undefined {
   }
 }
 
+/** 上传目录里的文件属于哪条会话（resolveUploadFile 返回的真实路径）。认不出来返回 undefined */
+export function uploadKeyOf(file: string): string | undefined {
+  try {
+    const rel = path.relative(fs.realpathSync(uploadsRoot), file);
+    const first = rel.split(path.sep)[0];
+    if (!first || first.startsWith("..") || path.isAbsolute(rel)) return undefined;
+    return decodeURIComponent(first);
+  } catch {
+    return undefined;
+  }
+}
+
 /** 附件清单的文字说明，两个 agent 都用它告诉模型文件在哪。 */
 export function describeAttachments(
   saved: SavedAttachment[],

package/src/core/users.ts

@@ -0,0 +1,261 @@
+// 用户：Web 登录的账号。
+//
+// 这是「信任型」多用户：账号分开的是会话列表、授权、通知和设置权限，不是安全边界 ——
+// 所有 agent 都以同一个系统用户运行，谁都能让 agent 去读这台机器上的任何东西。
+// 只把账号给你信任的人（README「多用户」）。
+//
+// 归属规则（ownedBy）：
+//   - 有主的东西（Web 会话、agent 会话、推送订阅）只属于主人；
+//   - 主人已经被删掉了，归管理员；
+//   - 没有主的（飞书会话、终端里开的 agent 会话、升级前就有的 Web 会话）归管理员。
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { EventEmitter } from "node:events";
+import { dataDir, readJson, writeJsonAtomic } from "../home.js";
+import { config } from "./config.js";
+
+export type Role = "admin" | "member";
+
+export type User = {
+  id: string;
+  /** 登录名，不区分大小写，唯一 */
+  name: string;
+  role: Role;
+  passwordHash: string;
+  createdAt: number;
+  disabled?: boolean;
+};
+
+export type PublicUser = Omit<User, "passwordHash">;
+
+type StoreShape = { users: User[] };
+
+const usersPath = path.join(dataDir, "users.json");
+/** 用户增删改、停用、改密码：登录态要重新校验 */
+export const userEvents = new EventEmitter<{ changed: [] }>();
+
+let cache: User[] | null = null;
+let loadedMtime = 0;
+
+function mtimeOf(file: string): number {
+  try {
+    return fs.statSync(file).mtimeMs;
+  } catch {
+    return 0;
+  }
+}
+
+/** 上次看文件有没有变的时间：广播事件时每个连接都要查归属，别每次都 stat 一下 */
+let checkedAt = 0;
+const RECHECK_MS = 1000;
+
+function load(): User[] {
+  // 终端里 agent-loft user … 会改这个文件：变了就重新读（最多晚 1 秒发现）
+  const now = Date.now();
+  if (cache && cache.length > 0 && now - checkedAt < RECHECK_MS) return cache;
+  checkedAt = now;
+  const mtime = mtimeOf(usersPath);
+  if (!cache || mtime !== loadedMtime) {
+    const raw = readJson<StoreShape>(usersPath, { users: [] });
+    cache = Array.isArray(raw.users) ? raw.users.filter((u) => u && typeof u.id === "string" && typeof u.name === "string") : [];
+    loadedMtime = mtime;
+  }
+  migrateLegacy(cache);
+  return cache;
+}
+
+function save(list: User[]): void {
+  cache = list;
+  writeJsonAtomic(usersPath, { users: list });
+  loadedMtime = mtimeOf(usersPath);
+  userEvents.emit("changed");
+}
+
+/**
+ * 升级前只有一个登录密码（config.web.passwordHash）：变成一个叫 admin 的管理员，密码不变。
+ * 不改动旧字段 —— 万一回退到老版本还能照常登录；之后改密码时再把它清掉（见 setUserPassword）。
+ */
+function migrateLegacy(list: User[]): void {
+  if (list.length > 0) return;
+  let legacy = "";
+  try {
+    legacy = config().web.passwordHash;
+  } catch {
+    return;
+  }
+  if (!legacy) return;
+  list.push({ id: newId(), name: "admin", role: "admin", passwordHash: legacy, createdAt: Date.now() });
+  writeJsonAtomic(usersPath, { users: list });
+  loadedMtime = mtimeOf(usersPath);
+  console.log("[用户] 已把原来的登录密码迁移为管理员账号 admin");
+}
+
+function newId(): string {
+  return `u_${crypto.randomBytes(5).toString("hex")}`;
+}
+
+function publicUser(u: User): PublicUser {
+  const { passwordHash: _hidden, ...rest } = u;
+  return { ...rest };
+}
+
+// ---------- 密码 ----------
+
+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")}`;
+}
+
+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);
+}
+
+/** 用户名不存在时也算一遍 scrypt，响应时间上看不出用户名对不对 */
+let dummyHash: string | null = null;
+const dummy = () => (dummyHash ??= hashPassword(crypto.randomBytes(12).toString("hex")));
+
+function checkPassword(password: string): void {
+  if (password.length < 8) throw new Error("密码至少 8 位");
+  if (password.length > 256) throw new Error("密码太长了");
+}
+
+function checkName(name: string): string {
+  const n = name.trim();
+  if (!/^[\p{L}\p{N}_.@-]{1,32}$/u.test(n)) throw new Error("用户名 1～32 个字符，只能用文字、数字和 _ . @ -");
+  return n;
+}
+
+// ---------- 查询 ----------
+
+export function hasUsers(): boolean {
+  return load().length > 0;
+}
+
+export function listUsers(): PublicUser[] {
+  return load().map(publicUser);
+}
+
+export function getUser(id: string | undefined): User | undefined {
+  if (!id) return undefined;
+  return load().find((u) => u.id === id);
+}
+
+export function findUserByName(name: string): User | undefined {
+  const n = name.trim().toLowerCase();
+  return load().find((u) => u.name.toLowerCase() === n);
+}
+
+/** 可以登录的用户（没被停用） */
+export function activeUsers(): User[] {
+  return load().filter((u) => !u.disabled);
+}
+
+/** 有没有普通成员（没有的话，飞书那边什么都不用滤） */
+export function hasMembers(): boolean {
+  return load().some((u) => u.role !== "admin");
+}
+
+export function isAdmin(user: Pick<User, "role"> | undefined): boolean {
+  return user?.role === "admin";
+}
+
+/**
+ * 升级前的登录态、推送订阅没有记是谁的：都算最早的那个管理员的（就是迁移出来的 admin）。
+ */
+export function legacyOwnerId(): string | undefined {
+  return load()
+    .filter((u) => u.role === "admin" && !u.disabled)
+    .sort((a, b) => a.createdAt - b.createdAt)[0]?.id;
+}
+
+/** 归属规则，见文件开头 */
+export function ownedBy(user: Pick<User, "id" | "role">, owner: string | undefined): boolean {
+  if (owner) return owner === user.id || (user.role === "admin" && !getUser(owner));
+  return user.role === "admin";
+}
+
+/** 管理员能看到的（飞书那边是管理员的地盘：/web 只列这些，也只能接上这些） */
+export function adminVisible(owner: string | undefined): boolean {
+  if (!owner) return true;
+  const u = getUser(owner);
+  return !u || u.role === "admin";
+}
+
+/**
+ * 校验登录。name 没给、并且只有一个能登录的用户时就是他 —— 单用户时登录页和以前一样只要密码。
+ */
+export function verifyLogin(name: string | undefined, password: string): User | undefined {
+  const active = activeUsers();
+  const user = name?.trim() ? active.find((u) => u.name.toLowerCase() === name.trim().toLowerCase()) : active.length === 1 ? active[0] : undefined;
+  const ok = verifyPassword(password, user?.passwordHash ?? dummy());
+  return ok ? user : undefined;
+}
+
+// ---------- 修改 ----------
+
+/** 改完之后至少还要有一个能登录的管理员 */
+function assertAdminLeft(list: User[]): void {
+  if (!list.some((u) => u.role === "admin" && !u.disabled)) throw new Error("至少要保留一个能登录的管理员");
+}
+
+export function createUser(params: { name: string; password: string; role?: Role }): PublicUser {
+  const list = load();
+  const name = checkName(params.name);
+  if (list.some((u) => u.name.toLowerCase() === name.toLowerCase())) throw new Error(`用户名「${name}」已经有人用了`);
+  checkPassword(params.password);
+  const user: User = {
+    id: newId(),
+    name,
+    role: params.role === "admin" ? "admin" : "member",
+    passwordHash: hashPassword(params.password),
+    createdAt: Date.now(),
+  };
+  save([...list, user]);
+  return publicUser(user);
+}
+
+export function updateUser(id: string, patch: { name?: string; role?: Role; disabled?: boolean; password?: string }): PublicUser {
+  const list = load().map((u) => ({ ...u }));
+  const user = list.find((u) => u.id === id);
+  if (!user) throw new Error("用户不存在");
+  if (patch.name !== undefined) {
+    const name = checkName(patch.name);
+    if (list.some((u) => u.id !== id && u.name.toLowerCase() === name.toLowerCase())) throw new Error(`用户名「${name}」已经有人用了`);
+    user.name = name;
+  }
+  if (patch.role !== undefined) user.role = patch.role === "admin" ? "admin" : "member";
+  if (patch.disabled !== undefined) {
+    if (patch.disabled) user.disabled = true;
+    else delete user.disabled;
+  }
+  if (patch.password !== undefined) {
+    checkPassword(patch.password);
+    user.passwordHash = hashPassword(patch.password);
+  }
+  assertAdminLeft(list);
+  save(list);
+  return publicUser(user);
+}
+
+export function removeUser(id: string): PublicUser {
+  const list = load();
+  const user = list.find((u) => u.id === id);
+  if (!user) throw new Error("用户不存在");
+  const rest = list.filter((u) => u.id !== id);
+  assertAdminLeft(rest);
+  save(rest);
+  return publicUser(user);
+}
+
+/** 测试用：换了 AGENT_LOFT_HOME 之后重新读 */
+export function resetUsersForTest(): void {
+  cache = null;
+  loadedMtime = 0;
+  checkedAt = 0;
+}