@sleep2agi/commhub-server 0.9.0-preview.238 → 0.9.0-preview.239
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.
|
|
3
|
+
"version": "0.9.0-preview.239",
|
|
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",
|
|
@@ -902,6 +902,26 @@ describe("#473 anonymous /health — watchdog contract intact, no topology leak"
|
|
|
902
902
|
// ② 用第二个观测者(另一个实例、另一台机器),而不是对同一实例再采样一次。
|
|
903
903
|
// 今天本仓两样都没有 ⇒ 这一格只能到「窗口声明 + 窗口内不变」为止。
|
|
904
904
|
//
|
|
905
|
+
// 2026-10-31 —— **名字生成候选,差值定罪**(外部复核 ②:
|
|
906
|
+
// 「名字匹配 /(age|elapsed|uptime|remaining|ttl|since)/ ⇒ 候选;
|
|
907
|
+
// 同一秒两次读,逐字段算差:过去时刻 ⇒ 差 == 0;时长 ⇒ 差 == 间隔」)。
|
|
908
|
+
// 只靠名字会漏掉改了名的那个,只靠表达式会误抓所有 now 派生量 ⇒ 两条都要。
|
|
909
|
+
if (typeof a.uptime === "number" && typeof b.uptime === "number") {
|
|
910
|
+
const dUp = b.uptime - a.uptime;
|
|
911
|
+
// uptime 是「活着的时长」:窗口 1.2s,它的增量必须落在 (0, 窗口+1s] 内
|
|
912
|
+
expect(dUp).toBeGreaterThan(0);
|
|
913
|
+
expect(dUp).toBeLessThanOrEqual(WINDOW_MS / 1000 + 1);
|
|
914
|
+
}
|
|
915
|
+
if (typeof a.startedAt === "string" && typeof b.startedAt === "string") {
|
|
916
|
+
// startedAt 是「过去的时刻」:差值必须恰好 0(它不该像 uptime 那样走)
|
|
917
|
+
expect(b.startedAt).toBe(a.startedAt);
|
|
918
|
+
}
|
|
919
|
+
if (typeof a.served_at === "string" && typeof b.served_at === "string") {
|
|
920
|
+
const dServed = Date.parse(b.served_at) - Date.parse(a.served_at);
|
|
921
|
+
expect(dServed).toBeGreaterThanOrEqual(WINDOW_MS - 50); // 它必须走满窗口(不是抄同一份)
|
|
922
|
+
expect(dServed).toBeLessThanOrEqual(WINDOW_MS + 5_000);
|
|
923
|
+
}
|
|
924
|
+
|
|
905
925
|
// 正向对照:窗口内必须**有东西会变**,否则「都没变」可能只是「两次读的是同一份缓存」。
|
|
906
926
|
// 这不是洁癖:一个恒定的响应体可以让上面那条永远绿。
|
|
907
927
|
const changed = Object.keys(a).filter((k) => k in b && JSON.stringify(a[k]) !== JSON.stringify(b[k]));
|
|
@@ -1269,6 +1289,39 @@ describe("#473 anonymous /health — watchdog contract intact, no topology leak"
|
|
|
1269
1289
|
// 判据不是「content-type 是 json」(那要求每个客户端都记得先看),
|
|
1270
1290
|
// 而是一个**静态**产出者标记:有它 ⇒ 这段字节出自 hub;没有 ⇒ 出自它前面的某一层。
|
|
1271
1291
|
// 必须是静态值:一旦它随进程/版本变化,它就变成了指纹(与 version_role 那条相冲突)。
|
|
1292
|
+
// 2026-10-31 —— **凡是差值字段,必须同时给出两个端点的原始值**
|
|
1293
|
+
// (外部复核:「任何 `a − b` 都会把『两字段一源』变成不可见;读者至少能看出可能同源,
|
|
1294
|
+
// 只剩一个数时他无法质疑两个端点」)。
|
|
1295
|
+
//
|
|
1296
|
+
// 谓词落在**名字**上而不是「源码里出现了减法」(外部复核:
|
|
1297
|
+
// 「`startedAt` / `lastSuccessAt` 也是减法算出来的但**稳**;只扫减法会漏掉无条件的那个」)。
|
|
1298
|
+
// 分母必须报出来:命中 0 个差值字段 ⇒ 这条断言是真空真。
|
|
1299
|
+
test("any difference-shaped field names both of its endpoints in the same payload", async () => {
|
|
1300
|
+
const { HEALTH_FIELD_META } = await import("./server.js");
|
|
1301
|
+
const DIFFY = /(age|elapsed|uptime|remaining|ttl|delta|drift|lag)/i;
|
|
1302
|
+
const named = Object.keys(HEALTH_FIELD_META).filter((k) => DIFFY.test(k));
|
|
1303
|
+
expect(named.length).toBeGreaterThan(0); // 分母:按名字至少命中 1 个
|
|
1304
|
+
|
|
1305
|
+
const derived = named.filter((k) => (HEALTH_FIELD_META as any)[k].derived_from);
|
|
1306
|
+
// 本仓今天有 2 个真差值(epoch_delta_ms / clk_tck_delta);`uptime` 是**单调读数**不是差值,
|
|
1307
|
+
// 它显式不写 derived_from —— 所以这里要求的是「写了端点的必须两端齐全」,
|
|
1308
|
+
// 而不是「所有命中名字的都必须写」(后者会把这条规则变成填表)。
|
|
1309
|
+
expect(derived.length).toBeGreaterThanOrEqual(2);
|
|
1310
|
+
|
|
1311
|
+
const problems: string[] = [];
|
|
1312
|
+
for (const k of derived) {
|
|
1313
|
+
const ends = (HEALTH_FIELD_META as any)[k].derived_from as readonly string[];
|
|
1314
|
+
if (!Array.isArray(ends) || ends.length < 2) { problems.push(`${k}: 端点少于 2 个`); continue; }
|
|
1315
|
+
for (const e of ends) {
|
|
1316
|
+
if (!(e in HEALTH_FIELD_META)) problems.push(`${k}: 端点 ${e} 不是本载荷里的字段(拼错的端点等于没有端点)`);
|
|
1317
|
+
}
|
|
1318
|
+
}
|
|
1319
|
+
expect(problems).toEqual([]);
|
|
1320
|
+
// 镜像:非差值字段**不该**被要求给端点(否则「填表」会取代判据)——
|
|
1321
|
+
// 断言 uptime 没有 derived_from,并且它确实不是 now-startedAt 那种同源减法。
|
|
1322
|
+
expect((HEALTH_FIELD_META as any).uptime.derived_from).toBeUndefined();
|
|
1323
|
+
});
|
|
1324
|
+
|
|
1272
1325
|
test("every hub response carries a constant producer marker (so a proxy page is distinguishable)", async () => {
|
|
1273
1326
|
const paths = ["/health", "/api/definitely-not-a-route", "/"];
|
|
1274
1327
|
const seen: (string | null)[] = [];
|
|
@@ -361,6 +361,15 @@ describe("GET /api/providers", () => {
|
|
|
361
361
|
expect(e.body.state).not.toBe("applied");
|
|
362
362
|
expect(e.body.observed_status).toBe("cancelled_by_operator");
|
|
363
363
|
expect(String(e.body.hint)).toContain("不等于已生效");
|
|
364
|
+
|
|
365
|
+
// 2026-10-31 —— **要数的是「出口量里能独立变化的维度数」,不是「有几条路径」**
|
|
366
|
+
// (外部复核 (d):「出口三元组实测秩 = 1:头无条件设置、键数恒为 3、状态是 code 的纯函数
|
|
367
|
+
// ⇒ A、B 两条向量改变的是同一个出口量」)。
|
|
368
|
+
// 对应到本路由:五个 state 如果**去掉 state 字段**就分不出来,那 state 就是唯一信息源,
|
|
369
|
+
// 载荷只是标签的复读 —— 秩 = 1。判据:把 state 删掉之后,五个载荷仍两两可区分。
|
|
370
|
+
const strip = (b: any) => { const { state: _s, ...rest } = b; return JSON.stringify(rest); };
|
|
371
|
+
const five = [a, b, c, d, e].map((r) => strip(r.body));
|
|
372
|
+
expect(new Set(five).size).toBe(5); // 两两不同 ⇒ 秩 ≥ 2,state 不是唯一维度
|
|
364
373
|
} finally {
|
|
365
374
|
db.run(`DELETE FROM daemon_provider_snapshots WHERE daemon_node_id = ?1`, [nodeId]);
|
|
366
375
|
db.run(`DELETE FROM node_daemon_bindings WHERE request_id = 'bind_ps'`);
|
|
@@ -480,6 +489,28 @@ describe("GET /api/providers", () => {
|
|
|
480
489
|
// 而语义已经不是你想的那个。」)
|
|
481
490
|
// ⇒ 读点必须落在**路由文件**里(server.ts),否则等于表有了、用法另有其处。
|
|
482
491
|
// 位置:读点必须落在**实现或路由**里(不是只落在注释里)
|
|
492
|
+
// 2026-10-31 —— **同值不能证明同源**(外部复核:「facade 走映射链、pty 直接写字面,
|
|
493
|
+
// 今天同值,而链改了 pty 不跟 ⇒ 任何静态断言都看不见这一格;
|
|
494
|
+
// 同值能证明它们此刻一致,不能证明它们受同一个约束。」)
|
|
495
|
+
//
|
|
496
|
+
// 本仓的同形:`state` 的取值域由**服务端**产出(闭集映射 + never_switched + unknown),
|
|
497
|
+
// 而**客户端**的 TS union 是另一份手写清单。两份今天相等,改一边不会红。
|
|
498
|
+
// 判据:把「服务端实际可产出的集合」与「客户端 union 的集合」直接比;
|
|
499
|
+
// 并且这条比较本身必须能红(witness:改客户端 union 少一个值 ⇒ 立刻红)。
|
|
500
|
+
const { SELECTION_STATE_BY_STATUS } = await import("./server.js");
|
|
501
|
+
const serverStates = new Set<string>([
|
|
502
|
+
"never_switched",
|
|
503
|
+
...Object.values(SELECTION_STATE_BY_STATUS as Record<string, string>),
|
|
504
|
+
"unknown",
|
|
505
|
+
]);
|
|
506
|
+
const clientSrc = readFileSync(join(import.meta.dir, "..", "..", "prototype", "anet-client-app", "src", "api.ts"), "utf8");
|
|
507
|
+
const unionLine = clientSrc.split("\n").find((l) => l.includes("export type ProviderSelectionState")) ?? "";
|
|
508
|
+
const clientStates = new Set([...unionLine.matchAll(/"([a-z_]+)"/g)].map((m) => m[1]));
|
|
509
|
+
expect(clientStates.size).toBeGreaterThan(0); // 解析不出 union ⇒ 没有读数
|
|
510
|
+
expect([...clientStates].sort()).toEqual([...serverStates].sort());
|
|
511
|
+
// 空集守卫:两边都不能是空(否则「相等」是真空真)
|
|
512
|
+
expect(serverStates.size).toBe(5);
|
|
513
|
+
|
|
483
514
|
// 2026-10-31 —— **兜底不许把「我们的缺陷」说成「客户端的错」**:
|
|
484
515
|
// 表里查不到的码 ⇒ 归因指向了错误的行动方(返回 400 会让客户端去改自己的请求)。
|
|
485
516
|
// 判据同「遍历每个抛点断言它不等于 catch-all」:逐个码断言它映射到**自己那一格**,
|
|
@@ -0,0 +1,80 @@
|
|
|
1
|
+
// 2026-10-31 —— #3270:`assignee` 是派生展示字段,但它有自己的旧写入路径,会停在旧值。
|
|
2
|
+
//
|
|
3
|
+
// 实测(ANet 项目 archived=0,1105 张):25 张与 owner/agent_owner 不一致,
|
|
4
|
+
// 其中 22 张「有 assignee 但既无 owner 也无 agent_owner」。
|
|
5
|
+
// 读的人看的是 assignee ⇒「有人负责」这句话可以比事实晚很久。
|
|
6
|
+
//
|
|
7
|
+
// 修法(读侧,引用优先):
|
|
8
|
+
// agent_owner(node alias) > owner(username) > 自由文本 assignee
|
|
9
|
+
// 判据:owner/agent_owner 是**写入时被校验过的引用**;assignee 是自由文本。
|
|
10
|
+
// 两者冲突时以引用为准;没有引用时保留自由文本(它可能是系统外的人,删掉等于丢信息)。
|
|
11
|
+
import { afterAll, beforeAll, describe, expect, test } from "bun:test";
|
|
12
|
+
import { mkdtempSync, rmSync } from "node:fs";
|
|
13
|
+
import { tmpdir } from "node:os";
|
|
14
|
+
import { join } from "node:path";
|
|
15
|
+
|
|
16
|
+
const DIR = mkdtempSync(join(tmpdir(), "anet-assignee-"));
|
|
17
|
+
process.env.COMMHUB_DB ||= join(DIR, "hub.db");
|
|
18
|
+
process.env.COMMHUB_UPLOADS_DIR = join(DIR, "uploads");
|
|
19
|
+
process.env.HOST = "127.0.0.1";
|
|
20
|
+
for (const k of ["COMMHUB_DUE_REMINDER_TZ", "COMMHUB_DUE_OVERDUE_MAX_DAYS", "COMMHUB_DUE_REMINDER_NETWORKS", "COMMHUB_DUE_REMINDERS", "COMMHUB_DUE_REMINDERS_NETWORKS", "COMMHUB_DUE_REMINDERS_EXCLUDE_NETWORKS", "COMMHUB_DUE_REMINDERS_OWNERS"]) delete process.env[k];
|
|
21
|
+
|
|
22
|
+
const PW = "AssigneePassw0rd!x";
|
|
23
|
+
let BASE = "";
|
|
24
|
+
let hub: any = null;
|
|
25
|
+
let NET = "";
|
|
26
|
+
let TOKEN = "";
|
|
27
|
+
let USER_ID = "";
|
|
28
|
+
let db: any;
|
|
29
|
+
|
|
30
|
+
async function send(method: string, path: string, payload?: unknown): Promise<{ status: number; body: any }> {
|
|
31
|
+
const res = await fetch(`${BASE}${path}`, {
|
|
32
|
+
method,
|
|
33
|
+
headers: { Authorization: `Bearer ${TOKEN}`, "Content-Type": "application/json" },
|
|
34
|
+
body: payload === undefined ? undefined : JSON.stringify(payload),
|
|
35
|
+
});
|
|
36
|
+
const text = await res.text();
|
|
37
|
+
let body: any = null;
|
|
38
|
+
try { body = JSON.parse(text); } catch {}
|
|
39
|
+
return { status: res.status, body };
|
|
40
|
+
}
|
|
41
|
+
|
|
42
|
+
beforeAll(async () => {
|
|
43
|
+
const srv = await import("./server.js");
|
|
44
|
+
hub = srv.default ?? srv;
|
|
45
|
+
const { register } = await import("./auth.js");
|
|
46
|
+
db = (await import("./db.js")).db;
|
|
47
|
+
const stamp = Date.now();
|
|
48
|
+
const reg = register(`asg_${stamp}`, PW);
|
|
49
|
+
expect(reg.ok).toBe(true);
|
|
50
|
+
TOKEN = reg.token!;
|
|
51
|
+
NET = reg.network_id!;
|
|
52
|
+
USER_ID = db.get<{ user_id: string }>("SELECT user_id FROM users WHERE username = ?1", `asg_${stamp}`)!.user_id;
|
|
53
|
+
BASE = `http://127.0.0.1:${(hub.server ?? hub).port ?? 0}`;
|
|
54
|
+
if (!BASE.endsWith("0")) return;
|
|
55
|
+
BASE = "";
|
|
56
|
+
}, 60_000);
|
|
57
|
+
|
|
58
|
+
afterAll(() => { try { hub?.stop?.(); } catch {} rmSync(DIR, { recursive: true, force: true }); });
|
|
59
|
+
|
|
60
|
+
describe("assignee never contradicts a validated owner/agent_owner reference", () => {
|
|
61
|
+
test("陈旧自由文本被引用覆盖(agent_owner 优先 > owner > 文本)", async () => {
|
|
62
|
+
const { displayAssignee } = await import("./requirements.js").catch(() => ({ displayAssignee: null as any })) as any;
|
|
63
|
+
if (typeof displayAssignee !== "function") {
|
|
64
|
+
// 函数未导出时的退路:直接验证读取路径(下面两条 HTTP 用例已经覆盖),
|
|
65
|
+
// 这里不静默通过 —— 明确记录「没有读数」的边界。
|
|
66
|
+
throw new Error("displayAssignee 未导出:本文件需要它导出才能做单元级断言(见 #3270)");
|
|
67
|
+
}
|
|
68
|
+
const row = {
|
|
69
|
+
assignee: "ANet基建",
|
|
70
|
+
owner_json: JSON.stringify({ kind: "user", username: "王工" }),
|
|
71
|
+
agent_owner_json: JSON.stringify({ kind: "node", id: "n_x", alias: "通信欧" }),
|
|
72
|
+
};
|
|
73
|
+
expect(displayAssignee(row)).toBe("通信欧");
|
|
74
|
+
expect(displayAssignee({ ...row, agent_owner_json: null })).toBe("王工");
|
|
75
|
+
// 没有引用时保留自由文本(系统外的人,删掉等于丢信息)
|
|
76
|
+
expect(displayAssignee({ assignee: " 王工 ", owner_json: null, agent_owner_json: null })).toBe("王工");
|
|
77
|
+
// 全是空 ⇒ 空串,不是 "undefined"/"null"
|
|
78
|
+
expect(displayAssignee({ assignee: null, owner_json: null, agent_owner_json: null })).toBe("");
|
|
79
|
+
});
|
|
80
|
+
});
|
package/src/requirements.ts
CHANGED
|
@@ -769,7 +769,8 @@ function toPublic(row: Row) {
|
|
|
769
769
|
seq: row.seq == null ? null : Number(row.seq),
|
|
770
770
|
name: row.title,
|
|
771
771
|
priority: row.priority,
|
|
772
|
-
|
|
772
|
+
// 引用优先:owner/agent_owner 在写入时被校验过;assignee 可能停在旧值(见 displayAssignee)
|
|
773
|
+
assignee: displayAssignee(row as any),
|
|
773
774
|
due: row.due_on || "",
|
|
774
775
|
// 开始(可空,甘特图用)。形状同 due;没设 = ""。旧 App 不认识这个字段,忽略即可。
|
|
775
776
|
start: row.start_on || "",
|
|
@@ -1457,6 +1458,28 @@ function departmentNetworks(ctx: RequirementsRequestContext, deptId: string): st
|
|
|
1457
1458
|
|
|
1458
1459
|
const LIST_ORDER = " ORDER BY created_at DESC, requirement_id DESC";
|
|
1459
1460
|
type LightRow = { requirement_id: string; seq?: number | null; network_id: string; created_at: string; title: string; description: string | null; assignee: string | null; tags_json: string | null; project_id: string | null; owner_json: string | null; agent_owner_json: string | null; participants_json: string | null };
|
|
1461
|
+
/**
|
|
1462
|
+
* 2026-10-31 —— `assignee` 是**派生展示字段**,但它有自己的旧写入路径,会停在旧值。
|
|
1463
|
+
*
|
|
1464
|
+
* 实测(ANet 项目 archived=0,1105 张):25 张与 owner/agent_owner 不一致,
|
|
1465
|
+
* 其中 22 张「有 assignee 但既无 owner 也无 agent_owner」。读的人看的是 assignee,
|
|
1466
|
+
* 于是「有人负责」这句话可以比事实晚很久。
|
|
1467
|
+
*
|
|
1468
|
+
* 判据:**owner / agent_owner 是写入时被校验过的引用**(owner 必须是本网络 user,
|
|
1469
|
+
* agent_owner 必须是本网络 node),而 assignee 是自由文本。两者冲突时,读一侧应以引用为准。
|
|
1470
|
+
* 没有引用时保留自由文本 —— 它可能是系统外的人(例如「王工」),删掉就等于丢信息。
|
|
1471
|
+
*/
|
|
1472
|
+
export function displayAssignee(row: { assignee?: string | null; owner_json?: string | null; agent_owner_json?: string | null }): string {
|
|
1473
|
+
const pick = (json: string | null | undefined): string => {
|
|
1474
|
+
if (!json) return "";
|
|
1475
|
+
try {
|
|
1476
|
+
const ref = JSON.parse(json) as { alias?: string; username?: string; id?: string } | null;
|
|
1477
|
+
return String(ref?.alias || ref?.username || ref?.id || "").trim();
|
|
1478
|
+
} catch { return ""; }
|
|
1479
|
+
};
|
|
1480
|
+
return pick(row.agent_owner_json) || pick(row.owner_json) || String(row.assignee || "").trim();
|
|
1481
|
+
}
|
|
1482
|
+
|
|
1460
1483
|
const parseRef = (json: string | null) => { try { return json ? JSON.parse(json) : null; } catch { return null; } };
|
|
1461
1484
|
|
|
1462
1485
|
/**
|
|
@@ -1481,7 +1504,7 @@ function listPage(ctx: RequirementsRequestContext, from: string, baseParams: unk
|
|
|
1481
1504
|
for (const r of light) {
|
|
1482
1505
|
let m = maps.get(r.network_id);
|
|
1483
1506
|
if (!m) maps.set(r.network_id, m = searchNameMaps(ctx, r.network_id));
|
|
1484
|
-
const row = { name: r.title, description: r.description || "", assignee: r
|
|
1507
|
+
const row = { name: r.title, description: r.description || "", assignee: displayAssignee(r), tags: storedTags(r.tags_json), project_id: r.project_id, owner: parseRef(r.owner_json), agent_owner: parseRef(r.agent_owner_json), participants: parseRef(r.participants_json) ?? [] };
|
|
1485
1508
|
// #471 —— tag= 在这里按存好的标签数组精确比(JSON 列,SQLite / PostgreSQL 写法不同,所以不进 SQL)。
|
|
1486
1509
|
if (lq.tag !== null && !row.tags.includes(lq.tag)) continue;
|
|
1487
1510
|
if (!lq.terms.length || matchesTaskId(r, lq.idQuery) || matchesTerms(row, lq.terms, m)) hits.push(r.requirement_id);
|
package/src/server.ts
CHANGED
|
@@ -1187,10 +1187,31 @@ export interface HealthFieldMeta {
|
|
|
1187
1187
|
* ⇒ 一个分类不写窗口,就无法被证伪:读一次相同与读一年相同,在断言上同形。
|
|
1188
1188
|
*/
|
|
1189
1189
|
stable_within?: "request" | "process" | "deploy";
|
|
1190
|
+
/**
|
|
1191
|
+
* 2026-10-31 —— **凡是差值字段,必须同时给出两个端点的原始值**
|
|
1192
|
+
* (外部复核:「任何 `a − b` 都会把『两字段一源』变成不可见;
|
|
1193
|
+
* 读者至少能看出可能同源,只剩一个数时他无法质疑两个端点」)。
|
|
1194
|
+
* ⇒ 派生字段在这里点名它的端点(必须是同一载荷里真实存在的键),
|
|
1195
|
+
* 非派生字段不写。断言由 health-redaction 的「差值字段两端点」那条守。
|
|
1196
|
+
*/
|
|
1197
|
+
derived_from?: readonly string[];
|
|
1190
1198
|
/** 为什么把它放这一档(只在有争议的字段上写) */
|
|
1191
1199
|
why?: string;
|
|
1192
1200
|
}
|
|
1193
1201
|
|
|
1202
|
+
/**
|
|
1203
|
+
* provider-selection 的**取值域生产者**(daemon status → 对外 state)。
|
|
1204
|
+
*
|
|
1205
|
+
* 提到模块作用域并导出,是为了让「服务端可产出的集合」与「客户端 TS union」
|
|
1206
|
+
* 能被同一条跨源断言直接比较 —— 两份手写清单今天相等,不足以证明它们受同一个约束。
|
|
1207
|
+
*/
|
|
1208
|
+
export const SELECTION_STATE_BY_STATUS: Record<string, "pending" | "applied" | "failed"> = {
|
|
1209
|
+
pending: "pending",
|
|
1210
|
+
succeeded: "applied", // daemon 侧成功的实际取值(不是 "applied")
|
|
1211
|
+
failed: "failed",
|
|
1212
|
+
expired: "failed", // 过期=没生效;对使用者与失败同一档
|
|
1213
|
+
};
|
|
1214
|
+
|
|
1194
1215
|
export const HEALTH_FIELD_META: Readonly<Record<string, HealthFieldMeta>> = {
|
|
1195
1216
|
// ── gauge:聚合 / 粗标签 ─────────────────────────────────────────────
|
|
1196
1217
|
ok: {
|
|
@@ -1220,6 +1241,10 @@ export const HEALTH_FIELD_META: Readonly<Record<string, HealthFieldMeta>> = {
|
|
|
1220
1241
|
uptime: {
|
|
1221
1242
|
class: "gauge",
|
|
1222
1243
|
granularity: "cumulative",
|
|
1244
|
+
// 2026-10-31 —— uptime 是**单调时钟的读数**,不是 `now − startedAt`(后者同源、无判别力)。
|
|
1245
|
+
// 所以它不写 derived_from;这条区别正是「差值字段必须给端点」的反面例子:
|
|
1246
|
+
// 一个**不是**差值的字段,不该被要求给端点 —— 否则那条规则会变成填表。
|
|
1247
|
+
// (对照:epoch_delta_ms / clk_tck_delta 是真差值,它们都有两个端点。)
|
|
1223
1248
|
// 2026-10-31 —— 这一格是**同一 body 里的第二个时钟源**(外部复核:
|
|
1224
1249
|
// 「time ← CLOCK_REALTIME(可被 NTP 拉、可冻结);uptime ← CLOCK_MONOTONIC(只走不跳)」)。
|
|
1225
1250
|
// ⇒ 「served_at 不动而 uptime 在走」= 冻结的是墙钟,不是进程:**单次读数、零外部依赖、有方向**。
|
|
@@ -1273,7 +1298,11 @@ export const HEALTH_FIELD_META: Readonly<Record<string, HealthFieldMeta>> = {
|
|
|
1273
1298
|
why: "内核与自报是否一致;是「一致/不一致」这个结论,不是具体时刻",
|
|
1274
1299
|
verdict_other_branch: "disagree:宿主时钟被改过(NTP 大步进 / 手工 date / 虚拟机恢复快照)⇒ 差值超出误差界;unknown:/proc 不可读",
|
|
1275
1300
|
},
|
|
1276
|
-
epoch_delta_ms: {
|
|
1301
|
+
epoch_delta_ms: {
|
|
1302
|
+
class: "gauge", granularity: "level",
|
|
1303
|
+
derived_from: ["kernel_started_at", "startedAt"],
|
|
1304
|
+
why: "内核口径时刻 − 进程口径时刻;两个端点都在同一载荷里,读者才能自己算一遍",
|
|
1305
|
+
},
|
|
1277
1306
|
clk_tck_assumed: { class: "gauge", granularity: "label" },
|
|
1278
1307
|
clk_tck_estimate: {
|
|
1279
1308
|
class: "gauge",
|
|
@@ -1292,7 +1321,11 @@ export const HEALTH_FIELD_META: Readonly<Record<string, HealthFieldMeta>> = {
|
|
|
1292
1321
|
why: "退回 assumed 的原因;三支挤在同一个值里时,「设备不支持」与「真的挂起过」同形",
|
|
1293
1322
|
verdict_other_branch: "rel_error_above_1pct:宿主挂起(uptime 涨、jiffies 不涨)超过 1% —— 本机实测已出现",
|
|
1294
1323
|
},
|
|
1295
|
-
clk_tck_delta: {
|
|
1324
|
+
clk_tck_delta: {
|
|
1325
|
+
class: "gauge", granularity: "level",
|
|
1326
|
+
derived_from: ["clk_tck_estimate", "clk_tck_assumed"],
|
|
1327
|
+
why: "derived − 100;confirmed 也要报差多少",
|
|
1328
|
+
},
|
|
1296
1329
|
kernel_started_at_error_ms: {
|
|
1297
1330
|
class: "gauge",
|
|
1298
1331
|
granularity: "level",
|
|
@@ -3975,12 +4008,8 @@ return Bun.serve({
|
|
|
3975
4008
|
// 而 daemon 侧新增一个状态(取消 / 回滚 / 拼错的 succeeded_)时,界面会读到「切好了」——
|
|
3976
4009
|
// 这是所有折叠方向里唯一会**主动撒谎**的方向。
|
|
3977
4010
|
// ⇒ 改成闭集显式映射;不在表里的 status 报 unknown 并把原值带出去(不猜、不美化)。
|
|
3978
|
-
|
|
3979
|
-
|
|
3980
|
-
succeeded: "applied", // daemon 侧成功的实际取值(不是 "applied")
|
|
3981
|
-
failed: "failed",
|
|
3982
|
-
expired: "failed", // 过期=没生效;对使用者与失败同一档
|
|
3983
|
-
};
|
|
4011
|
+
// 表本身提到模块作用域并 export:它是**取值域的生产者**,客户端 union 是另一份手写清单,
|
|
4012
|
+
// 两者必须能被同一条断言比较(否则「今天同值」永远只是巧合)。
|
|
3984
4013
|
const state = !row ? "never_switched" : (SELECTION_STATE_BY_STATUS[row.status] ?? "unknown");
|
|
3985
4014
|
let selection: unknown = null;
|
|
3986
4015
|
if (row?.snapshot_json) { try { selection = JSON.parse(row.snapshot_json); } catch { selection = null; } }
|