@sleep2agi/commhub-server 0.9.0-preview.12 → 0.9.0-preview.121

package/src/create-node-unicode-name.test.ts

@@ -0,0 +1,120 @@
+// Board #652 — create_node takes Chinese / Unicode node names (the alias); illegal
+// characters are refused with a reason before any row is written; the in-flight
+// uniqueness check still holds. Driven through the REAL /mcp entry (zod schema +
+// handler) on a private port with a temp DB, then get_create_request as the daemon.
+
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+const DIR = mkdtempSync(join(tmpdir(), "anet-652-"));
+process.env.COMMHUB_DB ||= join(DIR, "hub.db");
+process.env.HOST = "127.0.0.1";
+
+const { db } = await import("./db.js");
+const { register, createNetworkTokenForNode } = await import("./auth.js");
+
+const PW = "Unicode652Passw0rd!x";
+let BASE = "";
+let hub: any = null;
+let OWNER = "";
+let OWNER_ID = "";
+let NET = "";
+let DAEMON_TOK = "";
+const DAEMON_ID = "node_t652_daemon";
+
+async function rpc(token: string, method: string, params?: unknown): Promise<any> {
+  const res = await fetch(`${BASE}/mcp`, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json", Accept: "application/json, text/event-stream", "MCP-Protocol-Version": "2025-03-26" },
+    body: JSON.stringify({ jsonrpc: "2.0", id: 1, method, ...(params === undefined ? {} : { params }) }),
+  });
+  const raw = await res.text();
+  const lines = raw.split("\n").filter(x => x.startsWith("data:"));
+  return lines.length ? JSON.parse(lines.at(-1)!.slice(5).trim()) : JSON.parse(raw);
+}
+async function mcp(token: string, name: string, args: Record<string, unknown>): Promise<any> {
+  const out = await rpc(token, "tools/call", { name, arguments: args });
+  const text = out?.result?.content?.[0]?.text;
+  if (typeof text !== "string") return { _raw: out };
+  try { return JSON.parse(text); } catch { return { _text: text, isError: out.result.isError }; }
+}
+const create = (name: string) => mcp(OWNER, "create_node", {
+  daemon_node_id: DAEMON_ID, network_id: NET,
+  node_spec: { name, runtime: "claude-agent-sdk", model: "claude-sonnet-4-5", flags: {} },
+});
+const rows = (name: string) =>
+  db.get<{ n: number }>("SELECT COUNT(*) AS n FROM node_create_requests WHERE daemon_node_id = ?1 AND child_name = ?2", DAEMON_ID, name)?.n ?? -1;
+
+beforeAll(async () => {
+  const a = register(`t652_owner_${Date.now()}`, PW, undefined, "Owner");
+  if (!a.ok) throw new Error("register failed");
+  OWNER = a.token!; OWNER_ID = a.user!.user_id; NET = a.network_id!;
+  const mod: any = await import("./server.js");
+  hub = mod.bootServer({ port: 0, hostname: "127.0.0.1" });
+  BASE = `http://127.0.0.1:${hub.port}`;
+  const t = createNetworkTokenForNode(OWNER_ID, NET, "t652-daemon", DAEMON_ID);
+  if (!t.ok || !t.token) throw new Error("daemon token failed: " + t.error);
+  DAEMON_TOK = t.token;
+  db.run(
+    `INSERT OR REPLACE INTO nodes (node_id, node_name, alias, runtime, model, config_path, channels, server, hostname, network_id, config_revision, config_snapshot)
+     VALUES (?1, 't652-daemon', 't652-daemon', 'claude-agent-sdk', 'm', '/tmp/cfg.json', '[]', 'h', 'h', ?2, 0, ?3)`,
+    [DAEMON_ID, NET, JSON.stringify({ role: "host_supervisor", daemon_capabilities: { runtimes_supported: ["claude-agent-sdk"] } })],
+  );
+});
+afterAll(() => {
+  try { hub?.stop?.(true); } catch {}
+  rmSync(DIR, { recursive: true, force: true });
+});
+
+describe("#652 create_node via /mcp — Unicode names", () => {
+  test("「测试」 is accepted; the daemon gets the same alias", async () => {
+    const r = await create("测试");
+    expect(r.ok).toBe(true);
+    expect(String(r.request_id)).toMatch(/^cr_/);
+    expect(rows("测试")).toBe(1);
+    const g = await mcp(DAEMON_TOK, "get_create_request", { request_id: r.request_id });
+    expect(g.ok).toBe(true);
+    expect(g.node_spec.name).toBe("测试");
+  });
+
+  test("upper case / digit-first ASCII and 64 CJK characters pass the zod bound and the rule", async () => {
+    for (const name of ["研发助手A", "Demo2", "9lives", "测".repeat(64)]) {
+      const r = await create(name);
+      expect({ name, ok: r.ok, error: r.error }).toEqual({ name, ok: true, error: undefined });
+    }
+  });
+
+  test("surrounding whitespace is trimmed before it is stored", async () => {
+    const r = await create("  前后空格  ");
+    expect(r.ok).toBe(true);
+    expect(rows("前后空格")).toBe(1);
+    expect(rows("  前后空格  ")).toBe(0);
+  });
+
+  test("illegal characters are refused with reason + char + message, and no row is written", async () => {
+    for (const [name, reason] of [["a/b", "forbidden_char"], ["a\\b", "forbidden_char"], ["a:b", "forbidden_char"],
+      [".hidden", "forbidden_char"], ["..", "forbidden_char"], ["a b", "forbidden_char"], ["a\u0007b", "forbidden_char"],
+      ["a\nb", "forbidden_char"], ["a\tb", "forbidden_char"], ["a\u001fb", "forbidden_char"], ["a\u007fb", "forbidden_char"],
+      ["a\u2028b", "forbidden_char"], ["a\u2029b", "forbidden_char"],
+      ["-x", "leading_dash"], ["测".repeat(65), "too_long"]] as const) {
+      const r = await create(name);
+      expect({ name, error: r.error, reason: r.reason }).toEqual({ name, error: "node_name_invalid", reason });
+      expect(String(r.message ?? "").length).toBeGreaterThan(0);
+      expect(rows(name)).toBe(0);
+    }
+    const slash = await create("a/b");
+    expect(slash.char).toBe("/");
+    expect(slash.message).toContain("/");
+  });
+
+  test("uniqueness: a second in-flight request for the same Chinese name is a conflict", async () => {
+    const first = await create("重复名字");
+    expect(first.ok).toBe(true);
+    const second = await create("重复名字");
+    expect(second.ok).toBe(false);
+    expect(second.error).toBe("node_name_conflict");
+    expect(rows("重复名字")).toBe(1);
+  });
+});

package/src/create-node-validate.test.ts

@@ -1,25 +1,39 @@
 import { describe, expect, test } from "bun:test";
 import {
   ValidationError,
-  validateName, validateRuntime, validateModel, validateFlagValue,
+  validateName, validateRuntime, validateModel, validateFlagValue, RUNTIMES,
   validateEnvRefs, validateChannelsP1, serializeEnvLocal, buildAnetArgs,
-  MAX_ENV_KEYS_PER_NODE,
+  MAX_ENV_KEYS_PER_NODE, validateFlagsForRuntime, validateOpenCodeV2ProviderModel, COPRESENCE_FLAG_RUNTIMES,
 } from "./create-node-validate.js";
 
 const okSecret = (k: string, _net: string, key: string) => k === key ? `value-of-${k}` : undefined;
 const allow = (k: string) => new Set<string>([k, "ANTHROPIC_API_KEY", "OPENAI_API_KEY"]);
 
-describe("validateName (§4.2.2)", () => {
-  test("good names", () => {
-    for (const n of ["a", "demo-bot", "node_1", "z2", "abc-def-ghi"]) {
+describe("validateName (§4.2.2, #652 Unicode names)", () => {
+  test("good names — incl. Chinese, upper case, digits first", () => {
+    for (const n of ["a", "demo-bot", "node_1", "z2", "abc-def-ghi", "测试", "研发助手A", "Demo", "1demo", "测".repeat(64)]) {
       expect(() => validateName(n)).not.toThrow();
     }
   });
-  test("rejects shell-injection-like names", () => {
-    for (const n of [";rm -rf /", "demo bot", "Demo", "1demo", "-demo", "demo;rm", "demo$INJECT", "x".repeat(65)]) {
+  test("returns the trimmed name", () => {
+    expect(validateName("  测试 ")).toBe("测试");
+  });
+  test("rejects shell-injection-like and path-like names with a reason", () => {
+    for (const n of [";rm -rf /", "demo bot", "-demo", "demo;rm", "demo$INJECT", "x".repeat(65), "测".repeat(65),
+      "a/b", "a\\b", "a:b", ".hidden", "..", "a\u0000b", "a`id`", "", "   "]) {
       expect(() => validateName(n)).toThrow(ValidationError);
     }
   });
+  test("error carries reason + offending char + a readable message", () => {
+    try { validateName("a/b"); throw new Error("no throw"); }
+    catch (e: any) {
+      expect(e).toBeInstanceOf(ValidationError);
+      expect(e.code).toBe("node_name_invalid");
+      expect(e.detail.reason).toBe("forbidden_char");
+      expect(e.detail.char).toBe("/");
+      expect(String(e.detail.message)).toContain("/");
+    }
+  });
 });
 
 describe("validateRuntime / validateModel (§4.2.2)", () => {
@@ -35,6 +49,15 @@ describe("validateRuntime / validateModel (§4.2.2)", () => {
     expect(() => validateModel("gpt-4o")).not.toThrow();
     expect(() => validateModel("bad model")).toThrow(ValidationError);
     expect(() => validateModel("x;rm")).toThrow(ValidationError);
+    // provider/model(OpenCode 共存;桌面向导 0.2.61 起发这种形状,Vincent 2026-09-08 撞到 model_invalid)
+    expect(() => validateModel("opencode/mimo-v2.5-free")).not.toThrow();
+    expect(() => validateModel("anthropic/claude-sonnet-4")).not.toThrow();
+    expect(() => validateModel("a/b/c")).toThrow(ValidationError);      // 只许一个斜杠
+    expect(() => validateModel("/model")).toThrow(ValidationError);     // 不能以斜杠开头
+    expect(() => validateModel("provider/")).toThrow(ValidationError);  // 不能以斜杠结尾
+    expect(() => validateModel("../x")).toThrow(ValidationError);       // 纯点段(路径穿越形状)
+    expect(() => validateModel("x/.")).toThrow(ValidationError);
+    expect(() => validateModel("open code/m")).toThrow(ValidationError);
     expect(() => validateModel("")).toThrow(ValidationError);
   });
 });
@@ -60,6 +83,30 @@ describe("validateFlagValue (§4.2.2)", () => {
     expect(() => validateFlagValue("permissionMode", "plan")).not.toThrow();
     expect(() => validateFlagValue("permissionMode", "anything-else")).toThrow(ValidationError);
   });
+  // #605 —— agent-node 按毫秒读 flags.timeout(默认 300000)。这里曾收 1..86400(秒的形状):
+  // 600 原样到子节点 = 0.6 秒超时;600000(10 分钟)反被拒。现在与 update_node_config 同一把尺子。
+  test("timeout is milliseconds: 0 or 1000..3_600_000 (#605)", () => {
+    for (const v of [0, 1000, 300_000, 600_000, 3_600_000]) {
+      expect(() => validateFlagValue("timeout", v)).not.toThrow();
+    }
+    for (const v of [1, 600, 999, 86_400 * 1000 + 1, 3_600_001, -1, 1500.5, "600000", null]) {
+      expect(() => validateFlagValue("timeout", v)).toThrow(ValidationError);
+    }
+    try { validateFlagValue("timeout", 600); throw new Error("unreachable"); }
+    catch (e) {
+      expect(e).toBeInstanceOf(ValidationError);
+      expect((e as ValidationError).code).toBe("flag_value_invalid");
+      expect(String((e as ValidationError).detail?.reason)).toContain("milliseconds");
+    }
+  });
+  test("timeout range matches update_node_config's (#605)", async () => {
+    const { validatePatch } = await import("./config-apply-validate.js");
+    for (const v of [0, 1, 600, 999, 1000, 600_000, 3_600_000, 3_600_001, -1, 1.5]) {
+      let createOk = true;
+      try { validateFlagValue("timeout", v); } catch { createOk = false; }
+      expect({ v, ok: createOk }).toEqual({ v, ok: validatePatch(undefined, { timeout: v }) === null });
+    }
+  });
 });
 
 describe("validateEnvRefs (§4.4.7 + B1 G7/G8 sub-cases)", () => {
@@ -169,6 +216,41 @@ describe("buildAnetArgs (§4.2.2 F2 — fully validated argv)", () => {
     expect(args).toContain("--permission-mode");
     expect(args[args.indexOf("--permission-mode") + 1]).toBe("plan");
   });
+  test("OpenCode V2 requires provider/model only after unsafe opt-in", () => {
+    let unsafe = "";
+    try {
+      buildAnetArgs({ name: "v2", runtime: "opencode-cli", flags: { opencodeGeneration: "v2" } });
+    } catch (e) { unsafe = (e as ValidationError).code; }
+    expect(unsafe).toBe("opencode_v2_requires_unsafe_opt_in");
+    let missing = "";
+    try {
+      buildAnetArgs({ name: "v2", runtime: "opencode-cli", flags: { opencodeGeneration: "v2", opencodeUnsafeTools: true } });
+    } catch (e) { missing = (e as ValidationError).code; }
+    expect(missing).toBe("opencode_v2_requires_provider_model");
+    let bare = "";
+    try {
+      buildAnetArgs({ name: "v2", runtime: "opencode-cli", model: "opencode", flags: { opencodeGeneration: "v2", opencodeUnsafeTools: true } });
+    } catch (e) { bare = (e as ValidationError).code; }
+    expect(bare).toBe("opencode_v2_requires_provider_model");
+    const args = buildAnetArgs({
+      name: "v2", runtime: "opencode-cli", model: "stub/model",
+      flags: { opencodeGeneration: "v2", opencodeUnsafeTools: true },
+    });
+    expect(args).toContain("stub/model");
+    expect(() => validateOpenCodeV2ProviderModel("opencode-cli", undefined, { opencodeGeneration: "v2" })).not.toThrow();
+    expect(() => validateOpenCodeV2ProviderModel("claude-agent-sdk", undefined, { opencodeGeneration: "v2", opencodeUnsafeTools: true })).not.toThrow();
+    expect(buildAnetArgs({ name: "x", runtime: "opencode-cli" })).toEqual(["node", "create", "x", "--runtime", "opencode-cli"]);
+  });
+  test("omitted model is allowed and does not emit --model", () => {
+    const args = buildAnetArgs({
+      name: "x", runtime: "codex-sdk",
+      flags: { permissionMode: "plan" },
+    });
+    expect(args).toEqual(["node", "create", "x", "--runtime", "codex-sdk", "--permission-mode", "plan"]);
+  });
+  test("empty model is still rejected", () => {
+    expect(() => buildAnetArgs({ name: "x", runtime: "codex-sdk", model: "" })).toThrow(ValidationError);
+  });
   test("rejects bad name with shell metachar", () => {
     expect(() => buildAnetArgs({ name: ";rm -rf /", runtime: "claude-agent-sdk", model: "x" })).toThrow(ValidationError);
   });
@@ -185,3 +267,107 @@ describe("buildAnetArgs (§4.2.2 F2 — fully validated argv)", () => {
     } as any)).toThrow(ValidationError);
   });
 });
+
+// ─── runtime_invalid 要说清「允许哪些」和「还有什么路」 ────────────────
+//
+// 2026-08-28 实测：从 Dashboard 建一个 codex-app-server 节点，用户拿到的是
+//   {"ok":false,"error":"runtime_invalid","value":"codex-app-server"}
+// 而目标机器的 daemon 日志里一行都没有 —— 请求被 hub 拦在最前面，
+// 用户无从知道①哪些允许②是不是打错了③有没有别的办法。
+// 🔴 2026-08-28:这一节原本拿 `codex-app-server` / `opencode-cli` 当"非法 runtime"的例子。
+//    #1298 把 hub 的 RUNTIMES 从 3 个放开到 7 个之后,那两个变成了合法值,这两条测试因此红了 ——
+//    **测试正确地抓到了行为变更**。修法是换例子,不是削弱断言:
+//    意图仍然是「非法 runtime 要给可操作的报错」,只是例子换成永远不会合法的字符串。
+describe("validateRuntime — 报错要可操作", () => {
+  function thrown(v: unknown): any {
+    try { validateRuntime(v); } catch (e: any) { return e; }
+    throw new Error("expected validateRuntime to throw");
+  }
+
+  test("非法 runtime 的报错带上允许集合", () => {
+    const e = thrown("definitely-not-a-runtime");
+    expect(e.code).toBe("runtime_invalid");
+    expect(Array.isArray(e.detail?.allowed)).toBe(true);
+    // 🔴 断言它等于 RUNTIMES 本身,而不是等于一份手抄的清单 ——
+    //    手抄的那份会漂,漂了之后报错会理直气壮地告诉用户一组错的名字。
+    expect(e.detail.allowed).toEqual([...RUNTIMES]);
+  });
+
+  test("报错带上一条出路提示", () => {
+    const e = thrown("another-bogus-runtime");
+    expect(typeof e.detail?.hint).toBe("string");
+    expect(e.detail.hint.length).toBeGreaterThan(10);
+    // 提示必须点名那条真实存在的路,否则它只是安慰话
+    expect(e.detail.hint).toContain("anet node create");
+  });
+
+  test("仍然回报用户传进来的那个值（便于识别是不是打错了）", () => {
+    const e = thrown("codex-app-servr");   // 故意少一个 e
+    expect(e.detail.value).toBe("codex-app-servr");
+  });
+
+  test("🔴 合法 runtime 一个都不能被这次改动误伤", () => {
+    for (const r of RUNTIMES) {
+      expect(() => validateRuntime(r)).not.toThrow();
+    }
+    // 正控：非字符串必须仍然被拒 —— 否则上面那条循环全过也说明不了什么
+    expect(() => validateRuntime(123 as any)).toThrow();
+    expect(() => validateRuntime(undefined as any)).toThrow();
+  });
+});
+
+// #1298 —— daemon 远程创建放开到 7 个 runtime（Vincent 2026-08-28 定，
+// 理由是兜底排错：节点不动了，人要能进去跟 Codex / Claude Code 对话）。
+describe("#1298 RUNTIMES —— 七个都放行，且与 CLI 侧一致", () => {
+  test("三个共存 runtime 不再被拒", () => {
+    for (const r of ["codex-app-server", "grok-build-cli", "opencode-cli"]) {
+      expect(() => validateRuntime(r)).not.toThrow();
+    }
+  });
+  test("原有四个仍然放行（放开不该顺手改坏别的）", () => {
+    for (const r of ["claude-agent-sdk", "claude-code-cli", "codex-sdk", "grok-build-acp"]) {
+      expect(() => validateRuntime(r)).not.toThrow();
+    }
+  });
+  test("🔴 恰好七个 —— 多一个少一个都要有人解释", () => {
+    expect(RUNTIMES.length).toBe(7);
+    // 正控：不在名单里的仍然被拒，证明上面不是"什么都放行"
+    expect(() => validateRuntime("definitely-not-a-runtime")).toThrow();
+    expect(() => validateRuntime("")).toThrow();
+  });
+});
+
+// #584 —— app「Codex（TUI 共存）」经 daemon 建出来的是无头节点:create_node 没有任何字段能表达「要共存」。
+describe("#584 flags.copresence —— 建节点时的共存开关", () => {
+  test("is a known flag key and must be boolean", () => {
+    expect(() => validateFlagValue("copresence", true)).not.toThrow();
+    expect(() => validateFlagValue("copresence", false)).not.toThrow();
+    for (const bad of ["true", 1, null, {}]) {
+      try { validateFlagValue("copresence", bad); throw new Error("did not throw"); }
+      catch (e) { expect((e as ValidationError).code).toBe("flag_value_invalid"); }
+    }
+  });
+  test("only codex-app-server accepts it — elsewhere it would be swallowed silently", () => {
+    expect(() => validateFlagsForRuntime("codex-app-server", { copresence: true })).not.toThrow();
+    expect(() => validateFlagsForRuntime("claude-agent-sdk", { permissionMode: "default" })).not.toThrow();
+    expect(() => validateFlagsForRuntime("claude-agent-sdk", undefined)).not.toThrow();
+    for (const rt of ["claude-agent-sdk", "claude-code-cli", "codex-sdk", "grok-build-acp", "grok-build-cli", "opencode-cli"]) {
+      try { validateFlagsForRuntime(rt, { copresence: true }); throw new Error(`did not throw for ${rt}`); }
+      catch (e) {
+        expect((e as ValidationError).code).toBe("flag_not_applicable_to_runtime");
+        expect((e as ValidationError).detail).toMatchObject({ field: "copresence", runtime: rt, applicable: [...COPRESENCE_FLAG_RUNTIMES] });
+      }
+    }
+  });
+  test("buildAnetArgs emits the CLI's boolean `--copresence` (no value), and nothing for false", () => {
+    expect(buildAnetArgs({ name: "cx", runtime: "codex-app-server", flags: { copresence: true } }))
+      .toEqual(["node", "create", "cx", "--runtime", "codex-app-server", "--copresence"]);
+    expect(buildAnetArgs({ name: "cx", runtime: "codex-app-server", flags: { copresence: false } }))
+      .toEqual(["node", "create", "cx", "--runtime", "codex-app-server"]);
+    expect(() => buildAnetArgs({ name: "cx", runtime: "codex-sdk", flags: { copresence: true } })).toThrow(ValidationError);
+  });
+  test("the old request shape (no flag) is unchanged", () => {
+    expect(buildAnetArgs({ name: "cx", runtime: "codex-app-server", flags: { permissionMode: "default" } }))
+      .toEqual(["node", "create", "cx", "--runtime", "codex-app-server", "--permission-mode", "default"]);
+  });
+});