@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
@@ -148,7 +148,11 @@ describe("#1279 authoritative scoped requirement-event wake over HTTP/MCP", () =
148
148
  expect(created.ok).toBe(true); const id = created.schedule.schedule_id;
149
149
  expect(created.schedule.schedule.requirement_wake.tag).toBe("ANet");
150
150
  expect((await mcp(nodes.b.token, "schedule_update", { schedule_id: id, schedule: { type: "interval", every_seconds: 180, requirement_wake: null } })).ok).toBe(false);
151
- expect((await mcp(nodes.a.token, "schedule_batch_interval", { schedule_ids: [id], every_seconds: 180 })).ok).toBe(true);
151
+ const bi = await mcp(nodes.a.token, "schedule_batch_interval", { schedule_ids: [id], every_seconds: 180 });
152
+ // #3275 批次 4 —— 批量改间隔是**部分成功**语义:updated / failed / results 三个一起才有意义。
153
+ // 只断言 ok 时,「失败了几条」和「分别为什么」都拿不到 —— 而批量操作恰恰最需要这个。
154
+ expect(Object.keys(bi).sort()).toEqual(["failed", "ok", "results", "updated"]);
155
+ expect(bi.ok).toBe(true);
152
156
  expect(state(id).requirement_wake_json).toBeTruthy();
153
157
  expect((await mcp(nodes.a.token, "schedule_update", { schedule_id: id, name: "metadata" })).ok).toBe(true);
154
158
  expect(state(id).requirement_wake_json).toBeTruthy();
package/src/server.ts CHANGED
@@ -44,7 +44,7 @@ import { notifyExpiredTasks, type ExpiredTaskRow } from "./task-expiry-notice.js
44
44
  import { expireStaleOpenTasks } from "./task-stale-open.js";
45
45
  import { expireDeliveredToOfflineTargets } from "./task-offline-delivery.js";
46
46
  import { flagOrphanTasks } from "./task-orphan.js";
47
- import { addAgentNetworkScope, addHumanNetworkScope, addNetworkScope, addOwnTrafficScope, addAgentTimelineScope, canRestWriteNetwork, canRestWriteNetworkAsHuman, getUserNetworkIds, resolveRestNetworkScope, resolveRestWriteNetworkId, singleNetworkId, type RestNetworkScope } from "./network-scope.js";
47
+ import { addAgentNetworkScope, addHumanNetworkScope, addNetworkScope, addOwnTrafficScope, addAgentTimelineScope, canRestWriteNetwork, canRestWriteNetworkAsHuman, canRestWriteNodeSecurity, getUserNetworkIds, resolveRestNetworkScope, resolveRestWriteNetworkId, singleNetworkId, type RestNetworkScope } from "./network-scope.js";
48
48
  import { withBusyElapsed } from "./scheduled-failure-code.js";
49
49
  import { pickAliasNetwork } from "./rest-alias-network-fallback.js";
50
50
  import { lifecycleProjections, lifecycleRequestResponse } from "./node-lifecycle-read.js";
@@ -123,6 +123,7 @@ import { parseHubTimestamp } from "./hub-timestamp";
123
123
  import { logTaskRejection } from "./task-rejection-log.js";
124
124
  import { taskRejectionCounters } from "./rejection-counters.js";
125
125
  import { neverConsumedExpiryCounters, noteNeverConsumedExpiry, neverConsumeGate, persistentNeverConsumedExpiries } from "./expiry-counters.js";
126
+ import { authAbuseSnapshot, noteLoginIpRateLimited, noteLoginLocked, noteRegisterRateLimited } from "./auth-abuse-counters.js";
126
127
  import { legacyLicenseField, licenseStateOf } from "./license-state.js";
127
128
  import { AVATAR_FIELD, avatarUrl, inspectAvatarImage, isMultipart, isValidAvatarVersion, MAX_AVATAR_BYTES, MAX_AVATAR_STORAGE_BYTES } from "./user-avatar-image.js";
128
129
 
@@ -2363,6 +2364,7 @@ return Bun.serve({
2363
2364
  if (url.pathname === "/api/auth/register" && req.method === "POST") {
2364
2365
  const clientIP = req.headers.get("x-forwarded-for")?.split(",")[0]?.trim() || "unknown";
2365
2366
  if (!checkRateLimit(clientIP, 30)) {
2367
+ noteRegisterRateLimited(clientIP);
2366
2368
  return withCors(req, Response.json({ ok: false, error: "too many requests, try again later" }, { status: 429 }));
2367
2369
  }
2368
2370
  try {
@@ -2380,6 +2382,7 @@ return Bun.serve({
2380
2382
  const ipRate = sharedLoginIpRateLimiter.check(clientIP || "unknown");
2381
2383
  if (!ipRate.allowed) {
2382
2384
  logAudit(null, null, "login_rate_limited", "auth", undefined, clientIP);
2385
+ noteLoginIpRateLimited(clientIP);
2383
2386
  return withCors(req, Response.json(
2384
2387
  { ok: false, error: "rate_limited", message: "Too many login attempts. Try again later.", retry_after_ms: ipRate.retryAfterMs },
2385
2388
  { status: 429, headers: { "Retry-After": String(Math.ceil((ipRate.retryAfterMs ?? 1000) / 1000)) } }
@@ -2390,6 +2393,7 @@ return Bun.serve({
2390
2393
  const lock = sharedLoginFailureLockout.check(body.username);
2391
2394
  if (lock.locked) {
2392
2395
  logAudit(null, body.username, "login_locked", "auth", undefined, `retry_after_ms=${lock.retryAfterMs ?? 0}`);
2396
+ noteLoginLocked(body.username);
2393
2397
  return withCors(req, Response.json(
2394
2398
  { ok: false, error: "login_locked", message: "Too many failed login attempts. Try again later.", retry_after_ms: lock.retryAfterMs },
2395
2399
  { status: 429, headers: { "Retry-After": String(Math.ceil((lock.retryAfterMs ?? 1000) / 1000)) } }
@@ -3843,6 +3847,11 @@ return Bun.serve({
3843
3847
  task_rejections: taskRejectionCounters(),
3844
3848
  // #3271 —— 「到死都没被取走」按节点分桶。窗口用同一个 since。
3845
3849
  task_expiries_never_consumed: neverConsumedExpiryCounters(),
3850
+ // #3314 B 类 —— 故意匿名的那两条路由(register / login)没有身份门,
3851
+ // 它们的健康度只能从「限流与锁定命中了几次、打到了几个不同来源」读出来。
3852
+ // 比值才是有意义的部分:命中数 ≫ 去重数 ⇒ 单点重试;两者接近 ⇒ 换 IP / 撒网。
3853
+ // 只给计数与去重数,不给 IP / 用户名的值(集合本身不出进程)。
3854
+ auth_abuse: authAbuseSnapshot(),
3846
3855
  },
3847
3856
  // 🔴 2026-10-31 —— 上面那个 counters 对象**不在匿名投影里**(PUBLIC_HEALTH_KEYS)。
3848
3857
  // 而 #3271 交付时我把「观察它有没有 fire」写成了 `/health.counters.…` ——
@@ -4055,7 +4064,7 @@ return Bun.serve({
4055
4064
  // 看不见这个节点(不在它的网络里)与不存在同一个 404。
4056
4065
  if (!node || !node.network_id || (!role && !isAdmin)) return withCors(req, Response.json({ ok: false, error: "node_not_found" }, { status: 404 }));
4057
4066
  // 节点主人、网络 owner / admin、Hub 管理员能改;部门负责人和别的成员不能(RFC-041 §2.3 / §2.4)。
4058
- if (!isAdmin && node.owner_user_id !== restAuth.userId && role !== "owner" && role !== "admin") {
4067
+ if (!canRestWriteNodeSecurity(restAuth, node.owner_user_id, role, isAdmin)) {
4059
4068
  return withCors(req, Response.json({ ok: false, error: "permission_denied", message: "only the node's owner or a network owner/admin can change its permission mode" }, { status: 403 }));
4060
4069
  }
4061
4070
  const previous = (node.permission_mode || "normal") as NodePermissionMode;
@@ -4228,7 +4237,7 @@ return Bun.serve({
4228
4237
  "SELECT node_id, network_id, owner_user_id, tool_allowlist FROM nodes WHERE node_id = ?1", nodeRef3);
4229
4238
  const role3 = node3?.network_id ? getUserNetworkRole(restAuth.userId, node3.network_id) : null;
4230
4239
  if (!node3 || !node3.network_id || (!role3 && !isAdmin)) return withCors(req, Response.json({ ok: false, error: "node_not_found" }, { status: 404 }));
4231
- if (!isAdmin && node3.owner_user_id !== restAuth.userId && role3 !== "owner" && role3 !== "admin") {
4240
+ if (!canRestWriteNodeSecurity(restAuth, node3.owner_user_id, role3, isAdmin)) {
4232
4241
  return withCors(req, Response.json({ ok: false, error: "permission_denied", message: "only the node's owner or a network owner/admin can change its tool allowlist" }, { status: 403 }));
4233
4242
  }
4234
4243
  const nextTools = tools.length ? JSON.stringify(tools) : null;
@@ -4262,7 +4271,7 @@ return Bun.serve({
4262
4271
  "SELECT node_id, network_id, owner_user_id, rest_allowlist FROM nodes WHERE node_id = ?1", nodeRef4);
4263
4272
  const role4 = node4?.network_id ? getUserNetworkRole(restAuth.userId, node4.network_id) : null;
4264
4273
  if (!node4 || !node4.network_id || (!role4 && !isAdmin)) return withCors(req, Response.json({ ok: false, error: "node_not_found" }, { status: 404 }));
4265
- if (!isAdmin && node4.owner_user_id !== restAuth.userId && role4 !== "owner" && role4 !== "admin") {
4274
+ if (!canRestWriteNodeSecurity(restAuth, node4.owner_user_id, role4, isAdmin)) {
4266
4275
  return withCors(req, Response.json({ ok: false, error: "permission_denied", message: "only the node's owner or a network owner/admin can change its REST allowlist" }, { status: 403 }));
4267
4276
  }
4268
4277
  const nextRoutes = routes.length ? JSON.stringify(routes) : null;
@@ -4303,7 +4312,7 @@ return Bun.serve({
4303
4312
  "SELECT node_id, network_id, owner_user_id, peer_allowlist FROM nodes WHERE node_id = ?1", nodeRef2);
4304
4313
  const role2 = node2?.network_id ? getUserNetworkRole(restAuth.userId, node2.network_id) : null;
4305
4314
  if (!node2 || !node2.network_id || (!role2 && !isAdmin)) return withCors(req, Response.json({ ok: false, error: "node_not_found" }, { status: 404 }));
4306
- if (!isAdmin && node2.owner_user_id !== restAuth.userId && role2 !== "owner" && role2 !== "admin") {
4315
+ if (!canRestWriteNodeSecurity(restAuth, node2.owner_user_id, role2, isAdmin)) {
4307
4316
  return withCors(req, Response.json({ ok: false, error: "permission_denied", message: "only the node's owner or a network owner/admin can change its peer allowlist" }, { status: 403 }));
4308
4317
  }
4309
4318
  const nextValue = peers.length ? JSON.stringify(peers) : null;
@@ -6965,6 +6974,8 @@ return Bun.serve({
6965
6974
  // 客户端在**没有 daemon 绑定**时用它当建议列表。读法同 role:快照可能是文本或对象;
6966
6975
  // 解析失败/形状不对 = 这一格没有(null),不影响整行。
6967
6976
  let opencodeCatalog: string[] | null = null;
6977
+ // null = daemon 没报采集时刻(不是「很久以前」,也不是「刚刚」)
6978
+ let opencodeCatalogSeenAt: string | null = null;
6968
6979
  let opencodeGeneration: "v1" | "v2" | null = null;
6969
6980
  let opencodeMode: string | null = null;
6970
6981
  let opencodeServer: string | null = null;
@@ -6977,6 +6988,13 @@ return Bun.serve({
6977
6988
  const raw = parsed?.opencode_catalog;
6978
6989
  if (Array.isArray(raw) && raw.every((m: unknown) => typeof m === "string" && m.length <= 400)) {
6979
6990
  opencodeCatalog = raw.slice(0, 400);
6991
+ // #3144 —— 目录是**快照**:51 个模型是刚才采集的还是三周前的,
6992
+ // 读的人此前分不出(`last_seen_at` 是节点心跳,不是采集时刻)。
6993
+ // 这里只做**投影**:daemon 报了 `opencode_catalog_seen_at` 就带出来,
6994
+ // 没报就是 null(显式三态,不塌成「很久以前」也不塌成「刚刚」)。
6995
+ const seen = parsed?.opencode_catalog_seen_at;
6996
+ opencodeCatalogSeenAt =
6997
+ typeof seen === "string" && seen.length > 0 && seen.length <= 40 ? seen : null;
6980
6998
  }
6981
6999
  // #2293 —— 客户端「Runtime · V2」和「OpenCode Server」两行要的正是快照里这三格标量。
6982
7000
  // PR #1092 之前从 `node.config_snapshot` 读,但这个端点**刻意不带整个快照**
@@ -7004,6 +7022,8 @@ return Bun.serve({
7004
7022
  attrs_revision: Number(r.attrs_revision ?? 0),
7005
7023
  role,
7006
7024
  opencode_catalog: opencodeCatalog,
7025
+ // 见上:null 表示 daemon 未上报;非 null 是它自己给的采集时刻
7026
+ opencode_catalog_seen_at: opencodeCatalogSeenAt,
7007
7027
  opencode_generation: opencodeGeneration,
7008
7028
  opencode_mode: opencodeMode,
7009
7029
  opencode_server: opencodeServer,
@@ -81,8 +81,10 @@ describe("SkillHub real Hub + SQLite", () => {
81
81
  expect(Object.keys(nodeList).sort()).toEqual(["ok", "reviewer", "skills"]);
82
82
  expect(nodeList.reviewer).toBe(false);
83
83
  // 详情未找到:只有两个键;多一个键就意味着错误响应开始夹带上下文。
84
- expect(Object.keys(await tool(nodeToken, "get_skill", { network_id: networkId, skill_id: skillId })).sort())
85
- .toEqual(["error", "ok"]);
84
+ // #3275 批次 4 —— 同变量口径:先接住再断言(内联 `Object.keys(await f())` 在语义上一样,
85
+ // 但没有任何变量名可供归因;这条改完之后,它就是一次可被引用的形状断言)。
86
+ const missing = await tool(nodeToken, "get_skill", { network_id: networkId, skill_id: skillId });
87
+ expect(Object.keys(missing).sort()).toEqual(["error", "ok"]);
86
88
  expect((await tool(nodeToken, "get_skill", { network_id: networkId, skill_id: skillId })).error).toBe("skill_not_found");
87
89
  const ownerList = await tool(ownerToken, "list_skills", { network_id: networkId, include_pending: true });
88
90
  expect(ownerList.reviewer).toBe(true);
@@ -0,0 +1,182 @@
1
+ // #3309 读数覆盖第五批 —— 四个 error 字面量此前在测试里一次都没出现过:
2
+ //
3
+ // ack_start_request : request_not_ackable / child_pid_required
4
+ // get_create_request: not_a_clone / env_blob_unavailable
5
+ //
6
+ // 这四条有一个共同形状:**请求存在、也确实是发给你的,但当前这一刻的载荷/状态不对**。
7
+ // 只断言 ok===false 时,它们与 request_not_found / not_your_request / cross_network_request
8
+ // 完全同形 —— 而前三者的处置是「换个 id / 换台机器 / 换网络」,后两者的处置是
9
+ // 「按当前状态重发」或「别按 clone 流程要」。所以必须断言确切值。
10
+ //
11
+ // ⚠ 故意没测 `request_vanished` 与 `finalize_tx_failed`:
12
+ // · 前者在代码里标着 "Should never happen given the earlier row read" ——
13
+ // 要让它发生只能伪造一个不可能的中间态(先读到行、再让行消失),
14
+ // 那种测试证明不了真实系统里的任何东西;
15
+ // · 后者要求事务里的 SQL 真的失败,而本仓没有可注入的失败点。
16
+ // 宁可写明「这两条没有读数」,也不写一条用手段造出来的绿。
17
+ import { afterAll, beforeEach, describe, expect, test } from "bun:test";
18
+ import { db } from "./db.js";
19
+ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
20
+ import { registerTools } from "./tools.js";
21
+
22
+ const NET = "net_5th_err";
23
+ const DAEMON_NODE = "node_5th_daemon";
24
+ const DAEMON_ALIAS = "5th-daemon";
25
+ const DAEMON_USER = "u_5th_owner";
26
+ const DAEMON_TOKEN = "tok_5th_daemon";
27
+
28
+ type ToolHandler = (args: any) => Promise<{ content: Array<{ type: "text"; text: string }> }>;
29
+
30
+ function cleanup() {
31
+ for (const t of ["audit_log", "node_start_requests", "node_create_requests", "nodes", "api_tokens", "network_members"]) {
32
+ try { db.run(`DELETE FROM ${t} WHERE network_id = ?1`, [NET]); } catch {}
33
+ }
34
+ try { db.run("DELETE FROM networks WHERE network_id = ?1", [NET]); } catch {}
35
+ try { db.run("DELETE FROM users WHERE user_id = ?1", [DAEMON_USER]); } catch {}
36
+ }
37
+
38
+ function seedDaemon() {
39
+ cleanup();
40
+ db.run("INSERT INTO users (user_id, username, password_hash, role, created_at) VALUES (?1, ?1, 'x', 'user', datetime('now'))", [DAEMON_USER]);
41
+ db.run("INSERT INTO networks (network_id, network_name, owner_id, created_at) VALUES (?1, ?1, ?2, datetime('now'))", [NET, DAEMON_USER]);
42
+ db.run("INSERT INTO network_members (user_id, network_id, role, joined_at) VALUES (?1, ?2, 'owner', datetime('now'))", [DAEMON_USER, NET]);
43
+ db.run(
44
+ `INSERT INTO nodes (node_id, node_name, alias, network_id, created_at, updated_at)
45
+ VALUES (?1, ?2, ?2, ?3, datetime('now'), datetime('now'))`,
46
+ [DAEMON_NODE, DAEMON_ALIAS, NET],
47
+ );
48
+ db.run(
49
+ `INSERT INTO api_tokens (token_id, user_id, network_id, scope, name, token_hash, expires_at, revoked_at)
50
+ VALUES (?1, ?2, ?3, 'network', ?4, ?5, NULL, NULL)`,
51
+ [DAEMON_TOKEN, DAEMON_USER, NET, `node:${DAEMON_ALIAS}`, `hash_${DAEMON_TOKEN}`],
52
+ );
53
+ }
54
+
55
+ function handlers(): Record<string, ToolHandler> {
56
+ const server = new McpServer({ name: "t", version: "0" }) as any;
57
+ const out: Record<string, ToolHandler> = {};
58
+ const orig = server.tool.bind(server);
59
+ server.tool = (n: string, d: string, s: any, h: ToolHandler) => { out[n] = h; return orig(n, d, s, h); };
60
+ const origReg = server.registerTool?.bind(server);
61
+ if (origReg) server.registerTool = (n: string, cfg: any, h: ToolHandler) => { out[n] = h; return origReg(n, cfg, h); };
62
+ registerTools(server, undefined, NET, DAEMON_USER, DAEMON_ALIAS, true, DAEMON_TOKEN);
63
+ return out;
64
+ }
65
+
66
+ async function call(name: string, args: Record<string, unknown>) {
67
+ const r = await handlers()[name](args);
68
+ return JSON.parse(r.content[0].text) as { ok?: boolean; error?: string; [k: string]: unknown };
69
+ }
70
+
71
+ function seedStartRequest(request_id: string, status: string) {
72
+ db.run(
73
+ `INSERT INTO node_start_requests (request_id, network_id, daemon_node_id, child_node_id, child_alias,
74
+ created_by_token, status, created_at)
75
+ VALUES (?1, ?2, ?3, ?4, 'child-5th', ?5, ?6, ?7)`,
76
+ [request_id, NET, DAEMON_NODE, `n_5th_child_${request_id}`, DAEMON_TOKEN, status, Date.now()],
77
+ );
78
+ }
79
+
80
+ function seedCreateRequest(request_id: string, opts: { status?: string; clone?: boolean } = {}) {
81
+ db.run(
82
+ `INSERT INTO node_create_requests (request_id, daemon_node_id, child_name, network_id, runtime, model,
83
+ flags_json, env_keys, status, created_at, created_by_token)
84
+ VALUES (?1, ?2, ?1, ?3, 'opencode-cli', NULL, '{}', '[]', ?4, ?5, ?6)`,
85
+ // child_name 用 request_id 本身:表上有 (daemon_node_id, child_name) 的唯一约束,
86
+ // 两条测试行共用同一个名字会 SQLITE_CONSTRAINT_UNIQUE。
87
+ [request_id, DAEMON_NODE, NET, opts.status ?? "pending", Date.now(), DAEMON_TOKEN],
88
+ );
89
+ }
90
+
91
+ beforeEach(seedDaemon);
92
+ afterAll(cleanup);
93
+
94
+ describe("#3309 ack_start_request / get_create_request 的错误值域", () => {
95
+ test("ack 一个已结束的启动请求 ⇒ request_not_ackable(带当前 status)", async () => {
96
+ seedStartRequest("sr_done", "succeeded");
97
+ const r = await call("ack_start_request", { request_id: "sr_done", status: "started", child_pid: 1234 });
98
+ expect(r.ok).toBe(false);
99
+ expect(r.error).toBe("request_not_ackable");
100
+ // 带上当前状态:只看「不可 ack」时,读的人还得回查库里那行现在是什么。
101
+ expect(r.status).toBe("succeeded");
102
+ });
103
+
104
+ test("ack started 但不给 child_pid ⇒ child_pid_required", async () => {
105
+ seedStartRequest("sr_nopid", "pending");
106
+ const r = await call("ack_start_request", { request_id: "sr_nopid", status: "started" });
107
+ expect(r.ok).toBe(false);
108
+ expect(r.error).toBe("child_pid_required");
109
+ // 与 request_not_ackable 的区别:这个请求**本来可以** ack,只是少了一个字段。
110
+ expect(r.error).not.toBe("request_not_ackable");
111
+ });
112
+
113
+ // 2026-11-01 —— **两侧写在同一条测试里**(而不是两条):
114
+ // 分在两条里时,「一条红一条绿」会产生「有一个通过」的假象;
115
+ // 而合成一条之后,互补性由这条测试自己保证。
116
+ // 代价在失败信息:所以每一条断言都带一句**指名是哪一侧**的消息。
117
+ test("clone 与 non-clone 两侧互斥(各一例,同一条测试)", async () => {
118
+ seedCreateRequest("cr_plain", { status: "pending" });
119
+ const asClone = await call("get_create_request", { request_id: "cr_plain", expect_clone: true });
120
+ expect(asClone.ok, "非 clone 请求被当成 clone 要 ⇒ 应当拒绝").toBe(false);
121
+ expect(asClone.error).toBe("not_a_clone");
122
+
123
+ seedCreateRequest("cr_isclone", { status: "pending" });
124
+ db.run("UPDATE node_create_requests SET clone_json = ?1 WHERE request_id = 'cr_isclone'",
125
+ [JSON.stringify({ from_node_id: "n_src" })]);
126
+ const asPlain = await call("get_create_request", { request_id: "cr_isclone" });
127
+ expect(asPlain.ok, "clone 请求被当成非 clone 要 ⇒ 应当拒绝").toBe(false);
128
+ expect(asPlain.error).toBe("clone_request");
129
+
130
+ // 互斥:两侧的 error 必须不同 —— 相同说明「区分」这件事根本没发生。
131
+ expect(asPlain.error).not.toBe(asClone.error);
132
+ });
133
+
134
+ test("「缺 blob」与「状态不对」两侧互斥(各一例,同一条测试)", async () => {
135
+ seedCreateRequest("cr_noblob", { status: "pending" });
136
+ const noBlob = await call("get_create_request", { request_id: "cr_noblob" });
137
+ expect(noBlob.ok, "pending 但没有 blob ⇒ 应当拒绝").toBe(false);
138
+ expect(noBlob.error).toBe("env_blob_unavailable");
139
+
140
+ seedCreateRequest("cr_delivered", { status: "delivered" });
141
+ const notPending = await call("get_create_request", { request_id: "cr_delivered" });
142
+ expect(notPending.ok, "状态不是 pending ⇒ 应当拒绝").toBe(false);
143
+ expect(notPending.error).toBe("request_not_pending");
144
+ expect(notPending.current_status).toBe("delivered");
145
+
146
+ expect(notPending.error).not.toBe(noBlob.error);
147
+ });
148
+
149
+ test("launch_verified=true 却不给有效 pid ⇒ verified_child_pid_required", async () => {
150
+ seedCreateRequest("cr_verified", { status: "delivered" });
151
+ const r = await call("ack_create_request", {
152
+ request_id: "cr_verified", status: "started", launch_verified: true,
153
+ });
154
+ expect(r.ok).toBe(false);
155
+ expect(r.error).toBe("verified_child_pid_required");
156
+ // 与 child_pid_required(ack_start_request 的那条)区别:这条只在**声明已验证**时才要求 pid,
157
+ // 不声明验证时 pid 可以缺 —— 两种「缺 pid」处置完全不同。
158
+ expect(r.error).not.toBe("child_pid_required");
159
+ });
160
+
161
+ test("不声明 launch_verified 时不要求 pid(证明上一条是条件触发的)", async () => {
162
+ seedCreateRequest("cr_unverified", { status: "delivered" });
163
+ const r = await call("ack_create_request", { request_id: "cr_unverified", status: "started" });
164
+ expect(r.error).not.toBe("verified_child_pid_required");
165
+ });
166
+
167
+ test("这四条载荷都没有 code 字段(现状,不是契约)", async () => {
168
+ seedStartRequest("sr_done2", "succeeded");
169
+ seedStartRequest("sr_nopid2", "pending");
170
+ seedCreateRequest("cr_plain2", { status: "pending" });
171
+ const replies = [
172
+ await call("ack_start_request", { request_id: "sr_done2", status: "started", child_pid: 1 }),
173
+ await call("ack_start_request", { request_id: "sr_nopid2", status: "started" }),
174
+ await call("get_create_request", { request_id: "cr_plain2", expect_clone: true }),
175
+ await call("get_create_request", { request_id: "cr_plain2" }),
176
+ ];
177
+ for (const r of replies) {
178
+ expect(r.ok).toBe(false);
179
+ expect(Object.prototype.hasOwnProperty.call(r, "code")).toBe(false);
180
+ }
181
+ });
182
+ });
@@ -0,0 +1,122 @@
1
+ // #3309 读数覆盖第八批 —— 两个 error 字面量此前在测试里一次都没出现过:
2
+ //
3
+ // get_start_request : request_not_startable
4
+ // submit_skill : node_identity_unbound
5
+ //
6
+ // 两条都是「身份/状态对了,但这一格不允许」:
7
+ // request_not_startable ⇒ 这份启动请求已经结束(succeeded/failed),不能再拉
8
+ // node_identity_unbound ⇒ 令牌自称是节点,却没有绑定任何别名 ⇒ 身份不可追溯
9
+ //
10
+ // 后者尤其值得钉住:它是**唯一一条「拒绝写入」的身份校验**,
11
+ // 而 SkillHub 的内容是永久快照 —— 让一个无法追溯身份的写入进来,
12
+ // 事后没法回答「这份技能是谁提交的」。
13
+ import { afterAll, beforeEach, describe, expect, test } from "bun:test";
14
+ import { db } from "./db.js";
15
+ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
16
+ import { registerTools } from "./tools.js";
17
+
18
+ const NET = "net_8th_err";
19
+ const USER = "u_8th_owner";
20
+ const DAEMON_NODE = "node_8th_daemon";
21
+ const DAEMON_ALIAS = "8th-daemon";
22
+ const DAEMON_TOKEN = "tok_8th_daemon";
23
+
24
+ type ToolHandler = (args: any) => Promise<{ content: Array<{ type: "text"; text: string }> }>;
25
+
26
+ /** callerAlias 传 null 才能走到 node_identity_unbound:那是「自称节点却没绑定别名」。 */
27
+ function handlers(opts: { alias?: string | null } = {}): Record<string, ToolHandler> {
28
+ const server = new McpServer({ name: "t", version: "0" }) as any;
29
+ const out: Record<string, ToolHandler> = {};
30
+ const orig = server.tool.bind(server);
31
+ server.tool = (n: string, d: string, s: any, h: ToolHandler) => { out[n] = h; return orig(n, d, s, h); };
32
+ registerTools(server, undefined, NET, USER, opts.alias === undefined ? DAEMON_ALIAS : opts.alias, true, DAEMON_TOKEN);
33
+ return out;
34
+ }
35
+
36
+ async function call(name: string, args: Record<string, unknown>, opts: { alias?: string | null } = {}) {
37
+ const r = await handlers(opts)[name](args);
38
+ return JSON.parse(r.content[0].text) as { ok?: boolean; error?: string; [k: string]: unknown };
39
+ }
40
+
41
+ function cleanup() {
42
+ for (const t of ["skillhub_skills", "node_start_requests", "nodes", "api_tokens", "network_members"]) {
43
+ try { db.run(`DELETE FROM ${t} WHERE network_id = ?1`, [NET]); } catch {}
44
+ }
45
+ try { db.run("DELETE FROM networks WHERE network_id = ?1", [NET]); } catch {}
46
+ try { db.run("DELETE FROM users WHERE user_id = ?1", [USER]); } catch {}
47
+ }
48
+
49
+ function seed() {
50
+ cleanup();
51
+ db.run("INSERT INTO users (user_id, username, password_hash, role, created_at) VALUES (?1, ?1, 'x', 'user', datetime('now'))", [USER]);
52
+ db.run("INSERT INTO networks (network_id, network_name, owner_id, created_at) VALUES (?1, ?1, ?2, datetime('now'))", [NET, USER]);
53
+ db.run("INSERT INTO network_members (user_id, network_id, role, joined_at) VALUES (?1, ?2, 'owner', datetime('now'))", [USER, NET]);
54
+ db.run(
55
+ `INSERT INTO nodes (node_id, node_name, alias, network_id, created_at, updated_at)
56
+ VALUES (?1, ?2, ?2, ?3, datetime('now'), datetime('now'))`,
57
+ [DAEMON_NODE, DAEMON_ALIAS, NET],
58
+ );
59
+ db.run(
60
+ `INSERT INTO api_tokens (token_id, user_id, network_id, scope, name, token_hash, expires_at, revoked_at)
61
+ VALUES (?1, ?2, ?3, 'network', ?4, ?5, NULL, NULL)`,
62
+ [DAEMON_TOKEN, USER, NET, `node:${DAEMON_ALIAS}`, `hash_${DAEMON_TOKEN}`],
63
+ );
64
+ }
65
+
66
+ function seedStart(request_id: string, status: string) {
67
+ db.run(
68
+ `INSERT INTO node_start_requests (request_id, network_id, daemon_node_id, child_node_id, child_alias,
69
+ created_by_token, status, created_at)
70
+ VALUES (?1, ?2, ?3, ?4, 'child-8th', ?5, ?6, ?7)`,
71
+ [request_id, NET, DAEMON_NODE, `n_8th_child_${request_id}`, DAEMON_TOKEN, status, Date.now()],
72
+ );
73
+ }
74
+
75
+ const skill = {
76
+ slug: "eighth-skill", name: "Eighth", version: "1.0.0", content: "# body",
77
+ };
78
+
79
+ beforeEach(seed);
80
+ afterAll(cleanup);
81
+
82
+ describe("#3309 get_start_request / submit_skill 的错误值域", () => {
83
+ test("拉一份已结束的启动请求 ⇒ request_not_startable(带当前 status)", async () => {
84
+ seedStart("sr_8th_done", "succeeded");
85
+ const r = await call("get_start_request", { request_id: "sr_8th_done" });
86
+ expect(r.ok).toBe(false);
87
+ expect(r.error).toBe("request_not_startable");
88
+ expect(r.status).toBe("succeeded");
89
+ // 与 request_not_found 的区别:它确实存在、也确实发给这台机器,只是已经结束了。
90
+ expect(r.error).not.toBe("request_not_found");
91
+ });
92
+
93
+ test("反向:pending 的启动请求可以拉(证明上一条是「状态」而不是「总被拒」)", async () => {
94
+ seedStart("sr_8th_pending", "pending");
95
+ const r = await call("get_start_request", { request_id: "sr_8th_pending" });
96
+ // 会不会成功取决于后续 hydration,但**不该**再是 request_not_startable。
97
+ expect(r.error).not.toBe("request_not_startable");
98
+ });
99
+
100
+ test("节点令牌却没有绑定别名 ⇒ node_identity_unbound", async () => {
101
+ const r = await call("submit_skill", skill, { alias: null });
102
+ expect(r.ok).toBe(false);
103
+ expect(r.error).toBe("node_identity_unbound");
104
+ });
105
+
106
+ test("反向:绑定了别名的节点可以提交(证明上一条是「身份」而不是「节点不能写」)", async () => {
107
+ const r = await call("submit_skill", skill);
108
+ expect(r.error).not.toBe("node_identity_unbound");
109
+ });
110
+
111
+ test("两条载荷都没有 code 字段(现状,不是契约)", async () => {
112
+ seedStart("sr_8th_done2", "succeeded");
113
+ const replies = [
114
+ await call("get_start_request", { request_id: "sr_8th_done2" }),
115
+ await call("submit_skill", skill, { alias: null }),
116
+ ];
117
+ for (const r of replies) {
118
+ expect(r.ok).toBe(false);
119
+ expect(Object.prototype.hasOwnProperty.call(r, "code")).toBe(false);
120
+ }
121
+ });
122
+ });
@@ -118,6 +118,12 @@ describe("task consumed_at identity and lifecycle", () => {
118
118
  );
119
119
  const handler = toolsFor({ alias: NODE_A, nodeToken: true }).list_tasks;
120
120
  const first = await call(handler, { from_node_id: `id_${NODE_A}`, durable_cursor: true, limit: 100 });
121
+ // #3309 分支 —— list_tasks 的两个成功出口不是同一形状:
122
+ // 非游标:{ok, tasks, …} (无 capability)
123
+ // 游标 :多一个 capability = "list_tasks.immutable-node-cursor.v1"
124
+ // 只断言 capability 的值时,「顺手把它也加到非游标那条」不会有东西变红。
125
+ // 实测五键:我按源码读成三键(漏了 count 与 stats)——又一次「按代码读会少」
126
+ expect(Object.keys(first).sort()).toEqual(["capability", "count", "next_cursor", "ok", "stats", "tasks"]);
121
127
  expect(first.capability).toBe("list_tasks.immutable-node-cursor.v1");
122
128
  expect(first.tasks).toHaveLength(100);
123
129
  const second = await call(handler, { from_node_id: `id_${NODE_A}`, durable_cursor: true, limit: 100, ...first.next_cursor });
@@ -108,6 +108,12 @@ describe("send_task durable idempotency", () => {
108
108
  const replay = await call(handler, args);
109
109
 
110
110
  expect(first.ok).toBe(true);
111
+ // #3309 分支 —— send_task 的**第二个出口**(幂等重放)此前只有 toEqual 整体比较,
112
+ // 而工具名不在那一行(`call(handler, args)`)⇒ 归因不到。补一条同变量键集:
113
+ // 重放回执比新派单少 actual_to 之外的队列建议,多 idempotent_replay / task_status。
114
+ expect(Object.keys(replay).sort()).toEqual([
115
+ "actual_to", "idempotent_replay", "message_id", "ok", "task_id", "task_status",
116
+ ]);
111
117
  expect(replay).toEqual({
112
118
  ok: true,
113
119
  message_id: first.message_id,
@@ -0,0 +1,76 @@
1
+ // #3309 读数覆盖第九批 —— 一个错误字面量,三个工具共用:
2
+ //
3
+ // "task not found" ← retry_task / get_task / reassign_task
4
+ //
5
+ // 它此前在测试里一次都没出现过。而它正是最容易一直没人断言的那一类:
6
+ // **一句读起来像文案的英文短语**。所有人都会以为它「肯定被测过」,
7
+ // 而按字符串去找,一次都没有。
8
+ //
9
+ // 为什么值得单独钉:这三个工具在「id 打错了」时都落到同一句话,
10
+ // 而它们的补救完全不同(重试另一个 id / 查另一个 id / 把它派给别人)。
11
+ // 一旦有人为了「更友好」把其中一处改成 `task_not_found`,只有断言能发现。
12
+ import { afterAll, beforeEach, describe, expect, test } from "bun:test";
13
+ import { db } from "./db.js";
14
+ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
15
+ import { registerTools } from "./tools.js";
16
+
17
+ const NET = "net_9th_err";
18
+ const USER = "u_9th_owner";
19
+ const ALIAS = "9th-node";
20
+
21
+ type ToolHandler = (args: any) => Promise<{ content: Array<{ type: "text"; text: string }> }>;
22
+
23
+ function handlers(): Record<string, ToolHandler> {
24
+ const server = new McpServer({ name: "t", version: "0" }) as any;
25
+ const out: Record<string, ToolHandler> = {};
26
+ const orig = server.tool.bind(server);
27
+ server.tool = (n: string, d: string, s: any, h: ToolHandler) => { out[n] = h; return orig(n, d, s, h); };
28
+ registerTools(server, undefined, NET, USER, ALIAS, false, null);
29
+ return out;
30
+ }
31
+
32
+ async function call(name: string, args: Record<string, unknown>) {
33
+ const r = await handlers()[name](args);
34
+ return JSON.parse(r.content[0].text) as { ok?: boolean; error?: string; [k: string]: unknown };
35
+ }
36
+
37
+ function cleanup() {
38
+ try { db.run("DELETE FROM network_members WHERE network_id = ?1", [NET]); } catch {}
39
+ try { db.run("DELETE FROM networks WHERE network_id = ?1", [NET]); } catch {}
40
+ try { db.run("DELETE FROM users WHERE user_id = ?1", [USER]); } catch {}
41
+ }
42
+
43
+ function seed() {
44
+ cleanup();
45
+ db.run("INSERT INTO users (user_id, username, password_hash, role, created_at) VALUES (?1, ?1, 'x', 'user', datetime('now'))", [USER]);
46
+ db.run("INSERT INTO networks (network_id, network_name, owner_id, created_at) VALUES (?1, ?1, ?2, datetime('now'))", [NET, USER]);
47
+ db.run("INSERT INTO network_members (user_id, network_id, role, joined_at) VALUES (?1, ?2, 'owner', datetime('now'))", [USER, NET]);
48
+ }
49
+
50
+ beforeEach(seed);
51
+ afterAll(cleanup);
52
+
53
+ describe('#3309 「task not found」:三个工具共用同一句话', () => {
54
+ test("三个工具在不存在的 id 上给出**同一句**(逐字相同)", async () => {
55
+ const missing = "task_9th_does_not_exist";
56
+ const got = [
57
+ await call("get_task", { task_id: missing }),
58
+ await call("retry_task", { task_id: missing }),
59
+ await call("reassign_task", { task_id: missing, to_name: "someone-else" }),
60
+ ];
61
+ for (const [i, r] of got.entries()) {
62
+ expect(r.ok, `第 ${i + 1} 个工具应当拒绝`).toBe(false);
63
+ // 逐字相同是**故意的**:调用方按这一句分支;改一处就多出一种拼写。
64
+ expect(r.error, `第 ${i + 1} 个工具的 error 应当是同一句`).toBe("task not found");
65
+ }
66
+ // 三处必须真的同一个字符串 —— 任何一个被「统一成 code」都会让这条红。
67
+ expect(new Set(got.map((r) => r.error)).size, "三个工具不该给出不同拼写").toBe(1);
68
+ });
69
+
70
+ test("这句话**带空格**(不是 code 风格)—— 现状,记下来", async () => {
71
+ const r = await call("get_task", { task_id: "task_9th_missing" });
72
+ // 带空格的值最容易被当成文案而没人断言;这条测试存在的理由是把它钉成契约。
73
+ expect(String(r.error)).toContain(" ");
74
+ expect(String(r.error)).not.toMatch(/^[a-z0-9_]+$/);
75
+ });
76
+ });