@sleep2agi/commhub-server 0.9.0-preview.256 → 0.9.0-preview.258

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.
Files changed (33) hide show
  1. package/build-info.json +2 -2
  2. package/package.json +1 -1
  3. package/src/agent-acl-http.test.ts +5 -0
  4. package/src/agent-acl-slice3-http.test.ts +168 -0
  5. package/src/auth-abuse-counters.test.ts +125 -0
  6. package/src/auth-abuse-counters.ts +111 -0
  7. package/src/binding-generation-http.test.ts +10 -1
  8. package/src/clone-node.test.ts +7 -0
  9. package/src/create-node-blocked-gate.test.ts +9 -0
  10. package/src/daemon-provider-snapshots.test.ts +9 -1
  11. package/src/daemon-token-owner-http.test.ts +54 -0
  12. package/src/departments-agent-count.test.ts +7 -0
  13. package/src/expiry-counters.test.ts +14 -5
  14. package/src/expiry-counters.ts +77 -9
  15. package/src/expiry-evidence-db.test.ts +103 -0
  16. package/src/inbox-count-sse.test.ts +8 -0
  17. package/src/mcp-projects-events-http.test.ts +3 -0
  18. package/src/mcp-write-network-resolution.test.ts +15 -0
  19. package/src/network-scope.ts +24 -0
  20. package/src/node-daemon-bindings.test.ts +12 -2
  21. package/src/node-files-transport.test.ts +3 -0
  22. package/src/node-logs-transport.test.ts +3 -0
  23. package/src/node-security-write-gate.test.ts +72 -0
  24. package/src/provider-tools-shape.test.ts +16 -1
  25. package/src/requirement-participant-notify-http.test.ts +4 -0
  26. package/src/requirements-mcp.test.ts +17 -1
  27. package/src/rules-file-transport.test.ts +38 -4
  28. package/src/schedule-agent-mcp-http.test.ts +12 -1
  29. package/src/scheduled-requirement-wake-http.test.ts +5 -1
  30. package/src/server.ts +14 -5
  31. package/src/skillhub-http.test.ts +4 -2
  32. package/src/task-consumption.test.ts +6 -0
  33. package/src/task-idempotency-mcp.test.ts +6 -0
@@ -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
- test("表里的历史很旧(超过时效)⇒ 放行:节点可能已经恢复", () => {
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(true);
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
 
@@ -87,29 +87,81 @@ export const NEVER_CONSUME_STALE_MS = 2 * 60 * 60_000;
87
87
  * · 进程内计数器:本次进程内发生的最新鲜的那几条(可能在 tasks 行写之前就有)
88
88
  * · tasks 表:跨重启的历史(窗口由调用方给,默认 7 天 —— 与「节点可能恢复」同一个取舍)
89
89
  */
90
- export interface PersistentExpiryEvidence { expiries: number; last_at: string | null }
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)).toISOString().replace("T", " ").slice(0, 19);
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 consumed_at IS NULL
105
- AND created_at >= ?3`,
106
- alias, networkId, since)
147
+ WHERE to_name = ?1 AND network_id = ?2 AND status = 'expired' AND result IS NULL
148
+ AND created_at > ?3
149
+ -- #3271 后续 —— **诊断探针不算证据**:我自己派去测「它到底消不消费」的 probe,
150
+ -- 过期后与「一条真活没人接」在表里同形;用它去证明节点不行,是自证。
151
+ AND COALESCE(meta_json, '') NOT LIKE '%"probe"%'`,
152
+ alias, networkId, boundary)
107
153
  : db.get<{ n: number; last: string | null }>(
108
154
  `SELECT COUNT(*) AS n, MAX(created_at) AS last FROM tasks
109
- WHERE to_name = ?1 AND status = 'expired' AND consumed_at IS NULL
110
- AND created_at >= ?2`,
111
- alias, since);
112
- return { expiries: Number(row?.n ?? 0), last_at: row?.last ?? null };
155
+ WHERE to_name = ?1 AND status = 'expired' AND result IS NULL
156
+ AND created_at > ?2
157
+ AND COALESCE(meta_json, '') NOT LIKE '%"probe"%'`,
158
+ alias, boundary);
159
+
160
+ return {
161
+ expiries: Number(row?.n ?? 0),
162
+ last_at: row?.last ?? null,
163
+ last_reply_at: lastReplyAt,
164
+ };
113
165
  }
114
166
 
115
167
  export type NeverConsumeGate =
@@ -134,6 +186,22 @@ export function neverConsumeGate(input: {
134
186
  const fromDb = input.persistent?.expiries ?? 0;
135
187
  const expiries = Math.max(fromMemory, fromDb);
136
188
  if (expiries < limit) return { ok: true };
189
+ // DB 证据**自带边界**(「最后一次回复之后」),所以它不需要固定 TTL —— 那个 TTL 是我拍的。
190
+ // 只有「纯内存计数」这条路才需要时效:它没有回复时间可比,只能靠时长兜底。
191
+ if (fromDb >= limit) {
192
+ if (input.force && input.forceAllowed) return { ok: true };
193
+ return {
194
+ ok: false,
195
+ error: "target_never_consumes",
196
+ alias: input.alias,
197
+ expiries,
198
+ window_since: input.counters.since,
199
+ message:
200
+ `this target has ${fromDb} expired task(s) with no reply since its last reply`
201
+ + `${input.persistent?.last_reply_at ? ` (${input.persistent.last_reply_at})` : " (it has never replied)"}; `
202
+ + `nothing will queue correctly here until it replies again — pass force:true (user tokens) if you know it recovered`,
203
+ };
204
+ }
137
205
  // 2026-10-31 —— **只数不衰减会把恢复了的节点永久拉黑**。
138
206
  // 实测的教训来自另一台机(TM中转运维):连「抑制了多少」这个数本身都在被环缓冲淘汰,
139
207
  // 所以任何「累计」都只在它的窗口内可引用;这里把窗口写进判据:最近一次过期超过 TTL ⇒ 放行。
@@ -0,0 +1,103 @@
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
+ // #3271 后续 —— 诊断探针不算证据。
81
+ // 现场:我给一台节点派了 3 条 probe 去测「它到底消不消费」,其中 2 条过期 ⇒
82
+ // 「回复后无回复过期 = 2」,再涨一条就会触发闸 —— 而那一条也会是我的 probe。
83
+ // **用自己的探针去证明节点不行,是自证。** ⇒ meta_json 里带 `"probe"` 的行不参与计数。
84
+ test("🔴 meta_json 里带 probe 的过期不计入(诊断流量不是证据)", () => {
85
+ const now = Date.parse("2026-10-31T22:00:00.000Z");
86
+ db.run(
87
+ `INSERT INTO tasks (task_id, to_name, status, content, network_id, created_at, meta_json)
88
+ VALUES ('t_probe', ?1, 'expired', 'probe', ?2, '2026-10-31 09:00:00', '{"probe":true}')`,
89
+ [ALIAS, NET]);
90
+ task("t_real", "expired", "2026-10-31 10:00:00");
91
+ const ev = persistentNeverConsumedExpiries(db, ALIAS, NET, { now });
92
+ expect(ev.expiries).toBe(1); // 只剩那条真活
93
+ });
94
+
95
+ test("别的节点的账不串台", () => {
96
+ const now = Date.parse("2026-10-31T22:00:00.000Z");
97
+ db.run(
98
+ `INSERT INTO tasks (task_id, to_name, status, content, network_id, created_at)
99
+ VALUES ('t_other', 'someone-else', 'expired', 'probe', ?1, '2026-10-31 09:00:00')`, [NET]);
100
+ expect(persistentNeverConsumedExpiries(db, ALIAS, NET, { now }).expiries).toBe(0);
101
+ expect(persistentNeverConsumedExpiries(db, "someone-else", NET, { now }).expiries).toBe(1);
102
+ });
103
+ });
@@ -241,6 +241,10 @@ describe("#1440 new_task inbox_count on requeue paths", () => {
241
241
 
242
242
  const tools = buildHandlers(SENDER);
243
243
  const res = await call(tools.retry_task, { task_id: taskId, network_id: NET });
244
+ // #3275 批次 4 —— retry_task 三键(实测)。`retried_to` 是**改派后落在谁那儿**:
245
+ // 与 send_task 的 actual_to 同义,但少了它,调用方只能假设「还是原来那个」——
246
+ // 而这个假设在「原目标已下线」时正是错的那一次。
247
+ expect(Object.keys(res).sort()).toEqual(["ok", "retried_to", "task_id"]);
244
248
  expect(res.ok).toBe(true);
245
249
 
246
250
  const evt = await readFrame(reader);
@@ -281,6 +285,10 @@ describe("#1440 broadcast delivery set", () => {
281
285
 
282
286
  const tools = buildHandlers(SENDER);
283
287
  const res = await call(tools.broadcast, { message: "all hands", network_id: NET });
288
+ // #3275 批次 3 —— broadcast 回执三键:**message_ids 与 recipients 不是一回事**
289
+ // (一条消息 × N 个收件人,或 N 条消息 × 1 个收件人,取决于实现),
290
+ // 少了 recipients,调用方无法回答「谁没收到」。
291
+ expect(Object.keys(res).sort()).toEqual(["message_ids", "ok", "recipients"]);
284
292
 
285
293
  // The active recipient is served — this proves the broadcast ran, so
286
294
  // the absence checked below is "not sent", not "not yet sent"
@@ -90,6 +90,9 @@ describe("discoverable", () => {
90
90
  describe("projects_create / projects_update", () => {
91
91
  test("owner: create, rename, recolour, archive, unarchive — same rows the app sees", async () => {
92
92
  const created = await mcp(U.owner.token, "projects_create", { network_id: NET, name: "mpe-项目甲" });
93
+ // #3275 批次 4 —— projects_create 与 projects_update 同形({ok, project}):
94
+ // 「写项目」这一族回**实体**,不回集合。两个工具各自钉,不互相代言。
95
+ expect(Object.keys(created).sort()).toEqual(["ok", "project"]);
93
96
  expect(created.ok).toBe(true);
94
97
  const id = created.project.id as string;
95
98
  expect(created.project.name).toBe("mpe-项目甲");
@@ -163,6 +163,12 @@ describe("utok single-network auto-resolve (no network_id argument)", () => {
163
163
  test("send_task resolves to the only membership", async () => {
164
164
  const { tools } = buildHandlers({ userId: U_SINGLE });
165
165
  const r = await call(tools["send_task"], { alias: A1, task: "x517 g1 send_task", priority: "normal" });
166
+ // #3275 批次 2 —— 同变量口径:`send_task` 的成功回执是 7 键(实测,不是推断)。
167
+ // 这七格里 queue_ahead / target_busy / est_wait_minutes 是「建议」:
168
+ // 少一个,调用方就不知道排在第几位;多一个,客户端会多一条没人写过的分支。
169
+ expect(Object.keys(r).sort()).toEqual([
170
+ "actual_to", "est_wait_minutes", "message_id", "ok", "queue_ahead", "session_status", "target_busy",
171
+ ]);
166
172
  expect(r.ok).toBe(true);
167
173
  expect(taskRow("x517 g1 send_task")?.network_id).toBe(NET_A);
168
174
  });
@@ -170,6 +176,8 @@ describe("utok single-network auto-resolve (no network_id argument)", () => {
170
176
  test("send_message resolves to the only membership", async () => {
171
177
  const { tools } = buildHandlers({ userId: U_SINGLE });
172
178
  const r = await call(tools["send_message"], { alias: A1, message: "x517 g1 send_message" });
179
+ // #3275 批次 2 —— send_message 外层闭集(实测)
180
+ expect(Object.keys(r).sort()).toEqual(["message_id", "ok", "session_status"]);
173
181
  expect(r.ok).toBe(true);
174
182
  expect(inboxRow("x517 g1 send_message")?.network_id).toBe(NET_A);
175
183
  });
@@ -194,6 +202,9 @@ describe("utok single-network auto-resolve (no network_id argument)", () => {
194
202
  const { tools } = buildHandlers({ userId: U_SINGLE });
195
203
  const t = makeTask(A1, "delivered", "x517 g1 send_ack");
196
204
  const r = await call(tools["send_ack"], { task_id: t });
205
+ // #3275 批次 2 —— send_ack 外层闭集(实测):`updated` 是**这次是否真的改了状态**,
206
+ // 与 ok 不同(ok=调用成功);少了它,客户端分不清「已 ack」与「早就是 ack 状态」。
207
+ expect(Object.keys(r).sort()).toEqual(["ok", "task_id", "updated"]);
197
208
  expect(r.ok).toBe(true);
198
209
  expect(taskById(t)?.status).toBe("acked");
199
210
  });
@@ -221,6 +232,10 @@ describe("utok single-network auto-resolve (no network_id argument)", () => {
221
232
  const { tools } = buildHandlers({ userId: U_SINGLE });
222
233
  const t = makeTask(A1, "delivered", "x517 g1 reassign_task");
223
234
  const r = await call(tools["reassign_task"], { task_id: t, new_alias: A2 });
235
+ // #3275 批次 2 —— 同变量口径,形状由一次真实调用给出(不是按源码推断):
236
+ // 回执带**两端**(reassigned_from / reassigned_to)。少一个,调用方就不知道它是从哪来的;
237
+ // 而这两端正是「改派」与「新建」在回执上唯一可分的地方。
238
+ expect(Object.keys(r).sort()).toEqual(["ok", "reassigned_from", "reassigned_to", "task_id"]);
224
239
  expect(r.ok).toBe(true);
225
240
  expect(taskById(t)?.to_name).toBe(A2);
226
241
  });
@@ -266,6 +266,30 @@ export function canRestWriteNetwork(authCtx: { userId: string; networkId: string
266
266
  return !isAgentRestricted(authCtx.userId, networkId);
267
267
  }
268
268
 
269
+ /**
270
+ * 能不能改**节点自身的安全配置**(permission-mode / rest-allowlist / peer-allowlist)。
271
+ *
272
+ * 这一类比 canRestWriteNetwork **更严**:后者放行任何非 viewer 成员,而改白名单等于
273
+ * 改这台节点还能做什么,所以只许 节点主人 / 网络 owner / 网络 admin / Hub 管理员
274
+ * (RFC-041 §2.3 / §2.4)。
275
+ *
276
+ * 为什么单独具名而不是复用 canRestWriteNetwork:两处调用点看起来在讲同一件事
277
+ * ("谁能改这个节点"),但强度差在被调函数里 —— 合并的方向是**放宽**,不是重构。
278
+ * 具名之后,静态检查只要认一个名字;不具名时,新写的路由会照抄它附近那一行,
279
+ * 而"附近那一行"是哪一种取决于作者当时读到哪段代码。
280
+ */
281
+ export function canRestWriteNodeSecurity(
282
+ authCtx: { userId: string } | null,
283
+ ownerUserId: string | null,
284
+ networkRole: string | null,
285
+ isAdmin: boolean,
286
+ ): boolean {
287
+ if (isAdmin) return true;
288
+ if (!authCtx) return false;
289
+ if (ownerUserId && ownerUserId === authCtx.userId) return true;
290
+ return networkRole === "owner" || networkRole === "admin";
291
+ }
292
+
269
293
  /** 旧的「成员且不是 viewer」判据,不看 Agent 授权。只给人类侧写入用。 */
270
294
  export function canRestWriteNetworkAsHuman(authCtx: { userId: string; networkId: string | null } | null, networkId: string | null, isAdmin: boolean): boolean {
271
295
  if (!authCtx) return true; // legacy global token or open dev mode
@@ -61,8 +61,18 @@ test("adopted stop/start complete through existing protocol; revocation removes
61
61
  expect((await call(d.list_my_children)).children[0].lifecycle_state).toBe("stopped");
62
62
  const start = await call(u.start_node, { child_node_id: CHILD, network_id: NET }); expect(start.ok).toBe(true);
63
63
  expect((await call(d.get_start_request, { request_id: start.request_id })).ok).toBe(true);
64
- expect((await call(d.ack_start_request, { request_id: start.request_id, status: "started", child_pid: 4321 })).ok).toBe(true);
65
- expect((await call(u.unadopt_node, { node_id: CHILD })).ok).toBe(true);
64
+ // #3309 分支 —— ack_start_request 的**成功出口**(此前只钉了它的三条失败分支:
65
+ // request_not_found / not_your_request / cross_network_request)。
66
+ // 先接住再断言,形状由这次真实调用给出。
67
+ const startedAck = await call(d.ack_start_request, { request_id: start.request_id, status: "started", child_pid: 4321 });
68
+ expect(startedAck.ok).toBe(true);
69
+ expect(Object.keys(startedAck).sort()).toEqual(["ok", "status"]);
70
+ // #3275 批次 4 —— 先接住再断言(同变量口径)
71
+ const unadopted = await call(u.unadopt_node, { node_id: CHILD });
72
+ // #3275 批次 4 —— unadopt_node 两键 {ok, status}(实测):status 说明解绑后的生命周期档,
73
+ // 少了它,调用方只知「成功」,不知「现在是哪一档」。
74
+ expect(Object.keys(unadopted).sort()).toEqual(["ok", "status"]);
75
+ expect(unadopted.ok).toBe(true);
66
76
  expect((await call(d.list_my_children)).children).toHaveLength(0);
67
77
  expect((await call(u.stop_node, { child_node_id: CHILD, daemon_node_id: DAEMON, network_id: NET })).ok).toBe(false);
68
78
  });
@@ -251,6 +251,9 @@ describe("who may ask, and who may read the answer", () => {
251
251
  const other = await connect(asUserOtherLogin);
252
252
  try {
253
253
  const enq = await u.call("list_node_skills", { alias: SESSION_ALIAS });
254
+ // #3275 批次 4 —— list_node_skills 走的是**与 read/write/tail 同一条下发通道**
255
+ // (所以外层是三键 ok/op/request_id);技能清单本体在 get_rules_file_request 里回。
256
+ expect(Object.keys(enq).sort()).toEqual(["ok", "op", "request_id"]);
254
257
  expect(await other.call("get_rules_file_result", { request_id: enq.request_id })).toMatchObject({ ok: true, status: "pending" });
255
258
  } finally { await u.close(); await other.close(); }
256
259
  }, 20_000);
@@ -131,6 +131,9 @@ describe("round trip", () => {
131
131
  const a = await connect(asA);
132
132
  try {
133
133
  const enq = await u.call("tail_node_logs", { node_id: NODE_A_ID, network_id: NET, lines: 99999 > 2000 ? 2000 : 1, level: "warn", grep: "boom", since_ts: 5, path: "/etc/passwd" });
134
+ // #3275 批次 4 —— tail_node_logs 与 read_node_rules_file 是**同一套请求通道**(op 不同),
135
+ // 所以外层同形三键;钉它等于钉住「日志与规则文件共用一条下发通道」这个事实。
136
+ expect(Object.keys(enq).sort()).toEqual(["ok", "op", "request_id"]);
134
137
  expect(enq).toMatchObject({ ok: true, op: "logs_tail" });
135
138
  const pulled = (await a.call("get_rules_file_request", {})).request;
136
139
  expect(pulled.op).toBe("logs_tail");
@@ -0,0 +1,72 @@
1
+ // #3314 — 「改节点安全配置」的授权判据必须是**一个具名函数**,并且比
2
+ // 「往网络里写」更严(member 不行)。
3
+ //
4
+ // 为什么需要这条测试:这两件事在调用点长得一样(都是 `if (!<条件>) 403`),
5
+ // 而强度差在被调函数里 —— canRestWriteNetwork 放行任何非 viewer 成员,
6
+ // 改白名单则只许 节点主人 / 网络 owner / 网络 admin / Hub 管理员。
7
+ // 一旦有人为了「统一写法」把它们合并,方向是**放宽**,而放宽不会让任何
8
+ // 现有测试变红:现有夹具全是 owner / admin 探针。
9
+ //
10
+ // 所以这里直接钉两件事:
11
+ // 1. 矩阵:owner_user / network owner / network admin / hub admin 放行,
12
+ // member / viewer / 陌生人 / 无身份 拒绝;
13
+ // 2. 不对称:同一个 member 在 canRestWriteNetwork 下放行、在这条门下拒绝 ——
14
+ // 如果哪天两者相等,这条测试先红,而不是等一条新写的路由把白名单改了。
15
+
16
+ import { test } from "node:test";
17
+ import assert from "node:assert/strict";
18
+ import { canRestWriteNodeSecurity } from "./network-scope.js";
19
+
20
+ const OWNER_ID = "u-node-owner";
21
+ const ADMIN_ID = "u-node-admin";
22
+ const MEMBER_ID = "u-member";
23
+ const VIEWER_ID = "u-viewer";
24
+ const STRANGER_ID = "u-stranger";
25
+
26
+ function ctx(userId: string) {
27
+ return { userId };
28
+ }
29
+
30
+ test("node security gate: 节点主人可以改", () => {
31
+ assert.equal(canRestWriteNodeSecurity(ctx(OWNER_ID), OWNER_ID, null, false), true);
32
+ // 主人即使在该网络里没有角色(节点被挪过网络)仍然可以改自己的节点
33
+ assert.equal(canRestWriteNodeSecurity(ctx(OWNER_ID), OWNER_ID, "member", false), true);
34
+ });
35
+
36
+ test("node security gate: 网络 owner / admin 可以改别人的节点", () => {
37
+ assert.equal(canRestWriteNodeSecurity(ctx("u-net-owner"), "u-other", "owner", false), true);
38
+ assert.equal(canRestWriteNodeSecurity(ctx("u-net-admin"), "u-other", "admin", false), true);
39
+ });
40
+
41
+ test("node security gate: Hub 管理员可以改(且不依赖任何角色)", () => {
42
+ assert.equal(canRestWriteNodeSecurity(ctx(ADMIN_ID), "u-other", null, true), true);
43
+ assert.equal(canRestWriteNodeSecurity(ctx(ADMIN_ID), null, null, true), true);
44
+ });
45
+
46
+ test("node security gate: 普通成员 / viewer / 陌生人 / 无身份 全部拒绝", () => {
47
+ assert.equal(canRestWriteNodeSecurity(ctx(MEMBER_ID), "u-other", "member", false), false);
48
+ assert.equal(canRestWriteNodeSecurity(ctx(VIEWER_ID), "u-other", "viewer", false), false);
49
+ assert.equal(canRestWriteNodeSecurity(ctx(STRANGER_ID), "u-other", null, false), false);
50
+ assert.equal(canRestWriteNodeSecurity(null, "u-other", "owner", false), false);
51
+ });
52
+
53
+ test("node security gate: 孤儿节点(owner_user_id 为 null)不会被任何人「顺走」", () => {
54
+ // 没有主人的节点只能由网络 owner/admin 或 Hub 管理员改;
55
+ // 否则任意登录用户都能认领一台陌生节点的安全配置。
56
+ assert.equal(canRestWriteNodeSecurity(ctx(STRANGER_ID), null, null, false), false);
57
+ assert.equal(canRestWriteNodeSecurity(ctx("u-net-admin"), null, "admin", false), true);
58
+ });
59
+
60
+ test("node security gate 比 canRestWriteNetwork 更严:member 是分界线", async () => {
61
+ // 这条断言的意义不是「两个函数都写对了」,而是「它们**不允许**相等」。
62
+ // 若有人把它们合并成一个,下面两行里必然有一行红。
63
+ const { canRestWriteNetworkAsHuman } = await import("./network-scope.js");
64
+ // canRestWriteNetworkAsHuman 对 member 放行(!== viewer),对 stranger 拒绝。
65
+ // 这里用 userId 到一个不存在网络的方式调用,避免依赖真实 DB 角色:
66
+ // networkId=null ⇒ 非 admin 一律 false。所以真正的不对称要在有角色的网络里比,
67
+ // 那需要 DB 夹具;本测试只钉住「两者不是同一个函数」这个形状。
68
+ assert.notEqual(canRestWriteNodeSecurity, canRestWriteNetworkAsHuman);
69
+ // 纯函数层面的不对称:网络角色为 member 时,安全门拒绝(上面已断言),
70
+ // 而「写网络」那侧的判据只排除 viewer —— 记录在这里作为可读对照。
71
+ assert.equal(canRestWriteNodeSecurity(ctx(MEMBER_ID), "u-other", "member", false), false);
72
+ });
@@ -84,7 +84,16 @@ describe("provider 三件工具的形状", () => {
84
84
  const tools = handlers();
85
85
  // provider 的 secret 必须先在金库里 —— 这是工具自己的前置(实测第一次跑就撞上
86
86
  // `secret_not_in_vault`,提示原话是「upsert_network_secret first」)。
87
- const secret = await call(tools.upsert_network_secret, { network_id: NET, key: SECRET_KEY, value: "TEST-ONLY-probe-shape" });
87
+ // #3309 否定维度 —— 唯一哨兵值:它出现一次以上就说明有回显。
88
+ // 用随机后缀而不是字面量:字面量可能恰好在别处存在,会让「没回声」的断言因别的原因成立。
89
+ const SENTINEL = `SK-${Math.random().toString(36).slice(2)}-${Date.now()}`;
90
+ const secret = await call(tools.upsert_network_secret, { network_id: NET, key: SECRET_KEY, value: SENTINEL });
91
+ // #3275 批次 4 —— 写密钥的成功体**只回标识**(不回声任何值):
92
+ // 这条属性比键集本身更重要 —— 回读才回内容,写入路径永远不带值。
93
+ // 实测(首次写入):["key","ok"] —— 我按族推断多写了一个 `overwrote`,当场红。
94
+ // ⇒ 覆盖写入那条分支可能多一个字段,但**本夹具没走到,所以不声称**。
95
+ expect(Object.keys(secret).sort()).toEqual(["key", "ok"]);
96
+ expect(JSON.stringify(secret)).not.toContain(SENTINEL);
88
97
  expect(secret.ok).toBe(true);
89
98
  const up = await call(tools.upsert_provider, {
90
99
  name: "shape-provider", vendor: "anthropic", base_url: "https://api.anthropic.com",
@@ -96,8 +105,14 @@ describe("provider 三件工具的形状", () => {
96
105
  // 这个形状是对的:写入路径回**标识**,回读才回内容 —— 两件事分开,密钥那条线才不会被顺手带出来。
97
106
  expect(Object.keys(up).sort()).toEqual(["model_ids", "ok", "provider_id"]);
98
107
  expect(up.provider_id).toMatch(/^prov_/);
108
+ // #3309 否定维度 —— provider 的写回执同样不得携带密钥值(它只该带 secret_key_ref 这个名字)。
109
+ expect(JSON.stringify(up)).not.toContain(SENTINEL);
99
110
  expect(Array.isArray(up.model_ids)).toBe(true);
100
111
  expect(up.model_ids).toHaveLength(1);
112
+
113
+ // #3309 分支:upsert 的「no_changes」出口用同参再调一次**到不了** —— 实测返回
114
+ // {"ok":false,"error":…,"name":…}(重名优先于「无变化」)。要到达它需要一次以 provider_id
115
+ // 定位的更新,而本夹具没有那条路径 ⇒ **这里不声称覆盖**,登记在卡上。
101
116
  expect(up.model_ids[0]).toMatch(/^pm_/);
102
117
  });
103
118
 
@@ -231,6 +231,10 @@ describe("参与人能改的", () => {
231
231
  const no = await mcp(pat.token, "requirements_update", { id, network_id: NET, name: "改名" });
232
232
  expect(no).toMatchObject({ ok: false, error: "task_read_only", field: "name", status: 403 });
233
233
  const tog = await mcp(pat.token, "requirements_checklist_toggle", { id, network_id: NET, item_id: "i2", done: true });
234
+ // #3275 批次 2 —— 勾选清单项的外层闭集。**我先按族推断写成 {checklist, ok},实测红了**:
235
+ // 真实形状是 {ok, requirement} —— 回带的是**整张卡**,不是清单片段。
236
+ // ⇒ 这条注释就是那次推断的墓碑:同族的工具**不共享**回执形状,必须各自量。
237
+ expect(Object.keys(tog).sort()).toEqual(["ok", "requirement"]);
234
238
  expect(tog.ok).toBe(true);
235
239
  });
236
240
 
@@ -63,6 +63,9 @@ describe("requirements MCP tools", () => {
63
63
  // P0–P3:lowest(P3 极低)在建 / 改 / upsert 都能写;不认识的值在协议边界被拒
64
64
  expect((await s.call("requirements_create", { name: "x", priority: "urgent" })).mcpError).toBe(true);
65
65
  const low = await s.call("requirements_create", { name: "极低", priority: "lowest" });
66
+ // #3275 批次 2 —— 创建与更新的**外层**是同一个闭集 {ok, requirement}。
67
+ // 这两个工具是今晚我每轮都在用的写面;钉住外层之后,「顺手加一个顶层键」才会红。
68
+ expect(Object.keys(low).sort()).toEqual(["ok", "requirement"]);
66
69
  expect(low.requirement.priority).toBe("lowest");
67
70
  expect((await s.call("requirements_update", { id: low.requirement.id, priority: "high" })).requirement.priority).toBe("high");
68
71
  expect((await s.call("requirements_update", { id: low.requirement.id, priority: "lowest" })).requirement.priority).toBe("lowest");
@@ -75,9 +78,13 @@ describe("requirements MCP tools", () => {
75
78
  try {
76
79
  const ref = "github:acme/widgets#42";
77
80
  const first = await s.call("requirements_upsert_by_external_ref", { external_ref: ref, external_url: "https://github.com/acme/widgets/issues/42", name: "修复登录", description: "issue 正文", checklist: [{ id: "c1", text: "复现" }, { id: "c2", text: "修" }] });
81
+ // #3275 批次 4 —— upsert 的外层与 create/update 同族:{ok, requirement, created}
82
+ // `created` 是 upsert 独有的:调用方靠它区分「新建」与「命中已有」。
83
+ expect(Object.keys(first).sort()).toEqual(["created", "ok", "requirement"]);
78
84
  expect(first.ok).toBe(true);
79
85
  expect(first.created).toBe(true);
80
86
  const tagged = await s.call("requirements_update", { id: first.requirement.id, tags: ["release"] });
87
+ expect(Object.keys(tagged).sort()).toEqual(["ok", "requirement"]);
81
88
  expect(tagged.requirement.tags).toEqual(["release"]);
82
89
  expect(first.requirement.created_by).toEqual({ kind: "node", id: "node_gh_sync" });
83
90
  const again = await s.call("requirements_upsert_by_external_ref", { external_ref: ref, name: "修复登录(改了标题)" });
@@ -95,7 +102,16 @@ describe("requirements MCP tools", () => {
95
102
  expect((await s.call("requirements_update", { id, column: "doing", agent_owner: { kind: "node", id: "node_gh_sync" } })).requirement.column).toBe("doing");
96
103
  const ticked = await s.call("requirements_checklist_toggle", { id, item_id: "c1", done: true });
97
104
  expect(ticked.requirement.checklist.map((i: any) => i.done)).toEqual([true, false]);
98
- expect((await s.call("requirements_get", { id })).requirement.agent_owner).toEqual({ kind: "node", id: "node_gh_sync" });
105
+ // #3275 批次 2 —— 同变量口径:`requirements_get` 的**外层**是闭集,内层 requirement 是实体投影。
106
+ // 今晚我每轮都靠这个工具读卡,而它的键集从来没有被钉过:
107
+ // 少一个 `column` 前端就分不出列;多一个字段,客户端会多一条没人写过的分支。
108
+ const got = await s.call("requirements_get", { id });
109
+ expect(Object.keys(got).sort()).toEqual(["ok", "requirement"]);
110
+ expect(got.requirement.agent_owner).toEqual({ kind: "node", id: "node_gh_sync" });
111
+ // 内层必须带这几个字段(不是全键集:实体字段会随产品增长,钉**读卡必需**的那几个)
112
+ for (const k of ["id", "seq", "name", "column", "tags", "updatedAt"]) {
113
+ expect(got.requirement).toHaveProperty(k);
114
+ }
99
115
  expect((await s.call("requirements_list", { status: "doing", agent_owner: "node:node_gh_sync" })).requirements.map((r: any) => r.id)).toContain(id);
100
116
  expect((await s.call("requirements_update", { id, owner: { kind: "node", id: "node_gh_sync" }, agent_owner: null })).error).toBe("owner_must_be_human");
101
117
  expect((await s.call("requirements_update", { id, archived: true })).requirement.archived).toBe(true);