@sleep2agi/commhub-server 0.9.0-preview.162 → 0.9.0-preview.164

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/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@sleep2agi/commhub-server",
3
- "version": "0.9.0-preview.162",
3
+ "version": "0.9.0-preview.164",
4
4
  "description": "CommHub Server — AI Agent communication hub with MCP protocol, multi-network isolation, user auth, and MCP tools (17 collaboration-core + node/provider ops tools; authoritative list: docs-site/docs/api/mcp-tools.md).",
5
5
  "type": "module",
6
6
  "main": "src/index.ts",
@@ -0,0 +1,152 @@
1
+ // #2571(第三轮)—— 告警阈值从「全局常数」改成「每个目标自己的 p99 基线」。
2
+ //
3
+ // 现场(2026-10-27):同一个 `10 分钟没消费就报警` 的判据,在两种节奏下表现相反 ——
4
+ // 7 天基线:delivered→首次活动 p90=6s、p99=12min ⇒ 超过 600s 只占 1.2%
5
+ // 某一晚: p90=411s、p99=1573s ⇒ 超过 600s 占 5.4%,其中 43% 最终成功
6
+ // 全队一起变慢时,全局常数会炸一屏;而单个节点卡死时,又必须能显形。
7
+ //
8
+ // 这个文件钉住四件事:
9
+ // 1. 没有基线(样本不足/老库)⇒ **与 .163 完全一致**(沿用全局下限,不漏报不误报);
10
+ // 2. 基线比全局更宽(慢节点)⇒ 更晚才报;
11
+ // 3. 基线比全局更窄(快节点)⇒ **仍然不早于全局下限**(不允许比 600s 更敏感);
12
+ // 4. 基线只由**成功且已进 runtime** 的样本算出来,且样本不足不写行。
13
+
14
+ import { afterAll, beforeAll, describe, expect, test } from "bun:test";
15
+ import { db } from "./db.js";
16
+ import {
17
+ ALIAS_BASELINE_TABLE,
18
+ BASELINE_MIN_SAMPLES,
19
+ aliasBaseline,
20
+ ensureAliasBaselineTable,
21
+ refreshAliasBaseline,
22
+ } from "./alias-baseline.js";
23
+ import { recordDeliveredStaleEvents } from "./task-lifecycle-watcher.js";
24
+
25
+ const stamp = `${Date.now()}`;
26
+ let NET = "";
27
+ const NOW = new Date("2026-10-27T03:00:00.000Z");
28
+
29
+ function iso(secondsAgo: number): string {
30
+ return new Date(NOW.getTime() - secondsAgo * 1000).toISOString().slice(0, 19).replace("T", " ");
31
+ }
32
+
33
+ function seedTask(id: string, toName: string, deliveredSecondsAgo: number) {
34
+ db.run(
35
+ `INSERT INTO tasks (task_id, from_name, to_name, status, content, delivered_at, network_id)
36
+ VALUES (?1, 'sender', ?2, 'delivered', 'baseline fixture', ?3, ?4)`,
37
+ [id, toName, iso(deliveredSecondsAgo), NET],
38
+ );
39
+ }
40
+
41
+ function seedSession(alias: string, status: string) {
42
+ db.run(
43
+ `INSERT INTO sessions (resume_id, alias, node_id, status, network_id, registered_at)
44
+ VALUES (?1, ?2, ?3, ?4, ?5, datetime('now'))`,
45
+ [`res_${alias}_${stamp}`, alias, `n_${alias}_${stamp}`, status, NET],
46
+ );
47
+ }
48
+
49
+ function setBaseline(alias: string, p99: number, samples = 100) {
50
+ ensureAliasBaselineTable();
51
+ db.run(
52
+ `INSERT INTO ${ALIAS_BASELINE_TABLE} (alias, network_id, p99_seconds, samples, computed_at)
53
+ VALUES (?1, ?2, ?3, ?4, ?5)
54
+ ON CONFLICT(alias, network_id) DO UPDATE SET p99_seconds = excluded.p99_seconds, samples = excluded.samples`,
55
+ [alias, NET, p99, samples, NOW.toISOString()],
56
+ );
57
+ }
58
+
59
+ const eventsFor = (taskId: string) =>
60
+ db.all<{ event_type: string }>("SELECT event_type FROM task_events WHERE task_id = ?1", [taskId]).map(r => r.event_type);
61
+
62
+ beforeAll(async () => {
63
+ const { register } = await import("./auth.js");
64
+ const auth = register(`baseline_owner_${stamp}`, "Baseline-Owner-Strong-1!", undefined, "tester");
65
+ expect(auth.ok).toBe(true);
66
+ NET = auth.network_id!;
67
+ ensureAliasBaselineTable();
68
+ });
69
+
70
+ afterAll(() => {
71
+ try {
72
+ db.run(`DELETE FROM task_events WHERE task_id LIKE ?1`, [`bl-%-${stamp}`]);
73
+ db.run(`DELETE FROM tasks WHERE task_id LIKE ?1`, [`bl-%-${stamp}`]);
74
+ db.run(`DELETE FROM sessions WHERE alias LIKE ?1`, [`bl-%-${stamp}`]);
75
+ db.run(`DELETE FROM ${ALIAS_BASELINE_TABLE} WHERE alias LIKE ?1`, [`bl-%-${stamp}`]);
76
+ } catch {}
77
+ });
78
+
79
+ describe("#2571 alias p99 baseline", () => {
80
+ test("没有基线 ⇒ 沿用全局下限(与 .163 行为一致)", () => {
81
+ seedSession(`bl-nobase-${stamp}`, "idle");
82
+ seedTask(`bl-nobase-task-${stamp}`, `bl-nobase-${stamp}`, 700);
83
+ recordDeliveredStaleEvents(NOW);
84
+ expect(eventsFor(`bl-nobase-task-${stamp}`)).toContain("task.warning.delivered_stale_600s");
85
+ });
86
+
87
+ test("基线更宽(慢节点):700 秒不报,超过 p99×1.5 才报", () => {
88
+ seedSession(`bl-slow-${stamp}`, "idle");
89
+ setBaseline(`bl-slow-${stamp}`, 3600); // 阈值 5400s
90
+ seedTask(`bl-slow-700-${stamp}`, `bl-slow-${stamp}`, 700);
91
+ seedTask(`bl-slow-6000-${stamp}`, `bl-slow-${stamp}`, 6000);
92
+ recordDeliveredStaleEvents(NOW);
93
+ expect(eventsFor(`bl-slow-700-${stamp}`)).toEqual([]);
94
+ expect(eventsFor(`bl-slow-6000-${stamp}`)).toContain("task.warning.delivered_stale_600s");
95
+ });
96
+
97
+ test("基线极大(p99=50min)时,等满 30 分钟仍然报(上限兜底)", () => {
98
+ seedSession(`bl-very-slow-${stamp}`, "idle");
99
+ setBaseline(`bl-very-slow-${stamp}`, 3017); // ×1.5 = 4525s,若无上限就永远不报
100
+ seedTask(`bl-very-slow-1900-${stamp}`, `bl-very-slow-${stamp}`, 1900);
101
+ seedTask(`bl-very-slow-1700-${stamp}`, `bl-very-slow-${stamp}`, 1700);
102
+ recordDeliveredStaleEvents(NOW);
103
+ expect(eventsFor(`bl-very-slow-1900-${stamp}`)).toContain("task.warning.delivered_stale_600s");
104
+ expect(eventsFor(`bl-very-slow-1700-${stamp}`)).toEqual([]);
105
+ });
106
+
107
+ test("基线更窄(快节点):不允许比全局下限更敏感", () => {
108
+ seedSession(`bl-fast-${stamp}`, "idle");
109
+ setBaseline(`bl-fast-${stamp}`, 2); // 阈值 max(600, 3) = 600
110
+ seedTask(`bl-fast-120-${stamp}`, `bl-fast-${stamp}`, 120);
111
+ recordDeliveredStaleEvents(NOW);
112
+ expect(eventsFor(`bl-fast-120-${stamp}`)).toEqual([]);
113
+ });
114
+
115
+ test("refresh 只用成功且已进 runtime 的样本", () => {
116
+ const alias = `bl-refresh-${stamp}`;
117
+ // 20 条成功的(delivered→started 各 10s),2 条失败的(不应计入)
118
+ for (let i = 0; i < BASELINE_MIN_SAMPLES; i++) {
119
+ db.run(
120
+ `INSERT INTO tasks (task_id, from_name, to_name, status, content, delivered_at, started_at, completed_at, network_id)
121
+ VALUES (?1, 'sender', ?2, 'replied', 'x', ?3, ?4, ?5, ?6)`,
122
+ [`bl-ref-ok-${i}-${stamp}`, alias, iso(1000 - i), iso(990 - i), iso(985 - i), NET],
123
+ );
124
+ }
125
+ for (let i = 0; i < 5; i++) {
126
+ db.run(
127
+ `INSERT INTO tasks (task_id, from_name, to_name, status, content, delivered_at, completed_at, network_id)
128
+ VALUES (?1, 'sender', ?2, 'failed', 'x', ?3, ?4, ?5)`,
129
+ [`bl-ref-bad-${i}-${stamp}`, alias, iso(5000 - i), iso(1000), NET],
130
+ );
131
+ }
132
+ refreshAliasBaseline(NOW);
133
+ const row = aliasBaseline(alias, NET);
134
+ expect(row).not.toBeNull();
135
+ expect(row!.samples).toBe(BASELINE_MIN_SAMPLES); // 失败的不算
136
+ expect(row!.p99Seconds).toBeGreaterThanOrEqual(9); // 10s 左右的样本
137
+ expect(row!.p99Seconds).toBeLessThanOrEqual(11);
138
+ });
139
+
140
+ test("样本不足不写基线行(退回全局)", () => {
141
+ const alias = `bl-thin-${stamp}`;
142
+ for (let i = 0; i < BASELINE_MIN_SAMPLES - 1; i++) {
143
+ db.run(
144
+ `INSERT INTO tasks (task_id, from_name, to_name, status, content, delivered_at, started_at, completed_at, network_id)
145
+ VALUES (?1, 'sender', ?2, 'replied', 'x', ?3, ?4, ?5, ?6)`,
146
+ [`bl-thin-${i}-${stamp}`, alias, iso(1000 - i), iso(995 - i), iso(990 - i), NET],
147
+ );
148
+ }
149
+ refreshAliasBaseline(NOW);
150
+ expect(aliasBaseline(alias, NET)).toBeNull();
151
+ });
152
+ });
@@ -0,0 +1,102 @@
1
+ // #2571(第三轮)—— 每个目标自己的「投递→首次活动」p99 基线。
2
+ //
3
+ // 为什么需要(2026-10-27 实测):
4
+ // 同一个「10 分钟没消费就报警」的判据,在两种节奏下表现完全相反 ——
5
+ // 7 天基线:delivered→首次活动 p50=1s p90=6s p99=12min ⇒ >600s 只占 1.2%
6
+ // 某一晚: p50=32s p90=411s p99=1573s ⇒ >600s 占 5.4%,其中 43% 最终成功
7
+ // 全局常数不可能同时适配“全员都在跑长 turn”和“某个节点单独卡死”。
8
+ // ⇒ 判据改成 **age > max(全局下限, 该 alias 自己的 p99 × 1.5)**:
9
+ // 全队一起变慢 ⇒ 各自基线一起抬高,不炸屏;单个节点变慢 ⇒ 它自己的基线没高,立刻显形。
10
+ //
11
+ // 这张表只是**缓存**(派生数据):算错了重算即可,不影响投递/回复语义。
12
+ // 样本不足(< MIN_SAMPLES)的 alias 不写行 ⇒ 巡逻退回全局阈值(行为与 .163 完全一致)。
13
+
14
+ import { db } from "./db.js";
15
+
16
+ export const ALIAS_BASELINE_TABLE = "alias_latency_baseline";
17
+ export const BASELINE_WINDOW_DAYS = 7;
18
+ export const BASELINE_MIN_SAMPLES = 20;
19
+ /** 阈值 = max(全局下限, p99 × 这个倍数)。1.5 是“比它自己最慢的 1% 再宽 50%”。 */
20
+ export const BASELINE_P99_FACTOR = 1.5;
21
+
22
+ /**
23
+ * 基线的**上限**:再慢的节点,等满 30 分钟也必须报。
24
+ *
25
+ * 没有这条上限时,p99=3017s(50 分钟)的节点会把自己的阈值推到 75 分钟 —— 它卡死时永远不报。
26
+ * 生产实测(2026-10-27 用最近 24h 数据回溯模拟):加基线后 46 条 → 8 条(-83%),
27
+ * 但被抑制的样本里出现了 `TMA设计师` 两条最终 **failed** 的任务(它的 p99 是 50 分钟)
28
+ * ⇒ 慢节点需要一条“无论如何都要响”的底线。
29
+ */
30
+ export const BASELINE_MAX_SECONDS = 1800;
31
+
32
+ export function ensureAliasBaselineTable(): void {
33
+ db.exec(`
34
+ CREATE TABLE IF NOT EXISTS ${ALIAS_BASELINE_TABLE} (
35
+ alias TEXT NOT NULL,
36
+ network_id TEXT NOT NULL,
37
+ p99_seconds INTEGER NOT NULL,
38
+ samples INTEGER NOT NULL,
39
+ computed_at TEXT NOT NULL,
40
+ PRIMARY KEY (alias, network_id)
41
+ );
42
+ CREATE INDEX IF NOT EXISTS idx_alias_baseline_computed
43
+ ON ${ALIAS_BASELINE_TABLE}(computed_at);
44
+ `);
45
+ }
46
+
47
+ /**
48
+ * 重新计算基线。只统计**成功任务**(replied)且已经进过 runtime 的样本:
49
+ * 失败/未开始的任务会把“没消费”混进“消费慢”,两者不是一回事。
50
+ */
51
+ export function refreshAliasBaseline(now = new Date()): { rows: number } {
52
+ ensureAliasBaselineTable();
53
+ const iso = now.toISOString();
54
+ const since = new Date(now.getTime() - BASELINE_WINDOW_DAYS * 86_400_000).toISOString();
55
+ const result = db.run(
56
+ `INSERT INTO ${ALIAS_BASELINE_TABLE} (alias, network_id, p99_seconds, samples, computed_at)
57
+ SELECT alias, network_id, CAST(seconds AS INTEGER), samples, ?2
58
+ FROM (
59
+ SELECT to_name AS alias,
60
+ network_id,
61
+ seconds,
62
+ samples,
63
+ ROW_NUMBER() OVER (PARTITION BY to_name, network_id ORDER BY seconds) AS rn,
64
+ CAST(samples * 0.99 AS INTEGER) AS p99_rank
65
+ FROM (
66
+ SELECT to_name,
67
+ network_id,
68
+ (julianday(COALESCE(started_at, runtime_submitted_at, completed_at)) - julianday(delivered_at)) * 86400.0 AS seconds,
69
+ COUNT(*) OVER (PARTITION BY to_name, network_id) AS samples
70
+ FROM tasks
71
+ WHERE status = 'replied'
72
+ AND delivered_at IS NOT NULL
73
+ AND COALESCE(started_at, runtime_submitted_at, completed_at) IS NOT NULL
74
+ AND created_at >= ?1
75
+ )
76
+ )
77
+ WHERE samples >= ?3
78
+ AND rn = MAX(1, p99_rank)
79
+ ON CONFLICT(alias, network_id) DO UPDATE SET
80
+ p99_seconds = excluded.p99_seconds,
81
+ samples = excluded.samples,
82
+ computed_at = excluded.computed_at`,
83
+ [since, iso, BASELINE_MIN_SAMPLES],
84
+ );
85
+ // 窗口内没有样本的 alias(长期不活跃)不该继续用旧基线兜着。
86
+ db.run(`DELETE FROM ${ALIAS_BASELINE_TABLE} WHERE computed_at < ?1`, [since]);
87
+ return { rows: result.changes };
88
+ }
89
+
90
+ /** 只读查询(排障 / 测试用)。 */
91
+ export function aliasBaseline(alias: string, networkId: string): { p99Seconds: number; samples: number } | null {
92
+ try {
93
+ const row = db.get<{ p99_seconds: number; samples: number }>(
94
+ `SELECT p99_seconds, samples FROM ${ALIAS_BASELINE_TABLE} WHERE alias = ?1 AND network_id = ?2`,
95
+ alias, networkId,
96
+ );
97
+ return row ? { p99Seconds: Number(row.p99_seconds), samples: Number(row.samples) } : null;
98
+ } catch {
99
+ // 表还没建(老库/单测里没跑过 refresh)⇒ 当作没有基线。
100
+ return null;
101
+ }
102
+ }
@@ -0,0 +1,128 @@
1
+ // #2664 —— `backfillMessageNodeIds()` 从「逐行相关子查询」改成「物化的别名→node_id 表 + UPDATE … FROM」。
2
+ //
3
+ // 这次改写**只为了快**(生产副本实测单条 6.56s → 0.29s;boot 期六条约 10s → 约 0.75s),
4
+ // 而“快”最容易顺手改坏的是**选哪一行 / 谁不该被改**:
5
+ // · 人的用户名不能被映射成节点(`NOT EXISTS users.username`);
6
+ // · 改过名的节点走 rename_txn(只认 `committed`);
7
+ // · 已经有 node_id 的行**不能被覆盖**;
8
+ // · 重复调用幂等。
9
+ //
10
+ // 注:`sessions` 上有 `UNIQUE (network_id, alias)` 且 `network_id NOT NULL`,
11
+ // 所以“同一 alias 多条 session 时取 updated_at 最新”在当前 schema 下**不可构造**;
12
+ // 窗口函数只是为了在 PG / 老库形状下保持与旧 `ORDER BY … LIMIT 1` 等价,不是新语义。
13
+
14
+ import { afterAll, beforeAll, describe, expect, test } from "bun:test";
15
+ import { db, backfillMessageNodeIds } from "./db.js";
16
+
17
+ let networkId = "";
18
+ const stamp = `${Date.now()}`;
19
+
20
+ function session(alias: string, nodeId: string | null, updatedAt: string, network = networkId) {
21
+ db.run(
22
+ `INSERT INTO sessions (resume_id, alias, node_id, status, network_id, registered_at, updated_at)
23
+ VALUES (?1, ?2, ?3, 'idle', ?4, ?5, ?5)`,
24
+ [`res_${alias}_${stamp}`, alias, nodeId, network, updatedAt],
25
+ );
26
+ }
27
+
28
+ function task(id: string, fromName: string, toName: string, network = networkId) {
29
+ db.run(
30
+ `INSERT INTO tasks (task_id, from_name, to_name, content, status, network_id)
31
+ VALUES (?1, ?2, ?3, 'fixture', 'delivered', ?4)`,
32
+ [id, fromName, toName, network],
33
+ );
34
+ }
35
+
36
+ function nodeIds(id: string) {
37
+ return db.get<{ from_node_id: string | null; to_node_id: string | null }>(
38
+ "SELECT from_node_id, to_node_id FROM tasks WHERE task_id = ?1",
39
+ [`${id}-${stamp}`],
40
+ )!;
41
+ }
42
+
43
+ beforeAll(async () => {
44
+ const { register } = await import("./auth.js");
45
+ const auth = register(`bf_owner_${stamp}`, "Bf-Owner-Strong-1!", undefined, "tester");
46
+ expect(auth.ok).toBe(true);
47
+ networkId = auth.network_id!;
48
+
49
+ session(`bf-node-${stamp}`, `node-${stamp}`, "2026-10-20 00:00:00");
50
+ // 人类用户:即便 sessions 里出现过同名行,也不能把任务归到那个 node
51
+ session(`bf-human-${stamp}`, `node-should-not-win-${stamp}`, "2026-10-20 00:00:00");
52
+ db.run(
53
+ `INSERT INTO users (user_id, username, display_name, role, password_hash, created_at)
54
+ VALUES (?1, ?2, '人类', 'member', 'x', datetime('now'))`,
55
+ [`u_bf_${stamp}`, `bf-human-${stamp}`],
56
+ );
57
+
58
+ task(`bf-fresh-${stamp}`, `bf-node-${stamp}`, `bf-node-${stamp}`);
59
+ task(`bf-human-task-${stamp}`, `bf-human-${stamp}`, `bf-node-${stamp}`);
60
+ task(`bf-preset-${stamp}`, `bf-node-${stamp}`, `bf-node-${stamp}`);
61
+ db.run(`UPDATE tasks SET from_node_id = 'preset-node', to_node_id = 'preset-node' WHERE task_id = ?1`, [
62
+ `bf-preset-${stamp}`,
63
+ ]);
64
+
65
+ // rename_txn:旧别名 → 新别名(committed 生效;pending 不生效)
66
+ session(`bf-new-alias-${stamp}`, `node-renamed-${stamp}`, "2026-10-20 00:00:00");
67
+ db.run(
68
+ `INSERT INTO rename_txn (txn_id, old_alias, new_alias, status, network_id, committed_at)
69
+ VALUES (?1, ?2, ?3, 'committed', ?4, '2026-10-21 00:00:00')`,
70
+ [`txn_bf_${stamp}`, `bf-old-alias-${stamp}`, `bf-new-alias-${stamp}`, networkId],
71
+ );
72
+ task(`bf-renamed-${stamp}`, `bf-old-alias-${stamp}`, `bf-old-alias-${stamp}`);
73
+
74
+ db.run(
75
+ `INSERT INTO rename_txn (txn_id, old_alias, new_alias, status, network_id, committed_at)
76
+ VALUES (?1, ?2, ?3, 'pending', ?4, NULL)`,
77
+ [`txn_bf_pending_${stamp}`, `bf-pending-alias-${stamp}`, `bf-new-alias-${stamp}`, networkId],
78
+ );
79
+ task(`bf-pending-${stamp}`, `bf-pending-alias-${stamp}`, `bf-pending-alias-${stamp}`);
80
+
81
+ backfillMessageNodeIds();
82
+ });
83
+
84
+ afterAll(() => {
85
+ try {
86
+ db.run(`DELETE FROM tasks WHERE task_id LIKE ?1`, [`bf-%-${stamp}`]);
87
+ db.run(`DELETE FROM sessions WHERE alias LIKE ?1`, [`bf-%-${stamp}`]);
88
+ db.run(`DELETE FROM rename_txn WHERE txn_id LIKE ?1`, [`txn_bf%${stamp}`]);
89
+ db.run(`DELETE FROM users WHERE username LIKE ?1`, [`bf-human-${stamp}`]);
90
+ } catch {}
91
+ });
92
+
93
+ describe("#2664 backfill semantics unchanged by the join rewrite", () => {
94
+ test("普通别名能补上 from/to 两侧的 node_id", () => {
95
+ expect(nodeIds("bf-fresh").from_node_id).toBe(`node-${stamp}`);
96
+ expect(nodeIds("bf-fresh").to_node_id).toBe(`node-${stamp}`);
97
+ });
98
+
99
+ test("人的用户名不会被映射成节点", () => {
100
+ expect(nodeIds("bf-human-task").from_node_id).toBeNull();
101
+ });
102
+
103
+ test("已经有 node_id 的行不被覆盖", () => {
104
+ expect(nodeIds("bf-preset").from_node_id).toBe("preset-node");
105
+ expect(nodeIds("bf-preset").to_node_id).toBe("preset-node");
106
+ });
107
+
108
+ test("改过名的节点按 rename_txn 的旧别名补上", () => {
109
+ expect(nodeIds("bf-renamed").from_node_id).toBe(`node-renamed-${stamp}`);
110
+ expect(nodeIds("bf-renamed").to_node_id).toBe(`node-renamed-${stamp}`);
111
+ });
112
+
113
+ test("未提交(pending)的改名不生效", () => {
114
+ expect(nodeIds("bf-pending").from_node_id).toBeNull();
115
+ expect(nodeIds("bf-pending").to_node_id).toBeNull();
116
+ });
117
+
118
+ test("第二次调用是幂等的", () => {
119
+ const count = () =>
120
+ db.get<{ n: number }>(
121
+ `SELECT COUNT(*) AS n FROM tasks WHERE network_id = ?1 AND (from_node_id IS NOT NULL OR to_node_id IS NOT NULL)`,
122
+ [networkId],
123
+ )!.n;
124
+ const before = count();
125
+ backfillMessageNodeIds();
126
+ expect(count()).toBe(before);
127
+ });
128
+ });
package/src/db.ts CHANGED
@@ -1303,6 +1303,18 @@ try { db.exec("CREATE INDEX IF NOT EXISTS idx_tasks_to_node ON tasks(to_node_id)
1303
1303
  try { db.exec("CREATE INDEX IF NOT EXISTS idx_inbox_node ON inbox(node_id)"); } catch {}
1304
1304
 
1305
1305
  export function backfillMessageNodeIds() {
1306
+ // #2664 —— 旧写法是 6 条 `UPDATE … SET x = (SELECT … WHERE alias = t.name …)`:
1307
+ // 每条都对 **84k 行 tasks.from_node_id IS NULL / 36k 行 inbox.node_id IS NULL** 逐行
1308
+ // 跑一次相关子查询,而子查询里的 `COALESCE(network_id,'default')` 让
1309
+ // idx_sessions_network_alias_unique 用不上 ⇒ 每行扫一遍 369 行 sessions。
1310
+ // 生产实测(`.162` 慢 SQL 日志,2026-10-27 00:21 重启):5398ms / 2451ms / 1270ms,
1311
+ // 而且当次命中 0 行 —— **结果是 0,代价不是 0**。
1312
+ //
1313
+ // 改成 `UPDATE … FROM (物化后的别名→node_id 表)`:sessions/rename_txn 只扫一遍,
1314
+ // 每行只做一次自动索引探测。同一份生产库副本上 6.56s → 0.29s。
1315
+ // 语义不变:同一 (alias, network) 取 `updated_at` / `committed_at` 最新的那一行;
1316
+ // 仍然是「先按 session 别名直连,再补 rename_txn 的旧别名」;对 tasks 仍排除人是发送方的情况。
1317
+ const t0 = performance.now();
1306
1318
  let inboxDirect = 0;
1307
1319
  let inboxRenamed = 0;
1308
1320
  let tasksToDirect = 0;
@@ -1313,157 +1325,146 @@ export function backfillMessageNodeIds() {
1313
1325
  try {
1314
1326
  inboxDirect = db.run(`
1315
1327
  UPDATE inbox
1316
- SET node_id = (
1317
- SELECT s.node_id FROM sessions s
1318
- WHERE s.node_id IS NOT NULL
1319
- AND s.alias = inbox.session_name
1320
- AND COALESCE(s.network_id, 'default') = COALESCE(inbox.network_id, 'default')
1321
- ORDER BY s.updated_at DESC
1322
- LIMIT 1
1323
- )
1324
- WHERE node_id IS NULL
1325
- AND EXISTS (
1326
- SELECT 1 FROM sessions s
1327
- WHERE s.node_id IS NOT NULL
1328
- AND s.alias = inbox.session_name
1329
- AND COALESCE(s.network_id, 'default') = COALESCE(inbox.network_id, 'default')
1330
- )
1328
+ SET node_id = pick.node_id
1329
+ FROM (
1330
+ SELECT alias, COALESCE(network_id, 'default') AS net, node_id,
1331
+ ROW_NUMBER() OVER (
1332
+ PARTITION BY alias, COALESCE(network_id, 'default')
1333
+ ORDER BY updated_at DESC
1334
+ ) AS rn
1335
+ FROM sessions
1336
+ WHERE node_id IS NOT NULL
1337
+ ) pick
1338
+ WHERE pick.rn = 1
1339
+ AND pick.alias = inbox.session_name
1340
+ AND pick.net = COALESCE(inbox.network_id, 'default')
1341
+ AND inbox.node_id IS NULL
1331
1342
  `).changes;
1332
1343
  } catch {}
1333
1344
 
1334
1345
  try {
1335
1346
  inboxRenamed = db.run(`
1336
1347
  UPDATE inbox
1337
- SET node_id = (
1338
- SELECT s.node_id FROM rename_txn r
1348
+ SET node_id = pick.node_id
1349
+ FROM (
1350
+ SELECT r.old_alias AS old_alias,
1351
+ COALESCE(r.network_id, 'default') AS net,
1352
+ s.node_id AS node_id,
1353
+ ROW_NUMBER() OVER (
1354
+ PARTITION BY r.old_alias, COALESCE(r.network_id, 'default')
1355
+ ORDER BY r.committed_at DESC
1356
+ ) AS rn
1357
+ FROM rename_txn r
1339
1358
  JOIN sessions s
1340
1359
  ON s.alias = r.new_alias
1341
1360
  AND COALESCE(s.network_id, 'default') = COALESCE(r.network_id, 'default')
1342
1361
  WHERE s.node_id IS NOT NULL
1343
1362
  AND r.status = 'committed'
1344
- AND r.old_alias = inbox.session_name
1345
- AND COALESCE(r.network_id, 'default') = COALESCE(inbox.network_id, 'default')
1346
- ORDER BY r.committed_at DESC
1347
- LIMIT 1
1348
- )
1349
- WHERE node_id IS NULL
1350
- AND EXISTS (
1351
- SELECT 1 FROM rename_txn r
1352
- JOIN sessions s
1353
- ON s.alias = r.new_alias
1354
- AND COALESCE(s.network_id, 'default') = COALESCE(r.network_id, 'default')
1355
- WHERE s.node_id IS NOT NULL
1356
- AND r.status = 'committed'
1357
- AND r.old_alias = inbox.session_name
1358
- AND COALESCE(r.network_id, 'default') = COALESCE(inbox.network_id, 'default')
1359
- )
1363
+ ) pick
1364
+ WHERE pick.rn = 1
1365
+ AND pick.old_alias = inbox.session_name
1366
+ AND pick.net = COALESCE(inbox.network_id, 'default')
1367
+ AND inbox.node_id IS NULL
1360
1368
  `).changes;
1361
1369
  } catch {}
1362
1370
 
1363
1371
  try {
1364
1372
  tasksToDirect = db.run(`
1365
1373
  UPDATE tasks
1366
- SET to_node_id = (
1367
- SELECT s.node_id FROM sessions s
1368
- WHERE s.node_id IS NOT NULL
1369
- AND s.alias = tasks.to_name
1370
- AND COALESCE(s.network_id, 'default') = COALESCE(tasks.network_id, 'default')
1371
- ORDER BY s.updated_at DESC
1372
- LIMIT 1
1373
- )
1374
- WHERE to_node_id IS NULL
1375
- AND EXISTS (
1376
- SELECT 1 FROM sessions s
1377
- WHERE s.node_id IS NOT NULL
1378
- AND s.alias = tasks.to_name
1379
- AND COALESCE(s.network_id, 'default') = COALESCE(tasks.network_id, 'default')
1380
- )
1374
+ SET to_node_id = pick.node_id
1375
+ FROM (
1376
+ SELECT alias, COALESCE(network_id, 'default') AS net, node_id,
1377
+ ROW_NUMBER() OVER (
1378
+ PARTITION BY alias, COALESCE(network_id, 'default')
1379
+ ORDER BY updated_at DESC
1380
+ ) AS rn
1381
+ FROM sessions
1382
+ WHERE node_id IS NOT NULL
1383
+ ) pick
1384
+ WHERE pick.rn = 1
1385
+ AND pick.alias = tasks.to_name
1386
+ AND pick.net = COALESCE(tasks.network_id, 'default')
1387
+ AND tasks.to_node_id IS NULL
1381
1388
  `).changes;
1382
1389
  } catch {}
1383
1390
 
1384
1391
  try {
1385
1392
  tasksToRenamed = db.run(`
1386
1393
  UPDATE tasks
1387
- SET to_node_id = (
1388
- SELECT s.node_id FROM rename_txn r
1394
+ SET to_node_id = pick.node_id
1395
+ FROM (
1396
+ SELECT r.old_alias AS old_alias,
1397
+ COALESCE(r.network_id, 'default') AS net,
1398
+ s.node_id AS node_id,
1399
+ ROW_NUMBER() OVER (
1400
+ PARTITION BY r.old_alias, COALESCE(r.network_id, 'default')
1401
+ ORDER BY r.committed_at DESC
1402
+ ) AS rn
1403
+ FROM rename_txn r
1389
1404
  JOIN sessions s
1390
1405
  ON s.alias = r.new_alias
1391
1406
  AND COALESCE(s.network_id, 'default') = COALESCE(r.network_id, 'default')
1392
1407
  WHERE s.node_id IS NOT NULL
1393
1408
  AND r.status = 'committed'
1394
- AND r.old_alias = tasks.to_name
1395
- AND COALESCE(r.network_id, 'default') = COALESCE(tasks.network_id, 'default')
1396
- ORDER BY r.committed_at DESC
1397
- LIMIT 1
1398
- )
1399
- WHERE to_node_id IS NULL
1400
- AND EXISTS (
1401
- SELECT 1 FROM rename_txn r
1402
- JOIN sessions s
1403
- ON s.alias = r.new_alias
1404
- AND COALESCE(s.network_id, 'default') = COALESCE(r.network_id, 'default')
1405
- WHERE s.node_id IS NOT NULL
1406
- AND r.status = 'committed'
1407
- AND r.old_alias = tasks.to_name
1408
- AND COALESCE(r.network_id, 'default') = COALESCE(tasks.network_id, 'default')
1409
- )
1409
+ ) pick
1410
+ WHERE pick.rn = 1
1411
+ AND pick.old_alias = tasks.to_name
1412
+ AND pick.net = COALESCE(tasks.network_id, 'default')
1413
+ AND tasks.to_node_id IS NULL
1410
1414
  `).changes;
1411
1415
  } catch {}
1412
1416
 
1413
1417
  try {
1414
1418
  tasksFromDirect = db.run(`
1415
1419
  UPDATE tasks
1416
- SET from_node_id = (
1417
- SELECT s.node_id FROM sessions s
1418
- WHERE s.node_id IS NOT NULL
1419
- AND s.alias = tasks.from_name
1420
- AND COALESCE(s.network_id, 'default') = COALESCE(tasks.network_id, 'default')
1421
- ORDER BY s.updated_at DESC
1422
- LIMIT 1
1423
- )
1424
- WHERE from_node_id IS NULL
1420
+ SET from_node_id = pick.node_id
1421
+ FROM (
1422
+ SELECT alias, COALESCE(network_id, 'default') AS net, node_id,
1423
+ ROW_NUMBER() OVER (
1424
+ PARTITION BY alias, COALESCE(network_id, 'default')
1425
+ ORDER BY updated_at DESC
1426
+ ) AS rn
1427
+ FROM sessions
1428
+ WHERE node_id IS NOT NULL
1429
+ ) pick
1430
+ WHERE pick.rn = 1
1431
+ AND pick.alias = tasks.from_name
1432
+ AND pick.net = COALESCE(tasks.network_id, 'default')
1433
+ AND tasks.from_node_id IS NULL
1425
1434
  AND NOT EXISTS (SELECT 1 FROM users u WHERE u.username = tasks.from_name)
1426
- AND EXISTS (
1427
- SELECT 1 FROM sessions s
1428
- WHERE s.node_id IS NOT NULL
1429
- AND s.alias = tasks.from_name
1430
- AND COALESCE(s.network_id, 'default') = COALESCE(tasks.network_id, 'default')
1431
- )
1432
1435
  `).changes;
1433
1436
  } catch {}
1434
1437
 
1435
1438
  try {
1436
1439
  tasksFromRenamed = db.run(`
1437
1440
  UPDATE tasks
1438
- SET from_node_id = (
1439
- SELECT s.node_id FROM rename_txn r
1441
+ SET from_node_id = pick.node_id
1442
+ FROM (
1443
+ SELECT r.old_alias AS old_alias,
1444
+ COALESCE(r.network_id, 'default') AS net,
1445
+ s.node_id AS node_id,
1446
+ ROW_NUMBER() OVER (
1447
+ PARTITION BY r.old_alias, COALESCE(r.network_id, 'default')
1448
+ ORDER BY r.committed_at DESC
1449
+ ) AS rn
1450
+ FROM rename_txn r
1440
1451
  JOIN sessions s
1441
1452
  ON s.alias = r.new_alias
1442
1453
  AND COALESCE(s.network_id, 'default') = COALESCE(r.network_id, 'default')
1443
1454
  WHERE s.node_id IS NOT NULL
1444
1455
  AND r.status = 'committed'
1445
- AND r.old_alias = tasks.from_name
1446
- AND COALESCE(r.network_id, 'default') = COALESCE(tasks.network_id, 'default')
1447
- ORDER BY r.committed_at DESC
1448
- LIMIT 1
1449
- )
1450
- WHERE from_node_id IS NULL
1456
+ ) pick
1457
+ WHERE pick.rn = 1
1458
+ AND pick.old_alias = tasks.from_name
1459
+ AND pick.net = COALESCE(tasks.network_id, 'default')
1460
+ AND tasks.from_node_id IS NULL
1451
1461
  AND NOT EXISTS (SELECT 1 FROM users u WHERE u.username = tasks.from_name)
1452
- AND EXISTS (
1453
- SELECT 1 FROM rename_txn r
1454
- JOIN sessions s
1455
- ON s.alias = r.new_alias
1456
- AND COALESCE(s.network_id, 'default') = COALESCE(r.network_id, 'default')
1457
- WHERE s.node_id IS NOT NULL
1458
- AND r.status = 'committed'
1459
- AND r.old_alias = tasks.from_name
1460
- AND COALESCE(r.network_id, 'default') = COALESCE(tasks.network_id, 'default')
1461
- )
1462
1462
  `).changes;
1463
1463
  } catch {}
1464
1464
 
1465
1465
  const total = inboxDirect + inboxRenamed + tasksToDirect + tasksToRenamed + tasksFromDirect + tasksFromRenamed;
1466
- console.log(`[commhub] node_id backfill: inbox=${inboxDirect + inboxRenamed}, tasks.to=${tasksToDirect + tasksToRenamed}, tasks.from=${tasksFromDirect + tasksFromRenamed}, total=${total}`);
1466
+ // #2664 —— 旧日志只有条数,于是「total=0 却花了 10 秒」在生产里完全看不见。
1467
+ console.log(`[commhub] node_id backfill: inbox=${inboxDirect + inboxRenamed}, tasks.to=${tasksToDirect + tasksToRenamed}, tasks.from=${tasksFromDirect + tasksFromRenamed}, total=${total}, took=${Math.round(performance.now() - t0)}ms`);
1467
1468
  }
1468
1469
 
1469
1470
  backfillMessageNodeIds();