@sleep2agi/commhub-server 0.9.0-preview.219 → 0.9.0-preview.220
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/agent-acl-slice3-http.test.ts +388 -1
- package/src/config-apply-validate.test.ts +68 -0
- package/src/config-apply-validate.ts +69 -0
- package/src/cors-origins.test.ts +40 -0
- package/src/create-node-network-id.test.ts +12 -0
- package/src/department-heads-http.test.ts +20 -0
- package/src/departments-agent-count.test.ts +3 -0
- package/src/etag-of.test.ts +57 -0
- package/src/event-loop-lag.ts +20 -0
- package/src/health-anon-readers.ts +59 -0
- package/src/health-host-disk-2756.test.ts +23 -1
- package/src/health-redaction.test.ts +1063 -0
- package/src/hub-catalog-read-http.test.ts +79 -0
- package/src/hub-provider-config.test.ts +17 -0
- package/src/hub-provider-config.ts +19 -0
- package/src/license-state.test.ts +56 -0
- package/src/license-state.ts +48 -0
- package/src/list-host-supervisors.test.ts +10 -0
- package/src/mcp-projects-events-http.test.ts +3 -0
- package/src/mcp-write-network-resolution.test.ts +3 -0
- package/src/node-caller-identity-http.test.ts +9 -1
- package/src/node-health-dispatch-http.test.ts +58 -2
- package/src/node-health-guard.ts +16 -0
- package/src/node-skills-transport.test.ts +3 -0
- package/src/opencode-v2-catalog.ts +4 -0
- package/src/redact-tokens.test.ts +22 -1
- package/src/redact-tokens.ts +4 -1
- package/src/rejection-counters.test.ts +72 -0
- package/src/rejection-counters.ts +173 -0
- package/src/requirement-events-http.test.ts +27 -0
- package/src/route-callers-http.test.ts +1 -1
- package/src/serve-error.test.ts +35 -0
- package/src/serve-error.ts +33 -4
- package/src/server.ts +913 -17
- package/src/shared/probe-host-allowlist-drift.test.ts +45 -0
- package/src/skillhub-http.test.ts +35 -1
- package/src/status-read-cache.ts +8 -1
- package/src/task-late-reply-http.test.ts +7 -0
- package/src/task-rejection-log.ts +10 -1
- package/src/tmux-allowlist.test.ts +48 -0
- package/src/tool-audience.ts +10 -3
- package/src/tools.ts +99 -15
|
@@ -44,6 +44,51 @@ describe("RFC-028 P1 — hub/daemon probe-host-allowlist drift guard", () => {
|
|
|
44
44
|
}
|
|
45
45
|
});
|
|
46
46
|
|
|
47
|
+
// 2026-10-31 —— **跨源相等不是内容锁定**(外部复核:「两个 vantage 都得到同一个数不能当成同一读数」)。
|
|
48
|
+
// 下面那条 drift 断言比的是 hub 与 daemon 两份副本:
|
|
49
|
+
// 两边一起改 ⇒ 仍然相等 ⇒ 它绿着,而 SSRF 防线已经变了。
|
|
50
|
+
// ⇒ 再加一层「对着字面量」的身份锁 + 「每条都必须真的能命中」的阳性对照。
|
|
51
|
+
test("private-IP block lists are pinned by identity against literals", () => {
|
|
52
|
+
// ① 身份:逐条 source 相等(不是数量相等)
|
|
53
|
+
expect(HUB_V4.map((r) => r.source)).toEqual([
|
|
54
|
+
"^10\\.",
|
|
55
|
+
"^127\\.",
|
|
56
|
+
"^172\\.(1[6-9]|2[0-9]|3[0-1])\\.",
|
|
57
|
+
"^192\\.168\\.",
|
|
58
|
+
"^169\\.254\\.",
|
|
59
|
+
"^100\\.(6[4-9]|[7-9][0-9]|1[01][0-9]|12[0-7])\\.",
|
|
60
|
+
"^0\\.",
|
|
61
|
+
"^22[4-9]\\.",
|
|
62
|
+
"^23[0-9]\\.",
|
|
63
|
+
"^24[0-9]\\.",
|
|
64
|
+
"^25[0-5]\\.",
|
|
65
|
+
]);
|
|
66
|
+
expect(HUB_V6.map((r) => r.source)).toEqual([
|
|
67
|
+
"^::1$",
|
|
68
|
+
"^::$",
|
|
69
|
+
"^fe80:",
|
|
70
|
+
"^fc00:",
|
|
71
|
+
"^fd00:",
|
|
72
|
+
]);
|
|
73
|
+
});
|
|
74
|
+
|
|
75
|
+
test("every private-IP pattern actually fires (a never-matching entry is an empty slot)", () => {
|
|
76
|
+
// ② 阳性对照:清单里每一条都必须能命中至少一个代表地址。
|
|
77
|
+
// 一个永远匹配不到的模式,与「没有这一条」在行为上完全相同 —— 而清单会让人以为它有。
|
|
78
|
+
const v4Samples = ["10.1.2.3", "127.0.0.1", "172.16.0.1", "192.168.1.1", "169.254.169.254", "100.64.0.1", "0.0.0.0", "224.0.0.1", "239.1.1.1", "240.0.0.1", "255.255.255.255"];
|
|
79
|
+
expect(v4Samples).toHaveLength(HUB_V4.length);
|
|
80
|
+
HUB_V4.forEach((re, i) => {
|
|
81
|
+
expect(re.test(v4Samples[i])).toBe(true);
|
|
82
|
+
expect(re.test("8.8.8.8")).toBe(false); // 每一条都必须**不**命中公网地址
|
|
83
|
+
});
|
|
84
|
+
const v6Samples = ["::1", "::", "fe80::1", "fc00::1", "fd00::1"];
|
|
85
|
+
expect(v6Samples).toHaveLength(HUB_V6.length);
|
|
86
|
+
HUB_V6.forEach((re, i) => {
|
|
87
|
+
expect(re.test(v6Samples[i])).toBe(true);
|
|
88
|
+
expect(re.test("2001:4860:4860::8888")).toBe(false);
|
|
89
|
+
});
|
|
90
|
+
});
|
|
91
|
+
|
|
47
92
|
test("FORBIDDEN_IPV4_RE + FORBIDDEN_IPV6_RE sources equal at runtime", async () => {
|
|
48
93
|
const daemonMod = await import(DAEMON_PATH);
|
|
49
94
|
const daemonV4 = (daemonMod.FORBIDDEN_IPV4_RE as ReadonlyArray<RegExp>).map(r => r.source);
|
|
@@ -54,6 +54,8 @@ describe("SkillHub real Hub + SQLite", () => {
|
|
|
54
54
|
test("node submit is token-attributed, pending and immutable/idempotent", async () => {
|
|
55
55
|
const input = { network_id: networkId, slug: "incident-handoff", name: "Incident handoff", version: "1.0.0", description: "handoff", content: "# Incident handoff\n\nVerify facts." };
|
|
56
56
|
const first = await tool(nodeToken, "submit_skill", { ...input, source_alias: "forged-admin" });
|
|
57
|
+
// 精确键集(同变量口径):提交回执的字段集合必须稳定 —— 它会流到 dashboard 的「待审」列表。
|
|
58
|
+
expect(Object.keys(first).sort()).toEqual(["ok", "skill_id", "source_alias", "source_type", "status"]);
|
|
57
59
|
expect(first.ok).toBe(true); expect(first.status).toBe("pending"); expect(first.source_alias).toBe("skill-writer"); skillId = first.skill_id;
|
|
58
60
|
const retry = await tool(nodeToken, "submit_skill", input);
|
|
59
61
|
expect(retry.idempotent).toBe(true); expect(retry.skill_id).toBe(skillId);
|
|
@@ -71,14 +73,46 @@ describe("SkillHub real Hub + SQLite", () => {
|
|
|
71
73
|
test("pending is reviewer-only; owner publishes; published becomes visible", async () => {
|
|
72
74
|
const nodeList = await tool(nodeToken, "list_skills", { network_id: networkId, include_pending: true });
|
|
73
75
|
expect(nodeList.skills).toHaveLength(0);
|
|
76
|
+
// 2026-10-31 —— **精确键集**(#3171):这两个工具此前只有字段级断言,
|
|
77
|
+
// 于是「多给了一个字段」不会被任何测试发现 —— 而多给字段正是匿名/权限面最危险的改法。
|
|
78
|
+
// 列表投影固定三键;差别在 reviewer 的真假,而不是键的有无。
|
|
79
|
+
// (我第一版写成「非 reviewer 只有两键」—— 实测 reviewer 始终存在,只是 false。
|
|
80
|
+
// ⇒ 这条断言当场把我自己写错的形状说出来,这正是它应有的作用。)
|
|
81
|
+
expect(Object.keys(nodeList).sort()).toEqual(["ok", "reviewer", "skills"]);
|
|
82
|
+
expect(nodeList.reviewer).toBe(false);
|
|
83
|
+
// 详情未找到:只有两个键;多一个键就意味着错误响应开始夹带上下文。
|
|
84
|
+
expect(Object.keys(await tool(nodeToken, "get_skill", { network_id: networkId, skill_id: skillId })).sort())
|
|
85
|
+
.toEqual(["error", "ok"]);
|
|
74
86
|
expect((await tool(nodeToken, "get_skill", { network_id: networkId, skill_id: skillId })).error).toBe("skill_not_found");
|
|
75
87
|
const ownerList = await tool(ownerToken, "list_skills", { network_id: networkId, include_pending: true });
|
|
76
|
-
expect(ownerList.reviewer).toBe(true);
|
|
88
|
+
expect(ownerList.reviewer).toBe(true);
|
|
89
|
+
// reviewer 视角多一格 reviewer:三键,不多不少。
|
|
90
|
+
expect(Object.keys(ownerList).sort()).toEqual(["ok", "reviewer", "skills"]); expect(ownerList.skills.map((x: any) => x.skill_id)).toContain(skillId);
|
|
77
91
|
expect((await tool(ownerToken, "get_skill", { network_id: networkId, skill_id: skillId })).skill.content).toContain("Verify facts");
|
|
78
92
|
const reviewed = await tool(ownerToken, "review_skill", { network_id: networkId, skill_id: skillId, decision: "published" });
|
|
93
|
+
// 2026-10-31 —— **同变量口径的精确键集**(#3171):断言绑的是本次调用的结果。
|
|
94
|
+
// 实际形状(我第一版只写了 ok/status,被断言纠正):ok / skill_id / status / version。
|
|
95
|
+
expect(Object.keys(reviewed).sort()).toEqual(["ok", "skill_id", "status"]);
|
|
79
96
|
expect(reviewed.status).toBe("published");
|
|
80
97
|
const published = await tool(nodeToken, "list_skills", { network_id: networkId });
|
|
81
98
|
expect(published.skills.map((x: any) => x.skill_id)).toContain(skillId);
|
|
99
|
+
// 2026-10-31 —— **属性断言**(外部复核 (b):「断的是函数不产生条件键」,而不是几个样例)。
|
|
100
|
+
// 对 include_pending × query × limit 的笛卡尔组合逐一取键集,要求**全部相等**。
|
|
101
|
+
// 样例断言会说「这四个我试过」;属性断言说的是「任何组合都不变」——后者才是契约。
|
|
102
|
+
const combos: Array<Record<string, unknown>> = [];
|
|
103
|
+
for (const include_pending of [true, false]) {
|
|
104
|
+
for (const query of [undefined, "ship", "no-such-skill"]) {
|
|
105
|
+
for (const limit of [undefined, 1, 50]) {
|
|
106
|
+
combos.push({ network_id: networkId, include_pending, query, limit });
|
|
107
|
+
}
|
|
108
|
+
}
|
|
109
|
+
}
|
|
110
|
+
const keySets = new Set<string>();
|
|
111
|
+
for (const args of combos) {
|
|
112
|
+
const r = await tool(nodeToken, "list_skills", args as any);
|
|
113
|
+
keySets.add(JSON.stringify(Object.keys(r).sort()));
|
|
114
|
+
}
|
|
115
|
+
expect([...keySets]).toEqual([JSON.stringify(["ok", "reviewer", "skills"])]);
|
|
82
116
|
expect((await tool(nodeToken, "get_skill", { network_id: networkId, skill_id: skillId })).skill.skill_id).toBe(skillId);
|
|
83
117
|
const detail = (await tool(nodeToken, "get_skill", { network_id: networkId, skill_id: skillId })).skill;
|
|
84
118
|
expect(detail.created_by_user).toBeUndefined(); expect(detail.reviewed_by_user).toBeUndefined(); expect(detail.content_hash).toBeUndefined();
|
package/src/status-read-cache.ts
CHANGED
|
@@ -65,7 +65,14 @@ const MAX_ENTRIES = 64;
|
|
|
65
65
|
const memo = new Map<string, Entry>();
|
|
66
66
|
export const statusCacheStats = { hits: 0, misses: 0, uncacheable: 0 };
|
|
67
67
|
|
|
68
|
-
|
|
68
|
+
/**
|
|
69
|
+
* 2026-10-31 —— 导出只为测试可钉:ETag 是**正文的纯函数**,
|
|
70
|
+
* 而「纯函数」这个词不够——需要两条方向相反的读数:
|
|
71
|
+
* 必须不同:内容差一个字符(尤其是**最后一个字符**)⇒ ETag 必须不同
|
|
72
|
+
* 必须相同:同一份内容 ⇒ ETag 必须相同(否则每个响应都「变了」,304 永远不命中)
|
|
73
|
+
* 为什么差异要放在最后一个字符:任何截断式比较(前缀 / 前 N 位 hash)在差异靠后时仍会判等。
|
|
74
|
+
*/
|
|
75
|
+
export function etagOf(body: string): string {
|
|
69
76
|
return `"s-${Bun.hash(body).toString(36)}-${body.length.toString(36)}"`;
|
|
70
77
|
}
|
|
71
78
|
|
|
@@ -94,6 +94,13 @@ test("exact executor and exact turn append one late receipt without rewriting te
|
|
|
94
94
|
const legacyDetail = await get(owner.token, `/api/tasks?task_id=${taskId}&limit=1&network_id=${owner.network_id}`);
|
|
95
95
|
expect(legacyDetail.body.tasks[0].late_replies).toEqual(detail.body.task.late_replies);
|
|
96
96
|
const mcpDetail = await mcp(owner.token, "get_task", { task_id: taskId });
|
|
97
|
+
// 2026-10-31 —— **条件键要显式登记**(#3171):get_task 的 `pacing` 只在有 pacing 时出现,
|
|
98
|
+
// 所以这里不能写「键集恒等于三键」(那也是外部复核说的「条件键」)。
|
|
99
|
+
// 断言写成:两个必需键必在,且**除 pacing 外不许有别的键**。
|
|
100
|
+
const ks = Object.keys(mcpDetail);
|
|
101
|
+
expect(ks).toContain("ok");
|
|
102
|
+
expect(ks).toContain("task");
|
|
103
|
+
expect(ks.filter((k) => !["ok", "task", "pacing"].includes(k))).toEqual([]);
|
|
97
104
|
expect(mcpDetail.task.late_replies).toEqual(detail.body.task.late_replies);
|
|
98
105
|
|
|
99
106
|
const messages = await get(owner.token, `/api/messages?alias=${encodeURIComponent(owner.user.username)}&since=2000-01-01%2000:00:00`);
|
|
@@ -5,12 +5,18 @@
|
|
|
5
5
|
// identical from the server side. Every rejection branch now goes through
|
|
6
6
|
// logTaskRejection().
|
|
7
7
|
//
|
|
8
|
+
// 2026-10-31 —— 同一位置**顺带计数**(reason 分桶,见 rejection-counters.ts)。
|
|
9
|
+
// 为什么不只记日志:「今天拒了多少、分别为什么」要能随时读到,
|
|
10
|
+
// 而日志轮转后 grep 压缩文件是**静默 0**(读不到会被当成没发生)。
|
|
11
|
+
//
|
|
8
12
|
// What is logged is deliberately narrow: status, error code, the
|
|
9
13
|
// authenticated username, and the *requested* alias / network_id /
|
|
10
14
|
// client_request_id. Never the bearer token, the task text, or attachment
|
|
11
15
|
// ids. Request-supplied values are clipped and stripped of control
|
|
12
16
|
// characters so a client cannot forge extra log lines.
|
|
13
17
|
|
|
18
|
+
import { recordTaskRejection } from "./rejection-counters.js";
|
|
19
|
+
|
|
14
20
|
function ts(): string {
|
|
15
21
|
return new Date().toTimeString().slice(0, 8);
|
|
16
22
|
}
|
|
@@ -44,6 +50,9 @@ export async function logTaskRejection(res: Response, username: string | null |
|
|
|
44
50
|
try {
|
|
45
51
|
error = ((await res.clone().json()) as any)?.error;
|
|
46
52
|
} catch {}
|
|
47
|
-
|
|
53
|
+
const code = error ?? "unknown";
|
|
54
|
+
// 计数与日志在**同一个位置**发生 ⇒ 不会出现“记了日志没计数”或反之。
|
|
55
|
+
recordTaskRejection(res.status, code);
|
|
56
|
+
console.log(formatTaskRejection({ status: res.status, error: code, username: username || "anon", body }));
|
|
48
57
|
return res;
|
|
49
58
|
}
|
|
@@ -0,0 +1,48 @@
|
|
|
1
|
+
// 2026-10-31 —— tmux 端点允许清单的方向钉点。
|
|
2
|
+
//
|
|
3
|
+
// 为什么单独钉:这是本仓少见的「不匹配 ⇒ 拒绝」路径,判据错了不会报错,
|
|
4
|
+
// 只会**静默锁死**(fail-closed),而锁死的成因里有一类是字符串形态不一致:
|
|
5
|
+
// allowlist 人手写 IPv4(1.2.3.4),socket 在双栈监听下给 IPv4-mapped IPv6(::ffff:1.2.3.4)
|
|
6
|
+
// ⇒ 同一台机器在两个字符串下被判成两回事。
|
|
7
|
+
//
|
|
8
|
+
// 反向也要钉(must-fire):清单里有的公网 IP **必须**被放行——
|
|
9
|
+
// 否则「一律拒绝」的实现也能通过所有「拒绝」断言,而那是另一种坏法。
|
|
10
|
+
import { describe, expect, test } from "bun:test";
|
|
11
|
+
import { ipAllowedBy, normalizeRequestIp } from "./server.js";
|
|
12
|
+
|
|
13
|
+
const NONE: ReadonlySet<string> = new Set();
|
|
14
|
+
|
|
15
|
+
describe("tmux allowlist: 空清单的落点与两个方向的判别力", () => {
|
|
16
|
+
test("空清单 = 只允许本机(最严侧),而不是「谁都行」", () => {
|
|
17
|
+
expect(ipAllowedBy("127.0.0.1", NONE)).toBe(true);
|
|
18
|
+
expect(ipAllowedBy("::1", NONE)).toBe(true);
|
|
19
|
+
expect(ipAllowedBy("::ffff:127.0.0.1", NONE)).toBe(true);
|
|
20
|
+
expect(ipAllowedBy("8.8.8.8", NONE)).toBe(false);
|
|
21
|
+
// 拿不到地址时(无 X-Forwarded-For / 无 socket 信息)也是拒绝,不是放行
|
|
22
|
+
expect(ipAllowedBy("unknown", NONE)).toBe(false);
|
|
23
|
+
expect(ipAllowedBy("", NONE)).toBe(false);
|
|
24
|
+
});
|
|
25
|
+
|
|
26
|
+
test("清单里有的必须被放行(否则「一律拒绝」也能骗过上面那条)", () => {
|
|
27
|
+
const set = new Set(["1.2.3.4"]);
|
|
28
|
+
expect(ipAllowedBy("1.2.3.4", set)).toBe(true);
|
|
29
|
+
expect(ipAllowedBy("1.2.3.5", set)).toBe(false);
|
|
30
|
+
expect(ipAllowedBy("1.2.3.40", set)).toBe(false); // 前缀不算命中
|
|
31
|
+
});
|
|
32
|
+
|
|
33
|
+
test("IPv4-mapped IPv6 与 IPv4 是同一个主机(这一条就是那个静默锁死的补丁)", () => {
|
|
34
|
+
const set = new Set(["1.2.3.4"]);
|
|
35
|
+
expect(ipAllowedBy("::ffff:1.2.3.4", set)).toBe(true);
|
|
36
|
+
expect(normalizeRequestIp("::FFFF:1.2.3.4")).toBe("1.2.3.4");
|
|
37
|
+
// 对称:人手写成 mapped 形式,普通 IPv4 请求也要命中
|
|
38
|
+
const mapped = new Set([normalizeRequestIp("::ffff:5.6.7.8")]);
|
|
39
|
+
expect(ipAllowedBy("5.6.7.8", mapped)).toBe(true);
|
|
40
|
+
});
|
|
41
|
+
|
|
42
|
+
test("不做子串/前缀匹配:只有整串相等才算", () => {
|
|
43
|
+
const set = new Set(["10.0.0.1"]);
|
|
44
|
+
expect(ipAllowedBy("10.0.0.10", set)).toBe(false);
|
|
45
|
+
expect(ipAllowedBy("110.0.0.1", set)).toBe(false);
|
|
46
|
+
expect(normalizeRequestIp(" 10.0.0.1 ")).toBe("10.0.0.1");
|
|
47
|
+
});
|
|
48
|
+
});
|
package/src/tool-audience.ts
CHANGED
|
@@ -65,11 +65,18 @@ export const TOOL_AUDIENCE: Readonly<Record<string, ToolAudience>> = {
|
|
|
65
65
|
requirements_events: "both", requirements_comment: "both", projects_list: "both",
|
|
66
66
|
};
|
|
67
67
|
|
|
68
|
-
/**
|
|
68
|
+
/**
|
|
69
|
+
* 调用者:节点令牌(绑定网络)/ 用户令牌 / **没有身份**(旧的全局令牌、未开鉴权)。
|
|
70
|
+
*
|
|
71
|
+
* 2026-10-31 —— 第三种以前叫 `"unknown"`,这是**把「已知」写成了「未知」**:
|
|
72
|
+
* 我们完全知道它是什么(没有身份),只是不知道它**是谁**——
|
|
73
|
+
* 而 `unknown` 会让读者以为「查不清」,进而给它加一个 reason、加一次重试。
|
|
74
|
+
* 名字必须说清是「哪一类缺失」(外部复核 ②:reason 要写成「哪个前提没满足」,不能写成「未知」)。
|
|
75
|
+
*/
|
|
69
76
|
export type ToolCaller =
|
|
70
77
|
| { kind: "node"; tokenId: string | null; networkId: string | null; includeProtocol: boolean }
|
|
71
78
|
| { kind: "user"; includeProtocol: boolean }
|
|
72
|
-
| { kind: "
|
|
79
|
+
| { kind: "anonymous"; why: "no_identity" };
|
|
73
80
|
|
|
74
81
|
/** #487 的判定里「不看参数就必拒」的那几类;和 nodeDecide 同一规则(显式模式恒拒,其余看开关),只是不记日志。 */
|
|
75
82
|
function nodeHidden(name: string, verdictFor: (cls: string) => Verdict): boolean {
|
|
@@ -83,7 +90,7 @@ function nodeHidden(name: string, verdictFor: (cls: string) => Verdict): boolean
|
|
|
83
90
|
|
|
84
91
|
/** 这个调用者的 tools/list 里留哪些。没归类的工具一律留下(宁可多列;测试保证不会有没归类的)。 */
|
|
85
92
|
export function listedToolFilter(caller: ToolCaller): (name: string) => boolean {
|
|
86
|
-
if (caller.kind === "
|
|
93
|
+
if (caller.kind === "anonymous") return () => true;
|
|
87
94
|
if (caller.kind === "user") return name => { const a = TOOL_AUDIENCE[name]; return a !== "node" && a !== "protocol"; };
|
|
88
95
|
const id = caller.tokenId && caller.networkId ? nodeIdentity(caller.tokenId, caller.networkId) : null;
|
|
89
96
|
const verdictFor = (cls: string): Verdict => {
|
package/src/tools.ts
CHANGED
|
@@ -100,10 +100,10 @@ import {
|
|
|
100
100
|
computeApplyMode,
|
|
101
101
|
readOpencodeSnapshotFlags,
|
|
102
102
|
readConfigUpdateCapable,
|
|
103
|
+
configUpdateCapabilityDivergence,
|
|
103
104
|
validatePatch,
|
|
104
105
|
narrowChannelsPatch,
|
|
105
|
-
isAllowedToChangeFlag,
|
|
106
|
-
} from "./config-apply-validate.js";
|
|
106
|
+
isAllowedToChangeFlag, readSystemdSupervision } from "./config-apply-validate.js";
|
|
107
107
|
import { sharedSendDedup, buildDuplicateSendPayload } from "./send_dedup.js";
|
|
108
108
|
import { clientRequestIdFromMeta, idempotentTaskId, idempotentTaskMatches, type StoredIdempotentTask } from "./task-idempotency.js";
|
|
109
109
|
import { stampTaskAuthOrigin, type TaskAuthOrigin } from "./task-auth-origin.js";
|
|
@@ -3766,22 +3766,63 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
|
|
|
3766
3766
|
// 调用方看到的只有「超时」,永远学不到「这台节点现在是下线的」。
|
|
3767
3767
|
// 不擅自拒绝(会破坏合法流程),但必须把后果说在前面。
|
|
3768
3768
|
const configUpdateCapable = readConfigUpdateCapable(node.config_snapshot);
|
|
3769
|
-
|
|
3770
|
-
|
|
3771
|
-
|
|
3772
|
-
|
|
3773
|
-
|
|
3774
|
-
|
|
3775
|
-
|
|
3776
|
-
|
|
3777
|
-
|
|
3769
|
+
// 2026-10-31 —— 两个字段都被允许“遮住对方”的时候,被遮住的那个值就再也读不到了。
|
|
3770
|
+
// 文档说它们永远同值,所以**不同值**本身是信号(半升级 / 旧节点 / 手改快照)。
|
|
3771
|
+
// 判据不变(仍以 restart_supervised 为准),但分歧必须能被看见 ——
|
|
3772
|
+
// 否则「两个一致」与「有一个被遮住了」在调用方看来完全一样。
|
|
3773
|
+
const capabilityDivergence = configUpdateCapabilityDivergence(node.config_snapshot);
|
|
3774
|
+
const warnings: Array<{ code: string; message: string }> = [];
|
|
3775
|
+
if (capabilityDivergence) {
|
|
3776
|
+
warnings.push({
|
|
3777
|
+
code: "restart_supervision_flag_divergence",
|
|
3778
|
+
message: `config snapshot carries two disagreeing capability flags: `
|
|
3779
|
+
+ `restart_supervised=${capabilityDivergence.named} but config_update_capable=${capabilityDivergence.legacy}. `
|
|
3780
|
+
+ `The named field wins, so this update was classified as supervised=${capabilityDivergence.named}. `
|
|
3781
|
+
+ `They are documented to always agree, so a divergence means a half-upgraded node (a wrapper that `
|
|
3782
|
+
+ `forwards one flag but not the other), an older node, or a hand-edited snapshot. `
|
|
3783
|
+
+ `Verify how this node is launched before relying on a restart-tier change.`,
|
|
3784
|
+
});
|
|
3785
|
+
}
|
|
3786
|
+
// #3168 —— 具名判定优先:节点自己说了算,legacy 布尔只在「不知道」时兜底。
|
|
3787
|
+
const systemdSupervision = readSystemdSupervision(node.config_snapshot);
|
|
3788
|
+
if (applyMode !== "hot" && systemdSupervision === "not_supervised") {
|
|
3789
|
+
warnings.push({
|
|
3790
|
+
code: "restart_requires_manual_respawn",
|
|
3791
|
+
// 2026-10-31 —— 「意图 + 能力」两份要能对上:节点可能**声明**有重启能力,
|
|
3792
|
+
// 而同时**观测**到没人拉它。两者不一致时以观测为准,并且必须把冲突说出来 ——
|
|
3793
|
+
// 否则 restart_supervised=true 会被读成「已验证」。
|
|
3794
|
+
message: (configUpdateCapable === true
|
|
3795
|
+
? "this node DECLARES restart_supervised=true but REPORTS systemd_supervision=not_supervised. "
|
|
3796
|
+
+ "The declaration and the observation disagree; the observation wins. "
|
|
3797
|
+
: "")
|
|
3798
|
+
+ "this node reports systemd_supervision=not_supervised, i.e. it says nothing will respawn it. "
|
|
3799
|
+
+ "A restart-tier patch makes the process exit 75 and stay down: the update will time out and the "
|
|
3800
|
+
+ "node will be offline until someone starts it again. Use Stop -> Start instead of a restart-tier "
|
|
3801
|
+
+ "patch, or launch it under a supervisor first (anet start / pm2 / systemd).",
|
|
3802
|
+
});
|
|
3803
|
+
} else if (applyMode !== "hot" && systemdSupervision === null && configUpdateCapable === false) {
|
|
3804
|
+
warnings.push({
|
|
3805
|
+
code: "restart_supervision_unknown",
|
|
3806
|
+
// 不说 "no supervisor" —— 这个字段只说明「没有声明 sentinel-75 重启包装」,
|
|
3807
|
+
// 而 systemd/pm2 托管的节点同样可能报 false(它们不走那套包装)。
|
|
3808
|
+
// 「不能热更新」蕴含「这次需要重启」,但**不蕴含**「重启是安全的」,
|
|
3809
|
+
// 反过来也不蕴含「重启是危险的」。这里只能如实说“没有声明”,
|
|
3810
|
+
// 把判断交给调用方,并给出可执行的两种处置。
|
|
3811
|
+
message: "this node does not advertise config_update_capable=true, i.e. it does not declare "
|
|
3812
|
+
+ "a supervisor that honours the sentinel-75 restart path. If nothing respawns it, a "
|
|
3813
|
+
+ "restart-tier patch makes the process exit 75 and stay down: the update will time out "
|
|
3814
|
+
+ "and the node will be offline until it is started again. Verify how this node is "
|
|
3815
|
+
+ "launched (anet start / pm2 / systemd) before sending restart-tier changes; "
|
|
3816
|
+
+ "model-only changes on an OpenCode V2 co-presence node are hot and unaffected.",
|
|
3817
|
+
});
|
|
3818
|
+
}
|
|
3778
3819
|
|
|
3779
3820
|
return {
|
|
3780
3821
|
content: [{
|
|
3781
3822
|
type: "text" as const,
|
|
3782
3823
|
text: JSON.stringify({
|
|
3783
3824
|
ok: true, update_id: updateId, apply_mode: applyMode,
|
|
3784
|
-
...(warnings ? { warnings } : {}),
|
|
3825
|
+
...(warnings.length > 0 ? { warnings } : {}),
|
|
3785
3826
|
}),
|
|
3786
3827
|
}],
|
|
3787
3828
|
};
|
|
@@ -6596,9 +6637,52 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
|
|
|
6596
6637
|
`SELECT model_id, model_name, display_name, context_window, supports_vision, enabled FROM provider_models WHERE provider_id = ?1 AND enabled = 1 ORDER BY model_name`,
|
|
6597
6638
|
p.provider_id,
|
|
6598
6639
|
);
|
|
6599
|
-
|
|
6640
|
+
// 2026-10-31 —— 每个 provider 自己也要能说「我一个可用模型都没有」。
|
|
6641
|
+
// 否则客户端的模型下拉只会是空的,用户看不出是 provider 没配模型还是全部被停用。
|
|
6642
|
+
const modelsDisabled = db.get<any>(
|
|
6643
|
+
`SELECT COUNT(*) AS cnt FROM provider_models WHERE provider_id = ?1 AND enabled = 0`,
|
|
6644
|
+
p.provider_id,
|
|
6645
|
+
);
|
|
6646
|
+
return {
|
|
6647
|
+
...p,
|
|
6648
|
+
in_vault: true, // in_vault: true since we required it on upsert
|
|
6649
|
+
models,
|
|
6650
|
+
models_state: models.length > 0
|
|
6651
|
+
? "available"
|
|
6652
|
+
: ((modelsDisabled?.cnt ?? 0) > 0 ? "all_disabled" : "none_configured"),
|
|
6653
|
+
};
|
|
6600
6654
|
});
|
|
6601
|
-
|
|
6655
|
+
|
|
6656
|
+
// 2026-10-31 —— **空的 providers 数组有四种含义**,以前只回一个 `[]`:
|
|
6657
|
+
// ① 这个网络还没配过任何 provider(管理员还没录第一行)
|
|
6658
|
+
// ② 配过,但全被 enabled=0 停用
|
|
6659
|
+
// ③ 配过、也启用,但一条模型都没有(客户端下拉必然空)
|
|
6660
|
+
// ④ 查询本身失败(这一支会 throw,不会走到这里 —— 但读者需要知道它不在这个 `[]` 里)
|
|
6661
|
+
// 客户端拿到 `[]` 时无法区分 ①②③,于是空状态只能显示「没有」,
|
|
6662
|
+
// 这正是外部复核那句「兜底值必须说出自己是兜底」的现场版。
|
|
6663
|
+
// ⇒ 加 state + counts + hint(只有非 configured 时才给 hint,避免正常载荷变胖)。
|
|
6664
|
+
const disabledProviders = db.get<any>(
|
|
6665
|
+
`SELECT COUNT(*) AS cnt FROM providers WHERE network_id = ?1 AND enabled = 0`,
|
|
6666
|
+
effectiveNetId || "default",
|
|
6667
|
+
);
|
|
6668
|
+
const providerState = out.length > 0
|
|
6669
|
+
? "configured"
|
|
6670
|
+
: ((disabledProviders?.cnt ?? 0) > 0 ? "all_disabled" : "unconfigured");
|
|
6671
|
+
const stateBlock = {
|
|
6672
|
+
state: providerState,
|
|
6673
|
+
counts: {
|
|
6674
|
+
providers_enabled: out.length,
|
|
6675
|
+
providers_disabled: disabledProviders?.cnt ?? 0,
|
|
6676
|
+
models_enabled: out.reduce((n: number, p: any) => n + p.models.length, 0),
|
|
6677
|
+
providers_without_models: out.filter((p: any) => p.models_state !== "available").length,
|
|
6678
|
+
},
|
|
6679
|
+
...(providerState === "configured" ? {} : {
|
|
6680
|
+
hint: providerState === "all_disabled"
|
|
6681
|
+
? "此网络的 provider 全部被停用(enabled=0);管理员用 update_provider {enabled:true} 重新启用"
|
|
6682
|
+
: "此网络还没有任何 provider;管理员需要先录入一个 provider 及其模型,客户端才有可选模型",
|
|
6683
|
+
}),
|
|
6684
|
+
};
|
|
6685
|
+
return { content: [{ type: "text" as const, text: JSON.stringify({ ok: true, providers: out, ...stateBlock }) }] };
|
|
6602
6686
|
},
|
|
6603
6687
|
);
|
|
6604
6688
|
|
|
@@ -7184,7 +7268,7 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
|
|
|
7184
7268
|
// #478:tools/list 只列这个调用者真能用的工具(tool-audience.ts)。只滤列表,tools/call 不变。
|
|
7185
7269
|
const caller: ToolCaller = callerTokenIsNetwork
|
|
7186
7270
|
? { kind: "node", tokenId: callerTokenId ?? null, networkId: enforceNetworkId ?? null, includeProtocol: listing.includeProtocol === true }
|
|
7187
|
-
: enforceUserId ? { kind: "user", includeProtocol: listing.includeProtocol === true } : { kind: "
|
|
7271
|
+
: enforceUserId ? { kind: "user", includeProtocol: listing.includeProtocol === true } : { kind: "anonymous", why: "no_identity" };
|
|
7188
7272
|
scopeToolsList(server, listedToolFilter(caller));
|
|
7189
7273
|
}
|
|
7190
7274
|
|