@sleep2agi/commhub-server 0.9.0-preview.256 → 0.9.0-preview.257
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/build-info.json +2 -2
- package/package.json +1 -1
- package/src/expiry-counters.test.ts +14 -5
- package/src/expiry-counters.ts +73 -9
- package/src/expiry-evidence-db.test.ts +88 -0
package/build-info.json
CHANGED
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@sleep2agi/commhub-server",
|
|
3
|
-
"version": "0.9.0-preview.
|
|
3
|
+
"version": "0.9.0-preview.257",
|
|
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",
|
|
@@ -122,7 +122,7 @@ describe("#3271 证据的生命期必须 ≥ 故障的生命期(进程内计
|
|
|
122
122
|
test("🔴 内存计数为空,但 tasks 表里有 3 条历史 ⇒ 必须拒绝", () => {
|
|
123
123
|
const r = neverConsumeGate({
|
|
124
124
|
alias: "ghost", counters: empty, force: false, forceAllowed: true, now: NOW,
|
|
125
|
-
persistent: { expiries: 3, last_at: new Date(NOW - 60_000).toISOString().replace("T", " ").slice(0, 19) },
|
|
125
|
+
persistent: { expiries: 3, last_at: new Date(NOW - 60_000).toISOString().replace("T", " ").slice(0, 19), last_reply_at: null },
|
|
126
126
|
});
|
|
127
127
|
expect(r.ok).toBe(false);
|
|
128
128
|
if (r.ok) throw new Error("unreachable");
|
|
@@ -133,19 +133,28 @@ describe("#3271 证据的生命期必须 ≥ 故障的生命期(进程内计
|
|
|
133
133
|
const counters = { since: "s", total: 2, by_node: { ghost: 2 }, last_at: { ghost: new Date(NOW - 60_000).toISOString() } };
|
|
134
134
|
const r = neverConsumeGate({
|
|
135
135
|
alias: "ghost", counters, force: false, forceAllowed: true, now: NOW,
|
|
136
|
-
persistent: { expiries: 3, last_at: new Date(NOW - 60_000).toISOString().replace("T", " ").slice(0, 19) },
|
|
136
|
+
persistent: { expiries: 3, last_at: new Date(NOW - 60_000).toISOString().replace("T", " ").slice(0, 19), last_reply_at: null },
|
|
137
137
|
});
|
|
138
138
|
expect(r.ok).toBe(false);
|
|
139
139
|
if (r.ok) throw new Error("unreachable");
|
|
140
140
|
expect(r.expiries).toBe(3);
|
|
141
141
|
});
|
|
142
142
|
|
|
143
|
-
|
|
143
|
+
// 🔴 语义修正(2026-10-31 第二次实测):DB 证据**不用固定 TTL**。
|
|
144
|
+
// 固定 2 小时是我拍的,而那台节点的故障节律是「天」——于是闸在 22 小时前的那次过期之后
|
|
145
|
+
// 判「已恢复」并放行,而它这 22 小时一条都没回。
|
|
146
|
+
// 现在 DB 证据自带边界(「最后一次回复之后」),陈旧不陈旧由回复本身回答。
|
|
147
|
+
test("🔴 表里的历史很旧、但之后没有回复 ⇒ 仍然拒绝(固定 TTL 只留给纯内存计数)", () => {
|
|
144
148
|
const r = neverConsumeGate({
|
|
145
149
|
alias: "ghost", counters: empty, force: false, forceAllowed: true, now: NOW,
|
|
146
|
-
persistent: { expiries: 9, last_at: "2026-10-20T00:00:00" },
|
|
150
|
+
persistent: { expiries: 9, last_at: "2026-10-20T00:00:00", last_reply_at: "2026-10-18T00:00:00" },
|
|
147
151
|
});
|
|
148
|
-
expect(r.ok).toBe(
|
|
152
|
+
expect(r.ok).toBe(false);
|
|
153
|
+
});
|
|
154
|
+
|
|
155
|
+
test("纯内存计数仍然有 2 小时时效(没有回复时间可比,只能按时长兜底)", () => {
|
|
156
|
+
const counters = { since: "s", total: 9, by_node: { ghost: 9 }, last_at: { ghost: new Date(NOW - 3 * 3600_000).toISOString() } };
|
|
157
|
+
expect(neverConsumeGate({ alias: "ghost", counters, force: false, forceAllowed: true, now: NOW }).ok).toBe(true);
|
|
149
158
|
});
|
|
150
159
|
});
|
|
151
160
|
|
package/src/expiry-counters.ts
CHANGED
|
@@ -87,29 +87,77 @@ export const NEVER_CONSUME_STALE_MS = 2 * 60 * 60_000;
|
|
|
87
87
|
* · 进程内计数器:本次进程内发生的最新鲜的那几条(可能在 tasks 行写之前就有)
|
|
88
88
|
* · tasks 表:跨重启的历史(窗口由调用方给,默认 7 天 —— 与「节点可能恢复」同一个取舍)
|
|
89
89
|
*/
|
|
90
|
-
export interface PersistentExpiryEvidence {
|
|
90
|
+
export interface PersistentExpiryEvidence {
|
|
91
|
+
/** 「最后一次成功回复之后」仍过期且无回复的条数。 */
|
|
92
|
+
expiries: number;
|
|
93
|
+
/** 这些过期里最近的一条(用于读数,不用于时效判断)。 */
|
|
94
|
+
last_at: string | null;
|
|
95
|
+
/** 该节点最后一次成功回复的时间;null = 从来没有回复过(那才是真正的「从未消费」)。 */
|
|
96
|
+
last_reply_at: string | null;
|
|
97
|
+
}
|
|
91
98
|
|
|
92
99
|
export const NEVER_CONSUME_LOOKBACK_MS = 7 * 24 * 60 * 60_000;
|
|
93
100
|
|
|
101
|
+
/**
|
|
102
|
+
* #3271 🔴 2026-10-31 第二次修正 —— 判据的**语义**错了,不只是寿命。
|
|
103
|
+
*
|
|
104
|
+
* 第一次修正(内存 ∪ tasks 表)解决的是「部署清空计数器」,但生产实测仍然放行,查库后发现:
|
|
105
|
+
*
|
|
106
|
+
* tasks WHERE to_name='TM官网运维'
|
|
107
|
+
* replied 252 条 ← 它其实会干活
|
|
108
|
+
* status='expired' 37 条 且 consumed_at 全为 NULL
|
|
109
|
+
* 全库 consumed_at 非空 83,332 条(这个字段是被正常使用的)
|
|
110
|
+
*
|
|
111
|
+
* ⇒ **`consumed_at IS NULL` 不等于「从未取走」**:这台节点回复过 252 条,只是从不写这个字段。
|
|
112
|
+
* 计数器叫「从未取走」,量的却是「没写 consumed_at」—— 我把字段名当成了行为名。
|
|
113
|
+
*
|
|
114
|
+
* 所以判据改为**以「最后一次成功回复」为界**:
|
|
115
|
+
* 「在你最后一次回复之后,又有多少条过期且没人回」= 它到底还在不在服务。
|
|
116
|
+
* 之后已经回复过 ⇒ 放行(它是活的,只是某几条没接)。
|
|
117
|
+
*
|
|
118
|
+
* 这也让固定 TTL 变得不必要:DB 这条路自带边界(回复时间),
|
|
119
|
+
* 而固定 TTL 是凭直觉定的 —— 实测那台节点的故障节律是「天」,我给的是「2 小时」。
|
|
120
|
+
*/
|
|
94
121
|
export function persistentNeverConsumedExpiries(
|
|
95
122
|
db: { get<T = any>(sql: string, ...params: any[]): T | null },
|
|
96
123
|
alias: string,
|
|
97
124
|
networkId: string | null,
|
|
98
125
|
opts: { now?: number; lookbackMs?: number } = {},
|
|
99
126
|
): PersistentExpiryEvidence {
|
|
100
|
-
const since = new Date((opts.now ?? Date.now()) - (opts.lookbackMs ?? NEVER_CONSUME_LOOKBACK_MS))
|
|
127
|
+
const since = new Date((opts.now ?? Date.now()) - (opts.lookbackMs ?? NEVER_CONSUME_LOOKBACK_MS))
|
|
128
|
+
.toISOString().replace("T", " ").slice(0, 19);
|
|
129
|
+
|
|
130
|
+
// ① 最后一次成功回复(replied / completed 都算「还活着」的证据)
|
|
131
|
+
const reply = networkId
|
|
132
|
+
? db.get<{ last: string | null }>(
|
|
133
|
+
`SELECT MAX(COALESCE(completed_at, created_at)) AS last FROM tasks
|
|
134
|
+
WHERE to_name = ?1 AND network_id = ?2 AND status IN ('replied','completed')`,
|
|
135
|
+
alias, networkId)
|
|
136
|
+
: db.get<{ last: string | null }>(
|
|
137
|
+
`SELECT MAX(COALESCE(completed_at, created_at)) AS last FROM tasks
|
|
138
|
+
WHERE to_name = ?1 AND status IN ('replied','completed')`,
|
|
139
|
+
alias);
|
|
140
|
+
const lastReplyAt = reply?.last ?? null;
|
|
141
|
+
|
|
142
|
+
// ② 它之后仍「过期且无回复」的条数
|
|
143
|
+
const boundary = lastReplyAt && lastReplyAt > since ? lastReplyAt : since;
|
|
101
144
|
const row = networkId
|
|
102
145
|
? db.get<{ n: number; last: string | null }>(
|
|
103
146
|
`SELECT COUNT(*) AS n, MAX(created_at) AS last FROM tasks
|
|
104
|
-
WHERE to_name = ?1 AND network_id = ?2 AND status = 'expired' AND
|
|
105
|
-
AND created_at
|
|
106
|
-
alias, networkId,
|
|
147
|
+
WHERE to_name = ?1 AND network_id = ?2 AND status = 'expired' AND result IS NULL
|
|
148
|
+
AND created_at > ?3`,
|
|
149
|
+
alias, networkId, boundary)
|
|
107
150
|
: db.get<{ n: number; last: string | null }>(
|
|
108
151
|
`SELECT COUNT(*) AS n, MAX(created_at) AS last FROM tasks
|
|
109
|
-
WHERE to_name = ?1 AND status = 'expired' AND
|
|
110
|
-
AND created_at
|
|
111
|
-
alias,
|
|
112
|
-
|
|
152
|
+
WHERE to_name = ?1 AND status = 'expired' AND result IS NULL
|
|
153
|
+
AND created_at > ?2`,
|
|
154
|
+
alias, boundary);
|
|
155
|
+
|
|
156
|
+
return {
|
|
157
|
+
expiries: Number(row?.n ?? 0),
|
|
158
|
+
last_at: row?.last ?? null,
|
|
159
|
+
last_reply_at: lastReplyAt,
|
|
160
|
+
};
|
|
113
161
|
}
|
|
114
162
|
|
|
115
163
|
export type NeverConsumeGate =
|
|
@@ -134,6 +182,22 @@ export function neverConsumeGate(input: {
|
|
|
134
182
|
const fromDb = input.persistent?.expiries ?? 0;
|
|
135
183
|
const expiries = Math.max(fromMemory, fromDb);
|
|
136
184
|
if (expiries < limit) return { ok: true };
|
|
185
|
+
// DB 证据**自带边界**(「最后一次回复之后」),所以它不需要固定 TTL —— 那个 TTL 是我拍的。
|
|
186
|
+
// 只有「纯内存计数」这条路才需要时效:它没有回复时间可比,只能靠时长兜底。
|
|
187
|
+
if (fromDb >= limit) {
|
|
188
|
+
if (input.force && input.forceAllowed) return { ok: true };
|
|
189
|
+
return {
|
|
190
|
+
ok: false,
|
|
191
|
+
error: "target_never_consumes",
|
|
192
|
+
alias: input.alias,
|
|
193
|
+
expiries,
|
|
194
|
+
window_since: input.counters.since,
|
|
195
|
+
message:
|
|
196
|
+
`this target has ${fromDb} expired task(s) with no reply since its last reply`
|
|
197
|
+
+ `${input.persistent?.last_reply_at ? ` (${input.persistent.last_reply_at})` : " (it has never replied)"}; `
|
|
198
|
+
+ `nothing will queue correctly here until it replies again — pass force:true (user tokens) if you know it recovered`,
|
|
199
|
+
};
|
|
200
|
+
}
|
|
137
201
|
// 2026-10-31 —— **只数不衰减会把恢复了的节点永久拉黑**。
|
|
138
202
|
// 实测的教训来自另一台机(TM中转运维):连「抑制了多少」这个数本身都在被环缓冲淘汰,
|
|
139
203
|
// 所以任何「累计」都只在它的窗口内可引用;这里把窗口写进判据:最近一次过期超过 TTL ⇒ 放行。
|
|
@@ -0,0 +1,88 @@
|
|
|
1
|
+
// #3271 第二次修正的**数据层**判据:证据必须以「最后一次成功回复」为界。
|
|
2
|
+
//
|
|
3
|
+
// 为什么这条要有 DB 级测试:边界逻辑在 SQL 里(`created_at > MAX(COALESCE(completed_at, created_at))`),
|
|
4
|
+
// 纯函数测试用假的 get() 喂数据只能证明「我按我想的组装了」,证明不了「SQL 真的这么筛」。
|
|
5
|
+
//
|
|
6
|
+
// 现场(2026-10-31 生产实测):
|
|
7
|
+
// TM官网运维 replied 252 条、expired 37 条,而 consumed_at 全为 NULL
|
|
8
|
+
// ⇒「consumed_at IS NULL」被当成了「从未取走」,然而它明明会回。
|
|
9
|
+
import { afterAll, beforeEach, describe, expect, test } from "bun:test";
|
|
10
|
+
import { db } from "./db.js";
|
|
11
|
+
import { persistentNeverConsumedExpiries } from "./expiry-counters.js";
|
|
12
|
+
|
|
13
|
+
const NET = "net_expiry_evidence";
|
|
14
|
+
const ALIAS = "ghost-node";
|
|
15
|
+
|
|
16
|
+
function task(id: string, status: string, createdAt: string, extra: { result?: string | null; completed_at?: string | null; consumed_at?: string | null } = {}) {
|
|
17
|
+
db.run(
|
|
18
|
+
`INSERT INTO tasks (task_id, to_name, status, content, network_id, created_at, result, completed_at, consumed_at)
|
|
19
|
+
VALUES (?1, ?2, ?3, 'probe', ?4, ?5, ?6, ?7, ?8)`,
|
|
20
|
+
[id, ALIAS, status, NET, createdAt, extra.result ?? null, extra.completed_at ?? null, extra.consumed_at ?? null],
|
|
21
|
+
);
|
|
22
|
+
}
|
|
23
|
+
|
|
24
|
+
beforeEach(() => {
|
|
25
|
+
db.run("DELETE FROM tasks WHERE network_id = ?1", [NET]);
|
|
26
|
+
});
|
|
27
|
+
|
|
28
|
+
afterAll(() => {
|
|
29
|
+
db.run("DELETE FROM tasks WHERE network_id = ?1", [NET]);
|
|
30
|
+
});
|
|
31
|
+
|
|
32
|
+
describe("#3271 持久证据:以「最后一次回复」为界", () => {
|
|
33
|
+
test("🔴 回复之后的过期才算数:回复之前的过期不计入", () => {
|
|
34
|
+
const now = Date.parse("2026-10-31T22:00:00.000Z");
|
|
35
|
+
// 两次过期在回复之前 —— 那说明它当时还在服务,不该算作「之后没回」
|
|
36
|
+
task("t_old1", "expired", "2026-10-30 10:00:00");
|
|
37
|
+
task("t_old2", "expired", "2026-10-30 11:00:00");
|
|
38
|
+
// 一次成功回复(completed_at 比 created_at 晚)
|
|
39
|
+
task("t_reply", "replied", "2026-10-30 12:00:00", { result: "ok", completed_at: "2026-10-30 12:05:00" });
|
|
40
|
+
const ev = persistentNeverConsumedExpiries(db, ALIAS, NET, { now });
|
|
41
|
+
expect(ev.last_reply_at).toBe("2026-10-30 12:05:00");
|
|
42
|
+
expect(ev.expiries).toBe(0);
|
|
43
|
+
});
|
|
44
|
+
|
|
45
|
+
test("🔴 回复之后又连续过期 ⇒ 计数(这才是「它没在服务」)", () => {
|
|
46
|
+
const now = Date.parse("2026-10-31T22:00:00.000Z");
|
|
47
|
+
task("t_reply", "replied", "2026-10-29 12:00:00", { result: "ok", completed_at: "2026-10-29 12:05:00" });
|
|
48
|
+
task("t_e1", "expired", "2026-10-31 09:00:00");
|
|
49
|
+
task("t_e2", "expired", "2026-10-31 10:00:00");
|
|
50
|
+
task("t_e3", "expired", "2026-10-31 11:00:00");
|
|
51
|
+
const ev = persistentNeverConsumedExpiries(db, ALIAS, NET, { now });
|
|
52
|
+
expect(ev.expiries).toBe(3);
|
|
53
|
+
expect(ev.last_at).toBe("2026-10-31 11:00:00");
|
|
54
|
+
expect(ev.last_reply_at).toBe("2026-10-29 12:05:00");
|
|
55
|
+
});
|
|
56
|
+
|
|
57
|
+
test("「过期但有回复」不算:那是失败,不是没人接", () => {
|
|
58
|
+
const now = Date.parse("2026-10-31T22:00:00.000Z");
|
|
59
|
+
task("t_e1", "expired", "2026-10-31 09:00:00", { result: "回过了但还是被判过期" });
|
|
60
|
+
const ev = persistentNeverConsumedExpiries(db, ALIAS, NET, { now });
|
|
61
|
+
expect(ev.expiries).toBe(0);
|
|
62
|
+
});
|
|
63
|
+
|
|
64
|
+
test("从来没有回复过 ⇒ last_reply_at 为 null(那才是真正的「从未消费」)", () => {
|
|
65
|
+
const now = Date.parse("2026-10-31T22:00:00.000Z");
|
|
66
|
+
task("t_e1", "expired", "2026-10-31 09:00:00");
|
|
67
|
+
task("t_e2", "expired", "2026-10-31 10:00:00");
|
|
68
|
+
const ev = persistentNeverConsumedExpiries(db, ALIAS, NET, { now });
|
|
69
|
+
expect(ev.last_reply_at).toBeNull();
|
|
70
|
+
expect(ev.expiries).toBe(2);
|
|
71
|
+
});
|
|
72
|
+
|
|
73
|
+
test("窗口外的旧账不算:lookback 之外的不再计入", () => {
|
|
74
|
+
const now = Date.parse("2026-10-31T22:00:00.000Z");
|
|
75
|
+
task("t_ancient", "expired", "2026-01-01 00:00:00");
|
|
76
|
+
const ev = persistentNeverConsumedExpiries(db, ALIAS, NET, { now });
|
|
77
|
+
expect(ev.expiries).toBe(0);
|
|
78
|
+
});
|
|
79
|
+
|
|
80
|
+
test("别的节点的账不串台", () => {
|
|
81
|
+
const now = Date.parse("2026-10-31T22:00:00.000Z");
|
|
82
|
+
db.run(
|
|
83
|
+
`INSERT INTO tasks (task_id, to_name, status, content, network_id, created_at)
|
|
84
|
+
VALUES ('t_other', 'someone-else', 'expired', 'probe', ?1, '2026-10-31 09:00:00')`, [NET]);
|
|
85
|
+
expect(persistentNeverConsumedExpiries(db, ALIAS, NET, { now }).expiries).toBe(0);
|
|
86
|
+
expect(persistentNeverConsumedExpiries(db, "someone-else", NET, { now }).expiries).toBe(1);
|
|
87
|
+
});
|
|
88
|
+
});
|