@sleep2agi/commhub-server 0.9.0-preview.6 → 0.9.0-preview.60

package/src/blocked-exit-on-reply.test.ts

@@ -0,0 +1,122 @@
+import { afterAll, beforeEach, describe, expect, test } from "bun:test";
+import { db } from "./db.js";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { registerTools } from "./tools.js";
+
+// #1548 —— 一个活着、能收发任务的节点可以在名册里永远显示 `blocked`:
+// 只有 report_completion 会把 sessions.status 拉回 idle,而现在大多数 agent 用
+// send_reply(终态)结束任务、用 send_task 派活 —— 这两条路径此前都不碰 sessions.status。
+// 「它刚回了我一条终态消息 / 刚派了一条任务」本身就是最强的活性证据。
+// 只出 `blocked`;`working` 可能真在忙别的任务,不碰(保守)。
+const NET_ID = "net_1548_blocked";
+const USER_ID = "u_1548";
+const NODE_ID = "node_1548_agent";
+const AGENT_ALIAS = "agent-1548";
+const DISPATCHER_NODE_ID = "node_1548_dispatcher";
+const DISPATCHER_ALIAS = "dispatcher-1548";
+const AGENT_TOK_ID = "tok_1548";
+
+type ToolHandler = (args: any, extra?: any) => Promise<{ content: Array<{ type: "text"; text: string }> }>;
+
+function cleanup() {
+  for (const [sql, params] of [
+    ["DELETE FROM tasks WHERE network_id = ?1", [NET_ID]],
+    ["DELETE FROM inbox WHERE network_id = ?1", [NET_ID]],
+    ["DELETE FROM task_events WHERE network_id = ?1", [NET_ID]],
+    ["DELETE FROM sessions WHERE network_id = ?1", [NET_ID]],
+    ["DELETE FROM nodes WHERE network_id = ?1", [NET_ID]],
+    ["DELETE FROM api_tokens WHERE network_id = ?1", [NET_ID]],
+    ["DELETE FROM network_members WHERE network_id = ?1", [NET_ID]],
+    ["DELETE FROM networks WHERE network_id = ?1", [NET_ID]],
+    ["DELETE FROM users WHERE user_id = ?1", [USER_ID]],
+  ] as const) {
+    try { db.run(sql, params as any); } catch {}
+  }
+}
+beforeEach(cleanup);
+afterAll(cleanup);
+
+function seed(agentStatus: string) {
+  db.run(`INSERT INTO users (user_id, username, password_hash, role, created_at) VALUES (?1, ?2, 'x', 'user', datetime('now'))`, [USER_ID, USER_ID]);
+  db.run(`INSERT INTO networks (network_id, network_name, owner_id, created_at) VALUES (?1, ?2, ?3, datetime('now'))`, [NET_ID, NET_ID, USER_ID]);
+  db.run(
+    `INSERT INTO network_members (user_id, network_id, role, joined_at)
+     VALUES (?1, ?2, 'owner', datetime('now'))`,
+    [USER_ID, NET_ID],
+  );
+  for (const [nodeId, alias] of [[DISPATCHER_NODE_ID, DISPATCHER_ALIAS], [NODE_ID, AGENT_ALIAS]] as const) {
+    db.run(
+      `INSERT INTO nodes (node_id, node_name, alias, network_id, hostname, created_at, updated_at, lifecycle_state)
+       VALUES (?1, ?2, ?3, ?4, ?5, datetime('now'), datetime('now'), 'active')`,
+      [nodeId, alias, alias, NET_ID, `host-${alias}`],
+    );
+  }
+  db.run(
+    `INSERT INTO sessions (resume_id, alias, status, node_id, network_id, updated_at, last_seen_at)
+     VALUES (?1, ?2, 'idle', ?3, ?4, datetime('now'), datetime('now'))`,
+    [`res_${DISPATCHER_ALIAS}`, DISPATCHER_ALIAS, DISPATCHER_NODE_ID, NET_ID],
+  );
+  db.run(
+    `INSERT INTO sessions (resume_id, alias, status, node_id, network_id, updated_at, last_seen_at)
+     VALUES (?1, ?2, ?3, ?4, ?5, datetime('now'), datetime('now'))`,
+    [`res_${AGENT_ALIAS}`, AGENT_ALIAS, agentStatus, NODE_ID, NET_ID],
+  );
+  db.run(
+    `INSERT INTO api_tokens (token_id, user_id, network_id, scope, name, token_hash, expires_at, revoked_at)
+     VALUES (?1, ?2, ?3, 'network', ?4, ?5, NULL, NULL)`,
+    [AGENT_TOK_ID, USER_ID, NET_ID, `node:${AGENT_ALIAS}`, `hash_${AGENT_TOK_ID}`],
+  );
+}
+function makeTask(): string {
+  const id = "t_" + Math.random().toString(36).slice(2, 14);
+  db.run(
+    `INSERT INTO tasks (task_id, from_name, to_name, to_node_id, priority, status, content, requires_response, created_at, network_id)
+     VALUES (?1, ?2, ?3, ?4, 'normal', 'delivered', 'test', 'reply', datetime('now'), ?5)`,
+    [id, DISPATCHER_ALIAS, AGENT_ALIAS, NODE_ID, NET_ID],
+  );
+  return id;
+}
+function buildHandlers(): Record<string, ToolHandler> {
+  const server = new McpServer({ name: "test", version: "0" }) as any;
+  const tools: Record<string, ToolHandler> = {};
+  const origTool = server.tool.bind(server);
+  server.tool = (name: string, _desc: string, _schema: any, handler: ToolHandler) => { tools[name] = handler; return origTool(name, _desc, _schema, handler); };
+  const origRegisterTool = server.registerTool?.bind(server);
+  if (origRegisterTool) {
+    server.registerTool = (name: string, _cfg: any, handler: ToolHandler) => { tools[name] = handler; return origRegisterTool(name, _cfg, handler); };
+  }
+  registerTools(server, undefined, NET_ID, USER_ID, AGENT_ALIAS, true, AGENT_TOK_ID);
+  return tools;
+}
+async function call(handler: ToolHandler, args: any): Promise<any> {
+  const r = await handler(args);
+  return JSON.parse(r.content[0]!.text);
+}
+function agentStatus(): string {
+  return (db.get("SELECT status FROM sessions WHERE alias = ?1 AND network_id = ?2", [AGENT_ALIAS, NET_ID]) as { status: string }).status;
+}
+
+describe("#1548 blocked has an exit: a terminal reply or an outbound task proves the agent is alive", () => {
+  test("terminal send_reply from a blocked agent puts it back to idle", async () => {
+    seed("blocked");
+    const tools = buildHandlers();
+    const taskId = makeTask();
+    const r = await call(tools.send_reply!, { text: "done", in_reply_to: taskId, status: "replied", from_session: AGENT_ALIAS, network_id: NET_ID });
+    expect(r.ok, JSON.stringify(r)).toBe(true);
+    expect(agentStatus()).toBe("idle");
+  });
+  test("send_task from a blocked agent puts it back to idle", async () => {
+    seed("blocked");
+    const tools = buildHandlers();
+    const r = await call(tools.send_task!, { alias: DISPATCHER_ALIAS, task: "ping", priority: "normal", from_session: AGENT_ALIAS, network_id: NET_ID });
+    expect(r.ok, JSON.stringify(r)).toBe(true);
+    expect(agentStatus()).toBe("idle");
+  });
+  test("a working agent is left alone (it may be busy with another task)", async () => {
+    seed("working");
+    const tools = buildHandlers();
+    const taskId = makeTask();
+    await call(tools.send_reply!, { text: "done", in_reply_to: taskId, status: "replied", from_session: AGENT_ALIAS, network_id: NET_ID });
+    expect(agentStatus()).toBe("working");
+  });
+});

package/src/boot-side-effect.test.ts

@@ -0,0 +1,124 @@
+// #438 corrective — regression gate for the two boot-path failure modes:
+//
+//   1. import side effect: `import("./server.js")` must NOT bind any port.
+//      Pre-corrective (7fa3ad35, when this module was still index.ts with
+//      module-level `export const server = bootServer()`) this fails:
+//      witnessed-red showed the probe port EADDRINUSE right after import.
+//      The run-entry shim src/index.ts is the ONLY module whose import
+//      boots — by design, documented there — and is deliberately not
+//      imported anywhere in the test suite.
+//   2. silent no-op double start: `startHub()` is single-shot and must
+//      REJECT a second call observably — "I thought I started it but
+//      nothing happened" is the same failure family as the
+//      import.meta.main incident (#438 review).
+//
+// Test order inside this file matters: the no-side-effect probe must run
+// BEFORE anything calls startHub in this process. bun executes tests in
+// declaration order, and no other suite calls startHub.
+
+import { describe, expect, test } from "bun:test";
+
+const PROBE_PORT = 18500 + Math.floor(Math.random() * 500);
+
+describe("#438 corrective — importing server.ts is side-effect-free", () => {
+  test("importing server.js binds nothing (probe port stays free)", async () => {
+    // Pin the module's default PORT to the probe so that IF an import
+    // side effect ever regresses, it binds exactly the port we probe.
+    process.env.PORT = process.env.PORT || String(PROBE_PORT);
+    const probe = Number(process.env.PORT) || PROBE_PORT;
+    await import("./server.js");
+    // If import had booted a server, this bind would throw EADDRINUSE.
+    let listener: any = null;
+    expect(() => {
+      listener = Bun.listen({ hostname: "127.0.0.1", port: probe, socket: { data() {} } });
+    }).not.toThrow();
+    listener?.stop?.(true);
+  });
+});
+
+describe("#476 — import alone must let the process exit", () => {
+  test("a subprocess that only imports server.js exits by itself (no module-level timers hold the loop)", () => {
+    // Witnessed-red: pre-#476 (main 541a80aa) this child is killed by the
+    // timeout with a non-zero exit — two module-level setIntervals
+    // (rate-limit sweep + DB-writing task patrol) held the event loop
+    // after a bare import. Post-#476 both live inside startHub, so the
+    // child exits 0 on its own. Runs in a subprocess because the parent
+    // test process has its own handles and can't observe loop-emptiness.
+    const child = Bun.spawnSync({
+      cmd: ["bun", "-e", 'await import("./src/server.js");'],
+      cwd: `${import.meta.dir}/..`,
+      env: { ...process.env, COMMHUB_DB: process.env.COMMHUB_DB || "/tmp/anet-476-probe.db" },
+      timeout: 10_000,
+    });
+    expect(child.exitCode).toBe(0);
+  }, 15_000);
+
+  test("the moved task patrol actually FIRES under startHub (not just registered-looking)", () => {
+    // Fake-gate guard for the #476 move: stub patrolExpiredTasks to a
+    // no-op (or forget to register it in startHub) and this goes red.
+    // Runs in a subprocess because startHub is single-shot per process
+    // and the patrol period is shrunk via env for observability.
+    const script = `
+      process.env.COMMHUB_TASK_PATROL_MS = "100";
+      const { startHub } = await import("./src/server.js");
+      const { db } = await import("./src/db.js");
+      const hub = startHub({ port: 0, hostname: "127.0.0.1" });
+      db.run("DELETE FROM tasks WHERE task_id = 't476_patrol'");
+      db.run("INSERT INTO tasks (task_id, from_name, to_name, priority, status, content, created_at, expires_at) " +
+             "VALUES ('t476_patrol', 'a', 'b', 'normal', 'delivered', 'x', datetime('now'), datetime('now', '-1 minute'))");
+      await new Promise((r) => setTimeout(r, 600));
+      const row = db.get("SELECT status FROM tasks WHERE task_id = 't476_patrol'");
+      console.log("PATROL_RESULT:" + (row ? row.status : "missing"));
+      db.run("DELETE FROM tasks WHERE task_id = 't476_patrol'");
+      hub.stop(true);
+      process.exit(0);
+    `;
+    const child = Bun.spawnSync({
+      cmd: ["bun", "-e", script],
+      cwd: `${import.meta.dir}/..`,
+      env: { ...process.env, COMMHUB_DB: process.env.COMMHUB_DB || "/tmp/anet-476-patrol.db" },
+      timeout: 15_000,
+    });
+    const out = new TextDecoder().decode(child.stdout);
+    expect(out).toContain("PATROL_RESULT:expired");
+  }, 20_000);
+});
+
+describe("#438 corrective — startHub is explicit, single-shot, observable", () => {
+  test("startHub boots a live hub; second call throws with first boot's coordinates; bootServer stays available", async () => {
+    const { startHub, bootServer, getStartedHub } = await import("./server.js") as any;
+    expect(getStartedHub()).toBeNull();
+
+    const hub = startHub({ port: 0, hostname: "127.0.0.1" });
+    try {
+      expect(hub.port).toBeGreaterThan(0);
+      expect(getStartedHub()?.server).toBe(hub);
+
+      // Really listening — the production liveness probe, not just a
+      // non-null handle.
+      const health = await fetch(`http://127.0.0.1:${hub.port}/health`);
+      expect(health.status).toBe(200);
+      expect(((await health.json()) as any).ok).toBe(true);
+
+      // Second call must be an OBSERVABLE rejection, not a silent no-op,
+      // and must tell the caller where the first boot lives.
+      let thrown: Error | null = null;
+      try {
+        startHub({ port: 0 });
+      } catch (e: any) {
+        thrown = e;
+      }
+      expect(thrown).not.toBeNull();
+      expect(String(thrown!.message)).toContain("single-shot");
+      expect(String(thrown!.message)).toContain(String(hub.port));
+
+      // Throwaway instances stay available after startHub.
+      const extra = bootServer({ port: 0, hostname: "127.0.0.1" });
+      expect(extra.port).toBeGreaterThan(0);
+      expect(extra.port).not.toBe(hub.port);
+      extra.stop(true);
+    } finally {
+      hub.stop(true);
+    }
+  });
+});

package/src/config-apply-sec1.test.ts

@@ -721,3 +721,110 @@ describe("SEC-1 — update lifecycle: single-flight + cross-network pending look
     expect(inFlight).toBeDefined();
   });
 });
+
+// ── #260 P5 codex-catch regression: channels finalize ─────────────
+describe("finalizePendingMatchingUpdates — #260 P5 channels content-match", () => {
+  function insertPendingUpdate(opts: {
+    update_id?: string;
+    node_id: string;
+    network_id: string;
+    patch: any;
+    apply_mode: "hot" | "restart" | "restart_only";
+    status?: "pending" | "restarting";
+  }): string {
+    const id = opts.update_id ?? `cu_${uuidv4()}`;
+    db.run(
+      `INSERT INTO node_config_updates (update_id, node_id, network_id, patch_json, apply_mode, base_revision, status, created_at, created_by_token) VALUES (?1, ?2, ?3, ?4, ?5, 0, ?6, ?7, 'test')`,
+      [id, opts.node_id, opts.network_id, JSON.stringify(opts.patch), opts.apply_mode, opts.status ?? "pending", Date.now()],
+    );
+    return id;
+  }
+
+  test("channels-only patch: snapshot BEFORE apply (first boot) must NOT finalize", () => {
+    const nid = insertNode({ alias: "n-chan-1", network_id: "netA" });
+    const uid = insertPendingUpdate({
+      node_id: nid, network_id: "netA",
+      // Note the empty flags object — the pre-fix bug was that this
+      // trivially matched the flags loop and hub falsely finalized.
+      patch: { flags: {}, channels: ["feishu"] },
+      apply_mode: "restart",
+    });
+    // Node's startup snapshot BEFORE it consumed the update — no
+    // channels forked yet, so buildConfigSnapshot emits channels=[].
+    const r = finalizePendingMatchingUpdates(nid, { model: "x", flags: {}, channels: [] });
+    expect(r.finalizedCount).toBe(0);
+    expect(db.get<any>("SELECT status FROM node_config_updates WHERE update_id = ?1", uid).status).toBe("pending");
+  });
+
+  test("channels-only patch: snapshot AFTER apply (restart complete) finalizes", () => {
+    const nid = insertNode({ alias: "n-chan-2", network_id: "netA" });
+    const uid = insertPendingUpdate({
+      node_id: nid, network_id: "netA",
+      patch: { flags: {}, channels: ["feishu"] },
+      apply_mode: "restart",
+    });
+    const r = finalizePendingMatchingUpdates(nid, { model: "x", flags: {}, channels: ["feishu"] });
+    expect(r.finalizedCount).toBe(1);
+    expect(r.finalizedIds).toContain(uid);
+    expect(db.get<any>("SELECT status FROM node_config_updates WHERE update_id = ?1", uid).status).toBe("applied");
+  });
+
+  test("channels set-equality: order doesn't matter", () => {
+    const nid = insertNode({ alias: "n-chan-3", network_id: "netA" });
+    insertPendingUpdate({
+      node_id: nid, network_id: "netA",
+      patch: { flags: {}, channels: ["telegram", "feishu"] },
+      apply_mode: "restart",
+    });
+    // Snapshot order swapped — still matches.
+    const r = finalizePendingMatchingUpdates(nid, { model: "x", flags: {}, channels: ["feishu", "telegram"] });
+    expect(r.finalizedCount).toBe(1);
+  });
+
+  test("channels: [] disable-all — finalize when snapshot also [] (post-restart)", () => {
+    const nid = insertNode({ alias: "n-chan-4", network_id: "netA" });
+    insertPendingUpdate({
+      node_id: nid, network_id: "netA",
+      patch: { flags: {}, channels: [] },
+      apply_mode: "restart",
+    });
+    const r = finalizePendingMatchingUpdates(nid, { model: "x", flags: {}, channels: [] });
+    expect(r.finalizedCount).toBe(1);
+  });
+
+  test("channels: [] disable-all — do NOT finalize when snapshot still has channels", () => {
+    const nid = insertNode({ alias: "n-chan-5", network_id: "netA" });
+    insertPendingUpdate({
+      node_id: nid, network_id: "netA",
+      patch: { flags: {}, channels: [] },
+      apply_mode: "restart",
+    });
+    // Node hasn't restarted yet — old telegram worker still forked.
+    const r = finalizePendingMatchingUpdates(nid, { model: "x", flags: {}, channels: ["telegram"] });
+    expect(r.finalizedCount).toBe(0);
+  });
+
+  test("snapshot omits channels field entirely (pre-P5 agent-node) → NOT finalized on channels-carrying patch", () => {
+    const nid = insertNode({ alias: "n-chan-6", network_id: "netA" });
+    insertPendingUpdate({
+      node_id: nid, network_id: "netA",
+      patch: { flags: {}, channels: ["feishu"] },
+      apply_mode: "restart",
+    });
+    const r = finalizePendingMatchingUpdates(nid, { model: "x", flags: {} });  // no channels key
+    expect(r.finalizedCount).toBe(0);
+  });
+
+  test("model + channels compound match: both must satisfy", () => {
+    const nid = insertNode({ alias: "n-chan-7", network_id: "netA" });
+    insertPendingUpdate({
+      node_id: nid, network_id: "netA",
+      patch: { model: "opus-new", flags: {}, channels: ["telegram"] },
+      apply_mode: "restart",
+    });
+    // Wrong channels → not finalized even though model matches.
+    expect(finalizePendingMatchingUpdates(nid, { model: "opus-new", flags: {}, channels: [] }).finalizedCount).toBe(0);
+    // Both match → finalized.
+    expect(finalizePendingMatchingUpdates(nid, { model: "opus-new", flags: {}, channels: ["telegram"] }).finalizedCount).toBe(1);
+  });
+});

package/src/config-apply-validate.test.ts

@@ -9,9 +9,11 @@ import { describe, expect, test } from "bun:test";
 import {
   ALLOWED_FLAGS,
   SECURITY_SENSITIVE_FLAGS,
+  EDITABLE_CHANNELS,
   isAllowedToChangeFlag,
   computeApplyMode,
   validatePatch,
+  narrowChannelsPatch,
 } from "./config-apply-validate";
 
 describe("ALLOWED_FLAGS — exact contract (no silent extension)", () => {
@@ -258,3 +260,93 @@ describe("validatePatch — combinations", () => {
     expect(r?.field).toBe("flags.maxTurns");
   });
 });
+
+// ── #260 P5 — channels support (restart-tier, non-security-sensitive) ─
+describe("EDITABLE_CHANNELS — mirrors agent-node runtime capability (cli.ts:671-676)", () => {
+  test("contains exactly telegram + feishu (channels agent-node actually forks workers for)", () => {
+    expect(EDITABLE_CHANNELS.size).toBe(2);
+    expect(EDITABLE_CHANNELS.has("telegram")).toBe(true);
+    expect(EDITABLE_CHANNELS.has("feishu")).toBe(true);
+  });
+  test("commhub is NOT editable — it's the RPC transport, not a per-node channel worker", () => {
+    expect(EDITABLE_CHANNELS.has("commhub")).toBe(false);
+  });
+  test("wechat is NOT editable — roadmap only on dashboard", () => {
+    expect(EDITABLE_CHANNELS.has("wechat")).toBe(false);
+  });
+});
+
+describe("narrowChannelsPatch — hostile input hygiene at the wire boundary", () => {
+  test("straight allow-listed input passes verbatim", () => {
+    expect(narrowChannelsPatch(["telegram", "feishu"])).toEqual(["telegram", "feishu"]);
+  });
+  test("empty array preserved — 'disable all editable channels' is a real state", () => {
+    expect(narrowChannelsPatch([])).toEqual([]);
+  });
+  test("non-array returns null (patch didn't touch channels)", () => {
+    expect(narrowChannelsPatch(undefined)).toBeNull();
+    expect(narrowChannelsPatch("telegram" as any)).toBeNull();
+    expect(narrowChannelsPatch({} as any)).toBeNull();
+  });
+  test("case-folded to lower", () => {
+    expect(narrowChannelsPatch(["FEISHU", "Telegram"])).toEqual(["feishu", "telegram"]);
+  });
+  test("duplicates deduped (Set)", () => {
+    expect(narrowChannelsPatch(["telegram", "telegram", "feishu", "TELEGRAM"])).toEqual(["telegram", "feishu"]);
+  });
+  test("unknown channel keys dropped silently (roadmap wechat, transport commhub, evil keys)", () => {
+    expect(narrowChannelsPatch(["wechat", "telegram", "evil-hacker", "commhub"])).toEqual(["telegram"]);
+  });
+  test("non-string entries dropped (numbers, objects, nulls)", () => {
+    expect(narrowChannelsPatch(["telegram", 42, {}, null, "feishu"] as any)).toEqual(["telegram", "feishu"]);
+  });
+  test("SQL-injection-shaped value dropped (not exact key match)", () => {
+    expect(narrowChannelsPatch(["telegram; drop table users;", "feishu"])).toEqual(["feishu"]);
+  });
+  test("whitespace around a key still trims to the key", () => {
+    expect(narrowChannelsPatch(["  feishu  "])).toEqual(["feishu"]);
+  });
+});
+
+describe("computeApplyMode — channels tier (restart)", () => {
+  test("channels-only patch → restart (boot forks per-channel workers)", () => {
+    expect(computeApplyMode(undefined, {}, ["feishu"])).toBe("restart");
+  });
+  test("empty-array channels → restart (still a state change)", () => {
+    expect(computeApplyMode(undefined, {}, [])).toBe("restart");
+  });
+  test("no channels key + no flags + no model → restart_only", () => {
+    expect(computeApplyMode(undefined, {}, undefined)).toBe("restart_only");
+  });
+  test("channels + hot-tier flag together stays restart (upgrade rules)", () => {
+    expect(computeApplyMode(undefined, { maxTurns: 5 }, ["telegram"])).toBe("restart");
+  });
+  test("channels + model → restart (model was already restart)", () => {
+    expect(computeApplyMode("gpt-5", {}, ["feishu"])).toBe("restart");
+  });
+});
+
+describe("validatePatch — channels defensive gate", () => {
+  test("valid channels array passes", () => {
+    expect(validatePatch(undefined, {}, ["telegram", "feishu"])).toBeNull();
+    expect(validatePatch(undefined, {}, [])).toBeNull();
+    expect(validatePatch(undefined, {}, ["telegram"])).toBeNull();
+  });
+  test("commhub rejected — RPC transport, not a per-node channel", () => {
+    const r = validatePatch(undefined, {}, ["commhub"]);
+    expect(r?.field).toBe("channels.commhub");
+  });
+  test("out-of-allowlist channel rejected (caller bypassed narrowing)", () => {
+    const r = validatePatch(undefined, {}, ["wechat"]);
+    expect(r?.field).toBe("channels.wechat");
+    expect(r?.reason).toMatch(/allowlist/);
+  });
+  test("non-string entry rejected", () => {
+    const r = validatePatch(undefined, {}, [42] as any);
+    expect(r?.field).toBe("channels");
+  });
+  test("non-array rejected", () => {
+    const r = validatePatch(undefined, {}, "telegram" as any);
+    expect(r?.field).toBe("channels");
+  });
+});

package/src/config-apply-validate.ts

@@ -57,6 +57,35 @@ export const RESTART_REQUIRED_FLAGS = new Set<string>([
   "timeout",
 ]);
 
+/**
+ * Channels the dashboard may enable/disable on a node via
+ * update_node_config. Intentionally narrow — the panel only exposes
+ * enable/disable, per-channel secrets stay in the node's local
+ * config.json (see #260 wire discipline).
+ *
+ * The list mirrors agent-node's actual runtime capability. See
+ * agent-node/src/cli.ts:671-676 — CHANNELS are parsed into per-type
+ * worker inits (initTelegramChannel + initFeishuChannel), and any
+ * other channel type triggers `process.exit(1)` at boot. So the
+ * hub-side allow-list here is telegram + feishu ONLY. `commhub` is
+ * the RPC transport that every node speaks unconditionally; treating
+ * it as a per-node channel would be a UX lie (toggle looks off but
+ * commhub is always on).
+ *
+ * Dashboard PR #31 currently includes `commhub` in its own
+ * EDITABLE_CHANNELS whitelist — that follow-up narrowing is filed for
+ * the next dashboard rally, and until then hub silently drops any
+ * `commhub` entry via narrowChannelsPatch.
+ *
+ * Not part of SECURITY_SENSITIVE_FLAGS (通信龙 P5 派工): flipping a
+ * channel on/off is a lifecycle-tier operation like `restart_node`, not
+ * a privilege elevation. Cross-tenant reach is already gated by SEC-1.
+ */
+export const EDITABLE_CHANNELS = new Set<string>([
+  "telegram",
+  "feishu",
+]);
+
 /**
  * Role-gate for the patch's flag set. SEC-2 enforcement lives here.
  *
@@ -99,22 +128,53 @@ export function isAllowedToChangeFlag(
 
 /**
  * Classify the patch's required apply mode. Empty patch (model + flags
- * both empty) → "restart_only" (used by restart_node tool). Any
- * restart-required field present → "restart". Otherwise → "hot".
+ * both empty, no channels) → "restart_only" (used by restart_node tool).
+ * Any restart-required field present, OR a channels change → "restart"
+ * (channels is restart-tier by design: the node reads its channel set
+ * once at boot in agent-node/src/cli.ts and forks per-channel workers
+ * from it, so a channel enable/disable takes effect on process restart
+ * only — see #260 P5 wire discipline). Otherwise → "hot".
  */
 export function computeApplyMode(
   model: string | undefined,
   flags: Record<string, unknown>,
+  channels?: string[] | undefined,
 ): "hot" | "restart" | "restart_only" {
-  const fieldCount = (model !== undefined ? 1 : 0) + Object.keys(flags).length;
+  const fieldCount = (model !== undefined ? 1 : 0) + Object.keys(flags).length + (channels !== undefined ? 1 : 0);
   if (fieldCount === 0) return "restart_only";
   if (model !== undefined) return "restart";
+  if (channels !== undefined) return "restart";
   for (const key of Object.keys(flags)) {
     if (RESTART_REQUIRED_FLAGS.has(key)) return "restart";
   }
   return "hot";
 }
 
+/**
+ * Narrow + allow-list `channels` from untrusted patch JSON. Returns the
+ * final channel key list (case-folded, deduped, in EDITABLE_CHANNELS
+ * order-preserving), OR null if the input isn't an array. Non-strings,
+ * unknown keys, empty strings, and duplicates are silently dropped —
+ * same fail-shape as the dashboard route's whitelist so the two sides
+ * behave identically end-to-end. Callers pass `undefined` through when
+ * the patch didn't include a channels key at all (a distinct case from
+ * `channels: []` which means "disable all editable channels").
+ */
+export function narrowChannelsPatch(raw: unknown): string[] | null {
+  if (!Array.isArray(raw)) return null;
+  const allow = EDITABLE_CHANNELS;
+  const seen = new Set<string>();
+  const out: string[] = [];
+  for (const v of raw) {
+    if (typeof v !== "string") continue;
+    const key = v.trim().toLowerCase();
+    if (!allow.has(key) || seen.has(key)) continue;
+    seen.add(key);
+    out.push(key);
+  }
+  return out;
+}
+
 /**
  * Validate the patch shape — allowlist + per-field range / enum. Returns
  * null on pass, or `{ field, reason }` on reject. Caller wraps in error
@@ -123,12 +183,30 @@ export function computeApplyMode(
 export function validatePatch(
   model: string | undefined,
   flags: Record<string, unknown>,
+  channels?: string[] | undefined,
 ): { field: string; reason: string } | null {
   if (model !== undefined) {
     if (typeof model !== "string" || model.length === 0 || model.length > 200) {
       return { field: "model", reason: "must be a non-empty string ≤ 200 chars" };
     }
   }
+  if (channels !== undefined) {
+    // Zod already enforced string[], and narrowChannelsPatch dropped
+    // unknown keys before this point — but re-verify defensively so a
+    // future caller that skips narrowChannelsPatch can't smuggle
+    // unknown keys through validatePatch alone.
+    if (!Array.isArray(channels)) {
+      return { field: "channels", reason: "must be an array of strings" };
+    }
+    for (const c of channels) {
+      if (typeof c !== "string") {
+        return { field: "channels", reason: "must contain only strings" };
+      }
+      if (!EDITABLE_CHANNELS.has(c)) {
+        return { field: `channels.${c}`, reason: "not in editable channels allowlist" };
+      }
+    }
+  }
   for (const [key, val] of Object.entries(flags)) {
     if (!ALLOWED_FLAGS.has(key)) {
       return { field: `flags.${key}`, reason: "not in allowlist" };