@sleep2agi/commhub-server 0.9.0-preview.170 → 0.9.0-preview.172

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.170",
3
+ "version": "0.9.0-preview.172",
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",
@@ -11,7 +11,7 @@
11
11
 
12
12
  import { afterAll, beforeAll, describe, expect, test } from "bun:test";
13
13
  import { db } from "./db.js";
14
- import { BROADCAST_CHUNK, enqueueBroadcast } from "./broadcast-fanout.js";
14
+ import { BROADCAST_CHUNK, enqueueBroadcast, broadcastRecentState } from './broadcast-fanout.js';
15
15
 
16
16
  const stamp = `${Date.now()}`;
17
17
  let NET = "";
@@ -97,3 +97,22 @@ describe("#2721 broadcast fan-out is chunked", () => {
97
97
  expect(yields).toBe(0);
98
98
  });
99
99
  });
100
+
101
+ // #2721 —— /health 的 `broadcast` 一格:最近一次广播的时间/人数/批数/耗时。
102
+ describe('broadcastRecentState', () => {
103
+ test('records the last broadcast so a stall can be reconciled afterwards', async () => {
104
+ const targets = Array.from({ length: 7 }, (_, i) => ({ alias: `r${i}`, node_id: null, network_id: 'n1' }));
105
+ await enqueueBroadcast(targets, 'hello', 'hub', 'n1', {
106
+ isActive: () => true,
107
+ notify: () => {},
108
+ yieldBetweenChunks: async () => {},
109
+ chunkSize: 3,
110
+ });
111
+ const rec = broadcastRecentState();
112
+ expect(rec).not.toBeNull();
113
+ expect(rec!.recipients).toBe(7);
114
+ expect(rec!.chunks).toBe(3); // ceil(7/3)
115
+ expect(typeof rec!.took_ms).toBe('number');
116
+ expect(Number.isNaN(Date.parse(rec!.at))).toBe(false);
117
+ });
118
+ });
@@ -20,6 +20,26 @@ import { db } from "./db.js";
20
20
  /** 一批多少个收件人。50 是“一次事务不至于太长、又明显少于一次全量”的折中。 */
21
21
  export const BROADCAST_CHUNK = 50;
22
22
 
23
+ /**
24
+ * #2721 —— 最近一次广播的「事后可对上时间的」记录。
25
+ *
26
+ * 为什么要有:07:11 那次事故里,我花了不少时间才把“143.9 秒停顿”与“07:10 那条广播”
27
+ * 对上 —— 因为停顿记录(`event_loop.recent_stalls`)里只有时间与 RSS,没有“当时发生了什么”。
28
+ * 广播是唯一一种能一次性唤醒几百个 agent 的动作,值得在 `/health` 里留一格。
29
+ */
30
+ export type BroadcastRecord = {
31
+ at: string;
32
+ recipients: number;
33
+ chunks: number;
34
+ took_ms: number;
35
+ };
36
+
37
+ let lastBroadcast: BroadcastRecord | null = null;
38
+
39
+ export function broadcastRecentState(): BroadcastRecord | null {
40
+ return lastBroadcast;
41
+ }
42
+
23
43
  export type BroadcastTarget = { alias: string; node_id: string | null; network_id: string | null };
24
44
  export type BroadcastDelivered = { alias: string; netId: string | null };
25
45
 
@@ -40,6 +60,7 @@ export async function enqueueBroadcast(
40
60
  effectiveNetId: string | null,
41
61
  deps: BroadcastDeps,
42
62
  ): Promise<{ ids: string[]; delivered: BroadcastDelivered[] }> {
63
+ const startedMs = Date.now();
43
64
  const chunk = deps.chunkSize && deps.chunkSize > 0 ? deps.chunkSize : BROADCAST_CHUNK;
44
65
  const ids: string[] = [];
45
66
  const delivered: BroadcastDelivered[] = [];
@@ -67,5 +88,11 @@ export async function enqueueBroadcast(
67
88
  }
68
89
 
69
90
  for (const d of delivered) deps.notify(d.alias, d.netId);
91
+ lastBroadcast = {
92
+ at: new Date().toISOString(),
93
+ recipients: delivered.length,
94
+ chunks: Math.ceil(targets.length / chunk),
95
+ took_ms: Date.now() - startedMs,
96
+ };
70
97
  return { ids, delivered };
71
98
  }
@@ -19,6 +19,7 @@
19
19
 
20
20
  import { db, setScheduledRunTerminalHook } from "./db.js";
21
21
  import { sendAgentNotice } from "./agent-notice.js";
22
+ import { parseHubTimestamp } from "./hub-timestamp.js";
22
23
 
23
24
  export const SCHEDULE_FAILING_NOTICE_KIND = "schedule_failing";
24
25
  const ERROR_PREVIEW_CHARS = 300;
@@ -226,6 +227,110 @@ export function applyFailureBackoff(scheduleId: string, now = new Date()): { str
226
227
  return { streak, effective_seconds: effective };
227
228
  }
228
229
 
230
+ /**
231
+ * #2622(第二轮)—— 「跑不起来」的两类跳过也要退避。
232
+ *
233
+ * 生产 24h(2026-10-27):`previous_run_active` 2286 条、`target_offline` 1951 条,
234
+ * 而 `failureStreak()` 只数 `status='failed'`,**skipped 完全不计**,
235
+ * 于是一个 `every_seconds=180` 的排程可以在目标永久离线的状态下每 3 分钟写一行 skip,
236
+ * 一天 470 条,永不减速。
237
+ *
238
+ * 这里只做「放慢」,不改变派发语义:
239
+ * · 同一 error_code 连续出现 ≥ N(默认 3)⇒ 间隔按 2 倍放大,上限 1800 秒;
240
+ * · `target_offline` 的链用更长的上限(7200 秒 = 2 小时)——目标不在时没有理由每 3 分钟试一次;
241
+ * · 换链(原因变了)或出现成功 ⇒ 立刻回到原间隔;
242
+ * · 与 `no_change_backoff=1` 的排程互斥(那套逻辑自己拥有 backoff_* 三列)。
243
+ */
244
+ const NO_PROGRESS_CODES = ["previous_run_active", "target_offline"] as const;
245
+ export type NoProgressCause = (typeof NO_PROGRESS_CODES)[number];
246
+
247
+ function noProgressFromRuns(runs: Array<{ status: string; error_code: string | null }>): { cause: NoProgressCause | null; streak: number } {
248
+ const first = runs[0];
249
+ if (!first) return { cause: null, streak: 0 };
250
+ let cause: NoProgressCause | null = null;
251
+ if (first.status === "failed") cause = null; // 由 applyFailureBackoff 负责,避免两套逻辑抢同一列
252
+ else if (first.status === "skipped" && (NO_PROGRESS_CODES as readonly string[]).includes(first.error_code ?? "")) {
253
+ cause = first.error_code as NoProgressCause;
254
+ }
255
+ if (!cause) return { cause: null, streak: 0 };
256
+ let streak = 0;
257
+ for (const r of runs) {
258
+ if (r.status !== "skipped" || r.error_code !== cause) break;
259
+ streak++;
260
+ }
261
+ return { cause, streak };
262
+ }
263
+
264
+ export function noProgressBackoffRuns(): number {
265
+ return envInt("COMMHUB_SCHEDULE_NO_PROGRESS_BACKOFF_RUNS", 3, 1);
266
+ }
267
+
268
+ export function applyNoProgressBackoff(scheduleId: string, now = new Date()): { streak: number; effective_seconds: number | null; cause: NoProgressCause } | null {
269
+ const from = noProgressBackoffRuns();
270
+ if (from <= 0) return null;
271
+ const row = db.get<any>(
272
+ `SELECT schedule_id, revision, status, schedule_type, schedule_json, no_change_backoff,
273
+ backoff_effective_seconds, next_run_at
274
+ FROM scheduled_tasks WHERE schedule_id = ?1`,
275
+ scheduleId,
276
+ );
277
+ if (!row || row.status !== "active" || row.no_change_backoff === 1) return null;
278
+ if (row.schedule_type !== "interval") return null;
279
+ let spec: any = null;
280
+ try { spec = JSON.parse(row.schedule_json || "{}"); } catch { spec = null; }
281
+ const base = spec && spec.type === "interval" ? Number(spec.every_seconds) : NaN;
282
+ if (!Number.isFinite(base) || base <= 0) return null;
283
+
284
+ const runs = db.all<{ status: string; error_code: string | null }>(
285
+ `SELECT status, error_code FROM scheduled_task_runs
286
+ WHERE schedule_id = ?1 ORDER BY scheduled_for DESC, created_at DESC LIMIT 12`,
287
+ scheduleId,
288
+ );
289
+ const { cause, streak } = noProgressFromRuns(runs);
290
+
291
+ // 回到原间隔(成功 / 换链 / 未达阈值都走这里;只在真的退避过时才写)
292
+ const restore = () => {
293
+ if ((row.backoff_streak ?? 0) === 0 && row.backoff_effective_seconds == null) return;
294
+ // next_run_at 是 hub 的 TEXT UTC(无时区标记),必须走 parseHubTimestamp
295
+ const cur = parseHubTimestamp(row.next_run_at);
296
+ const next = cur === null
297
+ ? row.next_run_at
298
+ : new Date(Math.min(cur, now.getTime() + base * 1000)).toISOString();
299
+ db.run(
300
+ `UPDATE scheduled_tasks SET backoff_streak = 0, backoff_effective_seconds = NULL, next_run_at = ?1,
301
+ updated_at = datetime('now') WHERE schedule_id = ?2 AND revision = ?3 AND status = 'active'`,
302
+ [next, scheduleId, row.revision],
303
+ );
304
+ };
305
+
306
+ if (!cause) { restore(); return null; }
307
+
308
+ // 上限按原因分开:
309
+ // previous_run_active —— 上一次还在跑,30 分钟足够等到它结束;
310
+ // target_offline —— 目标连续 6 次不在(按 180s 基底已是 18 分钟),
311
+ // 再用 3 分钟一次的节奏去敲没有意义;2 小时一次仍能及时接住它回来。
312
+ // 判据:#2622「同类原因日增量 ≤20」——180s 基底配 2 小时上限 ⇒ 12 次/天。
313
+ const cap = cause === "target_offline" ? 7200 : 1800;
314
+ if (streak < from) { restore(); return null; }
315
+
316
+ const effective = Math.min(cap, base * 2 ** Math.min(streak - from + 1, 5));
317
+ const previous = row.backoff_effective_seconds ?? base;
318
+ let next = row.next_run_at;
319
+ if (effective !== previous && next) {
320
+ const candidate = now.getTime() + effective * 1000;
321
+ const existing = parseHubTimestamp(next);
322
+ if (existing !== null) {
323
+ next = new Date(effective > previous ? Math.max(existing, candidate) : Math.min(existing, candidate)).toISOString();
324
+ }
325
+ }
326
+ db.run(
327
+ `UPDATE scheduled_tasks SET backoff_streak = ?1, backoff_effective_seconds = ?2, next_run_at = ?3,
328
+ updated_at = datetime('now') WHERE schedule_id = ?4 AND revision = ?5 AND status = 'active'`,
329
+ [streak, effective, next, scheduleId, row.revision],
330
+ );
331
+ return { streak, effective_seconds: effective, cause };
332
+ }
333
+
229
334
  /** GET /runs 的附加字段。 */
230
335
  export function failureSummary(scheduleId: string): { consecutive_failures: number; failure_alert_threshold: number; last_failure_alert_at: string | null } {
231
336
  const streak = failureStreak(scheduleId);
@@ -0,0 +1,117 @@
1
+ // #2622(第二轮)—— 「跑不起来」的两类跳过也要退避。
2
+ //
3
+ // 生产 24h(2026-10-27):previous_run_active 2286 条、target_offline 1951 条,
4
+ // 而 failureStreak 只数 status='failed',skipped 完全不计 ⇒ 永远按原速重试。
5
+ //
6
+ // 这个文件钉住四件事:
7
+ // 1. 同一 error_code 连续 ≥3 次 ⇒ 间隔放大(有上限:previous_run_active 1800s / target_offline 3600s);
8
+ // 2. 换链(原因变了)或出现成功 ⇒ 立刻回到原间隔;
9
+ // 3. no_change_backoff=1 的排程由另一套逻辑拥有 backoff 列,这里完全不介入;
10
+ // 4. 非 interval 排程不介入。
11
+
12
+ import { afterAll, beforeAll, describe, expect, test } from "bun:test";
13
+ import { register } from "./auth.js";
14
+ import { db } from "./db.js";
15
+ import { applyNoProgressBackoff, noProgressBackoffRuns } from "./scheduled-failures.js";
16
+
17
+ const stamp = Date.now();
18
+ let NET = "";
19
+ let creatorId = "";
20
+
21
+ function seedSchedule(everySeconds = 180, extra: Record<string, unknown> = {}) {
22
+ const id = `sched_np_${crypto.randomUUID()}`;
23
+ db.run(
24
+ `INSERT INTO scheduled_tasks
25
+ (schedule_id, network_id, created_by, name, target_node_id, target_alias, task_content, priority,
26
+ schedule_type, schedule_json, timezone, status, next_run_at, overlap_policy)
27
+ VALUES (?1, ?2, ?3, 'np fixture', 'n_np', 'np-node', 'x', 'normal', 'interval', ?4,
28
+ 'Asia/Shanghai', 'active', ?5, 'skip')`,
29
+ [id, NET, creatorId, JSON.stringify({ type: "interval", every_seconds: everySeconds }),
30
+ new Date(Date.now() + everySeconds * 1000).toISOString()],
31
+ );
32
+ for (const [k, v] of Object.entries(extra)) db.run(`UPDATE scheduled_tasks SET ${k} = ?1 WHERE schedule_id = ?2`, [v as any, id]);
33
+ return id;
34
+ }
35
+
36
+ let seq = 0;
37
+ function addRun(scheduleId: string, status: string, code: string | null) {
38
+ seq += 1;
39
+ const when = new Date(Date.now() + seq * 1000).toISOString();
40
+ db.run(
41
+ `INSERT INTO scheduled_task_runs (run_id, schedule_id, network_id, scheduled_for, status, error_code, created_at)
42
+ VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?4)`,
43
+ [`srun_np_${crypto.randomUUID()}`, scheduleId, NET, when, status, code],
44
+ );
45
+ }
46
+
47
+ const reload = (id: string) => db.get<any>("SELECT * FROM scheduled_tasks WHERE schedule_id = ?1", id)!;
48
+
49
+ beforeAll(async () => {
50
+ const auth = register(`np_owner_${stamp}`, "Np-Owner-Strong-1!", undefined, "tester");
51
+ expect(auth.ok).toBe(true);
52
+ NET = auth.network_id!;
53
+ creatorId = auth.user_id!;
54
+ delete process.env.COMMHUB_SCHEDULE_NO_PROGRESS_BACKOFF_RUNS;
55
+ });
56
+
57
+ afterAll(() => { delete process.env.COMMHUB_SCHEDULE_NO_PROGRESS_BACKOFF_RUNS; });
58
+
59
+ describe("applyNoProgressBackoff (#2622)", () => {
60
+ test("defaults to 3 consecutive same-cause skips", () => {
61
+ expect(noProgressBackoffRuns()).toBe(3);
62
+ });
63
+
64
+ test("target_offline streak widens the interval (capped at 2h)", () => {
65
+ const id = seedSchedule(180);
66
+ for (let i = 0; i < 4; i++) addRun(id, "skipped", "target_offline");
67
+ const r = applyNoProgressBackoff(id)!;
68
+ expect(r.cause).toBe("target_offline");
69
+ expect(r.streak).toBe(4);
70
+ expect(r.effective_seconds).toBeGreaterThan(180);
71
+ expect(r.effective_seconds!).toBeLessThanOrEqual(7200);
72
+ expect(reload(id).backoff_effective_seconds).toBe(r.effective_seconds);
73
+ });
74
+
75
+ test("previous_run_active uses a shorter cap (30min)", () => {
76
+ const id = seedSchedule(180);
77
+ for (let i = 0; i < 10; i++) addRun(id, "skipped", "previous_run_active");
78
+ const r = applyNoProgressBackoff(id)!;
79
+ expect(r.cause).toBe("previous_run_active");
80
+ expect(r.effective_seconds).toBe(1800);
81
+ });
82
+
83
+ test("below the threshold it leaves the interval alone", () => {
84
+ const id = seedSchedule(180);
85
+ addRun(id, "skipped", "target_offline");
86
+ addRun(id, "skipped", "target_offline");
87
+ expect(applyNoProgressBackoff(id)).toBeNull();
88
+ expect(reload(id).backoff_effective_seconds).toBeNull();
89
+ });
90
+
91
+ test("a success resets the streak and restores the base interval", () => {
92
+ const id = seedSchedule(180);
93
+ for (let i = 0; i < 5; i++) addRun(id, "skipped", "target_offline");
94
+ const widened = applyNoProgressBackoff(id)!;
95
+ expect(widened.effective_seconds!).toBeGreaterThan(180);
96
+ addRun(id, "replied", null); // 成功一次
97
+ expect(applyNoProgressBackoff(id)).toBeNull();
98
+ const row = reload(id);
99
+ expect(row.backoff_streak).toBe(0);
100
+ expect(row.backoff_effective_seconds).toBeNull();
101
+ });
102
+
103
+ test("switching cause (different error_code) does not keep the streak", () => {
104
+ const id = seedSchedule(180);
105
+ addRun(id, "skipped", "target_offline");
106
+ addRun(id, "skipped", "target_offline");
107
+ addRun(id, "skipped", "previous_run_active"); // 最新一条换链 ⇒ streak=1
108
+ expect(applyNoProgressBackoff(id)).toBeNull();
109
+ });
110
+
111
+ test("schedules that opt into no_change_backoff are left to the other mechanism", () => {
112
+ const id = seedSchedule(180, { no_change_backoff: 1 });
113
+ for (let i = 0; i < 5; i++) addRun(id, "skipped", "target_offline");
114
+ expect(applyNoProgressBackoff(id)).toBeNull();
115
+ expect(reload(id).backoff_effective_seconds).toBeNull();
116
+ });
117
+ });
@@ -12,7 +12,8 @@ import { dispatchVerdict } from "./node-permissions.js";
12
12
  import { hasSubscribers, pushEvent, pushNetworkObserverEvent } from "./push.js";
13
13
  import { SCHEDULED_TASK_STORAGE_SELECT } from "./rest-projections.js";
14
14
  import { blockerTimedOut, blockerTimeoutClock, expireStuckBlocker, sendStuckNotice, skipsBlockedBy, stuckNoticeSkips, stuckTimeoutMs, type StuckNotice } from "./scheduled-stuck.js";
15
- import { evaluateScheduleFailures, failureSummary } from "./scheduled-failures.js";
15
+ import { applyNoProgressBackoff, evaluateScheduleFailures, failureSummary } from "./scheduled-failures.js";
16
+ import { parseHubTimestamp } from "./hub-timestamp.js";
16
17
  import { scheduledTargetOffline, sendOfflineNotice, type OfflineNotice } from "./scheduled-offline.js";
17
18
 
18
19
  export type ScheduleSpec =
@@ -449,6 +450,17 @@ export function dispatchScheduledOccurrence(row: ScheduledRow, scheduledFor: str
449
450
  targetAlias: targetNode.alias,
450
451
  };
451
452
  if (advanceSchedule) advance({ ...row, target_alias: targetNode.alias }, scheduledFor, advanceAfter);
453
+ // #2622 —— 目标长期离线时按同因链放慢(默认 3 次后 2 倍递增,上限 1 小时)。
454
+ try {
455
+ const bo = applyNoProgressBackoff(row.schedule_id);
456
+ if (bo && bo.effective_seconds) {
457
+ const sched = db.get<{ next_run_at: string | null }>("SELECT next_run_at FROM scheduled_tasks WHERE schedule_id = ?1", row.schedule_id);
458
+ const at = parseHubTimestamp(sched?.next_run_at);
459
+ if (at !== null) advance({ ...row, target_alias: targetNode.alias }, scheduledFor, new Date(at));
460
+ }
461
+ } catch (e: any) {
462
+ console.error(`[scheduled-tasks] no-progress backoff failed schedule=${row.schedule_id}: ${e?.message || e}`);
463
+ }
452
464
  return;
453
465
  }
454
466
  // Seeing the target online rearms exactly one warning for a future offline episode.
@@ -603,6 +615,13 @@ export function dispatchScheduledOccurrence(row: ScheduledRow, scheduledFor: str
603
615
  // Dispatch is not completion. Keep the run open until the exact bound
604
616
  // task reaches replied/failed/cancelled/expired; db.ts owns that mirror.
605
617
  db.run("UPDATE scheduled_task_runs SET task_id = ?1, status = ?2, completed_at = NULL WHERE run_id = ?3", [taskId, deliveryState, runId]);
618
+
619
+ // #2622 —— 上一层任务还没跑完时按同因链放慢(间隔 180s 的排程曾一天写 343 行 skip)。
620
+ try {
621
+ applyNoProgressBackoff(row.schedule_id);
622
+ } catch (e: any) {
623
+ console.error(`[scheduled-tasks] no-progress backoff failed schedule=${row.schedule_id}: ${e?.message || e}`);
624
+ }
606
625
  db.run(`UPDATE sessions SET task = ${sessionTaskOnDispatch("?1")}, updated_at = datetime('now') WHERE node_id = ?2 AND network_id = ?3`, [sessionTaskPreview(taskContent), node.node_id, row.network_id]);
607
626
  db.run("UPDATE scheduled_tasks SET target_alias = ?1, last_run_at = ?2, updated_at = datetime('now') WHERE schedule_id = ?3", [node.alias, scheduledFor, row.schedule_id]);
608
627
  if (advanceSchedule) advance({ ...row, target_alias: node.alias }, scheduledFor, advanceAfter);
package/src/server.ts CHANGED
@@ -31,7 +31,7 @@ import { createSSEStream, createNetworkObserverStream, createUserEventStream, pu
31
31
  import { enterMcpInflight, leaveMcpInflight, getMcpInflightStats } from "./mcp-inflight.js";
32
32
  import { eventLoopStats, startEventLoopLagMonitor } from "./event-loop-lag.js";
33
33
  import { aliasBaselineRefreshState, refreshAliasBaseline } from "./alias-baseline.js";
34
- import { enqueueBroadcast } from "./broadcast-fanout.js";
34
+ import { broadcastRecentState, enqueueBroadcast } from "./broadcast-fanout.js";
35
35
  import { assertNodeActive } from "./lifecycle-guard.js";
36
36
  import { pendingInboxCount } from "./inbox-count.js";
37
37
  import { notifyExpiredTasks, type ExpiredTaskRow } from "./task-expiry-notice.js";
@@ -78,6 +78,7 @@ import { mkdirSync, writeFileSync, readFileSync, readdirSync, existsSync, statSy
78
78
  import { dirname as pathDirname, join as pathJoin } from "path";
79
79
  import { startRetentionSweeper } from "./retention.js";
80
80
  import { sweepEmptyNodeRows } from "./empty-node-sweeper.js";
81
+ import { versionStats } from "./version-stats.js";
81
82
  import { startStaleSessionSweeper } from "./stale-sweeper.js";
82
83
  import {
83
84
  AUDIT_LOG_REST_SELECT,
@@ -2814,6 +2815,9 @@ return Bun.serve({
2814
2815
  // #2571 —— 告警阈值用的「每目标 p99 基线」最近一次刷新(只读聚合:时间/写了几行/现在共几行)。
2815
2816
  // 没有它,「这条告警为什么没报」只能进机器 sqlite 查。
2816
2817
  alert_baselines: aliasBaselineRefreshState(),
2818
+ // #2721 —— 最近一次广播(时间/收件人数/批数/耗时)。广播是唯一能一次性唤醒
2819
+ // 几百个 agent 的动作;没有这一格,事后只能把停顿记录和聊天记录对时间。
2820
+ broadcast: broadcastRecentState(),
2817
2821
  auth: DEV_OPEN ? "dev-open" : "user-token",
2818
2822
  security: DEV_OPEN ? "dev-open" : "secured",
2819
2823
  tmux: TMUX_ENABLED ? "enabled" : "disabled",
@@ -3189,6 +3193,19 @@ return Bun.serve({
3189
3193
  return withCors(req, Response.json({ ok: true, ...routeStats(minutes * 60_000, Date.now(), { byCaller }) }));
3190
3194
  }
3191
3195
 
3196
+ // ── #2720 REST: 版本债务(只读聚合)──
3197
+ // 为什么要有这一条:370 个 session 里 159 个没有版本号,而「没有版本」不是一个桶 ——
3198
+ // 24 个是 claude-code(LLM 会话自己调工具,没有版本概念),9 个才是老 agent-node。
3199
+ // 把两者混算会得出“升级节点能修好 33 个”的错误结论(只能修好 9 个)。
3200
+ // 返回聚合数字,不含 alias 明细;节点令牌只看自己绑定的网络。
3201
+ if (url.pathname === "/api/stats/versions" && req.method === "GET") {
3202
+ if (restAuth && !isAdmin && !restAuth.networkId) {
3203
+ return withCors(req, Response.json({ ok: false, error: "admin or network token required" }, { status: 403 }));
3204
+ }
3205
+ const scopeNet = restAuth?.networkId ?? null;
3206
+ return withCors(req, Response.json({ ok: true, ...versionStats(scopeNet) }));
3207
+ }
3208
+
3192
3209
  // ── #473 REST: SSE connection detail (ops-only) ──
3193
3210
  // The per-key breakdown /health used to expose anonymously: keys are
3194
3211
  // `{networkId}:{alias}` (+ `\0netobs:{networkId}` observer keys via
@@ -0,0 +1,66 @@
1
+ // #2720 —— 版本债务聚合:无版本要按 agent 拆,别把「没有版本概念」算成债务。
2
+ import { afterAll, beforeAll, describe, expect, test } from "bun:test";
3
+ import { db } from "./db.js";
4
+ import { versionStats } from "./version-stats.js";
5
+
6
+ let networkId = "";
7
+
8
+ function insertSession(alias: string, agent: string, version: string | null, status: string) {
9
+ db.run(
10
+ `INSERT INTO sessions (resume_id, alias, agent, version, status, network_id, registered_at)
11
+ VALUES (?1, ?2, ?3, ?4, ?5, ?6, '2026-10-01 00:00:00')`,
12
+ [`res_${alias}`, alias, agent, version, status, networkId],
13
+ );
14
+ }
15
+
16
+ beforeAll(async () => {
17
+ const { register } = await import("./auth.js");
18
+ const auth = register(`verstats_${Date.now()}`, "VerStats-Str0ng-1!", undefined, "watcher");
19
+ expect(auth.ok).toBe(true);
20
+ networkId = auth.network_id!;
21
+
22
+ insertSession("n-new", "agent-node:opencode", "2.3.0-preview.199", "idle");
23
+ insertSession("n-old", "agent-node:opencode", "2.3.0-preview.150", "idle");
24
+ insertSession("n-old-2", "agent-node:opencode", "2.3.0-preview.150", "working");
25
+ insertSession("n-gone", "agent-node:opencode", "2.3.0-preview.150", "offline");
26
+ // LLM 自己调工具的会话:没有版本是 n/a,不是债务
27
+ insertSession("cc-1", "claude-code", null, "idle");
28
+ insertSession("cc-2", "claude-code", null, "offline");
29
+ // 老 agent-node:该报没报,是真债务
30
+ insertSession("old-node-1", "agent-node:claude", null, "idle");
31
+ }, 30_000);
32
+
33
+ afterAll(() => {});
34
+
35
+ describe("versionStats (#2720)", () => {
36
+ test("counts sessions and active sessions for the network", () => {
37
+ const s = versionStats(networkId);
38
+ expect(s.sessions).toBeGreaterThanOrEqual(7);
39
+ expect(s.active).toBeGreaterThanOrEqual(5);
40
+ });
41
+
42
+ test("keeps 'no version' split by agent, with version_expected flag", () => {
43
+ const s = versionStats(networkId);
44
+ const cc = s.no_version_by_agent.find((x) => x.agent === "claude-code");
45
+ const oldNode = s.no_version_by_agent.find((x) => x.agent === "agent-node:claude");
46
+ expect(cc?.version_expected).toBe(false); // LLM 工具调用:n/a
47
+ expect(oldNode?.version_expected).toBe(true); // 老节点:真债务
48
+ });
49
+
50
+ test("active_missing_version excludes producers with no version concept", () => {
51
+ const s = versionStats(networkId);
52
+ // 只有 old-node-1 计入(cc-1 是 n/a)
53
+ expect(s.active_missing_version).toBe(1);
54
+ });
55
+
56
+ test("active_behind_same_agent counts actives on a non-top version", () => {
57
+ const s = versionStats(networkId);
58
+ // .150 有 2 个在线(idle+working),.199 是最高的一个
59
+ expect(s.active_behind_same_agent).toBeGreaterThanOrEqual(2);
60
+ });
61
+
62
+ test("scoping by an unknown network yields nothing", () => {
63
+ const s = versionStats("net_does_not_exist");
64
+ expect(s.sessions).toBe(0);
65
+ });
66
+ });
@@ -0,0 +1,109 @@
1
+ // #2720 —— 让「版本债务」自己更新,不靠人跑 SQL。
2
+ //
3
+ // 背景(2026-10-27 生产只读统计):370 个 session 里 159 个没有版本号,
4
+ // 其中 33 个**还在线**。继续拆下去才看清真相:
5
+ // · 24 个的 `agent` 是 `claude-code` —— 那是 Claude 会话自己调
6
+ // `commhub_report_status(status=…, task=…)` 写的,**它没有 version 这个概念**;
7
+ // · 剩下 9 个才是老 agent-node(#1809 之前每次上报不带 version)。
8
+ // ⇒ 「无版本」不是一个桶:对 `claude-code` 是 n/a,对 agent-node 才是债务。
9
+ // 把两者混在一起算,会得出「升级节点能修好 33 个」的错误结论(只能修好 9 个)。
10
+ //
11
+ // 这个模块只做聚合(只读),返回:
12
+ // by_version —— (agent, version) → 总数/在线数
13
+ // no_version —— 按 agent 拆开的「无版本」,让调用方自己判 n/a 还是债务
14
+ // agent_kind —— 该 agent 的上报方式(`llm-tool-call` = 不自带版本)
15
+
16
+ import { db } from "./db.js";
17
+
18
+ /** 这些 agent 的上报者是 LLM 会话自己调工具,没有打包版本号可报(不是缺字段)。 */
19
+ const LLM_TOOL_CALL_AGENTS = new Set(["claude-code"]);
20
+
21
+ export type VersionBucket = {
22
+ agent: string;
23
+ version: string | null;
24
+ sessions: number;
25
+ active: number;
26
+ /** false = 这个 agent 没有版本概念(n/a),而不是“该报未报”。 */
27
+ version_expected: boolean;
28
+ };
29
+
30
+ export type VersionStats = {
31
+ network_id: string | null;
32
+ sessions: number;
33
+ active: number;
34
+ by_version: VersionBucket[];
35
+ no_version_by_agent: Array<{ agent: string; sessions: number; version_expected: boolean }>;
36
+ /** 在线且「该报版本却没报」的总数 —— 这才是真正的债务口径。 */
37
+ active_missing_version: number;
38
+ /** 在线且版本落后于「在线里最高版本」的数量(只对字符串完全可比的同 agent 生效)。 */
39
+ active_behind_same_agent: number;
40
+ };
41
+
42
+ export function versionStats(networkId: string | null = null): VersionStats {
43
+ const rows = db.all<{ agent: string | null; version: string | null; status: string | null; c: number }>(
44
+ `SELECT COALESCE(agent, '') AS agent,
45
+ COALESCE(NULLIF(version, ''), '') AS version,
46
+ COALESCE(status, '') AS status,
47
+ COUNT(*) AS c
48
+ FROM sessions
49
+ WHERE (?1 IS NULL OR network_id = ?1)
50
+ GROUP BY 1, 2, 3`,
51
+ networkId,
52
+ );
53
+
54
+ const buckets = new Map<string, VersionBucket>();
55
+ let sessions = 0;
56
+ let active = 0;
57
+ for (const r of rows) {
58
+ const isActive = r.status !== "offline";
59
+ sessions += r.c;
60
+ if (isActive) active += r.c;
61
+ const version = r.version === "" ? null : r.version;
62
+ const key = `${r.agent}\u0000${version ?? ""}`;
63
+ const cur = buckets.get(key) ?? {
64
+ agent: r.agent,
65
+ version,
66
+ sessions: 0,
67
+ active: 0,
68
+ version_expected: !LLM_TOOL_CALL_AGENTS.has(r.agent),
69
+ };
70
+ cur.sessions += r.c;
71
+ if (isActive) cur.active += r.c;
72
+ buckets.set(key, cur);
73
+ }
74
+
75
+ const all = [...buckets.values()].sort((a, b) => b.sessions - a.sessions || a.agent.localeCompare(b.agent));
76
+
77
+ const noVersion = all
78
+ .filter((b) => b.version === null)
79
+ .map((b) => ({ agent: b.agent, sessions: b.sessions, version_expected: b.version_expected }));
80
+
81
+ // 每个 agent 在「在线」行里出现过的最高版本(仅用于粗判落后;不做语义版本比较,
82
+ // 只在字符串完全一致时才算“同一个版本”)。
83
+ const highest = new Map<string, string>();
84
+ for (const b of all) {
85
+ if (!b.version || b.active === 0) continue;
86
+ const cur = highest.get(b.agent);
87
+ if (!cur || b.version.localeCompare(cur) > 0) highest.set(b.agent, b.version);
88
+ }
89
+ let behind = 0;
90
+ for (const b of all) {
91
+ if (!b.version || b.active === 0) continue;
92
+ const top = highest.get(b.agent);
93
+ if (top && b.version !== top) behind += b.active;
94
+ }
95
+
96
+ const activeMissingVersion = all
97
+ .filter((b) => b.version === null && b.version_expected)
98
+ .reduce((n, b) => n + b.active, 0);
99
+
100
+ return {
101
+ network_id: networkId,
102
+ sessions,
103
+ active,
104
+ by_version: all,
105
+ no_version_by_agent: noVersion,
106
+ active_missing_version: activeMissingVersion,
107
+ active_behind_same_agent: behind,
108
+ };
109
+ }