agent-loft 0.2.90 → 0.2.94

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/src/core/hub.ts CHANGED
@@ -9,8 +9,11 @@
9
9
  // 说的话照样回到飞书。所以事件是广播出去的,每个订阅者自己挑感兴趣的会话。
10
10
  import crypto from "node:crypto";
11
11
  import { EventEmitter } from "node:events";
12
+ import fs from "node:fs";
13
+ import path from "node:path";
12
14
  import { config, onConfigChange, resolveWorkspacePath } from "./config.js";
13
- import { attachFooters, copyFooters, formatDuration, recordFooter } from "./footers.js";
15
+ import { attachFooters, copyFooters, formatDuration, recordFooter, setFooterChanges } from "./footers.js";
16
+ import { beginTurnSnapshot, finishTurnSnapshot } from "./turn-changes.js";
14
17
  import { removeHistoryRecord, replaceConversationRecords } from "./chat-history.js";
15
18
  import { recordUsage, usageOf, type UsageTotals } from "./usage.js";
16
19
  import { interactions, SETTLEMENT_LABEL } from "./interactions.js";
@@ -35,7 +38,7 @@ import { attachmentInfo, ensureUploadsDir, KIND_LABEL } from "./uploads.js";
35
38
  import { memoryOwnerOf, sessionMemory } from "./personal.js";
36
39
  import { exceedsPermission, minPermission, PERMISSION_LABEL, permissionCapOfAccess, permissionOfSandbox, type PermissionLevel } from "./permission.js";
37
40
  import { readMemory } from "./memory.js";
38
- import { getUser, userEvents } from "./users.js";
41
+ import { canUseFiles, getUser, userEvents } from "./users.js";
39
42
  import type {
40
43
  AgentDriver,
41
44
  AttachmentInfo,
@@ -49,6 +52,7 @@ import type {
49
52
  SessionSummary,
50
53
  StepKind,
51
54
  TodoItem,
55
+ TurnChanges,
52
56
  UserInput,
53
57
  } from "./types.js";
54
58
  import { buildCatalog, expandCustomCommand, type AgentCommand, type CommandEntry, type CommandPrefs } from "./command-catalog.js";
@@ -93,6 +97,8 @@ export type ConvEvent =
93
97
  | { type: "step"; kind: StepKind; text: string }
94
98
  /** agent 的任务清单变了(改完之后的整份) */
95
99
  | { type: "todos"; todos: TodoItem[] }
100
+ /** 这一轮改了哪些文件。快照做完才知道,比 result 晚到;at 对应 result 的 at(出错结束的轮次没有) */
101
+ | { type: "turn_changes"; changes: TurnChanges; at?: number }
96
102
  | { type: "delta"; text: string }
97
103
  | { type: "text"; text: string }
98
104
  /**
@@ -812,20 +818,22 @@ class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd]; "p
812
818
  const footer = parts.join(" ");
813
819
  const tag = this.takeTurnTag(key);
814
820
  const silent = !!tag?.smart && isSilentReply(result.text);
821
+ const at = Date.now();
815
822
  this.emitEvent(key, {
816
823
  type: "result",
817
824
  text: result.text,
818
825
  footer,
819
- at: Date.now(),
826
+ at,
820
827
  ...(result.anchor && !tag?.isolated ? { anchor: result.anchor } : {}),
821
828
  ...(tag ? { task: { id: tag.taskId, title: tag.title } } : {}),
822
829
  ...(silent ? { silent: true as const } : {}),
823
830
  });
824
831
  if (tag) this.emit("task", { ...tag, key, status: silent ? "silent" : "notified", text: result.text });
825
832
  const conv = getConversation(key);
826
- recordFooter(holder.session?.sessionId ?? (conv ? agentBinding(conv, agent).sessionId : undefined), result.text, footer);
833
+ const footerId = recordFooter(holder.session?.sessionId ?? (conv ? agentBinding(conv, agent).sessionId : undefined), result.text, footer);
827
834
  this.setInflight(key, (this.inflight.get(key) ?? 1) - 1);
828
835
  this.finishTurn(key);
836
+ this.reportTurnChanges(key, at, footerId);
829
837
  this.refreshRuntimeOnce(key, liveId);
830
838
  this.syncTitle(key, agent);
831
839
  this.dropIfStale(key);
@@ -853,6 +861,8 @@ class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd]; "p
853
861
  }
854
862
  this.setInflight(key, (this.inflight.get(key) ?? 1) - 1);
855
863
  this.finishTurn(key);
864
+ // 停止、出错之前可能已经改了文件,也要告诉用户。这种轮次没有脚注,刷新后就看不到了
865
+ this.reportTurnChanges(key);
856
866
  this.dropIfStale(key);
857
867
  },
858
868
  onContext: (ctx) => {
@@ -953,6 +963,46 @@ class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd]; "p
953
963
  }, delays[attempt]);
954
964
  }
955
965
 
966
+ // ---------- 每轮改了什么 ----------
967
+
968
+ /** 只给能用工作区面板的人做快照:看不到卡片,就没必要往他的仓库里写东西。没主人的会话归管理员 */
969
+ private tracksChanges(conv: Conversation): boolean {
970
+ return conv.owner ? canUseFiles(getUser(conv.owner)) || !getUser(conv.owner) : true;
971
+ }
972
+
973
+ /** 这个仓库里有没有别的会话正在跑(key 是 null 时不排除任何会话) */
974
+ busyInRepo(key: string | null, root: string): boolean {
975
+ const prefix = root.endsWith(path.sep) ? root : root + path.sep;
976
+ for (const [other, count] of this.inflight) {
977
+ if (other === key || count <= 0) continue;
978
+ const cwd = getConversation(other)?.cwd;
979
+ if (!cwd) continue;
980
+ try {
981
+ const real = fs.realpathSync(cwd);
982
+ if (real === root || real.startsWith(prefix)) return true;
983
+ } catch {
984
+ // 目录没了
985
+ }
986
+ }
987
+ return false;
988
+ }
989
+
990
+ private async snapshotBeforeTurn(key: string): Promise<void> {
991
+ const conv = getConversation(key);
992
+ if (!conv || !this.tracksChanges(conv)) return;
993
+ await beginTurnSnapshot(key, conv.cwd, (root) => this.busyInRepo(key, root));
994
+ }
995
+
996
+ private reportTurnChanges(key: string, at?: number, footerId?: number): void {
997
+ const conv = getConversation(key);
998
+ if (!conv || !this.tracksChanges(conv)) return;
999
+ void finishTurnSnapshot(key, conv.cwd, (root) => this.busyInRepo(key, root)).then((changes) => {
1000
+ if (!changes) return;
1001
+ if (footerId !== undefined) setFooterChanges(footerId, changes);
1002
+ this.emitEvent(key, { type: "turn_changes", changes, ...(at !== undefined ? { at } : {}) });
1003
+ });
1004
+ }
1005
+
956
1006
  /** 丢掉活着的会话(不动绑定)。挂着的审批一并取消,否则阻塞的那一轮永远走不完。 */
957
1007
  async drop(key: string, note: string): Promise<void> {
958
1008
  interactions.cancelAll(key, note);
@@ -1174,6 +1224,12 @@ class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd]; "p
1174
1224
  this.emitEvent(key, { type: "notice", text: blocked });
1175
1225
  return gone(blocked);
1176
1226
  }
1227
+ // 这一轮开始之前拍一张快照,结束时比较(排队的消息接着上一轮结束时的那张,见 turn-changes.ts)
1228
+ if (!this.isBusy(key)) {
1229
+ await this.snapshotBeforeTurn(key);
1230
+ if (waiting.cancelled) return;
1231
+ if (cancelled()) return gone("没有发出(停止了或者会话被切换了)");
1232
+ }
1177
1233
  if (task?.isolated) {
1178
1234
  if (this.isBusy(key)) return gone("对话正在回复,这次没有运行");
1179
1235
  await this.drop(key, "定时任务开始独立运行");
@@ -1839,7 +1895,7 @@ class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd]; "p
1839
1895
  updateAgentBinding(key, conv.agent, { sessionId, forkFrom: undefined });
1840
1896
  if (sessionId) {
1841
1897
  recordSessionOwner(sessionId, conv.owner);
1842
- for (const m of kept) if (m.footer) recordFooter(sessionId, m.text, m.footer);
1898
+ for (const m of kept) if (m.footer) recordFooter(sessionId, m.text, m.footer, m.changes);
1843
1899
  }
1844
1900
  const owner = memoryOwnerOf(conv);
1845
1901
  if (owner) replaceConversationRecords(owner, key, mergeSessionHistory(past, kept).flatMap((m) => {
@@ -41,7 +41,8 @@ function within(file: string, dir: string): boolean {
41
41
 
42
42
  export function isSensitivePath(file: string): boolean {
43
43
  const parts = file.split(path.sep);
44
- if (parts.some((p) => SENSITIVE_DIRS.has(p))) return true;
44
+ // 不分大小写的文件系统(macOS、Windows)上 .SSH 就是 .ssh
45
+ if (parts.some((p) => SENSITIVE_DIRS.has(p.toLowerCase()))) return true;
45
46
  if (sensitiveName(path.basename(file))) return true;
46
47
  const userHome = os.homedir();
47
48
  if (SENSITIVE_HOME.some((p) => within(file, path.join(userHome, p)))) return true;
@@ -0,0 +1,179 @@
1
+ // 每轮对话改了什么:一轮开始前和结束后各拍一张工作区快照(见 git.ts 的 snapshotTree),比较两张得出改动。
2
+ //
3
+ // 不靠 agent 上报:Codex 只说改了哪些路径,Claude 只报自己工具改的,用命令改的两边都不算。
4
+ //
5
+ // 时间线:
6
+ // - 发消息时会话空闲:先拍「开始」这张再把消息交给 agent(等不了太久,见 BEGIN_BUDGET_MS);
7
+ // - 一轮结束:拍「结束」这张,比较,有改动就记下来;
8
+ // - 排队的消息紧接着开始:不再拍,上一轮「结束」那张就是它的「开始」,每一轮都对得上。
9
+ //
10
+ // 工作区是共用的:这一轮期间你自己改的、同一仓库里别的会话改的都会算进来。别的会话在跑时会标出来(shared)。
11
+ //
12
+ // 快照是 git 对象,靠 refs/agent-loft/t/ 下的引用留着。每个仓库只留最近 KEEP_PER_REPO 轮,
13
+ // 更早的引用删掉,等 git gc 回收;那些轮次的摘要还在(存在脚注里),只是看不了具体内容了。
14
+ import crypto from "node:crypto";
15
+ import { sql, transaction } from "./db.js";
16
+ import { differingPaths, diffTrees, findRepo, GitError, keepTrees, restoreFromTree, snapshotTree, treeFileDiff, type GitDiff } from "./git.js";
17
+ import type { TurnChanges } from "./types.js";
18
+
19
+ /** 拍「开始」这张最多等这么久:消息不能因为仓库太大发不出去。超时这一轮就没有改动卡片 */
20
+ const BEGIN_BUDGET_MS = 5000;
21
+ const KEEP_PER_REPO = 200;
22
+ const KEEP_MAX_AGE_MS = 60 * 86400_000;
23
+ /** 摘要里最多列这么多个文件 */
24
+ const MAX_FILES_IN_SUMMARY = 200;
25
+
26
+ type Baseline = { cwd: string; root: string; tree: string; shared: boolean };
27
+
28
+ const baselines = new Map<string, Baseline>();
29
+ /** 同一条会话的快照按顺序来:结束那张没拍完,下一轮的开始不能抢在前面 */
30
+ const chains = new Map<string, Promise<unknown>>();
31
+ /** 每次开始加一:超时放弃的那次拍完了也不算数 */
32
+ const generations = new Map<string, number>();
33
+
34
+ function chain<T>(key: string, job: () => Promise<T>): Promise<T> {
35
+ const run = (chains.get(key) ?? Promise.resolve()).catch(() => {}).then(job);
36
+ const tail = run.catch(() => {});
37
+ chains.set(key, tail);
38
+ void tail.then(() => {
39
+ if (chains.get(key) === tail) chains.delete(key);
40
+ });
41
+ return run;
42
+ }
43
+
44
+ /** 一轮开始之前调用。不会抛错,也不会等太久 */
45
+ export async function beginTurnSnapshot(key: string, cwd: string, busyInRepo: (root: string) => boolean): Promise<void> {
46
+ const generation = (generations.get(key) ?? 0) + 1;
47
+ generations.set(key, generation);
48
+ const job = chain(key, async () => {
49
+ baselines.delete(key);
50
+ const repo = await findRepo(cwd);
51
+ if (!repo.repo) return;
52
+ const tree = await snapshotTree(repo.root);
53
+ if (tree && generations.get(key) === generation) baselines.set(key, { cwd, root: repo.root, tree, shared: busyInRepo(repo.root) });
54
+ }).catch((err) => console.error("[快照] 拍开始的快照失败:", err));
55
+ let timer: NodeJS.Timeout | undefined;
56
+ const timeout = new Promise<void>((resolve) => {
57
+ timer = setTimeout(() => {
58
+ // 这一轮要开始了,后面才拍完的不能当基准:里面可能已经有 agent 的改动
59
+ generations.set(key, generation + 1);
60
+ resolve();
61
+ }, BEGIN_BUDGET_MS);
62
+ timer.unref?.();
63
+ });
64
+ await Promise.race([job, timeout]);
65
+ clearTimeout(timer);
66
+ }
67
+
68
+ /** 一轮结束时调用。有改动返回摘要,没有(或者不是仓库、快照失败)返回 null。不会抛错 */
69
+ export function finishTurnSnapshot(key: string, cwd: string, busyInRepo: (root: string) => boolean): Promise<TurnChanges | null> {
70
+ return chain(key, async () => {
71
+ const base = baselines.get(key);
72
+ // 中途切了目录:基准是别的目录的
73
+ if (!base || base.cwd !== cwd) return null;
74
+ const shared = base.shared || busyInRepo(base.root);
75
+ const after = await snapshotTree(base.root);
76
+ if (!after) {
77
+ baselines.delete(key);
78
+ return null;
79
+ }
80
+ const before = base.tree;
81
+ // 下一轮接着这张比。接下来一轮的 shared 看它自己期间的情况
82
+ baselines.set(key, { ...base, tree: after, shared: busyInRepo(base.root) });
83
+ if (after === before) return null;
84
+ const files = await diffTrees(base.root, before, after);
85
+ if (!files?.length) return null;
86
+ const changes: TurnChanges = {
87
+ id: crypto.randomBytes(8).toString("hex"),
88
+ files: files.slice(0, MAX_FILES_IN_SUMMARY),
89
+ fileCount: files.length,
90
+ added: files.reduce((n, f) => n + f.added, 0),
91
+ removed: files.reduce((n, f) => n + f.removed, 0),
92
+ ...(shared ? { shared: true } : {}),
93
+ };
94
+ await remember(changes.id, base.root, before, after);
95
+ return changes;
96
+ }).catch((err) => {
97
+ console.error("[快照] 比较这一轮的改动失败:", err);
98
+ return null;
99
+ });
100
+ }
101
+
102
+ async function remember(id: string, root: string, before: string, after: string): Promise<void> {
103
+ const now = Date.now();
104
+ const kept = transaction(() => {
105
+ sql("INSERT INTO turn_changes (id, root, before_tree, after_tree, at) VALUES (?, ?, ?, ?, ?)").run(id, root, before, after, now);
106
+ sql("DELETE FROM turn_changes WHERE at < ?").run(now - KEEP_MAX_AGE_MS);
107
+ sql(
108
+ `DELETE FROM turn_changes WHERE root = ? AND id NOT IN (
109
+ SELECT id FROM turn_changes WHERE root = ? ORDER BY at DESC, rowid DESC LIMIT ?)`,
110
+ ).run(root, root, KEEP_PER_REPO);
111
+ return sql("SELECT before_tree AS b, after_tree AS a FROM turn_changes WHERE root = ?").all(root) as { b: string; a: string }[];
112
+ });
113
+ await keepTrees(root, kept.flatMap((r) => [r.b, r.a]));
114
+ }
115
+
116
+ /**
117
+ * 某一轮里一个文件的 diff。id 只在同一个仓库里认:不接受页面传来的 tree hash,
118
+ * 免得拼个 hash 读到仓库里任意的历史内容。记录没了、不是这个仓库的返回 undefined
119
+ */
120
+ export async function turnFileDiff(root: string, id: string, file: string): Promise<GitDiff | undefined> {
121
+ const row = turnRow(root, id);
122
+ return row ? treeFileDiff(root, row.b, row.a, file) : undefined;
123
+ }
124
+
125
+ // ---------- 撤销和重做 ----------
126
+ //
127
+ // 不需要记「撤销过没有」:看工作区现在的样子就知道。这一轮动过的文件和「结束」那张一样就是还在,
128
+ // 和「开始」那张一样就是撤销过了,都不一样就是之后又改过了。
129
+ // 只恢复这一轮动过的文件,别的文件不碰。重做就是反过来恢复成「结束」那张。
130
+
131
+ export type TurnState = {
132
+ /** applied:改动还在;undone:已经撤销了;diverged:这些文件之后又被改过;expired:快照没了;unavailable:现在判断不了(工作区文件太多之类) */
133
+ state: "applied" | "undone" | "diverged" | "expired" | "unavailable";
134
+ /** diverged 时:哪些文件和这一轮结束时不一样了 */
135
+ diverged?: string[];
136
+ };
137
+
138
+ type TurnRow = { root: string; b: string; a: string };
139
+
140
+ function turnRow(root: string, id: string): TurnRow | undefined {
141
+ const row = sql("SELECT root, before_tree AS b, after_tree AS a FROM turn_changes WHERE id = ?").get(id) as TurnRow | undefined;
142
+ return row && row.root === root ? row : undefined;
143
+ }
144
+
145
+ async function inspect(row: TurnRow): Promise<{ state: TurnState; files: string[] }> {
146
+ const files = await differingPaths(row.root, row.b, row.a);
147
+ if (!files) return { state: { state: "expired" }, files: [] };
148
+ const now = await snapshotTree(row.root);
149
+ if (!now) return { state: { state: "unavailable" }, files };
150
+ const [fromAfter, fromBefore] = await Promise.all([differingPaths(row.root, row.a, now), differingPaths(row.root, row.b, now)]);
151
+ if (!fromAfter || !fromBefore) return { state: { state: "expired" }, files };
152
+ const mine = new Set(files);
153
+ const changed = fromAfter.filter((f) => mine.has(f));
154
+ if (!changed.length) return { state: { state: "applied" }, files };
155
+ if (!fromBefore.some((f) => mine.has(f))) return { state: { state: "undone" }, files };
156
+ return { state: { state: "diverged", diverged: changed }, files };
157
+ }
158
+
159
+ export async function turnState(root: string, id: string): Promise<TurnState> {
160
+ const row = turnRow(root, id);
161
+ return row ? (await inspect(row)).state : { state: "expired" };
162
+ }
163
+
164
+ /**
165
+ * 撤销(undo)或重做(redo)一轮。文件之后又被改过时不动手,报 409 并列出文件;force 明确要覆盖。
166
+ * 只改工作区里这些文件,暂存区、对话记录都不变
167
+ */
168
+ export async function revertTurn(root: string, id: string, direction: "undo" | "redo", force: boolean): Promise<TurnState> {
169
+ const row = turnRow(root, id);
170
+ if (!row) throw new GitError(404, "这一轮的快照已经清理了,不能撤销");
171
+ const { state, files } = await inspect(row);
172
+ if (state.state === "expired") throw new GitError(404, "这一轮的快照已经清理了,不能撤销");
173
+ if (state.state === "unavailable") throw new GitError(409, "现在判断不了这些文件的状态(工作区的改动太多,或者这个仓库配置了自定义过滤器),没有动手");
174
+ const done = direction === "undo" ? "undone" : "applied";
175
+ if (state.state === done) return state;
176
+ if (state.state === "diverged" && !force) throw new GitError(409, "这些文件之后又被改过了", { conflict: "diverged", files: state.diverged });
177
+ await restoreFromTree(root, direction === "undo" ? row.b : row.a, files);
178
+ return (await inspect(row)).state;
179
+ }
package/src/core/types.ts CHANGED
@@ -196,10 +196,23 @@ export type HistoryMessage = {
196
196
  anchor?: string;
197
197
  /** 助手消息:这一轮的用时 / 费用 / tokens(agent-loft 自己记的,agent 记录里没有) */
198
198
  footer?: string;
199
+ /** 助手消息:这一轮改了哪些文件(agent-loft 自己比较快照得出的,见 turn-changes.ts) */
200
+ changes?: TurnChanges;
199
201
  /** 用户消息:带的附件(从消息里的附件清单解析出来) */
200
202
  attachments?: AttachmentInfo[];
201
203
  };
202
204
 
205
+ /** 一轮对话改了什么。files 太多时只留前一部分,fileCount、added、removed 是全部的 */
206
+ export type TurnChanges = {
207
+ id: string;
208
+ files: { path: string; oldPath?: string; status: string; added: number; removed: number; binary?: boolean }[];
209
+ fileCount: number;
210
+ added: number;
211
+ removed: number;
212
+ /** 这一轮期间同一个仓库里还有别的会话在跑:可能混入了它们的改动 */
213
+ shared?: boolean;
214
+ };
215
+
203
216
  export type SessionOptions = {
204
217
  cwd: string;
205
218
  model?: string;
package/src/core/users.ts CHANGED
@@ -30,6 +30,8 @@ export type User = {
30
30
  disabled?: boolean;
31
31
  /** 成员能不能用远程控制(终端、桌面)。管理员一直能用,不看这个 */
32
32
  remote?: boolean;
33
+ /** 成员能不能用工作区面板(浏览文件、看 Git 改动)。管理员一直能用,不看这个 */
34
+ files?: boolean;
33
35
  permissions?: ResourcePermissions;
34
36
  };
35
37
 
@@ -177,6 +179,12 @@ export function canUseRemote(user: Pick<User, "role" | "disabled" | "remote"> |
177
179
  return user.role === "admin" || user.remote === true;
178
180
  }
179
181
 
182
+ /** 能不能用工作区面板:能看到工作目录里的所有文件,比「只看 agent 提到的文件」宽得多,成员要单独开 */
183
+ export function canUseFiles(user: Pick<User, "role" | "disabled" | "files"> | undefined): boolean {
184
+ if (!user || user.disabled) return false;
185
+ return user.role === "admin" || user.files === true;
186
+ }
187
+
180
188
  export function canUseResource(user: Pick<User, "role" | "disabled" | "permissions"> | undefined, kind: ResourceKind, id: string): boolean {
181
189
  if (!user || user.disabled) return false;
182
190
  return user.role === "admin" || user.permissions?.[kind] == null || user.permissions[kind]!.includes(id);
@@ -233,7 +241,7 @@ function assertAdminLeft(list: User[]): void {
233
241
  if (!list.some((u) => u.role === "admin" && !u.disabled)) throw new Error("至少要保留一个能登录的管理员");
234
242
  }
235
243
 
236
- export function createUser(params: { name: string; password: string; role?: Role; remote?: boolean; permissions?: unknown }): PublicUser {
244
+ export function createUser(params: { name: string; password: string; role?: Role; remote?: boolean; files?: boolean; permissions?: unknown }): PublicUser {
237
245
  const list = load();
238
246
  const name = checkName(params.name);
239
247
  if (list.some((u) => u.name.toLowerCase() === name.toLowerCase())) throw new Error(`用户名「${name}」已经有人用了`);
@@ -245,6 +253,7 @@ export function createUser(params: { name: string; password: string; role?: Role
245
253
  passwordHash: hashPassword(params.password),
246
254
  createdAt: Date.now(),
247
255
  ...(params.remote === true ? { remote: true } : {}),
256
+ ...(params.files === true ? { files: true } : {}),
248
257
  ...(params.permissions !== undefined ? { permissions: cleanPermissions(params.permissions) } : {}),
249
258
  };
250
259
  save([...list, user]);
@@ -253,7 +262,7 @@ export function createUser(params: { name: string; password: string; role?: Role
253
262
 
254
263
  export function updateUser(
255
264
  id: string,
256
- patch: { name?: string; role?: Role; disabled?: boolean; password?: string; remote?: boolean; permissions?: unknown },
265
+ patch: { name?: string; role?: Role; disabled?: boolean; password?: string; remote?: boolean; files?: boolean; permissions?: unknown },
257
266
  ): PublicUser {
258
267
  const list = load().map((u) => ({ ...u }));
259
268
  const user = list.find((u) => u.id === id);
@@ -272,6 +281,10 @@ export function updateUser(
272
281
  if (patch.remote) user.remote = true;
273
282
  else delete user.remote;
274
283
  }
284
+ if (patch.files !== undefined) {
285
+ if (patch.files) user.files = true;
286
+ else delete user.files;
287
+ }
275
288
  if (patch.permissions !== undefined) user.permissions = cleanPermissions(patch.permissions, user.permissions);
276
289
  if (patch.password !== undefined) {
277
290
  checkPassword(patch.password);