@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.
- package/build-info.json +2 -2
- package/package.json +1 -1
- package/src/agent-acl-http.test.ts +5 -0
- package/src/agent-acl-slice3-http.test.ts +168 -0
- package/src/api-nodes-shape.test.ts +38 -2
- package/src/auth-abuse-counters.test.ts +125 -0
- package/src/auth-abuse-counters.ts +122 -0
- package/src/binding-generation-http.test.ts +10 -1
- package/src/clone-node.test.ts +7 -0
- package/src/create-node-blocked-gate.test.ts +9 -0
- package/src/create-node-error-domain.test.ts +124 -0
- package/src/daemon-provider-snapshots.test.ts +9 -1
- package/src/daemon-token-owner-http.test.ts +54 -0
- package/src/departments-agent-count.test.ts +7 -0
- package/src/departments-mcp-error-domain.test.ts +135 -0
- package/src/expiry-counters.ts +6 -2
- package/src/expiry-evidence-db.test.ts +15 -0
- package/src/inbox-count-sse.test.ts +8 -0
- package/src/list-ack-error-domain.test.ts +108 -0
- package/src/mcp-projects-events-http.test.ts +3 -0
- package/src/mcp-write-network-resolution.test.ts +15 -0
- package/src/network-scope.ts +24 -0
- package/src/node-daemon-bindings.test.ts +12 -2
- package/src/node-files-transport.test.ts +3 -0
- package/src/node-logs-transport.test.ts +3 -0
- package/src/node-security-write-gate.test.ts +72 -0
- package/src/probe-provider-error-domain.test.ts +141 -0
- package/src/provider-skill-error-domain.test.ts +130 -0
- package/src/provider-tools-shape.test.ts +16 -1
- package/src/requirement-participant-notify-http.test.ts +4 -0
- package/src/requirements-mcp.test.ts +17 -1
- package/src/rules-file-transport.test.ts +38 -4
- package/src/schedule-agent-mcp-http.test.ts +12 -1
- package/src/scheduled-requirement-wake-http.test.ts +5 -1
- package/src/server.ts +25 -5
- package/src/skillhub-http.test.ts +4 -2
- package/src/start-request-error-domain.test.ts +182 -0
- package/src/start-skill-error-domain.test.ts +122 -0
- package/src/task-consumption.test.ts +6 -0
- package/src/task-idempotency-mcp.test.ts +6 -0
- package/src/task-not-found-error-domain.test.ts +76 -0
- 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
|
-
|
|
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
|
+
});
|
package/src/expiry-counters.ts
CHANGED
|
@@ -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
|
});
|