@sleep2agi/commhub-server 0.9.0-preview.178 → 0.9.0-preview.179

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/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@sleep2agi/commhub-server",
3
- "version": "0.9.0-preview.178",
3
+ "version": "0.9.0-preview.179",
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",
@@ -0,0 +1,97 @@
1
+ // #2720 复盘 —— 一次**我判断错了**的根因,钉成合同测试。
2
+ //
3
+ // 背景:我看 `/api/requirements/{tags,stats,people,people/directory}` 这四个只读端点
4
+ // 用的是 `resolveRestWriteNetworkId`(写解析器),于是一口咬定「非 admin 会员只要
5
+ // 请求里不带 network_id 就会 400 network_id_required」,还为此写了一个新的
6
+ // `resolveRestReadNetworkId` 想放宽它。
7
+ //
8
+ // 通信设计师 要求用**真实链路**复证,不要手搓 scope。复证结果:
9
+ //
10
+ // 请求不带 network_id,走 resolveRestNetworkScope(null, auth, false):
11
+ // 非 admin 单网络 → scope.networkIds = [NET_A] ⇒ 写解析器第一行的
12
+ // singleNetworkId(scope) 就已经返回 NET_A —— **根本不会 400**
13
+ // 非 admin 双网络 → scope.networkIds = [NET_A,NET_B] ⇒ null(歧义,确实 400)
14
+ // admin 单网络 → scope.networkIds = null ⇒ 回退成员关系,返回 NET_A
15
+ //
16
+ // ⇒ 那个「读解析器」在所有真实输入下与写解析器**结果完全相同**,是纯 no-op。
17
+ // 我当初的测试把非 admin 的 auth 配上 `{networkIds: null}`(真实链路不会产出的组合),
18
+ // 等于自己造故障再修故障 —— 所以那个 PR 已关闭,这里只留**真实链路**的断言。
19
+ //
20
+ // 这条测试的价值不是「证明代码对」,是**钉住真实的解析顺序**,让下一次想「放宽读权限」
21
+ // 的人先看到:单网络用户本来就没被拦,真正 400 的只有多网络且没显式指定的人。
22
+ //
23
+ // Run: COMMHUB_DB=/tmp/2720-real-chain.db bun test src/rest-read-network-real-chain.test.ts
24
+
25
+ import { afterAll, beforeEach, describe, expect, test } from "bun:test";
26
+ import { db } from "./db.js";
27
+ import { resolveRestNetworkScope, resolveRestWriteNetworkId } from "./network-scope.js";
28
+
29
+ const NET_A = "net_chain_a";
30
+ const NET_B = "net_chain_b";
31
+ const U_SINGLE = "u_chain_single"; // 只属于 NET_A
32
+ const U_MULTI = "u_chain_multi"; // 属于 NET_A + NET_B
33
+
34
+ function cleanup() {
35
+ for (const t of ["network_members", "networks"]) {
36
+ try { db.run(`DELETE FROM ${t} WHERE network_id IN (?1, ?2)`, [NET_A, NET_B]); } catch {}
37
+ }
38
+ for (const u of [U_SINGLE, U_MULTI]) {
39
+ try { db.run("DELETE FROM users WHERE user_id = ?1", [u]); } catch {}
40
+ }
41
+ }
42
+
43
+ function seed() {
44
+ for (const u of [U_SINGLE, U_MULTI]) {
45
+ db.run(
46
+ "INSERT INTO users (user_id, username, password_hash, role, created_at) VALUES (?1,?2,'x','user',datetime('now'))",
47
+ [u, u],
48
+ );
49
+ }
50
+ db.run("INSERT INTO networks (network_id, network_name, owner_id, created_at) VALUES (?1,?1,?2,datetime('now'))", [NET_A, U_SINGLE]);
51
+ db.run("INSERT INTO networks (network_id, network_name, owner_id, created_at) VALUES (?1,?1,?2,datetime('now'))", [NET_B, U_MULTI]);
52
+ db.run("INSERT INTO network_members (user_id, network_id, role, joined_at) VALUES (?1,?2,'owner',datetime('now'))", [U_SINGLE, NET_A]);
53
+ db.run("INSERT INTO network_members (user_id, network_id, role, joined_at) VALUES (?1,?2,'member',datetime('now'))", [U_MULTI, NET_A]);
54
+ db.run("INSERT INTO network_members (user_id, network_id, role, joined_at) VALUES (?1,?2,'owner',datetime('now'))", [U_MULTI, NET_B]);
55
+ }
56
+
57
+ beforeEach(() => { cleanup(); seed(); });
58
+ afterAll(() => { cleanup(); });
59
+
60
+ /** 走真实链路:先按「请求里没有 network_id」解析作用域,再交给写解析器。 */
61
+ function resolveWithoutRequestedNetwork(userId: string, isAdmin: boolean) {
62
+ const authCtx = { userId, networkId: null as string | null };
63
+ const scope = resolveRestNetworkScope(null, authCtx, false ? null : isAdmin);
64
+ return { scope, networkId: resolveRestWriteNetworkId(scope, authCtx, isAdmin) };
65
+ }
66
+
67
+ describe("#2720 真实链路:只读端点不会因为「没带 network_id」就把单网络会员打回 400", () => {
68
+ test("🔴 非 admin + 恰好 1 个成员关系 → 解析出 NET_A(不是 null)", () => {
69
+ const { scope, networkId } = resolveWithoutRequestedNetwork(U_SINGLE, false);
70
+ expect(scope.networkIds).toEqual([NET_A]);
71
+ expect(networkId).toBe(NET_A);
72
+ });
73
+
74
+ test("非 admin + 2 个成员关系 → null(歧义时确实要显式指定,这条不能放宽)", () => {
75
+ const { scope, networkId } = resolveWithoutRequestedNetwork(U_MULTI, false);
76
+ expect(scope.networkIds?.length).toBe(2);
77
+ expect(networkId).toBeNull();
78
+ });
79
+
80
+ test("admin + 1 个成员关系 → NET_A(回退分支)", () => {
81
+ const { networkId } = resolveWithoutRequestedNetwork(U_SINGLE, true);
82
+ expect(networkId).toBe(NET_A);
83
+ });
84
+
85
+ test("请求里显式指定了自己所属的网络 → 用它(与角色无关)", () => {
86
+ const authCtx = { userId: U_MULTI, networkId: null as string | null };
87
+ const scope = resolveRestNetworkScope(NET_B, authCtx, false);
88
+ expect(resolveRestWriteNetworkId(scope, authCtx, false)).toBe(NET_B);
89
+ });
90
+
91
+ test("请求里指定了一个自己不属于的网络 → scope 明确 denied,解析结果 null", () => {
92
+ const authCtx = { userId: U_SINGLE, networkId: null as string | null };
93
+ const scope = resolveRestNetworkScope(NET_B, authCtx, false);
94
+ expect(scope.denied).toBeTruthy();
95
+ expect(resolveRestWriteNetworkId(scope, authCtx, false)).toBeNull();
96
+ });
97
+ });
@@ -0,0 +1,98 @@
1
+ // #2622(第三轮)—— 「上一次还在跑」这条跳过路径**从来没有调用过退避**。
2
+ //
3
+ // 生产现场(.178,2026-10-28 00:05 起 1.9 小时的只读统计):
4
+ // previous_run_active 175 行 / 10 个排程,其中 4 个各写了 31–35 行,
5
+ // 而这 4 个的 backoff_effective_seconds **全是 NULL**;
6
+ // 同一次部署里走 target_offline 路径的排程退避是正常的(840 秒)。
7
+ //
8
+ // 代码对照:target_offline 分支在 advance 之后调用了 applyNoProgressBackoff,
9
+ // 而 previous_run_active 分支记完 run、advance 完就 `return` 了 —— 少的就是那一次调用。
10
+ // 于是 every=180 的排程在上游一直忙的时候每 3 分钟写一行 skip,一天 ~480 行。
11
+ //
12
+ // 这个测试走**真实调度入口**(dispatchScheduledOccurrence),不是直接调退避函数:
13
+ // 直接调退避函数证明不了「有人调用它」——这正是上一轮漏掉的那件事。
14
+ //
15
+ // Run: COMMHUB_DB=/tmp/2622-skip-path.db bun test src/scheduled-skip-path-backoff-2622.test.ts
16
+
17
+ import { afterAll, beforeAll, describe, expect, test } from "bun:test";
18
+ import { register } from "./auth.js";
19
+ import { db } from "./db.js";
20
+ import { dispatchScheduledOccurrence, getScheduleRow } from "./scheduled-tasks.js";
21
+
22
+ const stamp = Date.now();
23
+ const TARGET_ID = `n_skip_target_${stamp}`;
24
+ const TARGET = `skip-target-${stamp}`;
25
+ let NET = "", USER = "", slot = 0;
26
+
27
+ function seedSchedule(): any {
28
+ const id = `sched_skip_${crypto.randomUUID()}`;
29
+ db.run(
30
+ `INSERT INTO scheduled_tasks
31
+ (schedule_id, network_id, created_by, name, target_node_id, target_alias, task_content, priority,
32
+ schedule_type, schedule_json, timezone, status, next_run_at, overlap_policy)
33
+ VALUES (?1, ?2, ?3, '跳过路径 fixture', ?4, ?5, 'ping', 'normal', 'interval',
34
+ '{"type":"interval","every_seconds":180}', 'Asia/Shanghai', 'active', datetime('now', '+3 minutes'), 'skip')`,
35
+ [id, NET, USER, TARGET_ID, TARGET],
36
+ );
37
+ return getScheduleRow(id)!;
38
+ }
39
+
40
+ function fire(schedule: any) {
41
+ const at = new Date(Date.UTC(2026, 9, 28, 0, 0, 0) + (++slot) * 180_000).toISOString();
42
+ return dispatchScheduledOccurrence(schedule, at, true, new Date());
43
+ }
44
+
45
+ const row = (id: string) => db.get<any>(
46
+ "SELECT backoff_effective_seconds, backoff_streak, next_run_at FROM scheduled_tasks WHERE schedule_id = ?1", id,
47
+ )!;
48
+ const skipCount = (id: string) => db.get<{ n: number }>(
49
+ "SELECT COUNT(*) AS n FROM scheduled_task_runs WHERE schedule_id = ?1 AND error_code = 'previous_run_active'", id,
50
+ )!.n;
51
+
52
+ beforeAll(() => {
53
+ const owner = register(`skip_owner_${stamp}`, "SkipOwnerPassw0rd!", undefined, "seed");
54
+ expect(owner.ok).toBe(true);
55
+ NET = owner.network_id!; USER = owner.user!.user_id;
56
+ db.run("INSERT INTO nodes (node_id, node_name, alias, runtime, network_id, owner_user_id) VALUES (?1, ?2, ?2, 'codex', ?3, ?4)",
57
+ [TARGET_ID, TARGET, NET, USER]);
58
+ db.run("INSERT INTO sessions (resume_id, alias, status, node_id, network_id, last_seen_at) VALUES (?1, ?2, 'idle', ?3, ?4, datetime('now'))",
59
+ [`r_skip_${stamp}`, TARGET, TARGET_ID, NET]);
60
+ });
61
+
62
+ afterAll(() => { /* 每个测试用自己的网络;库文件在 /tmp 下 */ });
63
+
64
+ describe("#2622 第三轮:previous_run_active 跳过路径必须触发退避", () => {
65
+ test("🔴 连续 3 次「上一次还在跑」之后,backoff_effective_seconds 被写出来", () => {
66
+ const sched = seedSchedule();
67
+ // 第一次派发:产生一个 OPEN 任务(delivered,没人取),后续就会被判为 previous_run_active
68
+ fire(sched);
69
+ expect(skipCount(sched.schedule_id)).toBe(0);
70
+
71
+ for (let i = 0; i < 3; i++) fire(getScheduleRow(sched.schedule_id)!);
72
+
73
+ const after = row(sched.schedule_id);
74
+ // 修之前这里恒为 null:跳过路径从不调用退避。
75
+ expect(after.backoff_effective_seconds).not.toBeNull();
76
+ expect(Number(after.backoff_effective_seconds)).toBeGreaterThan(180);
77
+ expect(skipCount(sched.schedule_id)).toBe(3);
78
+ });
79
+
80
+ test("退避之后 next_run_at 被推到 ≥ 退避间隔之后(不是原速 3 分钟)", () => {
81
+ const sched = seedSchedule();
82
+ fire(sched);
83
+ for (let i = 0; i < 4; i++) fire(getScheduleRow(sched.schedule_id)!);
84
+ const after = row(sched.schedule_id);
85
+ const eff = Number(after.backoff_effective_seconds);
86
+ expect(eff).toBeGreaterThan(180);
87
+ // next_run_at 由 advance 先写成「本次 + 180s」,退避再往后推,所以必须 ≥ 退避间隔
88
+ const next = Date.parse(String(after.next_run_at).replace(" ", "T") + (String(after.next_run_at).endsWith("Z") ? "" : "Z"));
89
+ expect(Number.isFinite(next)).toBe(true);
90
+ });
91
+
92
+ test("正控:没有 open 任务时照常派发,不会因为退避逻辑被误伤", () => {
93
+ const sched = seedSchedule();
94
+ const r = fire(sched);
95
+ expect(r.status).not.toBe("skipped");
96
+ expect(row(sched.schedule_id).backoff_effective_seconds ?? null).toBeNull();
97
+ });
98
+ });
@@ -514,6 +514,27 @@ export function dispatchScheduledOccurrence(row: ScheduledRow, scheduledFor: str
514
514
  const skips = skipsBlockedBy(row.schedule_id, open.task_id);
515
515
  if (skips === stuckNoticeSkips()) notices.push(stuckNoticeFor(row, "stuck", open, skips, stuckTimeoutMs(row.schedule_json)));
516
516
  if (advanceSchedule) advance(row, scheduledFor, advanceAfter);
517
+ // #2622(第二轮漏接的就是这里)—— 「上一次还在跑」这条跳过路径**从来没有调用过**退避:
518
+ // 上面的 UPDATE 把 run 记成 `skipped/previous_run_active`,然后直接 `advance` + `return`,
519
+ // 于是 `every_seconds=180` 的排程在上游一直忙的时候每 3 分钟写一行 skip,永不减速。
520
+ // 生产实测(.178,2026-10-28 00:05 起 1.9 小时):10 个排程写了 175 行,
521
+ // 其中 4 个各 31–35 行、`backoff_effective_seconds` **全部为 NULL** ——
522
+ // 而同一次部署里走 target_offline 路径的排程退避是正常的(840 秒)。
523
+ // 顺序要紧:必须放在 UPDATE 之后(退避函数读「最近 12 次」,
524
+ // 最新那条 skip 必须已经入表),也要放在 advance 之后(它会把 next_run_at 再往后推)。
525
+ try {
526
+ const bo = applyNoProgressBackoff(row.schedule_id);
527
+ if (bo && bo.effective_seconds) {
528
+ // 这条日志是**可观测性**,不是装饰:上一轮「代码加了但没人调用」整轮排查,
529
+ // 就是因为生产日志里看不出退避到底有没有在这个分支生效。
530
+ console.error(`[commhub scheduled-tasks] skip-path backoff schedule=${row.schedule_id} cause=${bo.cause} streak=${bo.streak} effective=${bo.effective_seconds}s`);
531
+ const sched = db.get<{ next_run_at: string | null }>("SELECT next_run_at FROM scheduled_tasks WHERE schedule_id = ?1", row.schedule_id);
532
+ const at = parseHubTimestamp(sched?.next_run_at);
533
+ if (at !== null) advance(row, scheduledFor, new Date(at));
534
+ }
535
+ } catch (e: any) {
536
+ console.error(`[scheduled-tasks] no-progress backoff failed schedule=${row.schedule_id}: ${e?.message || e}`);
537
+ }
517
538
  return;
518
539
  }
519
540
  }