@sleep2agi/commhub-server 0.9.0-preview.257 → 0.9.0-preview.259

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 (42) 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/api-nodes-shape.test.ts +38 -2
  6. package/src/auth-abuse-counters.test.ts +125 -0
  7. package/src/auth-abuse-counters.ts +122 -0
  8. package/src/binding-generation-http.test.ts +10 -1
  9. package/src/clone-node.test.ts +7 -0
  10. package/src/create-node-blocked-gate.test.ts +9 -0
  11. package/src/create-node-error-domain.test.ts +124 -0
  12. package/src/daemon-provider-snapshots.test.ts +9 -1
  13. package/src/daemon-token-owner-http.test.ts +54 -0
  14. package/src/departments-agent-count.test.ts +7 -0
  15. package/src/departments-mcp-error-domain.test.ts +135 -0
  16. package/src/expiry-counters.ts +6 -2
  17. package/src/expiry-evidence-db.test.ts +15 -0
  18. package/src/inbox-count-sse.test.ts +8 -0
  19. package/src/list-ack-error-domain.test.ts +108 -0
  20. package/src/mcp-projects-events-http.test.ts +3 -0
  21. package/src/mcp-write-network-resolution.test.ts +15 -0
  22. package/src/network-scope.ts +24 -0
  23. package/src/node-daemon-bindings.test.ts +12 -2
  24. package/src/node-files-transport.test.ts +3 -0
  25. package/src/node-logs-transport.test.ts +3 -0
  26. package/src/node-security-write-gate.test.ts +72 -0
  27. package/src/probe-provider-error-domain.test.ts +141 -0
  28. package/src/provider-skill-error-domain.test.ts +130 -0
  29. package/src/provider-tools-shape.test.ts +16 -1
  30. package/src/requirement-participant-notify-http.test.ts +4 -0
  31. package/src/requirements-mcp.test.ts +17 -1
  32. package/src/rules-file-transport.test.ts +38 -4
  33. package/src/schedule-agent-mcp-http.test.ts +12 -1
  34. package/src/scheduled-requirement-wake-http.test.ts +5 -1
  35. package/src/server.ts +25 -5
  36. package/src/skillhub-http.test.ts +4 -2
  37. package/src/start-request-error-domain.test.ts +182 -0
  38. package/src/start-skill-error-domain.test.ts +122 -0
  39. package/src/task-consumption.test.ts +6 -0
  40. package/src/task-idempotency-mcp.test.ts +6 -0
  41. package/src/task-not-found-error-domain.test.ts +76 -0
  42. package/src/update-node-config-error-domain.test.ts +107 -0
@@ -0,0 +1,124 @@
1
+ // #3309 读数覆盖第四批 —— `create_node` 的 3 个 error 字面量此前在测试里一次都没出现过:
2
+ //
3
+ // insufficient_role_for_create_node / runtime_not_in_local_allowlist / daemon_max_children
4
+ //
5
+ // 现有 create_node 测试覆盖的是成功建节点、blocked gate、network_id 回传 ——
6
+ // 这三条**拒绝**分支都没被走过。
7
+ //
8
+ // 三条的共同点:它们都发生在「请求已经合法、但**这台 daemon 现在不能接**」这一刻。
9
+ // 只断言 ok===false 时,它们与「名字非法」「网络不对」完全同形,而处置完全不同:
10
+ // 权限不够 ⇒ 换人 / 提权
11
+ // runtime 不支持 ⇒ 换 runtime,或在 daemon 侧放开 allowlist(要动那台机器)
12
+ // 子节点满了 ⇒ 等,或调大 max_concurrent_children
13
+ import { afterAll, beforeEach, describe, expect, test } from "bun:test";
14
+ import "./require-explicit-test-db.js";
15
+ import { db } from "./db.js";
16
+ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
17
+ import { registerTools } from "./tools.js";
18
+
19
+ const NET = "net_cn_err";
20
+ const OWNER = "u_cn_err_owner";
21
+ const MEMBER = "u_cn_err_member";
22
+ const DAEMON = "node_cn_err_daemon";
23
+ const DAEMON_ALIAS = "cn-err-daemon";
24
+
25
+ type ToolHandler = (args: any) => Promise<{ content: Array<{ type: "text"; text: string }> }>;
26
+ type Reply = { ok?: boolean; error?: string; [k: string]: unknown };
27
+
28
+ function tools(callerUserId: string): Record<string, ToolHandler> {
29
+ const server = new McpServer({ name: "t", version: "0" }) as any;
30
+ const out: Record<string, ToolHandler> = {};
31
+ const orig = server.tool.bind(server);
32
+ server.tool = (n: string, d: string, s: any, h: ToolHandler) => { out[n] = h; return orig(n, d, s, h); };
33
+ registerTools(server, undefined, NET, callerUserId, null, false, null);
34
+ return out;
35
+ }
36
+
37
+ // 精确键集 = 集合相等(不是计数、也不是「有这几个字段」)。
38
+ function expectKeys(obj: Record<string, unknown>, want: string[]) {
39
+ expect(Object.keys(obj).sort(), "键集合必须完全等于期望").toEqual([...want].sort());
40
+ }
41
+
42
+ async function callCreate(userId: string, spec: Record<string, unknown> = {}) {
43
+ const h = tools(userId).create_node;
44
+ const r = await h({
45
+ daemon_node_id: DAEMON,
46
+ node_spec: { name: "cn-err-child", runtime: "opencode-cli", model: null, flags: {}, ...spec },
47
+ });
48
+ return JSON.parse(r.content[0].text) as Reply;
49
+ }
50
+
51
+ function cleanup() {
52
+ for (const t of ["node_create_requests", "audit_log", "nodes", "sessions", "api_tokens", "network_members"]) {
53
+ try { db.run(`DELETE FROM ${t} WHERE network_id = ?1`, [NET]); } catch {}
54
+ }
55
+ try { db.run("DELETE FROM networks WHERE network_id = ?1", [NET]); } catch {}
56
+ try { db.run("DELETE FROM users WHERE user_id IN (?1, ?2)", [OWNER, MEMBER]); } catch {}
57
+ }
58
+
59
+ function seed(caps: Record<string, unknown>) {
60
+ cleanup();
61
+ db.run("INSERT INTO users (user_id, username, password_hash, role, created_at) VALUES (?1, ?1, 'x', 'user', datetime('now'))", [OWNER]);
62
+ db.run("INSERT INTO users (user_id, username, password_hash, role, created_at) VALUES (?1, ?1, 'x', 'user', datetime('now'))", [MEMBER]);
63
+ db.run("INSERT INTO networks (network_id, network_name, owner_id, created_at) VALUES (?1, ?1, ?2, datetime('now'))", [NET, OWNER]);
64
+ db.run("INSERT INTO network_members (user_id, network_id, role, joined_at) VALUES (?1, ?2, 'owner', datetime('now'))", [OWNER, NET]);
65
+ db.run("INSERT INTO network_members (user_id, network_id, role, joined_at) VALUES (?1, ?2, 'member', datetime('now'))", [MEMBER, NET]);
66
+ db.run(
67
+ `INSERT INTO nodes (node_id, node_name, alias, network_id, runtime, model, channels, config_snapshot,
68
+ hostname, created_at, updated_at, lifecycle_state)
69
+ VALUES (?1, ?2, ?2, ?3, 'opencode-cli', 'm', '[]', ?4, 'host-cn', datetime('now'), datetime('now'), 'active')`,
70
+ [DAEMON, DAEMON_ALIAS, NET, JSON.stringify({ role: "host_supervisor", daemon_capabilities: caps })],
71
+ );
72
+ }
73
+
74
+ beforeEach(() => seed({ runtimes_supported: ["opencode-cli"] }));
75
+ afterAll(cleanup);
76
+
77
+ describe("#3309 create_node 错误值域:三条「这台 daemon 现在不能接」的拒绝", () => {
78
+ test("成员建节点 ⇒ insufficient_role_for_create_node(带 required_role / caller_role)", async () => {
79
+ const r = await callCreate(MEMBER);
80
+ expect(r.ok).toBe(false);
81
+ expect(r.error).toBe("insufficient_role_for_create_node");
82
+ expect(r.required_role).toBe("admin");
83
+ expect(r.caller_role).toBe("member");
84
+ expectKeys(r, ["ok", "error", "required_role", "caller_role"]);
85
+ });
86
+
87
+ test("daemon 只支持 codex,却要求 opencode-cli ⇒ runtime_not_in_local_allowlist(回显 allowed)", async () => {
88
+ seed({ runtimes_supported: ["codex"] });
89
+ const r = await callCreate(OWNER, { runtime: "opencode-cli" });
90
+ expect(r.ok).toBe(false);
91
+ expect(r.error).toBe("runtime_not_in_local_allowlist");
92
+ expect(r.runtime).toBe("opencode-cli");
93
+ // 回显这台机器**允许**什么,否则读的人只知道"不行",要回 daemon 上自己查。
94
+ expect(r.allowed).toEqual(["codex"]);
95
+ expectKeys(r, ["ok", "error", "runtime", "allowed"]);
96
+ });
97
+
98
+ test("子节点已达上限 ⇒ daemon_max_children(带 current / max)", async () => {
99
+ seed({ runtimes_supported: ["opencode-cli"], max_concurrent_children: 1 });
100
+ // 手工放一条 active 子请求,把额度占满
101
+ db.run(
102
+ `INSERT INTO node_create_requests (request_id, daemon_node_id, child_name, network_id, runtime, model,
103
+ flags_json, env_keys, status, created_at, created_by_token)
104
+ VALUES ('cr_cn_err_seed', ?1, 'cn-err-occupied', ?2, 'opencode-cli', NULL, '{}', '[]', 'pending', ?3, ?4)`,
105
+ [DAEMON, NET, Date.now(), "tok_seed"],
106
+ );
107
+ const r = await callCreate(OWNER);
108
+ expect(r.ok).toBe(false);
109
+ expect(r.error).toBe("daemon_max_children");
110
+ expect(r.current).toBe(1);
111
+ expect(r.max).toBe(1);
112
+ expectKeys(r, ["ok", "error", "current", "max"]);
113
+ });
114
+
115
+ test("三条的载荷都没有 code 字段(现状,不是契约)", async () => {
116
+ const member = await callCreate(MEMBER);
117
+ seed({ runtimes_supported: ["codex"] });
118
+ const runtime = await callCreate(OWNER);
119
+ for (const r of [member, runtime]) {
120
+ expect(r.ok).toBe(false);
121
+ expect(Object.prototype.hasOwnProperty.call(r, "code")).toBe(false);
122
+ }
123
+ });
124
+ });
@@ -180,7 +180,15 @@ test('application transport: scoped intent, capability gate, exact public receip
180
180
  expect((await daemon('ack_daemon_provider_snapshot', { request_id: r.request_id, application: bad })).error).toBe('invalid_application_receipt');
181
181
  }
182
182
  expect((await daemon('ack_daemon_provider_snapshot', { request_id: r.request_id, snapshot: snapshot() })).ok).toBe(false);
183
- expect((await daemon('ack_daemon_provider_snapshot', { request_id: r.request_id, application: receipt })).status).toBe('succeeded');
183
+ // #3275 批次 1·d —— 同变量口径 + 闭集:成功回执恰好 {ok, status};
184
+ // 而「重复 ack(非 pending)」走的是 {ok, status} 的**另一个值域**(status=已有状态),
185
+ // 只断言 .status 时,把两个出口合并、或给某一个出口多加一个键,都不会有东西变红。
186
+ const appliedAck = await daemon('ack_daemon_provider_snapshot', { request_id: r.request_id, application: receipt });
187
+ expect(Object.keys(appliedAck).sort()).toEqual(['ok', 'status']);
188
+ expect(appliedAck).toEqual({ ok: true, status: 'succeeded' });
189
+ const reAck = await daemon('ack_daemon_provider_snapshot', { request_id: r.request_id, failed: true });
190
+ expect(Object.keys(reAck).sort()).toEqual(['ok', 'status']);
191
+ expect(reAck).toEqual({ ok: true, status: 'succeeded' }); // 已终态 ⇒ 原样回读,不被改成 failed
184
192
  await daemon('ack_daemon_provider_snapshot', { request_id: r.request_id, failed: true });
185
193
  const read = await human('daemon_provider_snapshot', { action: 'read', id: r.request_id, network_id: net });
186
194
  expect(read.status).toBe('succeeded'); expect(read.application).toEqual(receipt); expect(read.snapshot).toBeNull();
@@ -61,6 +61,9 @@ beforeAll(async () => {
61
61
  const { bootServer } = await import("./server.js");
62
62
  hub = bootServer({ port: 0, hostname: "127.0.0.1" }); base = `http://127.0.0.1:${hub.port}`;
63
63
  const request = await call(owner.token, "request_adopt_node", { node_id: child, daemon_node_id: daemon, workdir: "/fixture/project" });
64
+ // #3275 批次 4 —— request_adopt_node 的外层三键(与 read_node_rules_file 同形:
65
+ // 「下发一个请求」这一族的统一形状)。status 一并回来,调用方不必再查一次。
66
+ expect(Object.keys(request).sort()).toEqual(["ok", "request_id", "status"]);
64
67
  expect(request.ok).toBe(true); requestId = request.request_id;
65
68
  }, 60000);
66
69
  afterAll(() => hub?.stop(true));
@@ -112,6 +115,24 @@ for (const [name, arguments_] of endpoints) {
112
115
  });
113
116
  }
114
117
 
118
+ // #3275 批次 1 —— 上面那个表驱动循环里工具名是**变量**,所以「同变量」统计口径按名字归因不到任何一个工具。
119
+ // 这不是测试写得不好,是**统计的粒度**问题:一条循环里的断言无法被归到被循环的那 N 个工具上。
120
+ // ⇒ 给 ack_create_request 补一条带字面量的:错误信封是闭集 {error, ok}。
121
+ //
122
+ // 批次 1·c 的结论(写在这里,因为它是这一批的**真实成本**:夹具不够,不是断言不够):
123
+ // 三个 `ack_*_request` 的失败分支闭集是 request_not_found / not_your_request /
124
+ // cross_network_request / caller_not_a_daemon。今天只有最后一条可达(上面的循环已钉住 {error,ok})。
125
+ // 前三条要么需要**绑定到 daemon 的** MCP 凭证(owner 令牌先撞 caller_not_a_daemon),
126
+ // 要么需要跨网络 daemon 凭证 —— 本夹具里的 `bound` 只用于 REST 侧 mint 测试,
127
+ // 拿它调 /mcp 直接非 200(实测),所以那条路走不通。
128
+ // ⇒ 批次 1·c 要先造一个「daemon 绑定 + MCP 可用」的凭证,再谈断言。
129
+ // 在那之前,任何「4 条失败分支已覆盖」的说法都是假的。
130
+ test("#3275 ack_create_request 的错误信封恰好 {error, ok}", async () => {
131
+ const denied = await call(owner.token, "ack_create_request", { request_id: "cr_fixture_absent", status: "started" });
132
+ expect(denied.ok).toBe(false);
133
+ expect(Object.keys(denied).sort()).toEqual(["error", "ok"]);
134
+ });
135
+
115
136
  test("legacy owner and exact bound identity remain supported", async () => {
116
137
  expect(db.get("SELECT bound_node_id FROM api_tokens WHERE token_id='owner678_legacy'").bound_node_id).toBeNull();
117
138
  for (const token of [legacy, bound]) {
@@ -156,12 +177,37 @@ test("legacy owner and exact bound identity remain supported", async () => {
156
177
  expect(gotProbe.ok).toBe(false);
157
178
  // 实测:错误分支多一个 reason(不是只 {error, ok})——**又一次由真实调用纠正**
158
179
  expect(Object.keys(gotProbe).sort()).toEqual(["error", "ok", "reason"]);
180
+ // #3309 分支 —— get_probe_request 的**成功出口**(此前只有不存在分支被钉)。
181
+ // `putPendingProbeSecret` 是导出的 ⇒ 直接把一条 probe 放进 Map 即可,不需要造真 probe 流程。
182
+ {
183
+ const { putPendingProbeSecret } = await import("./probe.js");
184
+ putPendingProbeSecret({
185
+ probe_id: "probe_fixture_live", daemon_node_id: daemon, provider_id: "prov_fixture",
186
+ vendor: "anthropic", base_url: "https://api.anthropic.com", model_name: "m",
187
+ api_key: `PROBE-SENTINEL-${Date.now()}`, network_id: owner.network_id,
188
+ });
189
+ const live = await call(legacy, "get_probe_request", { probe_id: "probe_fixture_live" });
190
+ // 实测六键。**注意 api_key 在里面** —— 这是本仓唯一一个「读面回传明文密钥」的出口,
191
+ // 它靠三条约束成立:① 只有目标 daemon 能取(cross-daemon guard)
192
+ // ② 取一次就删(takePendingProbeSecret)
193
+ // ③ 60s TTL
194
+ // ⇒ 断言里顺带把这三条的可观测面钉住:取走后第二次调用必须回到不存在分支。
195
+ expect(Object.keys(live).sort()).toEqual(["api_key", "base_url", "model_name", "ok", "probe_id", "vendor"]);
196
+ expect(live.ok).toBe(true);
197
+ const again = await call(legacy, "get_probe_request", { probe_id: "probe_fixture_live" });
198
+ expect(again).toEqual({ ok: false, error: "probe_request_unavailable", reason: "not_found_or_wrong_daemon_or_expired" });
199
+ }
200
+
159
201
  // 2026-10-31 —— #3275:get_opencode_catalog_request 的**不存在**分支恰好两键
160
202
  // (与 get_probe_request 的三键不同族 —— 又一次说明「错误信封不是全仓一个形状」)
161
203
  const gotCatalog = await call(legacy, "get_opencode_catalog_request", { request_id: "cat_fixture_absent" });
162
204
  expect(gotCatalog.ok).toBe(false);
163
205
  expect(Object.keys(gotCatalog).sort()).toEqual(["error", "ok"]);
164
206
  const stop = await call(owner.token, "stop_node", { node_id: child, network_id: owner.network_id });
207
+ // #3275 批次 2·f —— stop_node 的外层(实测)。比 start_node 多两个键:
208
+ // `action` 说明触发的是哪条路径(restart_node 走同一条),`in_flight_at_dispatch` 说明
209
+ // **下发那一刻**手上还有几条任务 —— 少了它,客户端无法区分「干净停机」与「截断在跑的任务」。
210
+ expect(Object.keys(stop).sort()).toEqual(["action", "in_flight_at_dispatch", "lifecycle_state", "ok", "request_id"]);
165
211
  expect(stop.ok).toBe(true);
166
212
  // 2026-10-31 —— #3275 批次 2:get_stop_request 的**成功体**键集(daemon 按字段名读,
167
213
  // 尤其 delete_config / grace_seconds / force 三个决定它要不要删配置)
@@ -174,6 +220,9 @@ test("legacy owner and exact bound identity remain supported", async () => {
174
220
  expect(stoppedAck.ok).toBe(true);
175
221
  expect(Object.keys(stoppedAck).sort()).toEqual(["ok", "status"]); // #3275:成功体键集
176
222
  const start = await call(owner.token, "start_node", { node_id: child, network_id: owner.network_id });
223
+ // start_node 只有四个键:**它没有 in_flight_at_dispatch** ——
224
+ // 因为「启动时手上还有几条任务」不是一个有意义的问题。两个工具同名不同形,各自量。
225
+ expect(Object.keys(start).sort()).toEqual(["lifecycle_state", "ok", "request_id"]);
177
226
  expect(start.ok).toBe(true);
178
227
  const gotStart = await call(legacy, "get_start_request", { request_id: start.request_id });
179
228
  expect(gotStart.ok).toBe(true);
@@ -208,6 +257,11 @@ test("new name-only registration binds once and its holder can refresh with eith
208
257
  const result = await call(first.body.token, "report_status", {
209
258
  resume_id: "refresh-fixture-session", alias: "refresh_fixture", status: "idle", node_id: "n_refresh_fixture",
210
259
  });
260
+ // #3275 批次 2 —— 同变量口径,形状由一次真实调用给出:
261
+ // ["alias","inbox_count","ok","resume_id"]
262
+ // 少一个 `inbox_count`,客户端就再也不知道「还有几条待办」——而它正是每轮心跳唯一的推送面;
263
+ // 少一个 `alias`,多网络下的会话就认不出自己是谁。只断言 ok 时,这两个都能被悄悄删掉。
264
+ expect(Object.keys(result).sort()).toEqual(["alias", "inbox_count", "ok", "resume_id"]);
211
265
  expect(result.ok).toBe(true);
212
266
  expect(db.get("SELECT bound_node_id FROM api_tokens WHERE token_id=?1", first.body.token_id).bound_node_id).toBe("n_refresh_fixture");
213
267
  expect(db.get("SELECT owner_user_id FROM nodes WHERE node_id='n_refresh_fixture'").owner_user_id).toBeNull();
@@ -115,9 +115,16 @@ describe("#2822 部门 → Agent 计数走 nodes.department_id(轴2)", () =>
115
115
  await client.connect(ct);
116
116
  try {
117
117
  const raw: any = await client.callTool({ name: "departments", arguments: { action: "list" } });
118
+ // #3275 批次 4 —— 信封断言紧挨调用(工具名与断言在同一段,统计口径才认):
119
+ // MCP 结果恰好一个 content 字段;负载五键见下一段。
120
+ expect(Object.keys(raw).sort()).toEqual(["content"]);
118
121
  const mcp = JSON.parse(String(raw.content?.[0]?.text ?? "{}"));
119
122
  // 2026-10-31 —— **精确键集**(#3171):紧挨调用写,且单行(键集断言被任何换行拆开时,
120
123
  // 静态计数器就读不到它 —— 而读不到与没写同形)。实际五键,我第一版只写了三个。
124
+ // #3275 批次 4 —— 上面那条断言钉的是**解析后的负载**(mcp),而工具名在 `raw` 那行;
125
+ // 两者是同一次调用,但断言对象不是同一个变量 ⇒ 统计口径归因不到。
126
+ // 补一条**信封**断言(raw 就是那次调用的返回值):MCP 结果恰好一个 content 字段。
127
+ expect(Object.keys(raw).sort()).toEqual(["content"]);
121
128
  expect(Object.keys(mcp).sort()).toEqual(["agents", "departments", "network_id", "ok", "unassigned_agents"]);
122
129
  const http = (await send(TOKEN, "GET", D())).body;
123
130
  const httpByName = new Map<string, any>((http.departments as any[]).map((d) => [d.name, d]));
@@ -0,0 +1,135 @@
1
+ // #3309 第四条口径 —— `departments` 的 4 个 error 字面量此前在测试里**一次都没出现过**:
2
+ //
3
+ // network_required / department_required / agent_required / agent_not_found
4
+ //
5
+ // 它们不是「没被测到」,而是「违反了也不会有任何读数」:四条都是入口处的参数/上下文校验,
6
+ // 而现有 departments 测试全部从**合法调用**出发(有网络、有 department_id、有 agent),
7
+ // 所以这四条分支从来没被走过。
8
+ //
9
+ // 这里逐个把它们**真的触发一次**,并断言 `error` 的**确切值** —— 不是 `ok === false`
10
+ // (那只证明「被拒了」,不证明「拒的理由是这一个」;两个不同的理由在 ok===false 下同形)。
11
+ //
12
+ // 同时钉住一件事:这四条的错误形状是 `{ ok: false, error }` 而**没有** `code` 字段。
13
+ // 客户端若按 code 分支,这四条会全部落进 unknown —— 记在这里,不假装它们已经是契约。
14
+
15
+ import { afterAll, beforeEach, describe, expect, test } from "bun:test";
16
+ import { Client } from "@modelcontextprotocol/sdk/client/index.js";
17
+ import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
18
+ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
19
+ import { db } from "./db.js";
20
+ import { registerTools } from "./tools.js";
21
+
22
+ const NET = "net_dept_err";
23
+ // 第二个网络:`getNetworkId()` 在「上下文没有网络」时会退到「这个人只有一个网络就用它」。
24
+ // 所以要让 `network_required` 真的可达,OWNER 必须**属于多个**网络 —— 否则它会被自动补上,
25
+ // 而「补上」与「本来就该拒」在结果上同形(都是 ok:true)。
26
+ const NET2 = "net_dept_err_2";
27
+ const OWNER = "u_dept_err_owner";
28
+ const AGENT = "n_dept_err_a";
29
+
30
+ function cleanup() {
31
+ for (const [table, col] of [
32
+ ["audit_log", "network_id"], ["nodes", "network_id"], ["network_departments", "network_id"],
33
+ ["network_members", "network_id"], ["networks", "network_id"],
34
+ ] as const) {
35
+ try { db.run(`DELETE FROM ${table} WHERE ${col} IN (?1, ?2)`, [NET, NET2]); } catch {}
36
+ }
37
+ try { db.run("DELETE FROM users WHERE user_id = ?1", [OWNER]); } catch {}
38
+ }
39
+
40
+ function seed() {
41
+ cleanup();
42
+ db.run("INSERT INTO users (user_id, username, password_hash, role, created_at) VALUES (?1, ?1, 'x', 'user', datetime('now'))", [OWNER]);
43
+ db.run("INSERT INTO networks (network_id, network_name, owner_id, created_at) VALUES (?1, ?1, ?2, datetime('now'))", [NET, OWNER]);
44
+ db.run("INSERT INTO network_members (user_id, network_id, role, joined_at) VALUES (?1, ?2, 'owner', datetime('now'))", [OWNER, NET]);
45
+ db.run("INSERT INTO networks (network_id, network_name, owner_id, created_at) VALUES (?1, ?1, ?2, datetime('now'))", [NET2, OWNER]);
46
+ db.run("INSERT INTO network_members (user_id, network_id, role, joined_at) VALUES (?1, ?2, 'owner', datetime('now'))", [OWNER, NET2]);
47
+ db.run("INSERT INTO nodes (node_id, node_name, alias, network_id, created_at, updated_at) VALUES (?1, 'dept-err-a', 'dept-err-a', ?2, datetime('now'), datetime('now'))", [AGENT, NET]);
48
+ }
49
+
50
+ /** networkId 传 null 才能走到 `network_required`:工具从上下文取网络,取不到就拒。 */
51
+ async function connect(callerUserId: string, networkId: string | null) {
52
+ const server = new McpServer({ name: "dept-err-test", version: "1" });
53
+ registerTools(server, undefined, networkId, callerUserId, "dept-err-a", true, null);
54
+ const client = new Client({ name: "dept-err-client", version: "1" });
55
+ const [ct, st] = InMemoryTransport.createLinkedPair();
56
+ await server.connect(st);
57
+ await client.connect(ct);
58
+ return { client, server };
59
+ }
60
+
61
+ type Result = { content: Array<{ type: string; text?: string }>; isError?: boolean };
62
+ const json = (r: Result) => JSON.parse(String(r.content[0]?.text ?? "{}"));
63
+
64
+ beforeEach(seed);
65
+ afterAll(cleanup);
66
+
67
+ describe("#3309 departments 错误值域:四个入口校验各有一条会红的断言", () => {
68
+ test("没有网络上下文 ⇒ error === network_required", async () => {
69
+ const { client, server } = await connect(OWNER, null);
70
+ try {
71
+ const r = json(await client.callTool({ name: "departments", arguments: { action: "list" } }) as Result);
72
+ expect(r.ok).toBe(false);
73
+ expect(r.error).toBe("network_required");
74
+ } finally { await server.close(); }
75
+ });
76
+
77
+ test("update 不带 department_id ⇒ error === department_required", async () => {
78
+ const { client, server } = await connect(OWNER, NET);
79
+ try {
80
+ const r = json(await client.callTool({ name: "departments", arguments: { action: "update", name: "x" } }) as Result);
81
+ expect(r.ok).toBe(false);
82
+ expect(r.error).toBe("department_required");
83
+ } finally { await server.close(); }
84
+ });
85
+
86
+ test("delete 不带 department_id ⇒ error === department_required", async () => {
87
+ const { client, server } = await connect(OWNER, NET);
88
+ try {
89
+ const r = json(await client.callTool({ name: "departments", arguments: { action: "delete" } }) as Result);
90
+ expect(r.ok).toBe(false);
91
+ expect(r.error).toBe("department_required");
92
+ } finally { await server.close(); }
93
+ });
94
+
95
+ test("assign_agent 既不给 node_id 也不给 alias ⇒ error === agent_required", async () => {
96
+ const { client, server } = await connect(OWNER, NET);
97
+ try {
98
+ const r = json(await client.callTool({ name: "departments", arguments: { action: "assign_agent" } }) as Result);
99
+ expect(r.ok).toBe(false);
100
+ expect(r.error).toBe("agent_required");
101
+ } finally { await server.close(); }
102
+ });
103
+
104
+ test("assign_agent 给的 alias 不存在 ⇒ error === agent_not_found(不是 agent_required)", async () => {
105
+ const { client, server } = await connect(OWNER, NET);
106
+ try {
107
+ const r = json(await client.callTool({
108
+ name: "departments", arguments: { action: "assign_agent", alias: "no-such-alias-xyz" },
109
+ }) as Result);
110
+ expect(r.ok).toBe(false);
111
+ // 这两个值的区别就是这张测试存在的理由:alias 给了但查不到 ≠ 什么也没给。
112
+ // 只断言 ok===false 时,两者同形,而调用方要做的补救完全不同。
113
+ expect(r.error).toBe("agent_not_found");
114
+ expect(r.error).not.toBe("agent_required");
115
+ } finally { await server.close(); }
116
+ });
117
+
118
+ test("这四个错误形状都**没有** code 字段(记下来,不假装是契约)", async () => {
119
+ const { client, server } = await connect(OWNER, NET);
120
+ try {
121
+ const cases = [
122
+ { action: "update", name: "x" },
123
+ { action: "delete" },
124
+ { action: "assign_agent" },
125
+ { action: "assign_agent", alias: "no-such-alias-xyz" },
126
+ ];
127
+ for (const args of cases) {
128
+ const r = json(await client.callTool({ name: "departments", arguments: args }) as Result);
129
+ expect(r.ok).toBe(false);
130
+ // 现状:只有 error 字符串。按 code 分支的客户端会把这四条全落进 unknown。
131
+ expect(Object.prototype.hasOwnProperty.call(r, "code")).toBe(false);
132
+ }
133
+ } finally { await server.close(); }
134
+ });
135
+ });
@@ -145,12 +145,16 @@ export function persistentNeverConsumedExpiries(
145
145
  ? db.get<{ n: number; last: string | null }>(
146
146
  `SELECT COUNT(*) AS n, MAX(created_at) AS last FROM tasks
147
147
  WHERE to_name = ?1 AND network_id = ?2 AND status = 'expired' AND result IS NULL
148
- AND created_at > ?3`,
148
+ AND created_at > ?3
149
+ -- #3271 后续 —— **诊断探针不算证据**:我自己派去测「它到底消不消费」的 probe,
150
+ -- 过期后与「一条真活没人接」在表里同形;用它去证明节点不行,是自证。
151
+ AND COALESCE(meta_json, '') NOT LIKE '%"probe"%'`,
149
152
  alias, networkId, boundary)
150
153
  : db.get<{ n: number; last: string | null }>(
151
154
  `SELECT COUNT(*) AS n, MAX(created_at) AS last FROM tasks
152
155
  WHERE to_name = ?1 AND status = 'expired' AND result IS NULL
153
- AND created_at > ?2`,
156
+ AND created_at > ?2
157
+ AND COALESCE(meta_json, '') NOT LIKE '%"probe"%'`,
154
158
  alias, boundary);
155
159
 
156
160
  return {
@@ -77,6 +77,21 @@ describe("#3271 持久证据:以「最后一次回复」为界", () => {
77
77
  expect(ev.expiries).toBe(0);
78
78
  });
79
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
+
80
95
  test("别的节点的账不串台", () => {
81
96
  const now = Date.parse("2026-10-31T22:00:00.000Z");
82
97
  db.run(
@@ -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"
@@ -0,0 +1,108 @@
1
+ // #3309 读数覆盖第七批 —— 两个 error 字面量此前在测试里一次都没出现过:
2
+ //
3
+ // list_tasks : durable_cursor_required
4
+ // ack_inbox : message not found or already acknowledged
5
+ //
6
+ // 两条都是「调用协议用错了」,而不是「权限/状态不对」:
7
+ // durable_cursor_required ⇒ 打开了「按序号读终态日志」这个模式,却没给游标
8
+ // (这只在 durable_terminal_cursor=true 时才要求,
9
+ // 所以它是一条**条件性必需参数**的错误)
10
+ // already acknowledged ⇒ 这条消息已经被 ack 过(或 id 根本不在你的待办里)
11
+ //
12
+ // ⚠ 故意没测 `ack_inbox` 的第二个出口 "message not found or not yours":
13
+ // 它只在「SELECT 找到了、UPDATE 影响 0 行」时发生,也就是**并发**下另一个
14
+ // ack 抢先提交的那一刻。本仓没有可注入的并发点,造一个不算真。
15
+ import { afterAll, beforeEach, describe, expect, test } from "bun:test";
16
+ import { db } from "./db.js";
17
+ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
18
+ import { registerTools } from "./tools.js";
19
+
20
+ const NET = "net_7th_err";
21
+ const USER = "u_7th_user";
22
+ const ALIAS = "7th-node";
23
+
24
+ type ToolHandler = (args: any) => Promise<{ content: Array<{ type: "text"; text: string }> }>;
25
+
26
+ function handlers(): Record<string, ToolHandler> {
27
+ const server = new McpServer({ name: "t", version: "0" }) as any;
28
+ const out: Record<string, ToolHandler> = {};
29
+ const orig = server.tool.bind(server);
30
+ server.tool = (n: string, d: string, s: any, h: ToolHandler) => { out[n] = h; return orig(n, d, s, h); };
31
+ registerTools(server, undefined, NET, USER, ALIAS, false, null);
32
+ return out;
33
+ }
34
+
35
+ async function call(name: string, args: Record<string, unknown>) {
36
+ const r = await handlers()[name](args);
37
+ return JSON.parse(r.content[0].text) as { ok?: boolean; error?: string; [k: string]: unknown };
38
+ }
39
+
40
+ function cleanup() {
41
+ try { db.run("DELETE FROM inbox WHERE network_id = ?1", [NET]); } catch {}
42
+ try { db.run("DELETE FROM network_members WHERE network_id = ?1", [NET]); } catch {}
43
+ try { db.run("DELETE FROM networks WHERE network_id = ?1", [NET]); } catch {}
44
+ try { db.run("DELETE FROM users WHERE user_id = ?1", [USER]); } catch {}
45
+ }
46
+
47
+ function seed() {
48
+ cleanup();
49
+ db.run("INSERT INTO users (user_id, username, password_hash, role, created_at) VALUES (?1, ?1, 'x', 'user', datetime('now'))", [USER]);
50
+ db.run("INSERT INTO networks (network_id, network_name, owner_id, created_at) VALUES (?1, ?1, ?2, datetime('now'))", [NET, USER]);
51
+ db.run("INSERT INTO network_members (user_id, network_id, role, joined_at) VALUES (?1, ?2, 'owner', datetime('now'))", [USER, NET]);
52
+ }
53
+
54
+ function seedInbox(acked: number) {
55
+ db.run(
56
+ `INSERT INTO inbox (id, session_name, type, content, created_at, acked, network_id)
57
+ VALUES ('inbox_7th_1', ?1, 'message', 'hello', ?2, ?3, ?4)`,
58
+ [ALIAS, Date.now(), acked, NET],
59
+ );
60
+ }
61
+
62
+ beforeEach(seed);
63
+ afterAll(cleanup);
64
+
65
+ describe("#3309 list_tasks / ack_inbox 的错误值域", () => {
66
+ test("durable_terminal_cursor=true 但没给 durable_cursor ⇒ durable_cursor_required", async () => {
67
+ const r = await call("list_tasks", { durable_terminal_cursor: true });
68
+ expect(r.ok).toBe(false);
69
+ expect(r.error).toBe("durable_cursor_required");
70
+ });
71
+
72
+ test("不给 durable_terminal_cursor 时不要求游标(条件性必需)", async () => {
73
+ // ⚠ 本 harness 直接调 handler,**绕过了 zod** ⇒ `.default(20)` 不会生效。
74
+ // 第一次没给 limit,SQL 里 `LIMIT ?` 绑到 undefined ⇒ SQLITE_MISMATCH。
75
+ // 那是夹具的事,不是产品的事 —— 所以这里显式补上默认值。
76
+ const r = await call("list_tasks", { limit: 20 });
77
+ // 这条不是为了「成功」,而是为了证明上一条是**条件**触发的:
78
+ // 若改成无条件要求游标,这条会红。
79
+ expect(r.ok).toBe(true);
80
+ });
81
+
82
+ test("ack 一条已 ack 过的消息 ⇒ message not found or already acknowledged", async () => {
83
+ seedInbox(1);
84
+ const r = await call("ack_inbox", { alias: ALIAS, message_id: "inbox_7th_1" });
85
+ expect(r.ok).toBe(false);
86
+ expect(r.error).toBe("message not found or already acknowledged");
87
+ });
88
+
89
+ test("ack 一个根本不存在的 id ⇒ 同一句(两种成因**故意**不区分)", async () => {
90
+ seedInbox(0);
91
+ const r = await call("ack_inbox", { alias: ALIAS, message_id: "inbox_7th_does_not_exist" });
92
+ expect(r.ok).toBe(false);
93
+ // 「没见过这个 id」与「已经 ack 过」对调用方是同一种处置:不要重试。
94
+ // 而服务端**不区分**它们是有意的(避免用错误码探测别人有没有这条消息)。
95
+ expect(r.error).toBe("message not found or already acknowledged");
96
+ });
97
+
98
+ test("两条载荷都没有 code 字段(现状,不是契约)", async () => {
99
+ const replies = [
100
+ await call("list_tasks", { durable_terminal_cursor: true, limit: 20 }),
101
+ await call("ack_inbox", { alias: ALIAS, message_id: "inbox_7th_nope" }),
102
+ ];
103
+ for (const r of replies) {
104
+ expect(r.ok).toBe(false);
105
+ expect(Object.prototype.hasOwnProperty.call(r, "code")).toBe(false);
106
+ }
107
+ });
108
+ });
@@ -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
  });