@sleep2agi/commhub-server 0.9.0-preview.237 → 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 +1 -1
- package/src/health-redaction.test.ts +132 -0
- package/src/hub-catalog-read-http.test.ts +31 -0
- package/src/requirements-assignee-drift.test.ts +80 -0
- package/src/requirements.ts +25 -2
- package/src/server.ts +65 -14
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",
|
|
@@ -852,6 +852,84 @@ describe("#473 anonymous /health — watchdog contract intact, no topology leak"
|
|
|
852
852
|
expect(HEALTH_FIELD_META.served_at.frozen_at_boot).toBeUndefined();
|
|
853
853
|
});
|
|
854
854
|
|
|
855
|
+
// 2026-10-31 —— **分类不决定「变不变」,还缺「窗口」这个参数**(外部复核 (e):
|
|
856
|
+
// 「`startedAt` 属 instance,却会在 failover 时变,正是你自己那张表的反例;
|
|
857
|
+
// 处理分三态 pinned / excluded / allowed,而不是混进白名单」)。
|
|
858
|
+
//
|
|
859
|
+
// 本仓的 `frozen_at_boot: true` 到此为止只是一条**声明**:没有任何断言把它和
|
|
860
|
+
// 「同一个进程在窗口内读两次,这个值不变」对上。声明与行为之间没有桥,
|
|
861
|
+
// 于是分类错了只会被下一个人读出来,不会被测试读出来。
|
|
862
|
+
//
|
|
863
|
+
// 判据(三态在这里的落法):
|
|
864
|
+
// pinned = frozen_at_boot:true ⇒ 窗口内必须**逐字节相同**,变了就红
|
|
865
|
+
// allowed = 没打 frozen 标 ⇒ 变不变都可以,本测试不管
|
|
866
|
+
// excluded = 会变且不该被 pinned ⇒ 必须存在并在正向对照里出现(见下)
|
|
867
|
+
// 窗口显式:WINDOW_MS 写在断言里,而不是「两次读一下大概就行」。
|
|
868
|
+
test("frozen_at_boot fields really do not change within a declared window", async () => {
|
|
869
|
+
const { HEALTH_FIELD_META } = await import("./server.js");
|
|
870
|
+
const WINDOW_MS = 1200;
|
|
871
|
+
expect(WINDOW_MS).toBeGreaterThan(0); // 窗口为 0 的「没变」不构成读数
|
|
872
|
+
|
|
873
|
+
const a = await (await fetch(`${BASE}/health`)).json() as Record<string, unknown>;
|
|
874
|
+
await new Promise((r) => setTimeout(r, WINDOW_MS));
|
|
875
|
+
const b = await (await fetch(`${BASE}/health`)).json() as Record<string, unknown>;
|
|
876
|
+
|
|
877
|
+
// 每一个 pinned 字段还必须**声明窗口**:不写窗口的「不变」无法被证伪。
|
|
878
|
+
// 三态(外部复核 (e)):pinned = 有窗口且窗口内必须不变;allowed = 没打标;
|
|
879
|
+
// excluded = 会变且不该被打成 pinned —— 它必须存在,否则「都 pinned」就没有反例。
|
|
880
|
+
const pinnedAll = Object.entries(HEALTH_FIELD_META).filter(([, m]) => m.frozen_at_boot === true);
|
|
881
|
+
const noWindow = pinnedAll.filter(([, m]) => !m.stable_within).map(([k]) => k);
|
|
882
|
+
expect(noWindow).toEqual([]); // 声明了 pinned 就必须声明窗口
|
|
883
|
+
const windows = new Set(pinnedAll.map(([, m]) => m.stable_within));
|
|
884
|
+
for (const w of windows) expect(["request", "process", "deploy"]).toContain(w as string);
|
|
885
|
+
|
|
886
|
+
const pinned = pinnedAll
|
|
887
|
+
.map(([k]) => k)
|
|
888
|
+
.filter((k) => k in a && k in b);
|
|
889
|
+
// 分母:匿名投影里至少要能看见 1 个 pinned 字段,否则这条测试是真空真
|
|
890
|
+
expect(pinned.length).toBeGreaterThan(0);
|
|
891
|
+
|
|
892
|
+
const moved = pinned.filter((k) => JSON.stringify(a[k]) !== JSON.stringify(b[k]));
|
|
893
|
+
expect(moved).toEqual([]); // 声明是 pinned,就必须在窗口内真的不动
|
|
894
|
+
|
|
895
|
+
// ⚠️ 这条检查的**弱点必须写出来**(否则它会被读成比实际更强的东西):
|
|
896
|
+
// 一个值**本来就在这个窗口里不变**的字段,即使被错误地标成 pinned,也照样通过。
|
|
897
|
+
// 实测 witness:把 `sessions_count` 标成 `frozen_at_boot + stable_within:"process"`,
|
|
898
|
+
// 测试**仍然绿** —— 因为空测试库里它恒为 0。
|
|
899
|
+
// ⇒ 这条断言真正守住的是「标了 pinned 的字段在窗口内不许变」,
|
|
900
|
+
// 它**不能**守住「pinned 打得对」。后者只有两种办法:
|
|
901
|
+
// ① 造一个真会变的场景(连接数变化 / 重启 / failover)再读两次;
|
|
902
|
+
// ② 用第二个观测者(另一个实例、另一台机器),而不是对同一实例再采样一次。
|
|
903
|
+
// 今天本仓两样都没有 ⇒ 这一格只能到「窗口声明 + 窗口内不变」为止。
|
|
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
|
+
|
|
925
|
+
// 正向对照:窗口内必须**有东西会变**,否则「都没变」可能只是「两次读的是同一份缓存」。
|
|
926
|
+
// 这不是洁癖:一个恒定的响应体可以让上面那条永远绿。
|
|
927
|
+
const changed = Object.keys(a).filter((k) => k in b && JSON.stringify(a[k]) !== JSON.stringify(b[k]));
|
|
928
|
+
expect(changed.length).toBeGreaterThan(0);
|
|
929
|
+
// 且变化必须**不含**任何 pinned 字段(与上面互为镜像:一条说“没变”,一条说“别的在变”)
|
|
930
|
+
expect(changed.filter((k) => pinned.includes(k))).toEqual([]);
|
|
931
|
+
});
|
|
932
|
+
|
|
855
933
|
// 2026-10-31 —— credential 的「可对账性」是**字段取值**,不是注释里的辩论。
|
|
856
934
|
test("joinability decides anonymity, not the reader's interpretation", async () => {
|
|
857
935
|
const { HEALTH_FIELD_META, mayBePublic } = await import("./server.js");
|
|
@@ -1206,6 +1284,60 @@ describe("#473 anonymous /health — watchdog contract intact, no topology leak"
|
|
|
1206
1284
|
expect(forbidden).toEqual([]);
|
|
1207
1285
|
});
|
|
1208
1286
|
|
|
1287
|
+
// 2026-10-31 —— **「谁写的」比「谁先谁后」更抗重构**(外部复核:头集合当主判据)。
|
|
1288
|
+
// 部署前面有 nginx/反代时,客户端拿到的错误页可能不是我们写的。
|
|
1289
|
+
// 判据不是「content-type 是 json」(那要求每个客户端都记得先看),
|
|
1290
|
+
// 而是一个**静态**产出者标记:有它 ⇒ 这段字节出自 hub;没有 ⇒ 出自它前面的某一层。
|
|
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
|
+
|
|
1325
|
+
test("every hub response carries a constant producer marker (so a proxy page is distinguishable)", async () => {
|
|
1326
|
+
const paths = ["/health", "/api/definitely-not-a-route", "/"];
|
|
1327
|
+
const seen: (string | null)[] = [];
|
|
1328
|
+
for (const path of paths) {
|
|
1329
|
+
const res = await fetch(`${BASE}${path}`);
|
|
1330
|
+
seen.push(res.headers.get("X-CommHub"));
|
|
1331
|
+
}
|
|
1332
|
+
// 三个不同出口(健康检查 / 404 / 帮助页)都必须带,且值相同
|
|
1333
|
+
expect(seen).toEqual(["hub", "hub", "hub"]);
|
|
1334
|
+
// 静态性:同一路径两次读到的值必须一致(否则它是指纹,不是产出者标记)
|
|
1335
|
+
const again = await fetch(`${BASE}/health`);
|
|
1336
|
+
expect(again.headers.get("X-CommHub")).toBe("hub");
|
|
1337
|
+
// 与「匿名无指纹」那条不冲突:这个头不含 git/commit/build 类词
|
|
1338
|
+
expect(/git|commit|build[-_]?(sha|id)?/.test("x-commhub")).toBe(false);
|
|
1339
|
+
});
|
|
1340
|
+
|
|
1209
1341
|
test("no dead entries: every allow-listed key is actually served to anonymous callers", async () => {
|
|
1210
1342
|
const { PUBLIC_HEALTH_KEYS } = await import("./server.js");
|
|
1211
1343
|
const plain = await (await fetch(`${BASE}/health`)).json() as any;
|
|
@@ -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
|
@@ -1173,10 +1173,45 @@ export interface HealthFieldMeta {
|
|
|
1173
1173
|
* 只写「什么算」的分类,对形似字段没有抵抗力。
|
|
1174
1174
|
*/
|
|
1175
1175
|
frozen_at_boot?: true;
|
|
1176
|
+
/**
|
|
1177
|
+
* 2026-10-31 —— **分类必须带窗口**(外部复核 (e):「六分类不决定『变不变』,
|
|
1178
|
+
* 还缺『窗口』这一参数;`startedAt` 属 instance 却会在 failover 时变,
|
|
1179
|
+
* 处理应分三态 pinned / excluded / allowed,而不是混进白名单」)。
|
|
1180
|
+
*
|
|
1181
|
+
* 「这个字段是常量」不是一句可以单独成立的话——它总得回答「在多长的时间里」。
|
|
1182
|
+
* 本仓的取值:
|
|
1183
|
+
* request —— 同一次请求内不变(例如聚合出来的标签)
|
|
1184
|
+
* process —— 同一个进程内不变(startedAt / pid / boot_id / git_commit);
|
|
1185
|
+
* **跨进程会变**(重启 / failover / 换制品),所以它不能用来做实例身份
|
|
1186
|
+
* deploy —— 跨进程也不变(例如 version_source 的取值域)
|
|
1187
|
+
* ⇒ 一个分类不写窗口,就无法被证伪:读一次相同与读一年相同,在断言上同形。
|
|
1188
|
+
*/
|
|
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[];
|
|
1176
1198
|
/** 为什么把它放这一档(只在有争议的字段上写) */
|
|
1177
1199
|
why?: string;
|
|
1178
1200
|
}
|
|
1179
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
|
+
|
|
1180
1215
|
export const HEALTH_FIELD_META: Readonly<Record<string, HealthFieldMeta>> = {
|
|
1181
1216
|
// ── gauge:聚合 / 粗标签 ─────────────────────────────────────────────
|
|
1182
1217
|
ok: {
|
|
@@ -1206,13 +1241,17 @@ export const HEALTH_FIELD_META: Readonly<Record<string, HealthFieldMeta>> = {
|
|
|
1206
1241
|
uptime: {
|
|
1207
1242
|
class: "gauge",
|
|
1208
1243
|
granularity: "cumulative",
|
|
1244
|
+
// 2026-10-31 —— uptime 是**单调时钟的读数**,不是 `now − startedAt`(后者同源、无判别力)。
|
|
1245
|
+
// 所以它不写 derived_from;这条区别正是「差值字段必须给端点」的反面例子:
|
|
1246
|
+
// 一个**不是**差值的字段,不该被要求给端点 —— 否则那条规则会变成填表。
|
|
1247
|
+
// (对照:epoch_delta_ms / clk_tck_delta 是真差值,它们都有两个端点。)
|
|
1209
1248
|
// 2026-10-31 —— 这一格是**同一 body 里的第二个时钟源**(外部复核:
|
|
1210
1249
|
// 「time ← CLOCK_REALTIME(可被 NTP 拉、可冻结);uptime ← CLOCK_MONOTONIC(只走不跳)」)。
|
|
1211
1250
|
// ⇒ 「served_at 不动而 uptime 在走」= 冻结的是墙钟,不是进程:**单次读数、零外部依赖、有方向**。
|
|
1212
1251
|
// 前提必须成立:uptime 来自 process.uptime()(单调),**不是** Date.now()-startedAt(同源就没判别力)。
|
|
1213
1252
|
why: "进程已运行秒数(process.uptime(),单调时钟)。与 served_at/startedAt 不同源:墙钟被 NTP 冻结时它仍在走 ⇒ 可判「是钟停了还是进程停了」",
|
|
1214
1253
|
},
|
|
1215
|
-
startedAt: { frozen_at_boot: true, class: "gauge", granularity: "instant", why: "窗口起点;去掉它,event_loop 里的 stall 计数就没有分母时刻戳" },
|
|
1254
|
+
startedAt: { frozen_at_boot: true, stable_within: "process", class: "gauge", granularity: "instant", why: "窗口起点;去掉它,event_loop 里的 stall 计数就没有分母时刻戳" },
|
|
1216
1255
|
sessions_count: { class: "gauge", granularity: "level" },
|
|
1217
1256
|
sse_connections: { class: "gauge", granularity: "level" },
|
|
1218
1257
|
mcp_inflight: { class: "gauge", granularity: "level" },
|
|
@@ -1259,7 +1298,11 @@ export const HEALTH_FIELD_META: Readonly<Record<string, HealthFieldMeta>> = {
|
|
|
1259
1298
|
why: "内核与自报是否一致;是「一致/不一致」这个结论,不是具体时刻",
|
|
1260
1299
|
verdict_other_branch: "disagree:宿主时钟被改过(NTP 大步进 / 手工 date / 虚拟机恢复快照)⇒ 差值超出误差界;unknown:/proc 不可读",
|
|
1261
1300
|
},
|
|
1262
|
-
epoch_delta_ms: {
|
|
1301
|
+
epoch_delta_ms: {
|
|
1302
|
+
class: "gauge", granularity: "level",
|
|
1303
|
+
derived_from: ["kernel_started_at", "startedAt"],
|
|
1304
|
+
why: "内核口径时刻 − 进程口径时刻;两个端点都在同一载荷里,读者才能自己算一遍",
|
|
1305
|
+
},
|
|
1263
1306
|
clk_tck_assumed: { class: "gauge", granularity: "label" },
|
|
1264
1307
|
clk_tck_estimate: {
|
|
1265
1308
|
class: "gauge",
|
|
@@ -1278,7 +1321,11 @@ export const HEALTH_FIELD_META: Readonly<Record<string, HealthFieldMeta>> = {
|
|
|
1278
1321
|
why: "退回 assumed 的原因;三支挤在同一个值里时,「设备不支持」与「真的挂起过」同形",
|
|
1279
1322
|
verdict_other_branch: "rel_error_above_1pct:宿主挂起(uptime 涨、jiffies 不涨)超过 1% —— 本机实测已出现",
|
|
1280
1323
|
},
|
|
1281
|
-
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
|
+
},
|
|
1282
1329
|
kernel_started_at_error_ms: {
|
|
1283
1330
|
class: "gauge",
|
|
1284
1331
|
granularity: "level",
|
|
@@ -1304,7 +1351,7 @@ export const HEALTH_FIELD_META: Readonly<Record<string, HealthFieldMeta>> = {
|
|
|
1304
1351
|
|
|
1305
1352
|
// ── landmark:精确位置/身份 ──────────────────────────────────────────
|
|
1306
1353
|
git_commit: {
|
|
1307
|
-
frozen_at_boot: true,
|
|
1354
|
+
frozen_at_boot: true, stable_within: "deploy",
|
|
1308
1355
|
class: "landmark",
|
|
1309
1356
|
why: "精确告诉外部这是哪一版代码(本仓公开)⇒ 等于指路到已知问题清单",
|
|
1310
1357
|
identity_class: "artifact",
|
|
@@ -1328,10 +1375,10 @@ export const HEALTH_FIELD_META: Readonly<Record<string, HealthFieldMeta>> = {
|
|
|
1328
1375
|
},
|
|
1329
1376
|
// 逐会话明细 = 拓扑 ⇒ 只需「有几个」,不需要「哪几个」(与 #473 的审计同一条)
|
|
1330
1377
|
sse_sessions: { class: "landmark", why: "按键列出连接 = 网络 id + 别名,正是 #473 那个泄露面" },
|
|
1331
|
-
pid: { frozen_at_boot: true, class: "landmark" },
|
|
1332
|
-
boot_id: { frozen_at_boot: true, class: "landmark" },
|
|
1333
|
-
proc_start_ticks: { frozen_at_boot: true, class: "landmark" },
|
|
1334
|
-
kernel_started_at: { frozen_at_boot: true, class: "landmark", why: "内核口径的精确启动时刻 ⇒ 可与外部日志对账" },
|
|
1378
|
+
pid: { frozen_at_boot: true, stable_within: "process", class: "landmark" },
|
|
1379
|
+
boot_id: { frozen_at_boot: true, stable_within: "process", class: "landmark" },
|
|
1380
|
+
proc_start_ticks: { frozen_at_boot: true, stable_within: "process", class: "landmark" },
|
|
1381
|
+
kernel_started_at: { frozen_at_boot: true, stable_within: "process", class: "landmark", why: "内核口径的精确启动时刻 ⇒ 可与外部日志对账" },
|
|
1335
1382
|
kernel_started_at_note: { class: "landmark" },
|
|
1336
1383
|
|
|
1337
1384
|
// ── credential ─────────────────────────────────────────────────────
|
|
@@ -1714,6 +1761,14 @@ function withCors(req: Request, res: Response): Response {
|
|
|
1714
1761
|
for (const [k, v] of Object.entries(headers)) {
|
|
1715
1762
|
res.headers.set(k, v);
|
|
1716
1763
|
}
|
|
1764
|
+
// 2026-10-31 —— **「谁写的」比「谁先谁后」更抗重构**(外部复核:
|
|
1765
|
+
// 「头集合作第二主判据:它判『谁写的』,不判『谁先谁后』」)。
|
|
1766
|
+
// 部署在前面有 nginx / 任何反代时,客户端拿到的错误页可能不是我们写的:
|
|
1767
|
+
// 代理的 502/504 页面是 HTML,而我们的错误是 JSON —— 但只靠 content-type 判,
|
|
1768
|
+
// 等于要求每个客户端都记得先看 content-type。
|
|
1769
|
+
// ⇒ 加一个**静态**的产出者标记:同一个值永远不变,所以它不构成指纹
|
|
1770
|
+
// (与 `version_role` / `git_commit` 那类「回答我站在哪一层」的头不是一回事)。
|
|
1771
|
+
res.headers.set("X-CommHub", "hub");
|
|
1717
1772
|
return res;
|
|
1718
1773
|
}
|
|
1719
1774
|
|
|
@@ -3953,12 +4008,8 @@ return Bun.serve({
|
|
|
3953
4008
|
// 而 daemon 侧新增一个状态(取消 / 回滚 / 拼错的 succeeded_)时,界面会读到「切好了」——
|
|
3954
4009
|
// 这是所有折叠方向里唯一会**主动撒谎**的方向。
|
|
3955
4010
|
// ⇒ 改成闭集显式映射;不在表里的 status 报 unknown 并把原值带出去(不猜、不美化)。
|
|
3956
|
-
|
|
3957
|
-
|
|
3958
|
-
succeeded: "applied", // daemon 侧成功的实际取值(不是 "applied")
|
|
3959
|
-
failed: "failed",
|
|
3960
|
-
expired: "failed", // 过期=没生效;对使用者与失败同一档
|
|
3961
|
-
};
|
|
4011
|
+
// 表本身提到模块作用域并 export:它是**取值域的生产者**,客户端 union 是另一份手写清单,
|
|
4012
|
+
// 两者必须能被同一条断言比较(否则「今天同值」永远只是巧合)。
|
|
3962
4013
|
const state = !row ? "never_switched" : (SELECTION_STATE_BY_STATUS[row.status] ?? "unknown");
|
|
3963
4014
|
let selection: unknown = null;
|
|
3964
4015
|
if (row?.snapshot_json) { try { selection = JSON.parse(row.snapshot_json); } catch { selection = null; } }
|