@sleep2agi/commhub-server 0.9.0-preview.247 → 0.9.0-preview.248

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/build-info.json CHANGED
@@ -1,7 +1,7 @@
1
1
  {
2
2
  "schema": 1,
3
- "commit": "4f3402b92ec816455b9976a600d98f7ae415da6b",
3
+ "commit": "2e35664f09fdf5ab46c692c3350120411e6a05dc",
4
4
  "dirty": false,
5
- "built_at": "2026-10-31T17:51:57.763Z",
5
+ "built_at": "2026-10-31T19:28:22.942Z",
6
6
  "source": "ci"
7
7
  }
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@sleep2agi/commhub-server",
3
- "version": "0.9.0-preview.247",
3
+ "version": "0.9.0-preview.248",
4
4
  "description": "CommHub Server — AI Agent communication hub with MCP protocol, multi-network isolation, user auth, and MCP tools (17 collaboration-core + node/provider ops tools; authoritative list: docs-site/docs/api/mcp-tools.md).",
5
5
  "type": "module",
6
6
  "main": "src/index.ts",
@@ -21,7 +21,13 @@ const list=(t=token)=>mcp(t,"list_my_children");
21
21
  const request=()=>mcp(owner.token,"request_adopt_node",{node_id:child,daemon_node_id:daemon,workdir:"/fixture/project"});
22
22
  const ack=(id:string,status="adopted")=>mcp(token,"ack_adopt_request",{request_id:id,status});
23
23
  const unadopt=()=>mcp(owner.token,"unadopt_node",{node_id:child});
24
- async function activate(){const r=await request();expect(r.ok).toBe(true);expect((await ack(r.request_id)).status).toBe("active");return r.request_id;}
24
+ async function activate(){
25
+ const r=await request();
26
+ // 2026-10-31 —— #3275:request_adopt_node 的形状(收养也是**下发一个请求**)。
27
+ // status 一并回来,调用方不必再查一次「这条请求现在是什么状态」。
28
+ expect(Object.keys(r).sort()).toEqual(["ok","request_id","status"]);
29
+ expect(r.ok).toBe(true);
30
+ expect((await ack(r.request_id)).status).toBe("active");return r.request_id;}
25
31
  beforeAll(async()=>{
26
32
  ({db}=await import("./db.js"));
27
33
  const {register}=await import("./auth.js");
@@ -120,6 +120,20 @@ describe("clone_node — happy path (Hub #938)", () => {
120
120
  name: "cloned-child",
121
121
  network_id: NET,
122
122
  });
123
+ // 2026-10-31 —— #3275:clone_node 的形状(此前只断言了散值)。
124
+ // 8 键,其中 contract 是**给人读的三句话**、session_contract 是**给程序读的契约**:
125
+ // contract { token, workdir, session } —— 三条「新开了什么」的散文
126
+ // session_contract { mode, runtime } —— 用来判断能不能照抄 session
127
+ // 两者都存在是有意的:散文解释给人,结构给调用方。少一个都不是「简化」,是某一方没法工作。
128
+ expect(Object.keys(r).sort()).toEqual([
129
+ "child_name", "contract", "copy_session", "daemon_node_id", "ok", "request_id",
130
+ "session_contract", "workdir_policy",
131
+ ]);
132
+ expect(Object.keys(r.contract).sort()).toEqual(["session", "token", "workdir"]);
133
+ // ⚠️ 这一条也是**真实调用**给出的:我第一版按猜测写成 [mode, runtime],
134
+ // 实际是 [detail, mode, runtime] —— 多出来的 detail 就是上面 contract.session 那句话的来源。
135
+ // (今天已经第三次栽在「按名字猜形状」上,所以这条消息留在这里当证据。)
136
+ expect(Object.keys(r.session_contract).sort()).toEqual(["detail", "mode", "runtime"]);
123
137
  expect(r.ok).toBe(true);
124
138
  expect(r.daemon_node_id).toBe(DAEMON);
125
139
  expect(r.child_name).toBe("cloned-child");
@@ -1,4 +1,6 @@
1
- // 2026-10-31 —— **本地直跑会看到 4 条红,那不是回归**(与 hub-provider-config.test.ts 同一类)。
1
+ // 2026-10-31 —— **本地直跑会看到若干条红,那不是回归**(与 hub-provider-config.test.ts 同一类)。
2
+ // ⚠️ 不要在这里写死条数:它随环境变(写下这句时是 4,同一周实测已是 6)。
3
+ // 要「几条、红在哪一档」就现跑:`scripts/run-server-tests.sh --triage daemon-provider-snapshots`
2
4
  //
3
5
  // 实测(本机,逐文件跑,独立 DB):
4
6
  // PASS 13 / FAIL 4
@@ -118,9 +120,18 @@ test('managed login: admin intent → capable target daemon → session manager
118
120
  expect((await command({ action: 'start', session_id: session, token: 'TEST-ONLY' })).ok).toBe(false);
119
121
  const start = await command({ action: 'start', session_id: session });
120
122
  expect(start.ok).toBe(true);
121
- expect((await daemon('pull_daemon_provider_snapshots', { accept_writes: true, accept_applications: true })).requests).toEqual([]);
123
+ // 2026-10-31 —— #3275:pull 的形状(本地可验的那一半)。
124
+ // ⚠️ 只钉**空结果**:非空 requests[0] 的形状要走完整条 daemon 链(容器里才有),
125
+ // 本地拿到的是空数组。把「本地能验的那一半」钉住,比按猜测写全更难被证伪。
126
+ const emptyPull = await daemon('pull_daemon_provider_snapshots', { accept_writes: true, accept_applications: true });
127
+ expect(Object.keys(emptyPull).sort()).toEqual(["ok", "requests"]);
128
+ expect(emptyPull.requests).toEqual([]);
122
129
  expect((await client('daemon', 'other')('pull_daemon_provider_snapshots', { accept_logins: true })).ok).toBe(false);
123
- expect((await daemon('ack_daemon_provider_snapshot', { request_id: start.request_id, login: { request_id: session, status: 'authenticated', token: 'TEST-ONLY' } })).ok).toBe(false);
130
+ // ack 的**拒绝**形状(真实调用给出):{ ok:false, error },且 error 是闭集里的具体码 ——
131
+ // 不是一句散文。拒绝比成功更容易在本地跑出来,所以先钉这一个方向。
132
+ const badAck = await daemon('ack_daemon_provider_snapshot', { request_id: start.request_id, login: { request_id: session, status: 'authenticated', token: 'TEST-ONLY' } });
133
+ expect(Object.keys(badAck).sort()).toEqual(["error", "ok"]);
134
+ expect(badAck).toMatchObject({ ok: false, error: "invalid_login_receipt" });
124
135
  await reconcileProviderSnapshots(deps);
125
136
  const challenge = await read(start.request_id);
126
137
  expect(challenge.status).toBe('succeeded');
@@ -0,0 +1,69 @@
1
+ // #3271 —— 「到死都没被取走」的计数:**正控 + 负数用例**。
2
+ //
3
+ // 现场:一台节点上 4 条任务,一次又一次「等满 60 分钟 ⇒ expired」,而积压数**两次读数都是 4**。
4
+ // 「又过期了一条」是可见的(Hub 会发通知),但「这台节点连续 N 次一次都没取走」没有读数。
5
+ //
6
+ // 这个计数器属于「只有异常路径能让它 +1」那一类 ⇒ 必须有 must-fire:
7
+ // ① 注入一条**未消费**就过期的任务 ⇒ 计数 +1(正控)
8
+ // ② 注入一条**已消费**后过期的任务 ⇒ 计数**不动**(负数用例)
9
+ // 少了 ②,这个计数就退化成「过期了多少条」——而那是另一个更没用的数。
10
+ import { afterAll, beforeEach, describe, expect, test } from "bun:test";
11
+ import { db } from "./db.js";
12
+ import { neverConsumedExpiryCounters, noteNeverConsumedExpiry, resetNeverConsumedExpiryCountersForTest } from "./expiry-counters.js";
13
+ import { patrolExpiredTasks } from "./server.js";
14
+
15
+ const NET = "net_expiry_cnt";
16
+
17
+ function seedTask(id: string, opts: { toName: string; consumed: boolean; expiredSecondsAgo?: number }) {
18
+ const ago = opts.expiredSecondsAgo ?? 120;
19
+ db.run(
20
+ `INSERT INTO tasks (task_id, network_id, from_name, to_name, content, status, created_at, expires_at, consumed_at)
21
+ VALUES (?1, ?2, 'sender', ?3, 'fixture', 'delivered', datetime('now', '-1 hour'), datetime('now', ?4), ?5)`,
22
+ [id, NET, opts.toName, `-${ago} seconds`, opts.consumed ? new Date(Date.now() - 3600_000).toISOString().replace("T", " ").slice(0, 19) : null],
23
+ );
24
+ }
25
+
26
+ function cleanup() {
27
+ try { db.run("DELETE FROM tasks WHERE network_id = ?1", [NET]); } catch {}
28
+ }
29
+
30
+ beforeEach(() => { cleanup(); resetNeverConsumedExpiryCountersForTest(); });
31
+ afterAll(() => { cleanup(); });
32
+
33
+ describe("#3271 从未取走过的过期计数", () => {
34
+ test("🔴 must-fire:未消费就过期的任务 ⇒ 该节点计数 +1", () => {
35
+ seedTask("t_never_1", { toName: "stuck-node", consumed: false });
36
+ patrolExpiredTasks();
37
+ const c = neverConsumedExpiryCounters();
38
+ expect(c.by_node["stuck-node"]).toBe(1);
39
+ expect(c.total).toBe(1);
40
+ expect(typeof c.since).toBe("string"); // 窗口左端必须在,否则「归零」与「没发生」同值
41
+ });
42
+
43
+ test("🔴 负数用例:**已消费**后过期的任务 ⇒ 计数不动(那不是「没人取」)", () => {
44
+ seedTask("t_consumed_1", { toName: "busy-but-alive", consumed: true });
45
+ patrolExpiredTasks();
46
+ expect(neverConsumedExpiryCounters().total).toBe(0);
47
+ });
48
+
49
+ test("按节点分桶:两个节点各一条 ⇒ 各自 1,总数 2", () => {
50
+ seedTask("t_a", { toName: "node-a", consumed: false });
51
+ seedTask("t_b", { toName: "node-b", consumed: false });
52
+ patrolExpiredTasks();
53
+ const c = neverConsumedExpiryCounters();
54
+ expect(c.by_node).toEqual({ "node-a": 1, "node-b": 1 });
55
+ expect(c.total).toBe(2);
56
+ });
57
+
58
+ test("同一个节点连续 N 次 ⇒ 累加(这是「这一台从来不吃活」的证据形态)", () => {
59
+ for (let i = 0; i < 4; i += 1) noteNeverConsumedExpiry("ghost-node");
60
+ expect(neverConsumedExpiryCounters().by_node["ghost-node"]).toBe(4);
61
+ });
62
+
63
+ test("桶按名字排序且空桶不出现 —— 读数要能直接对比两次快照", () => {
64
+ noteNeverConsumedExpiry("z-node");
65
+ noteNeverConsumedExpiry("a-node");
66
+ const c = neverConsumedExpiryCounters();
67
+ expect(Object.keys(c.by_node)).toEqual(["a-node", "z-node"]);
68
+ });
69
+ });
@@ -0,0 +1,51 @@
1
+ // 2026-10-31 —— **「这条任务到死都没被取走」要有计数**(#3271 的直接产物)。
2
+ //
3
+ // 现场:一台节点上有 4 条任务,一次又一次「等满 60 分钟 ⇒ expired」,而**积压数两次读数都是 4**。
4
+ // 「又过期了一条」是可见的(Hub 会发通知),但「这台节点连续 N 次一次都没取走」没有任何读数 ——
5
+ // 于是派单方只能靠人记住「这台不行」。
6
+ //
7
+ // 与 rejection-counters.ts 同一套约束:
8
+ // ① 按**节点**分桶,不是只有一个总数(要回答「是哪一台」)
9
+ // ② 窗口必须与 startedAt 一起读(进程重启归零,而「归零」与「没发生」同值)
10
+ // ③ 键必须有限:node id 来自我们自己的节点表,不随请求内容膨胀
11
+ //
12
+ // 🔴 最要紧的一条区分:**「过期时已经被取走过」不算「never picked up」**。
13
+ // server.ts 的 patrol 里那条注释(#500)已经写过:consumed_at < expires_at 的任务
14
+ // 只是「还没回报完成」,不是「没人取」。把它们算进来,计数就变成「过期了多少条」,
15
+ // 而那是另一个(更没用的)数。
16
+ //
17
+ // 本计数器属于「只有异常路径能让它 +1」那一类 ⇒ 必须有 must-fire:
18
+ // 注入一条真实过期(未消费)看它跳没跳,且**再注入一条已消费后过期的看它跳不跳**(负数用例)。
19
+ export type NeverConsumedExpiryCounters = {
20
+ /** 统计窗口左端(进程启动时刻,ISO)。与「归零」区分必需。 */
21
+ since: string;
22
+ /** 累计「过期且从未被取走」的任务数(所有节点)。 */
23
+ total: number;
24
+ /** 按节点分桶;键是 node alias(可读),值是计数。空桶不出现。 */
25
+ by_node: Record<string, number>;
26
+ };
27
+
28
+ const counters = new Map<string, number>();
29
+ let since = new Date().toISOString();
30
+
31
+ /** 记一次「过期且从未取走」。node 名用别名(人读),没有别名时退回 node id。 */
32
+ export function noteNeverConsumedExpiry(node: string): void {
33
+ const key = node || "(unknown)";
34
+ counters.set(key, (counters.get(key) ?? 0) + 1);
35
+ }
36
+
37
+ export function neverConsumedExpiryCounters(): NeverConsumedExpiryCounters {
38
+ let total = 0;
39
+ const by_node: Record<string, number> = {};
40
+ for (const [k, v] of [...counters.entries()].sort(([a], [b]) => a.localeCompare(b))) {
41
+ by_node[k] = v;
42
+ total += v;
43
+ }
44
+ return { since, total, by_node };
45
+ }
46
+
47
+ /** 仅测试用:清零并重置窗口。 */
48
+ export function resetNeverConsumedExpiryCountersForTest(now = new Date()): void {
49
+ counters.clear();
50
+ since = now.toISOString();
51
+ }
@@ -359,6 +359,14 @@ for (const shape of ["frozen", "legacy null", "wrong frozen", "same alias rebuil
359
359
  VALUES(?1,?2,?3,?4,?5,'fixture','{}','[]','started',?6,?7,'fixture')`,
360
360
  [`cr_${f.childId.slice(5)}`, f.daemonId, f.childAlias, f.childId, NET, childTok.tokenId, Date.now()]);
361
361
  const dispatched = await tool(ownerToken, "delete_node", { child_node_id: f.childId, daemon_node_id: f.daemonId, network_id: NET, confirm_alias: f.childAlias });
362
+ // 2026-10-31 —— #3275:delete_node 的形状(删节点是**下发**,不是立即删除)。
363
+ // in_flight_at_dispatch 是关键那一格:它告诉调用方「此刻这个节点上还有几条在飞」——
364
+ // 没有它,用户会以为删完就没在跑的任务了。
365
+ expect(Object.keys(dispatched as any).sort()).toEqual([
366
+ "action", "in_flight_at_dispatch", "lifecycle_state", "ok", "request_id",
367
+ ]);
368
+ expect((dispatched as any).action).toBe("delete");
369
+ expect((dispatched as any).lifecycle_state).toBe("deleting");
362
370
  expect(dispatched.ok).toBe(true);
363
371
  expect(db.get<{ child_token_id: string }>("SELECT child_token_id FROM node_stop_requests WHERE request_id=?1", dispatched.request_id)?.child_token_id).toBe(childTok.tokenId);
364
372
  if (shape === "legacy null" || shape === "wrong frozen") db.run("UPDATE node_stop_requests SET child_token_id=?1 WHERE request_id=?2", [shape === "wrong frozen" ? wrong.tokenId : null, dispatched.request_id]);
@@ -0,0 +1,150 @@
1
+ // #3275 —— provider 三件工具的形状:upsert_provider / probe_provider_model / get_probe_results。
2
+ //
3
+ // 为什么单独一个文件:这三件是**唯一三个在 server/src/*.test.ts 里没有任何调用点**的 MCP 工具
4
+ // (覆盖率报告里长期挂在 uncovered)。它们都要「先有 provider + model + daemon」才有东西可返回,
5
+ // 借用别人的夹具会把两个结论绑在一起 —— 所以自建最小种子。
6
+ //
7
+ // 判据:形状一律来自**真实调用**;跑不通的分支不写断言,而不是按名字猜一个(今天已经三次栽在这上面)。
8
+ import { afterAll, beforeEach, describe, expect, test } from "bun:test";
9
+ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
10
+ import { db } from "./db.js";
11
+ import { registerTools } from "./tools.js";
12
+ import { stopBackgroundProbeTimersForTest } from "./probe.js";
13
+
14
+ // 金库根密钥必须存在,否则 upsert_network_secret 直接失败(实测:第一次跑就是栽在这里)。
15
+ // 用固定测试值,且只在本进程内 —— 与 daemon-provider-snapshots.test.ts 同一做法。
16
+ process.env.ANET_HUB_SECRET_VAULT_KEY ||= "42".repeat(32);
17
+
18
+ const USER = "u_probe_shape";
19
+ const NET = "net_probe_shape";
20
+ const PROVIDER = "prov_shape";
21
+ const DAEMON = "node_probe_daemon";
22
+ const SECRET_KEY = "PROBE_SHAPE_KEY";
23
+
24
+ type ToolHandler = (args: any) => Promise<any>;
25
+ const REPLY = (body: unknown) => ({ content: [{ type: "text" as const, text: JSON.stringify(body) }] });
26
+
27
+ function handlers(): Record<string, ToolHandler> {
28
+ const server = new McpServer({ name: "test", version: "0" }) as any;
29
+ const tools: Record<string, ToolHandler> = {};
30
+ const orig = server.tool.bind(server);
31
+ server.tool = (name: string, desc: string, schema: any, handler: ToolHandler) => {
32
+ tools[name] = handler;
33
+ return orig(name, desc, schema, handler);
34
+ };
35
+ registerTools(server, undefined, NET, USER, null, false, null);
36
+ return tools;
37
+ }
38
+
39
+ async function call(handler: ToolHandler, args: any): Promise<any> {
40
+ const r = await handler(args);
41
+ return JSON.parse(r.content[0].text);
42
+ }
43
+
44
+ function seed(opts: { withProvider?: boolean } = {}) {
45
+ db.run(`INSERT INTO users (user_id, username, password_hash, role, created_at)
46
+ VALUES (?1, ?1, 'x', 'user', datetime('now'))`, [USER]);
47
+ db.run(`INSERT INTO networks (network_id, network_name, owner_id, created_at)
48
+ VALUES (?1, ?1, ?2, datetime('now'))`, [NET, USER]);
49
+ // 角色必须是 **owner**:`upsert_network_secret` 的拒绝体实测是
50
+ // { ok:false, error:"secret_owner_only", required_role:"owner", caller_role:"admin" }
51
+ // ⇒ admin 不够。这条也是真实调用给出的,不是从权限表读来的。
52
+ db.run(`INSERT INTO network_members (user_id, network_id, role, joined_at)
53
+ VALUES (?1, ?2, 'owner', datetime('now'))`, [USER, NET]);
54
+ db.run(`INSERT INTO nodes (node_id, node_name, alias, network_id, runtime, model, channels, config_snapshot,
55
+ hostname, created_at, updated_at, lifecycle_state)
56
+ VALUES (?1, 'probe-daemon', 'probe-daemon', ?2, 'claude-agent-sdk', 'm', '[]', '{}', 'host-p',
57
+ datetime('now'), datetime('now'), 'active')`, [DAEMON, NET]);
58
+ if (opts.withProvider !== false) {
59
+ db.run(`INSERT INTO providers (provider_id, network_id, name, vendor, base_url, secret_key_ref, created_at, created_by, enabled)
60
+ VALUES (?1, ?2, 'shape-provider', 'anthropic', 'https://api.anthropic.com', ?3, ?4, ?5, 1)`,
61
+ [PROVIDER, NET, SECRET_KEY, Date.now(), USER]);
62
+ db.run(`INSERT INTO provider_models (model_id, provider_id, model_name, display_name, created_at)
63
+ VALUES ('pm_shape', ?1, 'shape-model', 'Shape Model', ?2)`, [PROVIDER, Date.now()]);
64
+ }
65
+ }
66
+
67
+ function cleanup() {
68
+ for (const t of ["provider_models", "providers", "network_members", "nodes", "networks", "users"]) {
69
+ if (t === "provider_models") db.run("DELETE FROM provider_models WHERE provider_id = ?1", [PROVIDER]);
70
+ else if (t === "providers") db.run("DELETE FROM providers WHERE network_id = ?1", [NET]);
71
+ else if (t === "network_members") db.run("DELETE FROM network_members WHERE network_id = ?1", [NET]);
72
+ else if (t === "nodes") db.run("DELETE FROM nodes WHERE network_id = ?1", [NET]);
73
+ else if (t === "networks") db.run("DELETE FROM networks WHERE network_id = ?1", [NET]);
74
+ else db.run("DELETE FROM users WHERE user_id = ?1", [USER]);
75
+ }
76
+ }
77
+
78
+ beforeEach(() => { cleanup(); });
79
+ afterAll(() => { stopBackgroundProbeTimersForTest(); cleanup(); });
80
+
81
+ describe("provider 三件工具的形状", () => {
82
+ test("upsert_provider 成功体的键集(真实调用给出)", async () => {
83
+ seed({ withProvider: false });
84
+ const tools = handlers();
85
+ // provider 的 secret 必须先在金库里 —— 这是工具自己的前置(实测第一次跑就撞上
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" });
88
+ expect(secret.ok).toBe(true);
89
+ const up = await call(tools.upsert_provider, {
90
+ name: "shape-provider", vendor: "anthropic", base_url: "https://api.anthropic.com",
91
+ secret_key_ref: SECRET_KEY, network_id: NET,
92
+ models: [{ model_name: "shape-model", display_name: "Shape Model" }],
93
+ });
94
+ // 形状来自真实调用 —— 而且**纠了我一次**:我先把成功体写成 { ok, provider:{…}, models:[…] },
95
+ // 实际是三键 { ok, provider_id, model_ids }(不回声任何配置内容)。
96
+ // 这个形状是对的:写入路径回**标识**,回读才回内容 —— 两件事分开,密钥那条线才不会被顺手带出来。
97
+ expect(Object.keys(up).sort()).toEqual(["model_ids", "ok", "provider_id"]);
98
+ expect(up.provider_id).toMatch(/^prov_/);
99
+ expect(Array.isArray(up.model_ids)).toBe(true);
100
+ expect(up.model_ids).toHaveLength(1);
101
+ expect(up.model_ids[0]).toMatch(/^pm_/);
102
+ });
103
+
104
+ test("probe_provider_model 缺 model 时的拒绝体({ok,error,...})", async () => {
105
+ seed();
106
+ const tools = handlers();
107
+ const r = await call(tools.probe_provider_model, {
108
+ provider_id: PROVIDER, model_name: "no-such-model", daemon_node_id: DAEMON, network_id: NET,
109
+ });
110
+ expect(Object.keys(r).sort()).toEqual(["error", "model_name", "ok"]);
111
+ expect(r).toMatchObject({ ok: false, error: "model_not_found" });
112
+ });
113
+
114
+ test("probe_provider_model 缺 daemon 时的拒绝体", async () => {
115
+ seed();
116
+ const tools = handlers();
117
+ const r = await call(tools.probe_provider_model, {
118
+ provider_id: PROVIDER, model_name: "shape-model", daemon_node_id: "node_nope", network_id: NET,
119
+ });
120
+ expect(Object.keys(r).sort()).toEqual(["error", "ok"]);
121
+ expect(r).toMatchObject({ ok: false, error: "daemon_not_found" });
122
+ });
123
+
124
+ test("probe_provider_model 派发成功体的键集(真实调用给出)", async () => {
125
+ seed();
126
+ const tools = handlers();
127
+ const vault = await call(tools.upsert_network_secret, { network_id: NET, key: SECRET_KEY, value: "TEST-ONLY-probe-shape" });
128
+ expect(vault.ok).toBe(true);
129
+ const r = await call(tools.probe_provider_model, {
130
+ provider_id: PROVIDER, model_name: "shape-model", daemon_node_id: DAEMON, network_id: NET,
131
+ });
132
+ // 成功体是**派发凭据**,不是结果 —— 结果要去 get_probe_results 取。
133
+ // 两键:{ ok, probe_id }。与「一次调用直接返回结果」的设计相比,这个形状把
134
+ // 「下发」与「收结果」分成两次读,probe_id 是它们之间唯一的锚。
135
+ expect(Object.keys(r).sort()).toEqual(["ok", "probe_id"]);
136
+ expect(r.ok).toBe(true);
137
+ expect(r.probe_id).toMatch(/^pr_/);
138
+ });
139
+
140
+ test("get_probe_results 空历史的键集(真实调用给出)", async () => {
141
+ seed();
142
+ const tools = handlers();
143
+ const r = await call(tools.get_probe_results, { provider_id: PROVIDER, network_id: NET });
144
+ // 两键:{ ok, results }。results 是**数组**(空历史给空数组,不是 null)——
145
+ // 「没有历史」与「查不到」在这一层同形,所以判据是「ok 为真且 results 是数组」。
146
+ expect(Object.keys(r).sort()).toEqual(["ok", "results"]);
147
+ expect(r.ok).toBe(true);
148
+ expect(Array.isArray(r.results)).toBe(true);
149
+ });
150
+ });
@@ -417,11 +417,22 @@ describe("requirement_tags (MCP)", () => {
417
417
  expect((await send(admin.token, "POST", `/api/requirements/tags/create?network_id=${NET}`, { name: "MCP子", parent_id: null })).status).toBe(201);
418
418
 
419
419
  const listed = await mcp(admin.token, "requirement_tags", { action: "list" });
420
+ // 2026-10-31 —— #3275:requirement_tags 的两个动作形状都由真实调用给出。
421
+ // list 回 7 键(含 can_manage 与 counts —— 「这一页的树」与「我能不能改」是两件事,
422
+ // 客户端要同时决定怎么画和要不要画按钮);每行 6 键。
423
+ expect(Object.keys(listed).sort()).toEqual([
424
+ "can_manage", "colors", "counts", "networkId", "nodes", "ok", "tags",
425
+ ]);
426
+ expect(Object.keys((listed.nodes as any[])[0]).sort()).toEqual([
427
+ "color", "count", "depth", "name", "parent_id", "registered",
428
+ ]);
420
429
  const rows = listed.nodes as Array<{ name: string; parent_id: string | null; depth: number; registered: boolean }>;
421
430
  expect(rows.find(node => node.name === "MCP父")).toMatchObject({ parent_id: null, depth: 1, registered: true });
422
431
  expect(rows.find(node => node.name === "MCP子")).toMatchObject({ parent_id: null, depth: 1 });
423
432
 
424
433
  const moved = await mcp(admin.token, "requirement_tags", { action: "reparent", tag: "MCP子", parent: "MCP父" });
434
+ // reparent 回**四个数/名**,不回整棵树:调用方拿 affected/reparented 就能判断要不要重读。
435
+ expect(Object.keys(moved).sort()).toEqual(["affected", "ok", "op", "reparented"]);
425
436
  expect(moved).toMatchObject({ ok: true, op: "reparent", affected: 0, reparented: 1 });
426
437
  expect((await nodes(admin.token)).find(node => node.name === "MCP子")).toMatchObject({ parent_id: "MCP父", depth: 2 });
427
438
 
@@ -200,10 +200,21 @@ describe("batch interval updates (#816)", () => {
200
200
 
201
201
  test("two updates, deduplicated IDs, paused stays paused, unselected stays untouched", async () => {
202
202
  const a = (await create("b")).schedule, b = (await create("b")).schedule;
203
+ // 2026-10-31 —— #3275:schedule_batch_interval 的形状(批量接口的形状与单条不同,
204
+ // 这才是它值得单独钉的原因:**部分失败**是它独有的状态)。
205
+ // 外层 4 键 { ok, updated, failed, results }
206
+ // 每行 6 键 { schedule_id, ok, every_seconds, next_run_at, status, revision }
207
+ // ⇒ 「updated + failed == 提交的条数(去重后)」是一条守恒式:少了它没人知道有没有漏掉某一条。
203
208
  const untouched = (await create("b")).schedule;
204
209
  await mcp(node.b.token, "schedule_update", { schedule_id: b.schedule_id, status: "paused" });
205
210
  const before = Date.now();
206
211
  const result = await batch(node.b.token, [a.schedule_id, b.schedule_id, a.schedule_id]);
212
+ expect(Object.keys(result).sort()).toEqual(["failed", "ok", "results", "updated"]);
213
+ expect(Object.keys(result.results[0]).sort()).toEqual([
214
+ "every_seconds", "next_run_at", "ok", "revision", "schedule_id", "status",
215
+ ]);
216
+ expect(result.updated + result.failed).toBe(result.results.length);
217
+ expect(result.results).toHaveLength(2); // 三个 id、去重后两条
207
218
  expect(result).toMatchObject({ ok: true, updated: 2, failed: 0 });
208
219
  expect(result.results).toHaveLength(2);
209
220
  expect(result.results[0]).toMatchObject({ schedule_id: a.schedule_id, every_seconds: 600, revision: a.revision + 1, status: "active" });
@@ -140,10 +140,11 @@ describe("#690 scheduled run follows the real task lifecycle", () => {
140
140
  network_id: NET,
141
141
  attachments: [{ type: "file", file_id: "file_690_reply", name: "evidence.json", size: 12, mime: "application/json" }],
142
142
  });
143
- // 2026-10-31 —— #3275:report_completion 的形状。
144
- // ⚠️ warning 与 attachments_saved 是**条件键**(混合版本告警 / 有 artifact 时才出现);
145
- // 本夹具恰好两条都触发 ⇒ 这条断言钉的是「**条件键之外没有别的键**」,
146
- // 而不是「这两个键永远在」。
143
+ // 2026-10-31 —— #3275:**send_reply** 的形状(这里曾经写错过,见下)。
144
+ // ⚠️ 我把这段先写成了「report_completion 的形状」,而这一行的调用其实是 send_reply ——
145
+ // 两个工具的回执键集恰好相同,所以断言**照样绿**。这正是最坏的一类假证据:
146
+ // 它会对,但它说的不是它测的那件事。现在两边各自钉一次。
147
+ // warning 与 attachments_saved 是**条件键**(混合版本告警 / 有 artifact 时才出现)。
147
148
  expect(Object.keys(reply).sort()).toEqual([
148
149
  "attachments_saved", "message_id", "ok", "session_status", "warning",
149
150
  ]);
@@ -213,6 +214,19 @@ describe("#690 scheduled run follows the real task lifecycle", () => {
213
214
  result: "done",
214
215
  network_id: NET,
215
216
  });
217
+ // 2026-10-31 —— #3275:**report_completion** 在这条路径上的真实形状是 `{ ok, completion_id }`。
218
+ //
219
+ // 🔴 这一段我改了三版,每一版都错得不一样,值得留在这里:
220
+ // ① 先按 send_reply 的形状写成 5 键;因为断言挂在了**另一个用例的调用**上(两者同形),照样绿。
221
+ // ② 把断言挪到这里后立刻红 —— 说明 5 键从来不是这条路径的形状。
222
+ // ③ 我最早那次「探测」的输出(5 键)其实也打在 send_reply 上:
223
+ // patch 的定位文本在两个用例里完全相同,`replace(..., 1)` 命中的是第一个。
224
+ // ⇒ 教训:**同一文件里两段相同代码,replace 一次只会改到第一处**;
225
+ // 而「形状相同」比「形状不同」更容易让假证据活下来。
226
+ //
227
+ // 这条路径(定时任务被 report_completion 终结)回的是 completion_id;
228
+ // 走「回给某个节点」的那条路径会不会回 5 键,本地没有读数,**所以这里不写**。
229
+ expect(Object.keys(reply).sort()).toEqual(["completion_id", "ok"]);
216
230
  expect(reply.ok).toBe(true);
217
231
  expect(readRun(runId).status).toBe("replied");
218
232
  });
@@ -0,0 +1,118 @@
1
+ // #2149 的负控:**注入一个假秘密,断言它不出现在任何响应里**。
2
+ //
3
+ // 起因(#2149):TMA云鲸对 CommHub MCP 做只读扫描时收到 502,而**代理**生成的非 JSON 错误页
4
+ // 把本次请求的鉴权相关请求头回显在了正文里。那张卡的动作 2 是「修代理」,动作 3 是
5
+ // 「用注入的假秘密做负控:构造 502/超时/上游断开,断言响应与日志均无原值」。
6
+ //
7
+ // 代理不在本仓,但**本仓自己能承诺的那一半**同样需要负控:hub 自己的每一条错误路径
8
+ // 都不能回显 Authorization / 请求体里的口令。没有这条负控时,「我们没写这种代码」
9
+ // 与「我们写了但没人试过」在报告上同形。
10
+ //
11
+ // 判据:假秘密带随机后缀 ⇒ 一次真调用后,响应体、响应头、以及本进程的 stderr 都不含它。
12
+ import { afterAll, beforeAll, describe, expect, test } from "bun:test";
13
+ import { mkdtempSync, rmSync } from "node:fs";
14
+ import { tmpdir } from "node:os";
15
+ import { join } from "node:path";
16
+ import { register } from "./auth.js";
17
+
18
+ const DIR = mkdtempSync(join(tmpdir(), "anet-secret-echo-"));
19
+ const STAMP = () => `${Date.now().toString(36)}${Math.random().toString(36).slice(2, 10)}`;
20
+ let BASE = "";
21
+ let hub: any = null;
22
+ let USER = "";
23
+ const PW = "SecretEchoPassw0rd!x";
24
+
25
+ /** 每个用例自己造一个秘密:带随机后缀,确保它不可能「碰巧」出现在任何固定文案里。 */
26
+ const secret = () => `sk-ECHO-${STAMP()}`;
27
+
28
+ type Reply = { status: number; text: string; headers: string[] };
29
+
30
+ async function raw(path: string, init: RequestInit = {}): Promise<Reply> {
31
+ const res = await fetch(`${BASE}${path}`, init);
32
+ const text = await res.text();
33
+ return { status: res.status, text, headers: [...res.headers].map(([k, v]) => `${k}: ${v}`) };
34
+ }
35
+
36
+ function assertNoEcho(reply: Reply, needle: string, label: string) {
37
+ const where: string[] = [];
38
+ if (reply.text.includes(needle)) where.push("body");
39
+ if (reply.headers.join("\n").includes(needle)) where.push("headers");
40
+ expect({ label, leakedIn: where }).toEqual({ label, leakedIn: [] });
41
+ }
42
+
43
+ beforeAll(async () => {
44
+ process.env.COMMHUB_DB ||= join(DIR, "hub.db");
45
+ process.env.COMMHUB_UPLOADS_DIR = join(DIR, "uploads");
46
+ process.env.HOST = "127.0.0.1";
47
+ process.env.COMMHUB_LOGIN_IP_MAX = "1000";
48
+ USER = `echo_user_${Date.now()}`;
49
+ register(USER, PW);
50
+ const mod: any = await import("./server.js");
51
+ hub = mod.bootServer({ port: 0, hostname: "127.0.0.1" });
52
+ BASE = `http://127.0.0.1:${hub.port}`;
53
+ }, 30_000);
54
+
55
+ afterAll(() => {
56
+ try { hub?.stop?.(true); } catch {}
57
+ try { rmSync(DIR, { recursive: true, force: true }); } catch {}
58
+ });
59
+
60
+ describe("#2149 负控:注入的假秘密不得被回显", () => {
61
+ test("无效 Bearer token ⇒ 401 的回显里没有 token 原值", async () => {
62
+ const s = secret();
63
+ const r = await raw("/api/status", { headers: { Authorization: `Bearer ${s}` } });
64
+ expect(r.status).toBe(401);
65
+ assertNoEcho(r, s, "invalid bearer");
66
+ });
67
+
68
+ test("无效 token 打 MCP ⇒ 错误信封里没有 token 原值", async () => {
69
+ const s = secret();
70
+ const r = await raw("/mcp", {
71
+ method: "POST",
72
+ headers: { Authorization: `Bearer ${s}`, "Content-Type": "application/json", Accept: "application/json, text/event-stream" },
73
+ body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "tools/list", params: {} }),
74
+ });
75
+ expect(r.status).toBeGreaterThanOrEqual(400);
76
+ assertNoEcho(r, s, "mcp invalid bearer");
77
+ });
78
+
79
+ test("坏 JSON 请求体里塞秘密 ⇒ 400 的回显里没有正文原值", async () => {
80
+ const s = secret();
81
+ const r = await raw("/api/auth/login", {
82
+ method: "POST",
83
+ headers: { "Content-Type": "application/json" },
84
+ body: `{"username":"${USER}","password":"${s}",`, // 故意截断
85
+ });
86
+ expect(r.status).toBe(400);
87
+ assertNoEcho(r, s, "malformed json body");
88
+ });
89
+
90
+ test("口令错误的登录 ⇒ 401 的回显里没有口令原值", async () => {
91
+ const s = secret();
92
+ const r = await raw("/api/auth/login", {
93
+ method: "POST",
94
+ headers: { "Content-Type": "application/json" },
95
+ body: JSON.stringify({ username: USER, password: s }),
96
+ });
97
+ expect(r.status).toBe(401);
98
+ assertNoEcho(r, s, "wrong password");
99
+ });
100
+
101
+ test("未知路由 + 无效 token ⇒ 先 401(鉴权在路由匹配之前),回显里没有 token 原值", async () => {
102
+ // 实测:这里拿到的是 **401 而不是 404** —— 鉴权在路由匹配之前。
103
+ // 顺带说明一件事(值得记):无凭证的调用方无法通过状态码区分「路由不存在」与「路由存在但要鉴权」,
104
+ // 这是**探测面变小**,不是缺陷。所以我不断言 404,只断言「不许回显」。
105
+ const s = secret();
106
+ const r = await raw("/api/definitely-not-a-route", { headers: { Authorization: `Bearer ${s}` } });
107
+ expect(r.status).toBe(401);
108
+ assertNoEcho(r, s, "unknown route");
109
+ });
110
+
111
+ test("节点令牌打需要 user token 的端点 ⇒ 403 的回显里没有令牌原值", async () => {
112
+ // 这条覆盖的是「鉴权投影」这一层:拒绝消息会不会把调用方凭证带出来。
113
+ const s = secret();
114
+ const r = await raw("/api/providers", { headers: { Authorization: `Bearer ${s}` } });
115
+ expect([401, 403]).toContain(r.status);
116
+ assertNoEcho(r, s, "user-token-only endpoint");
117
+ });
118
+ });
package/src/server.ts CHANGED
@@ -122,6 +122,7 @@ import { createProductionSideThreadTransport } from "./side-thread-production.js
122
122
  import { parseHubTimestamp } from "./hub-timestamp";
123
123
  import { logTaskRejection } from "./task-rejection-log.js";
124
124
  import { taskRejectionCounters } from "./rejection-counters.js";
125
+ import { neverConsumedExpiryCounters, noteNeverConsumedExpiry } from "./expiry-counters.js";
125
126
  import { legacyLicenseField, licenseStateOf } from "./license-state.js";
126
127
  import { AVATAR_FIELD, avatarUrl, inspectAvatarImage, isMultipart, isValidAvatarVersion, MAX_AVATAR_BYTES, MAX_AVATAR_STORAGE_BYTES } from "./user-avatar-image.js";
127
128
 
@@ -1889,7 +1890,7 @@ export function patrolExpiredTasks(): void {
1889
1890
  // report_status match. Leave it for the node to finish. A consumed_at
1890
1891
  // stamped AFTER the deadline (late receipt replay) does not save it.
1891
1892
  const due = db.all<ExpiredTaskRow>(
1892
- `SELECT task_id, network_id, from_name, from_node_id, to_name, content, created_at, expires_at, parent_task_id, meta_json
1893
+ `SELECT task_id, network_id, from_name, from_node_id, to_name, to_node_id, content, created_at, expires_at, consumed_at, parent_task_id, meta_json
1893
1894
  FROM tasks
1894
1895
  WHERE expires_at IS NOT NULL AND expires_at < datetime('now')
1895
1896
  AND status IN ('created', 'delivered')
@@ -1924,7 +1925,15 @@ export function patrolExpiredTasks(): void {
1924
1925
  });
1925
1926
  if (expired.length > 0) {
1926
1927
  console.log(`[patrol] expired ${expired.length} stale task(s)`);
1927
- for (const task of expired) logTaskEvent(task.task_id, null, "expired", "patrol");
1928
+ for (const task of expired) {
1929
+ logTaskEvent(task.task_id, null, "expired", "patrol");
1930
+ // #3271 —— 只数「**从未取走**」那一批(consumed_at 为空)。
1931
+ // 取走过但没回报完成的(consumed_at < expires_at)不是「没人取」,把它们算进来,
1932
+ // 这个计数就退化成「过期了多少条」——那是另一个更没用的数。
1933
+ if ((task as any).consumed_at === undefined || (task as any).consumed_at === null) {
1934
+ noteNeverConsumedExpiry((task as any).to_name || (task as any).to_node_id || "(unknown)");
1935
+ }
1936
+ }
1928
1937
  // #500 — tell the sender, after commit (task-expiry-notice.ts).
1929
1938
  const notices = notifyExpiredTasks(expired);
1930
1939
  if (notices.length > 0) console.log(`[patrol] sent ${notices.length} expiry notice(s)`);
@@ -3820,7 +3829,12 @@ return Bun.serve({
3820
3829
  // 🔴 必须带窗口:计数器随进程重启归零,而「归零」与「没有发生」在读数上同值。
3821
3830
  // 所以它和 startedAt 一起读 —— 窗口 = [startedAt, now]。
3822
3831
  // (历史教训:拿累计值除以 uptime 当速率 ⇒ 分母与分子不独立 ⇒ 刚重启必假阳性。)
3823
- counters: { since: startedAtIso, task_rejections: taskRejectionCounters() },
3832
+ counters: {
3833
+ since: startedAtIso,
3834
+ task_rejections: taskRejectionCounters(),
3835
+ // #3271 —— 「到死都没被取走」按节点分桶。窗口用同一个 since。
3836
+ task_expiries_never_consumed: neverConsumedExpiryCounters(),
3837
+ },
3824
3838
  // #496 — public, stable capability data. Dashboard upload proxies
3825
3839
  // need the Hub's real limits before opening a streaming request;
3826
3840
  // duplicating these constants client-side creates a silent
@@ -218,7 +218,15 @@ describe("task consumed_at identity and lifecycle", () => {
218
218
  test("runtime submission is visible without claiming authoritative consumption", async () => {
219
219
  const taskId = await createTask("vendor request accepted but no turn event yet");
220
220
  const handler = toolsFor({ alias: NODE_A, nodeToken: true }).mark_tasks_runtime_submitted;
221
- expect((await call(handler, { task_ids: [taskId] })).ok).toBe(true);
221
+ const submitted = await call(handler, { task_ids: [taskId] });
222
+ // 2026-10-31 —— #3275:mark_tasks_runtime_submitted 的形状(此前只断言 ok)。
223
+ // 外层两键;每个 evidence 行 5 键 —— 其中 consumed_at 与 runtime_submitted_at **同时存在**
224
+ // 是有意的:这一条工具只推进「提交到运行时」,不推进「消费」。
225
+ expect(Object.keys(submitted).sort()).toEqual(["ok", "tasks"]);
226
+ expect(Object.keys(submitted.tasks[0]).sort()).toEqual([
227
+ "consumed_at", "runtime_submitted_at", "task_id", "thread_id", "turn_id",
228
+ ]);
229
+ expect(submitted.ok).toBe(true);
222
230
  expect(typeof runtimeSubmittedAt(taskId)).toBe("string");
223
231
  expect(consumedAt(taskId)).toBeNull();
224
232
  });
@@ -33,6 +33,9 @@ export type ExpiredTaskRow = {
33
33
  from_name: string | null;
34
34
  from_node_id: string | null;
35
35
  to_name: string;
36
+ /** #3271 —— 有它才能区分「从未取走」与「取走过但没回报完成」。可空:老查询不带这一列。 */
37
+ consumed_at?: string | null;
38
+ to_node_id?: string | null;
36
39
  content: string | null;
37
40
  created_at: string | null;
38
41
  expires_at: string | null;