agent-loft 0.2.58 → 0.2.60

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/db.ts ADDED
@@ -0,0 +1,367 @@
1
+ // 本地数据库:data/agent-loft.db(SQLite,用 Node 自带的 node:sqlite)。
2
+ //
3
+ // 放在这里的是会越用越多、或者好几个进程都要写的:会话(conversations)、会话归属(session_owners)、
4
+ // 聊天记录索引(history / history_meta)、每轮回复的脚注(footers)、用量(usage_sessions / usage_daily)、
5
+ // 每个人的记忆(memory)、资料库里的文件索引(files,文件本身还在上传目录里,见 library.ts)。
6
+ // 设置、用户、专家这类小配置还是 JSON 文件,方便直接打开看、手改。
7
+ //
8
+ // 主进程和每个会话的记忆工具子进程(mcp/memory-server.ts)会同时打开它:WAL 模式下读不挡写,
9
+ // 写和写之间由 busy_timeout 排队。
10
+ //
11
+ // 升级前的 JSON 第一次打开时导入(见 importLegacy),导入的那个文件改名成 .imported 留作备份。
12
+ import fs from "node:fs";
13
+ import path from "node:path";
14
+ import type { DatabaseSync, StatementSync } from "node:sqlite";
15
+ import { dataDir, readJson } from "../home.js";
16
+
17
+ export const dbPath = path.join(dataDir, "agent-loft.db");
18
+
19
+ /**
20
+ * node:sqlite 在 Node 22 上还挂着「实验性」:加载时打一行 ExperimentalWarning。
21
+ * 每个记忆工具子进程都会打一遍,看着像出错了,只把这一条吞掉。
22
+ */
23
+ function loadSqlite(): typeof import("node:sqlite") {
24
+ const emit = process.emitWarning;
25
+ process.emitWarning = function (this: unknown, warning: string | Error, ...rest: unknown[]) {
26
+ const message = typeof warning === "string" ? warning : warning?.message;
27
+ if (/SQLite/i.test(message ?? "")) return;
28
+ return (emit as (...a: unknown[]) => void).call(process, warning, ...rest);
29
+ } as typeof process.emitWarning;
30
+ try {
31
+ // 22.13 之前要加 --experimental-sqlite 才有,22.3 之前连 getBuiltinModule 都没有
32
+ const mod = process.getBuiltinModule?.("node:sqlite") as typeof import("node:sqlite") | undefined;
33
+ if (!mod) throw new Error(`agent-loft 需要 Node.js 22.13 以上(现在是 ${process.version}),请升级 Node.js`);
34
+ return mod;
35
+ } finally {
36
+ process.emitWarning = emit;
37
+ }
38
+ }
39
+
40
+ const SCHEMA = `
41
+ CREATE TABLE IF NOT EXISTS migrations (name TEXT PRIMARY KEY, at INTEGER NOT NULL);
42
+
43
+ CREATE TABLE IF NOT EXISTS conversations (
44
+ key TEXT PRIMARY KEY,
45
+ data TEXT NOT NULL
46
+ );
47
+
48
+ CREATE TABLE IF NOT EXISTS session_owners (
49
+ session_id TEXT PRIMARY KEY,
50
+ user_id TEXT NOT NULL
51
+ );
52
+
53
+ CREATE TABLE IF NOT EXISTS history (
54
+ id INTEGER PRIMARY KEY AUTOINCREMENT,
55
+ user_id TEXT NOT NULL,
56
+ conv_key TEXT NOT NULL,
57
+ agent TEXT NOT NULL,
58
+ role TEXT NOT NULL,
59
+ text TEXT NOT NULL,
60
+ ts INTEGER NOT NULL,
61
+ msg_id TEXT
62
+ );
63
+ CREATE INDEX IF NOT EXISTS history_user ON history (user_id, id);
64
+ CREATE INDEX IF NOT EXISTS history_user_conv ON history (user_id, conv_key);
65
+
66
+ CREATE TABLE IF NOT EXISTS history_meta (
67
+ user_id TEXT PRIMARY KEY,
68
+ data TEXT NOT NULL
69
+ );
70
+
71
+ CREATE TABLE IF NOT EXISTS footers (
72
+ id INTEGER PRIMARY KEY AUTOINCREMENT,
73
+ session_id TEXT NOT NULL,
74
+ tail TEXT NOT NULL,
75
+ footer TEXT NOT NULL,
76
+ at INTEGER NOT NULL
77
+ );
78
+ CREATE INDEX IF NOT EXISTS footers_session ON footers (session_id, id);
79
+
80
+ CREATE TABLE IF NOT EXISTS usage_sessions (
81
+ session_id TEXT PRIMARY KEY,
82
+ input INTEGER NOT NULL, cache_read INTEGER NOT NULL, cache_write INTEGER NOT NULL,
83
+ output INTEGER NOT NULL, reasoning INTEGER NOT NULL, cost_usd REAL,
84
+ at INTEGER NOT NULL
85
+ );
86
+
87
+ CREATE TABLE IF NOT EXISTS usage_daily (
88
+ day TEXT NOT NULL, owner TEXT NOT NULL, agent TEXT NOT NULL, model TEXT NOT NULL,
89
+ input INTEGER NOT NULL, cache_read INTEGER NOT NULL, cache_write INTEGER NOT NULL,
90
+ output INTEGER NOT NULL, reasoning INTEGER NOT NULL, cost_usd REAL,
91
+ PRIMARY KEY (day, owner, agent, model)
92
+ );
93
+
94
+ CREATE TABLE IF NOT EXISTS memory (
95
+ user_id TEXT PRIMARY KEY,
96
+ data TEXT NOT NULL
97
+ );
98
+
99
+ CREATE TABLE IF NOT EXISTS files (
100
+ id TEXT PRIMARY KEY,
101
+ owner TEXT NOT NULL,
102
+ conv_key TEXT NOT NULL,
103
+ path TEXT NOT NULL UNIQUE,
104
+ name TEXT NOT NULL,
105
+ kind TEXT NOT NULL,
106
+ size INTEGER NOT NULL,
107
+ source TEXT NOT NULL,
108
+ origin TEXT,
109
+ created_at INTEGER NOT NULL
110
+ );
111
+ CREATE INDEX IF NOT EXISTS files_owner ON files (owner, created_at);
112
+ CREATE INDEX IF NOT EXISTS files_conv ON files (conv_key);
113
+ CREATE INDEX IF NOT EXISTS files_origin ON files (origin);
114
+ `;
115
+
116
+ let db: DatabaseSync | null = null;
117
+
118
+ export function database(): DatabaseSync {
119
+ if (db) return db;
120
+ fs.mkdirSync(dataDir, { recursive: true, mode: 0o700 });
121
+ const fresh = !fs.existsSync(dbPath);
122
+ const { DatabaseSync } = loadSqlite();
123
+ const opened = new DatabaseSync(dbPath);
124
+ if (fresh) fs.chmodSync(dbPath, 0o600);
125
+ opened.exec("PRAGMA busy_timeout = 5000");
126
+ opened.exec("PRAGMA journal_mode = WAL");
127
+ opened.exec("PRAGMA synchronous = NORMAL");
128
+ opened.exec(SCHEMA);
129
+ db = opened;
130
+ importLegacy(opened);
131
+ return opened;
132
+ }
133
+
134
+ /** 「记忆改成默认关」的升级迁移跑过了(见 memory.ts 的 migrateMemoryDefault) */
135
+ export const MEMORY_DEFAULT_OFF = "memory-default-off";
136
+
137
+ /** 预编译的语句按 SQL 缓存:同一句反复执行不用每次重新解析 */
138
+ const statements = new Map<string, StatementSync>();
139
+
140
+ export function sql(text: string): StatementSync {
141
+ let stmt = statements.get(text);
142
+ if (!stmt) statements.set(text, (stmt = database().prepare(text)));
143
+ return stmt;
144
+ }
145
+
146
+ let depth = 0;
147
+
148
+ /**
149
+ * 事务。BEGIN IMMEDIATE:一开始就拿写锁,别的进程在 busy_timeout 里排队,不会读到一半被改。
150
+ * 事务里再开事务就并进外面那个。
151
+ */
152
+ export function transaction<T>(fn: () => T): T {
153
+ if (depth > 0) return fn();
154
+ const d = database();
155
+ d.exec("BEGIN IMMEDIATE");
156
+ depth++;
157
+ try {
158
+ const out = fn();
159
+ d.exec("COMMIT");
160
+ return out;
161
+ } catch (err) {
162
+ d.exec("ROLLBACK");
163
+ throw err;
164
+ } finally {
165
+ depth--;
166
+ }
167
+ }
168
+
169
+ /** 测试用:关掉连接,下次 database() 重新打开 */
170
+ export function closeDatabaseForTest(): void {
171
+ statements.clear();
172
+ db?.close();
173
+ db = null;
174
+ }
175
+
176
+ // ---------- 导入升级前的 JSON ----------
177
+ //
178
+ // 每个文件导入一次:导入和「导入过了」的标记在同一个事务里,中途崩了下次重来不会重复。
179
+ // 两个进程同时打开时,后拿到写锁的那个看到标记就跳过。导入完把文件改名留作备份。
180
+
181
+ type LegacyImport = { name: string; files: () => string[]; run: (d: DatabaseSync, file: string) => number };
182
+
183
+ const historyDir = path.join(dataDir, "history");
184
+ const memoryDir = path.join(dataDir, "memory");
185
+
186
+ const n0 = (v: unknown): number => (typeof v === "number" && Number.isFinite(v) && v > 0 ? v : 0);
187
+ type LegacyTotals = { input?: number; cacheRead?: number; cacheWrite?: number; output?: number; reasoning?: number; costUsd?: number };
188
+ const legacyTotals = (t: LegacyTotals) => [n0(t.input), n0(t.cacheRead), n0(t.cacheWrite), n0(t.output), n0(t.reasoning), n0(t.costUsd) || null] as const;
189
+
190
+ const LEGACY: LegacyImport[] = [
191
+ {
192
+ name: "conversations.json",
193
+ files: () => [path.join(dataDir, "conversations.json")],
194
+ run(d, file) {
195
+ const all = readJson<Record<string, { key?: string }>>(file, {});
196
+ const insert = d.prepare("INSERT OR REPLACE INTO conversations (key, data) VALUES (?, ?)");
197
+ let n = 0;
198
+ for (const [key, conv] of Object.entries(all)) {
199
+ if (!conv || typeof conv !== "object") continue;
200
+ insert.run(key, JSON.stringify({ ...conv, key }));
201
+ n++;
202
+ }
203
+ return n;
204
+ },
205
+ },
206
+ {
207
+ name: "session-owners.json",
208
+ files: () => [path.join(dataDir, "session-owners.json")],
209
+ run(d, file) {
210
+ const all = readJson<Record<string, string>>(file, {});
211
+ const insert = d.prepare("INSERT OR IGNORE INTO session_owners (session_id, user_id) VALUES (?, ?)");
212
+ let n = 0;
213
+ for (const [sessionId, userId] of Object.entries(all)) {
214
+ if (typeof userId !== "string") continue;
215
+ insert.run(sessionId, userId);
216
+ n++;
217
+ }
218
+ return n;
219
+ },
220
+ },
221
+ {
222
+ name: "footers.json",
223
+ files: () => [path.join(dataDir, "footers.json")],
224
+ run(d, file) {
225
+ const all = readJson<Record<string, { at?: number; entries?: { t?: string; f?: string }[] }>>(file, {});
226
+ const insert = d.prepare("INSERT INTO footers (session_id, tail, footer, at) VALUES (?, ?, ?, ?)");
227
+ let n = 0;
228
+ for (const [sessionId, slot] of Object.entries(all)) {
229
+ for (const e of slot?.entries ?? []) {
230
+ if (typeof e?.t !== "string" || typeof e.f !== "string") continue;
231
+ insert.run(sessionId, e.t, e.f, Number(slot.at) || 0);
232
+ n++;
233
+ }
234
+ }
235
+ return n;
236
+ },
237
+ },
238
+ {
239
+ name: "usage.json",
240
+ files: () => [path.join(dataDir, "usage.json")],
241
+ run(d, file) {
242
+ const all = readJson<Record<string, LegacyTotals & { at?: number }>>(file, {});
243
+ const insert = d.prepare(
244
+ "INSERT OR REPLACE INTO usage_sessions (session_id, input, cache_read, cache_write, output, reasoning, cost_usd, at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
245
+ );
246
+ let n = 0;
247
+ for (const [sessionId, t] of Object.entries(all)) {
248
+ if (!t || typeof t !== "object") continue;
249
+ insert.run(sessionId, ...legacyTotals(t), Number(t.at) || 0);
250
+ n++;
251
+ }
252
+ return n;
253
+ },
254
+ },
255
+ {
256
+ // 日期 →「owner\tagent\tmodel」→ 合计
257
+ name: "usage-daily.json",
258
+ files: () => [path.join(dataDir, "usage-daily.json")],
259
+ run(d, file) {
260
+ const all = readJson<Record<string, Record<string, LegacyTotals>>>(file, {});
261
+ const insert = d.prepare(
262
+ "INSERT OR REPLACE INTO usage_daily (day, owner, agent, model, input, cache_read, cache_write, output, reasoning, cost_usd) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
263
+ );
264
+ let n = 0;
265
+ for (const [day, buckets] of Object.entries(all)) {
266
+ for (const [k, t] of Object.entries(buckets ?? {})) {
267
+ if (!t || typeof t !== "object") continue;
268
+ const [owner = "", agent = "", model = ""] = k.split("\t");
269
+ insert.run(day, owner, agent, model, ...legacyTotals(t));
270
+ n++;
271
+ }
272
+ }
273
+ return n;
274
+ },
275
+ },
276
+ {
277
+ // 每个用户一份 <用户 id>.json;.default-off-migrated 是「记忆改成默认关」那次迁移跑过的标记(见 memory.ts)
278
+ name: "memory",
279
+ files: () => {
280
+ try {
281
+ return fs
282
+ .readdirSync(memoryDir)
283
+ .filter((f) => /^[A-Za-z0-9_]{1,64}\.json$/.test(f) || f === ".default-off-migrated")
284
+ .map((f) => path.join(memoryDir, f));
285
+ } catch {
286
+ return [];
287
+ }
288
+ },
289
+ run(d, file) {
290
+ const base = path.basename(file);
291
+ if (base === ".default-off-migrated") {
292
+ d.prepare("INSERT OR IGNORE INTO migrations (name, at) VALUES (?, ?)").run(MEMORY_DEFAULT_OFF, Date.now());
293
+ return 1;
294
+ }
295
+ const raw = readJson<unknown>(file, null);
296
+ if (!raw || typeof raw !== "object") return 0;
297
+ d.prepare("INSERT OR REPLACE INTO memory (user_id, data) VALUES (?, ?)").run(base.slice(0, -".json".length), JSON.stringify(raw));
298
+ return 1;
299
+ },
300
+ },
301
+ {
302
+ // 每个用户一份 <用户 id>.jsonl 和 <用户 id>.meta.json
303
+ name: "history",
304
+ files: () => {
305
+ try {
306
+ return fs
307
+ .readdirSync(historyDir)
308
+ .filter((f) => /^[A-Za-z0-9_]{1,64}\.(jsonl|meta\.json)$/.test(f))
309
+ .map((f) => path.join(historyDir, f));
310
+ } catch {
311
+ return [];
312
+ }
313
+ },
314
+ run(d, file) {
315
+ const base = path.basename(file);
316
+ if (base.endsWith(".meta.json")) {
317
+ const userId = base.slice(0, -".meta.json".length);
318
+ d.prepare("INSERT OR REPLACE INTO history_meta (user_id, data) VALUES (?, ?)").run(userId, JSON.stringify(readJson(file, {})));
319
+ return 1;
320
+ }
321
+ const userId = base.slice(0, -".jsonl".length);
322
+ const insert = d.prepare("INSERT INTO history (user_id, conv_key, agent, role, text, ts, msg_id) VALUES (?, ?, ?, ?, ?, ?, ?)");
323
+ let n = 0;
324
+ for (const line of fs.readFileSync(file, "utf8").split("\n")) {
325
+ if (!line) continue;
326
+ let r: { id?: unknown; k?: unknown; a?: unknown; r?: unknown; t?: unknown; ts?: unknown };
327
+ try {
328
+ r = JSON.parse(line);
329
+ } catch {
330
+ continue; // 写到一半被打断的行
331
+ }
332
+ if (typeof r.k !== "string" || typeof r.t !== "string" || (r.r !== "u" && r.r !== "a")) continue;
333
+ insert.run(userId, r.k, typeof r.a === "string" ? r.a : "", r.r, r.t, Number(r.ts) || 0, typeof r.id === "string" ? r.id : null);
334
+ n++;
335
+ }
336
+ return n;
337
+ },
338
+ },
339
+ ];
340
+
341
+ function importLegacy(d: DatabaseSync): void {
342
+ for (const item of LEGACY) {
343
+ for (const file of item.files()) {
344
+ if (!fs.existsSync(file)) continue;
345
+ const mark = `${item.name}:${path.basename(file)}`;
346
+ let count = -1;
347
+ d.exec("BEGIN IMMEDIATE");
348
+ try {
349
+ if (!d.prepare("SELECT 1 FROM migrations WHERE name = ?").get(mark) && fs.existsSync(file)) {
350
+ count = item.run(d, file);
351
+ d.prepare("INSERT INTO migrations (name, at) VALUES (?, ?)").run(mark, Date.now());
352
+ }
353
+ d.exec("COMMIT");
354
+ } catch (err) {
355
+ d.exec("ROLLBACK");
356
+ console.warn(`[数据库] 导入 ${file} 失败,先不动它:`, err);
357
+ continue;
358
+ }
359
+ try {
360
+ fs.renameSync(file, `${file}.imported`);
361
+ } catch {
362
+ // 别的进程刚改过名
363
+ }
364
+ if (count >= 0) console.log(`[数据库] 已导入 ${path.relative(dataDir, file)}(${count} 条),原文件改名为 .imported 留作备份`);
365
+ }
366
+ }
367
+ }
@@ -8,6 +8,7 @@
8
8
  // 自定义专家每人管自己的,不分享。存储:data/experts.json,只有主进程读写。
9
9
  import crypto from "node:crypto";
10
10
  import { EventEmitter } from "node:events";
11
+ import fs from "node:fs";
11
12
  import path from "node:path";
12
13
  import { dataDir, readJson, writeJsonAtomic } from "../home.js";
13
14
  import { resolveWorkspacePath } from "./config.js";
@@ -96,19 +97,76 @@ export function avatarImage(e: Pick<Expert, "avatar">): { type: string; data: Bu
96
97
  }
97
98
 
98
99
  const storePath = path.join(dataDir, "experts.json");
100
+ /** 头像图片单独放:<专家 id>.<扩展名>。experts.json 里只记文件名,免得几十 KB 的 base64 每次都跟着整个重写 */
101
+ const avatarDir = path.join(dataDir, "expert-avatars");
102
+ const AVATAR_EXT: Record<string, string> = { "image/png": "png", "image/jpeg": "jpg", "image/webp": "webp", "image/gif": "gif" };
103
+ const EXT_TYPE = Object.fromEntries(Object.entries(AVATAR_EXT).map(([t, e]) => [e, t]));
104
+
105
+ /** 存在 experts.json 里的样子:头像换成文件名 */
106
+ type StoredExpert = Omit<Expert, "avatar"> & { avatar?: string; avatarFile?: string };
99
107
 
100
108
  /** 专家改了 / 删了。owner:谁的。用着它的会话空闲下来要换上新的 */
101
109
  export const expertEvents = new EventEmitter<{ changed: [owner: string, id: string] }>();
102
110
 
103
111
  let cache: Expert[] | null = null;
104
112
 
113
+ function readAvatar(file: string): string | undefined {
114
+ const type = EXT_TYPE[path.extname(file).slice(1)];
115
+ if (!type || path.basename(file) !== file) return undefined;
116
+ try {
117
+ return `data:${type};base64,${fs.readFileSync(path.join(avatarDir, file)).toString("base64")}`;
118
+ } catch {
119
+ return undefined;
120
+ }
121
+ }
122
+
105
123
  function load(): Expert[] {
106
- cache ??= readJson<Expert[]>(storePath, []).filter((e) => e && typeof e.id === "string" && typeof e.owner === "string" && !isBuiltin(e.id));
124
+ if (cache) return cache;
125
+ let legacy = false;
126
+ cache = readJson<StoredExpert[]>(storePath, [])
127
+ .filter((e) => e && typeof e.id === "string" && typeof e.owner === "string" && !isBuiltin(e.id))
128
+ .map(({ avatarFile, avatar: inline, ...e }) => {
129
+ // 以前头像的 data URL 直接存在 experts.json 里:读进来照用,下面存一次就拆出去
130
+ if (inline) legacy = true;
131
+ const avatar = inline || (avatarFile ? readAvatar(avatarFile) : undefined);
132
+ return { ...e, ...(avatar ? { avatar } : {}) };
133
+ });
134
+ if (legacy) save();
107
135
  return cache;
108
136
  }
109
137
 
110
138
  function save(): void {
111
- writeJsonAtomic(storePath, load());
139
+ const list = load();
140
+ const keep = new Set<string>();
141
+ const stored: StoredExpert[] = list.map(({ avatar, ...e }) => {
142
+ const img = avatarImage({ ...(avatar ? { avatar } : {}) });
143
+ if (!img) return e;
144
+ const file = `${e.id}.${AVATAR_EXT[img.type]}`;
145
+ keep.add(file);
146
+ const target = path.join(avatarDir, file);
147
+ let same = false;
148
+ try {
149
+ same = fs.readFileSync(target).equals(img.data);
150
+ } catch {
151
+ // 还没有
152
+ }
153
+ if (!same) {
154
+ fs.mkdirSync(avatarDir, { recursive: true, mode: 0o700 });
155
+ const tmp = `${target}.${process.pid}.tmp`;
156
+ fs.writeFileSync(tmp, img.data, { mode: 0o600 });
157
+ fs.renameSync(tmp, target);
158
+ }
159
+ return { ...e, avatarFile: file };
160
+ });
161
+ writeJsonAtomic(storePath, stored);
162
+ // 删掉的专家、换了格式的头像留下的旧图片
163
+ let files: string[] = [];
164
+ try {
165
+ files = fs.readdirSync(avatarDir);
166
+ } catch {
167
+ // 目录还没有
168
+ }
169
+ for (const f of files) if (!keep.has(f)) fs.rmSync(path.join(avatarDir, f), { force: true });
112
170
  }
113
171
 
114
172
  export function resetExpertCache(): void {
@@ -2,17 +2,13 @@
2
2
  //
3
3
  // 它只在一轮结束的那一刻随 result 事件出现,agent 自己的会话记录里没有。页面重新加载
4
4
  // (手机切回前台、刷新)读的是 agent 的记录,脚注就丢了。所以在这里按会话记下来,
5
- // 读历史时再按回复正文的结尾对回去。
6
- import path from "node:path";
7
- import { dataDir, readJson, writeJsonAtomic } from "../home.js";
5
+ // 读历史时再按回复正文的结尾对回去。存在数据库的 footers 表里(见 db.ts),一轮一行。
6
+ import { sql, transaction } from "./db.js";
8
7
  import type { HistoryMessage } from "./types.js";
9
8
 
10
9
  /** t:回复正文(去掉空白后)的结尾;f:脚注 */
11
10
  type Entry = { t: string; f: string };
12
- type Store = Record<string, { at: number; entries: Entry[] }>;
13
11
 
14
- const FILE = () => path.join(dataDir, "footers.json");
15
- const MAX_SESSIONS = 300;
16
12
  const MAX_PER_SESSION = 1000;
17
13
  /** 存下来比对用的正文结尾长度 */
18
14
  const TAIL = 80;
@@ -29,26 +25,6 @@ export function formatDuration(ms: number): string {
29
25
  return `${m}分${s ? `${s}秒` : ""}`;
30
26
  }
31
27
 
32
- let store: Store | null = null;
33
- let timer: NodeJS.Timeout | null = null;
34
-
35
- function load(): Store {
36
- return (store ??= readJson<Store>(FILE(), {}));
37
- }
38
-
39
- function persistSoon(): void {
40
- if (timer) return;
41
- timer = setTimeout(() => {
42
- timer = null;
43
- const s = load();
44
- // 只留最近用过的会话
45
- const keys = Object.keys(s).sort((a, b) => s[b]!.at - s[a]!.at);
46
- for (const k of keys.slice(MAX_SESSIONS)) delete s[k];
47
- writeJsonAtomic(FILE(), s);
48
- }, 1000);
49
- timer.unref();
50
- }
51
-
52
28
  // 空白全去掉:实时的 result 和落盘的记录在换行、空格上可能不完全一致
53
29
  const squash = (text: string): string => text.replace(/\s+/g, "");
54
30
 
@@ -63,18 +39,24 @@ function endsWithTail(text: string, tail: string): boolean {
63
39
  export function recordFooter(sessionId: string | undefined, text: string, footer: string): void {
64
40
  const t = squash(text).slice(-TAIL);
65
41
  if (!sessionId || !t || !footer) return;
66
- const s = load();
67
- const slot = (s[sessionId] ??= { at: 0, entries: [] });
68
- slot.at = Date.now();
69
- slot.entries.push({ t, f: footer });
70
- if (slot.entries.length > MAX_PER_SESSION) slot.entries.splice(0, slot.entries.length - MAX_PER_SESSION);
71
- persistSoon();
42
+ transaction(() => {
43
+ sql("INSERT INTO footers (session_id, tail, footer, at) VALUES (?, ?, ?, ?)").run(sessionId, t, footer, Date.now());
44
+ // 一个会话只留最近这么多轮
45
+ sql(
46
+ `DELETE FROM footers WHERE session_id = ? AND id <= (
47
+ SELECT id FROM footers WHERE session_id = ? ORDER BY id DESC LIMIT 1 OFFSET ?)`,
48
+ ).run(sessionId, sessionId, MAX_PER_SESSION);
49
+ });
50
+ }
51
+
52
+ function entriesOf(sessionId: string): Entry[] {
53
+ return sql("SELECT tail AS t, footer AS f FROM footers WHERE session_id = ? ORDER BY id").all(sessionId) as Entry[];
72
54
  }
73
55
 
74
56
  /** 给历史里的助手消息按顺序配上脚注。同样的正文(比如两次都回「好的」)按先后一一对应 */
75
57
  export function attachFooters(sessionId: string, messages: HistoryMessage[]): HistoryMessage[] {
76
- const entries = load()[sessionId]?.entries;
77
- if (!entries?.length) return messages;
58
+ const entries = entriesOf(sessionId);
59
+ if (!entries.length) return messages;
78
60
  let next = 0;
79
61
  return messages.map((m) => {
80
62
  if (m.role !== "assistant" || next >= entries.length) return m;
@@ -88,13 +70,9 @@ export function attachFooters(sessionId: string, messages: HistoryMessage[]): Hi
88
70
 
89
71
  /** 分叉出的新会话沿用原会话的脚注:它的记录是原会话的前一段,attachFooters 按顺序配得上 */
90
72
  export function copyFooters(from: string, to: string): void {
91
- const src = load()[from];
92
- if (!src?.entries.length) return;
93
- load()[to] = { at: Date.now(), entries: src.entries.map((e) => ({ ...e })) };
94
- persistSoon();
95
- }
96
-
97
- /** 测试用 */
98
- export function resetFootersForTest(): void {
99
- store = null;
73
+ if (from === to || !sql("SELECT 1 FROM footers WHERE session_id = ? LIMIT 1").get(from)) return;
74
+ transaction(() => {
75
+ sql("DELETE FROM footers WHERE session_id = ?").run(to);
76
+ sql("INSERT INTO footers (session_id, tail, footer, at) SELECT ?, tail, footer, ? FROM footers WHERE session_id = ? ORDER BY id").run(to, Date.now(), from);
77
+ });
100
78
  }
package/src/core/hub.ts CHANGED
@@ -12,7 +12,7 @@ import { EventEmitter } from "node:events";
12
12
  import { config, onConfigChange, resolveWorkspacePath } from "./config.js";
13
13
  import { attachFooters, copyFooters, formatDuration, recordFooter } from "./footers.js";
14
14
  import { removeHistoryRecord, replaceConversationRecords } from "./chat-history.js";
15
- import { flushUsage, recordUsage, usageOf, type UsageTotals } from "./usage.js";
15
+ import { recordUsage, usageOf, type UsageTotals } from "./usage.js";
16
16
  import { interactions, SETTLEMENT_LABEL } from "./interactions.js";
17
17
  import {
18
18
  agentBinding,
@@ -27,7 +27,7 @@ import {
27
27
  updateConversation,
28
28
  type Conversation,
29
29
  } from "./store.js";
30
- import { attachmentInfo, clearUploads, ensureUploadsDir, KIND_LABEL } from "./uploads.js";
30
+ import { attachmentInfo, ensureUploadsDir, KIND_LABEL } from "./uploads.js";
31
31
  import { memoryOwnerOf, sessionMemory } from "./personal.js";
32
32
  import { readMemory } from "./memory.js";
33
33
  import { getUser } from "./users.js";
@@ -903,7 +903,7 @@ class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd] }>
903
903
  }
904
904
 
905
905
  /**
906
- * 切换类操作的统一入口:调用那一刻记下「有一个切换在排队」和发起时刻(清上传目录用),
906
+ * 切换类操作的统一入口:调用那一刻记下「有一个切换在排队」和发起时刻,
907
907
  * 进串行队列执行,结束后撤掉排队计数。真正换没换会话由操作自己 markSwitched。
908
908
  */
909
909
  private switchOp<T>(key: string, fn: (op: { at: number; seq: number }) => Promise<T>): Promise<T> {
@@ -914,14 +914,6 @@ class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd] }>
914
914
  });
915
915
  }
916
916
 
917
- /**
918
- * 切换类操作清上传目录:只清这次操作发起之前就有的文件。切换途中刚收到的附件
919
- * 属于切换之后的新消息,不能一起删掉。截止时间由各操作在入口自己捕获后传进来,
920
- * 不读共享状态 —— 否则后面再来一条命令就会把它覆盖掉。
921
- */
922
- private clearOldUploads(key: string, before: number): void {
923
- clearUploads(key, [], before);
924
- }
925
917
 
926
918
  /**
927
919
  * gen:这条消息是在哪个停止代次下收到的。渠道自己还要先做点异步的事(飞书下载附件)
@@ -1164,7 +1156,6 @@ class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd] }>
1164
1156
  await this.drop(key, "已开新会话");
1165
1157
  this.markSwitched(key, op.seq);
1166
1158
  updateAgentBinding(key, conv.agent, { sessionId: undefined, forkFrom: undefined, model: model || undefined, effort: undefined });
1167
- this.clearOldUploads(key, op.at);
1168
1159
  this.emitEvent(key, { type: "meta" });
1169
1160
  const runtime = await this.runtimeNow(key);
1170
1161
  return `已开新会话(${this.label(conv.agent)},模型 ${runtime.model ?? "默认"}${
@@ -1194,7 +1185,6 @@ class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd] }>
1194
1185
  }
1195
1186
  await this.drop(key, "会话已切换");
1196
1187
  this.markSwitched(key, op.seq);
1197
- if (sessionId !== agentBinding(conv).sessionId) this.clearOldUploads(key, op.at);
1198
1188
  updateAgentBinding(key, conv.agent, { sessionId, forkFrom: undefined });
1199
1189
  // 显式恢复 = 用户要接着它聊:刷新活跃时间,否则下一条消息会按恢复前的闲置时间判成过期
1200
1190
  touchConversation(key);
@@ -1372,7 +1362,6 @@ class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd] }>
1372
1362
  this.markSwitched(key, op.seq);
1373
1363
  // 新会话:所有 agent 的旧会话都不接着用(专家换了,上下文里的人设、权限都不对了)
1374
1364
  updateConversation(key, { agent: hit.engine, expert: isBuiltin(hit.id) ? undefined : hit.id, perAgent: {} });
1375
- this.clearOldUploads(key, op.at);
1376
1365
  this.emitEvent(key, { type: "meta" });
1377
1366
  return `已换成专家「${hit.label}」,开了新会话。`;
1378
1367
  }
@@ -1533,7 +1522,6 @@ class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd] }>
1533
1522
  Object.entries(conv.perAgent).map(([a, b]) => [a, { ...b, sessionId: undefined, forkFrom: undefined }]),
1534
1523
  );
1535
1524
  updateConversation(key, { cwd: resolved, cwdExplicit: true, perAgent });
1536
- this.clearOldUploads(key, op.at);
1537
1525
  this.emitEvent(key, { type: "meta" });
1538
1526
  return `工作目录已切换到 ${resolved},下条消息将开新会话。`;
1539
1527
  }
@@ -1781,7 +1769,6 @@ class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd] }>
1781
1769
  async shutdown(): Promise<void> {
1782
1770
  for (const key of [...this.live.keys()]) await this.drop(key, "服务正在重启");
1783
1771
  for (const driver of this.drivers.values()) await driver.stop().catch(() => {});
1784
- flushUsage();
1785
1772
  }
1786
1773
  }
1787
1774