@sleep2agi/commhub-server 0.9.0-preview.13 → 0.9.0-preview.130

package/src/session-task-on-dispatch.ts

@@ -0,0 +1,14 @@
+// Board #668. A dispatch preview is what the hub shows before the node
+// reports. Once the session is already working, that text is the task in
+// flight — a newer message waits in the inbox and must not replace it.
+// Idle and every other status still take the preview.
+
+const PLACEHOLDER = /^\?\d+$/;
+
+/** SQL expression for `sessions.task` on dispatch. `placeholder` is a `?N` bind. */
+export function sessionTaskOnDispatch(placeholder: string): string {
+  if (!PLACEHOLDER.test(placeholder)) {
+    throw new Error("sessionTaskOnDispatch placeholder must be a ?N bind");
+  }
+  return `CASE WHEN status = 'working' THEN task ELSE ${placeholder} END`;
+}

package/src/session-token-ownership-http.test.ts

@@ -0,0 +1,122 @@
+import { beforeAll, afterAll, expect, test } from "bun:test";
+import { mkdtempSync } from "node:fs";
+
+process.env.COMMHUB_DB ||= `${mkdtempSync("/tmp/session689-")}/hub.db`;
+let db: any, hub: ReturnType<typeof Bun.serve>, base: string;
+let owner: any, holder: any, member: any, admin: any, outsider: any;
+let generateNetworkToken: () => string, hashToken: (token: string) => string;
+async function mint(actor: any, alias: string, nodeId?: string, network = owner.network_id) {
+  const response = await fetch(`${base}/api/auth/node-token`, {
+    method: "POST", headers: { Authorization: `Bearer ${actor.token}`, "Content-Type": "application/json" },
+    body: JSON.stringify({ network_id: network, node_name: alias, ...(nodeId ? { node_id: nodeId } : {}) }),
+  });
+  return { status: response.status, body: await response.json() as any };
+}
+function session(alias: string, network = owner.network_id, nodeId: string | null = null) {
+  db.run("INSERT INTO sessions(resume_id,alias,network_id,node_id,status) VALUES(?1,?2,?3,?4,'offline')",
+    [crypto.randomUUID(), alias, network, nodeId]);
+}
+function credential(alias: string, actor = holder, options: { epoch?: number; revoked?: boolean; expired?: boolean; network?: string; bound?: string; scope?: string } = {}) {
+  const id = crypto.randomUUID();
+  db.run(`INSERT INTO api_tokens(token_id,token_hash,user_id,network_id,name,scope,node_identity_epoch,bound_node_id,revoked_at,expires_at)
+    VALUES(?1,?2,?3,?4,?5,?6,?7,?8,?9,?10)`,
+    [id, hashToken(generateNetworkToken()), actor.user.user_id, options.network ?? owner.network_id,
+      `node:${alias}`, options.scope ?? "network", options.epoch ?? 0, options.bound ?? null,
+      options.revoked ? "2000-01-01 00:00:00" : null, options.expired ? "2000-01-01 00:00:00" : null]);
+}
+function snapshot() {
+  return {
+    tokens: db.all("SELECT token_id,user_id,name,bound_node_id FROM api_tokens ORDER BY token_id"),
+    sessions: db.all("SELECT resume_id,alias,network_id,node_id,status FROM sessions ORDER BY resume_id"),
+    nodes: db.all("SELECT node_id,alias,network_id,owner_user_id FROM nodes ORDER BY node_id"),
+    audits: db.all("SELECT id,action,target_id FROM audit_log ORDER BY id"),
+  };
+}
+async function denied(actor: any, alias: string, nodeId?: string) {
+  const before = snapshot();
+  expect(await mint(actor, alias, nodeId)).toEqual({ status: 400, body: { ok: false, error: "node_owner_mismatch" } });
+  expect(snapshot()).toEqual(before);
+}
+beforeAll(async () => {
+  ({ db, generateNetworkToken, hashToken } = await import("./db.js"));
+  const { register } = await import("./auth.js");
+  owner = register("owner689", "Fixture-Strong1!");
+  holder = register("holder689", "Fixture-Strong1!");
+  member = register("member689", "Fixture-Strong1!");
+  admin = register("admin689", "Fixture-Strong1!");
+  outsider = register("outside689", "Fixture-Strong1!");
+  for (const actor of [holder, member, admin]) {
+    db.run("INSERT INTO network_members(network_id,user_id,role,agent_access) VALUES(?1,?2,?3,'all')",
+      [owner.network_id, actor.user.user_id, actor === admin ? "admin" : "member"]);
+  }
+  const { bootServer } = await import("./server.js");
+  hub = bootServer({ port: 0, hostname: "127.0.0.1" }); base = `http://127.0.0.1:${hub.port}`;
+}, 60000);
+afterAll(() => hub?.stop(true));
+
+test("existing session requires authority for both request shapes without writes", async () => {
+  session("existing689");
+  await denied(member, "existing689");
+  await denied(member, "existing689", "n_existing689");
+});
+test("network owner and administrator can restore a legacy identity", async () => {
+  for (const [actor, alias] of [[owner, "restore-owner689"], [admin, "restore-admin689"]]) {
+    session(alias);
+    expect((await mint(actor, alias)).status).toBe(200);
+    const withId = await mint(actor, alias, `n_${alias}`);
+    expect(withId.status).toBe(200);
+    expect(db.get("SELECT owner_user_id FROM nodes WHERE node_id=?1", `n_${alias}`).owner_user_id).toBe(actor.user.user_id);
+  }
+});
+test("unique legacy holder can refresh without rewriting the session", async () => {
+  session("holder-session689"); credential("holder-session689");
+  await denied(member, "holder-session689");
+  const before = db.get("SELECT * FROM sessions WHERE alias='holder-session689'");
+  expect((await mint(holder, "holder-session689")).status).toBe(200);
+  expect((await mint(holder, "holder-session689", "n_holder-session689")).status).toBe(200);
+  expect(db.get("SELECT * FROM sessions WHERE alias='holder-session689'")).toEqual(before);
+});
+test("current name-only holder can refresh while registration is pending", async () => {
+  expect((await mint(holder, "pending689")).status).toBe(200);
+  session("pending689");
+  await denied(member, "pending689", "n_pending689");
+  expect((await mint(holder, "pending689")).status).toBe(200);
+});
+for (const [label, options] of [
+  ["revoked", { revoked: true }], ["expired", { expired: true }],
+  ["renamed-general", { epoch: 1 }], ["wrong-scope", { scope: "full" }],
+  ["missing-bound-row", { bound: "n_missing689" }],
+] as const) {
+  test(`${label} credential is not session holder evidence`, async () => {
+    const alias = `${label}689`; session(alias); credential(alias, holder, options);
+    await denied(holder, alias);
+  });
+}
+test("conflicting legacy holders need administrator recovery", async () => {
+  session("ambiguous689"); credential("ambiguous689"); credential("ambiguous689", member);
+  await denied(holder, "ambiguous689"); await denied(member, "ambiguous689", "n_ambiguous689");
+  expect((await mint(admin, "ambiguous689")).status).toBe(200);
+});
+test("session and holder evidence stay in the requested network", async () => {
+  session("foreign-session689", outsider.network_id);
+  expect((await mint(member, "foreign-session689")).status).toBe(200);
+  session("foreign-holder689"); credential("foreign-holder689", holder, { network: holder.network_id });
+  await denied(holder, "foreign-holder689");
+  expect((await mint(outsider, "foreign-holder689")).body.error).toBe("no write access to this network");
+});
+test("administrators do not bypass an existing node owner", async () => {
+  db.run("INSERT INTO nodes(node_id,node_name,alias,network_id,owner_user_id) VALUES('n_owned689','owned689','owned689',?1,?2)",
+    [owner.network_id, holder.user.user_id]);
+  session("owned689", owner.network_id, "n_owned689");
+  await denied(admin, "owned689"); await denied(owner, "owned689", "n_owned689");
+  expect((await mint(holder, "owned689")).body.node_id).toBe("n_owned689");
+});
+test("viewer and restricted member gates still precede session recovery", async () => {
+  session("restricted689"); credential("restricted689");
+  db.run("UPDATE network_members SET agent_access='granted' WHERE network_id=?1 AND user_id=?2", [owner.network_id, holder.user.user_id]);
+  try { expect((await mint(holder, "restricted689")).body.error).toBe("restricted members cannot create network tokens"); }
+  finally { db.run("UPDATE network_members SET agent_access='all' WHERE network_id=?1 AND user_id=?2", [owner.network_id, holder.user.user_id]); }
+  db.run("UPDATE network_members SET role='viewer' WHERE network_id=?1 AND user_id=?2", [owner.network_id, member.user.user_id]);
+  try { expect((await mint(member, "restricted689")).body.error).toBe("no write access to this network"); }
+  finally { db.run("UPDATE network_members SET role='member' WHERE network_id=?1 AND user_id=?2", [owner.network_id, member.user.user_id]); }
+});

package/src/shared/codex-inventory.ts

@@ -0,0 +1,41 @@
+// #906 key-free existing Codex inventory. Identical public contract in each package.
+export function validCodexInventory(v: any): boolean {
+  const fields = (o: any, allowed: string[]) => o && typeof o === 'object' && !Array.isArray(o)
+    && Object.keys(o).every(k => allowed.includes(k));
+  const id = (s: any) => typeof s === 'string' && /^[A-Za-z0-9][A-Za-z0-9._:/-]{0,199}$/.test(s);
+  const nullable = (s: any) => s === null || id(s);
+  if (!fields(v, ['observed_at', 'scope', 'rows', 'installation', 'local_discovery']) || !Number.isSafeInteger(v.observed_at) || v.observed_at <= 0
+    || v.scope !== 'hub_bound_nodes' || !Array.isArray(v.rows) || v.rows.length > 200
+    || new Set(v.rows.map((r: any) => r?.node_id)).size !== v.rows.length) return false;
+  if (v.installation !== undefined && (!fields(v.installation, ['status', 'version'])
+    || !['found', 'missing', 'unknown'].includes(v.installation.status)
+    || !(v.installation.version === null || (typeof v.installation.version === 'string' && /^\d+\.\d+\.\d+(?:[-+.][0-9A-Za-z.-]+)?$/.test(v.installation.version) && v.installation.version.length <= 64)))) return false;
+  if (v.local_discovery !== undefined) {
+    const local = v.local_discovery;
+    if (!fields(local, ['status', 'rows']) || !['observed', 'unavailable', 'limit'].includes(local.status)
+      || !Array.isArray(local.rows) || (local.status !== 'observed' && local.rows.length !== 0)
+      || !validCodexInventory({ observed_at: v.observed_at, scope: v.scope, rows: local.rows })
+      || local.rows.some((r: any) => r.status !== 'observed' || r.config_revision !== null || v.rows.some((b: any) => b.node_id === r.node_id))) return false;
+  }
+  for (const r of v.rows) {
+    if (!r || !id(r.node_id) || typeof r.alias !== 'string' || !/^[\p{L}\p{N}][\p{L}\p{N}_.-]{0,99}$/u.test(r.alias)) return false;
+    if (['unavailable', 'not_codex'].includes(r.status)) {
+      if (!fields(r, ['node_id', 'alias', 'status'])) return false;
+      continue;
+    }
+    if (r.status !== 'observed' || !fields(r, ['node_id', 'alias', 'status', 'runtime', 'home_ref', 'home_source',
+      'config_status', 'configured_provider', 'configured_model', 'provider_ids', 'auth_kind', 'credential_status',
+      'account_fingerprint', 'verification', 'effective_state', 'node_configured_model', 'config_revision'])) return false;
+    if (r.config_revision !== undefined && r.config_revision !== null && (typeof r.config_revision !== 'string' || !/^[a-f0-9]{64}$/.test(r.config_revision))) return false;
+    if (!nullable(r.runtime) || !/^[a-f0-9]{16}$/.test(r.home_ref)
+      || !['host_default', 'config.codexHome', 'node-codex-home', 'config.env'].includes(r.home_source)
+      || !['read', 'missing', 'unreadable'].includes(r.config_status) || !nullable(r.configured_provider)
+      || !nullable(r.configured_model) || !nullable(r.node_configured_model)
+      || !Array.isArray(r.provider_ids) || r.provider_ids.length > 101 || !r.provider_ids.every(id)
+      || !['unknown', 'chatgpt', 'api_key'].includes(r.auth_kind)
+      || !['unknown', 'present', 'unreadable'].includes(r.credential_status)
+      || !(r.account_fingerprint === null || /^[a-f0-9]{16}$/.test(r.account_fingerprint))
+      || r.verification !== 'not_checked' || r.effective_state !== 'not_checked') return false;
+  }
+  return true;
+}

package/src/shared/daemon-provider-login.ts

@@ -0,0 +1,31 @@
+// #906 managed login transport: only explicit actions and secret-free projections.
+export type LoginIntent = { action: 'start' | 'read' | 'cancel' | 'save' | 'accounts'; session_id?: string; label?: string };
+const uuid = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/i;
+const object = (v: any) => v && typeof v === 'object' && !Array.isArray(v);
+const keys = (v: any, names: string[]) => Object.keys(v).every(k => names.includes(k));
+export function validLoginIntent(v: any): v is LoginIntent {
+  return object(v) && keys(v, ['action','session_id','label'])
+    && ['start','read','cancel','save','accounts'].includes(v.action)
+    && (v.action === 'accounts' ? v.session_id === undefined : typeof v.session_id === 'string' && uuid.test(v.session_id))
+    && (v.action === 'save' ? typeof v.label === 'string' && !!v.label.trim() && v.label.length <= 100 && !/[\x00-\x1f\x7f]/.test(v.label) : v.label === undefined);
+}
+export function validLoginReceipt(v: any, intent: LoginIntent, network: string, daemon: string): boolean {
+  if (!object(v)) return false;
+  if (intent.action === 'accounts') return keys(v, ['accounts']) && Array.isArray(v.accounts) && v.accounts.length <= 100
+    && v.accounts.every((a: any) => object(a) && keys(a, ['version','network_id','daemon_node_id','account_id','label','created_at','auth_state'])
+      && a.version === 1 && a.network_id === network && a.daemon_node_id === daemon
+      && typeof a.account_id === 'string' && uuid.test(a.account_id)
+      && typeof a.label === 'string' && a.label.length <= 100
+      && Number.isSafeInteger(a.created_at) && a.auth_state === 'not_checked');
+  if (!keys(v, ['request_id','status','error','challenge','account_id']) || v.request_id !== intent.session_id
+    || !['idle','starting','awaiting_user','verifying','authenticated','cancelled','failed'].includes(v.status)) return false;
+  if (v.error !== undefined && !['login_start_failed','login_rejected','account_read_failed','login_process_exited','login_expired'].includes(v.error)) return false;
+  if (v.account_id !== undefined && (v.status !== 'authenticated' || typeof v.account_id !== 'string' || !uuid.test(v.account_id))) return false;
+  if (intent.action === 'cancel' && v.status !== 'cancelled') return false;
+  if (intent.action === 'save' && (v.status !== 'authenticated' || !v.account_id)) return false;
+  if (v.status === 'awaiting_user') return object(v.challenge) && keys(v.challenge, ['loginId','verificationUrl','userCode'])
+    && typeof v.challenge.loginId === 'string' && uuid.test(v.challenge.loginId)
+    && v.challenge.verificationUrl === 'https://auth.openai.com/codex/device'
+    && typeof v.challenge.userCode === 'string' && /^[A-Z0-9-]{4,32}$/i.test(v.challenge.userCode);
+  return v.challenge === undefined;
+}

package/src/shared/daemon-provider-snapshot.ts

@@ -0,0 +1,52 @@
+// #906 public Provider snapshot contract. Mirrored across separately published
+// server/agent-node packages; drift is tested. No secret-shaped extension fields.
+import { validCodexInventory } from './codex-inventory.js';
+export function validateDaemonProviderSnapshot(value: unknown, networkId: string, daemonId: string): unknown {
+  const fail = (): never => { throw new Error("invalid_provider_snapshot"); };
+  const obj = (v: any, fields: string[]) => {
+    if (!v || typeof v !== "object" || Array.isArray(v) || Object.keys(v).some(k => !fields.includes(k))) fail();
+    return v;
+  };
+  const id = (v: unknown) => typeof v === "string" && /^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/.test(v);
+  const unique = (xs: any[], key: string) => { if (new Set(xs.map(x => x[key])).size !== xs.length) fail(); };
+  const arr = (v: any, max: number, empty = false): any[] => {
+    if (!Array.isArray(v) || (!empty && !v.length) || v.length > max) fail();
+    return v;
+  };
+  const s = obj(value, ["network_id", "daemon_node_id", "revision", "source", "providers", "codex_inventory"]);
+  if (s.codex_inventory !== undefined && !validCodexInventory(s.codex_inventory)) fail();
+  if (s.network_id !== networkId || s.daemon_node_id !== daemonId || s.source !== "daemon"
+    || !Number.isSafeInteger(s.revision) || s.revision < 0) fail();
+  const providers = arr(s.providers, 100, true);
+  unique(providers, "id");
+  for (const p of providers) {
+    obj(p, ["id", "label", "enabled", "runtimes"]);
+    if (!id(p.id) || typeof p.label !== "string" || !p.label.trim() || p.label.length > 100
+      || /[\x00-\x1f\x7f]/.test(p.label) || typeof p.enabled !== "boolean") fail();
+    const runtimes = arr(p.runtimes, 8); unique(runtimes, "runtime");
+    for (const r of runtimes) {
+      obj(r, ["runtime", "auth"]); if (r.runtime !== "codex-tui") fail();
+      const auths = arr(r.auth, 32); unique(auths, "id");
+      for (const a of auths) {
+        obj(a, ["id", "kind", "models", "baseUrl", "account_id", "credential_present", "verification", "application"]);
+        if (!id(a.id) || a.verification !== "not_checked" || a.application !== "not_applied") fail();
+        const models = arr(a.models, 200);
+        if (new Set(models).size !== models.length || models.some(m => typeof m !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._:-]{0,199}$/.test(m))) fail();
+        if (a.kind === "chatgpt") {
+          if (p.id !== "openai" || a.baseUrl !== undefined || typeof a.credential_present !== 'boolean') fail();
+          if (a.account_id !== undefined && (typeof a.account_id !== 'string' || !/^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/i.test(a.account_id))) fail();
+          if (a.credential_present && !a.account_id) fail();
+        } else if (a.kind === "api_key") {
+          if (a.account_id !== undefined) fail();
+          if (a.credential_present !== true || typeof a.baseUrl !== "string" || a.baseUrl.length > 2048) fail();
+          let u: URL; try { u = new URL(a.baseUrl); } catch { return fail(); }
+          if (!["https:", "http:"].includes(u.protocol) || u.username || u.password || u.search || u.hash) fail();
+        } else fail();
+      }
+    }
+  }
+  // JSON roundtrip detaches the validated object from mutable caller references.
+  const encoded = JSON.stringify(s);
+  if (new TextEncoder().encode(encoded).byteLength > 1024 * 1024) fail();
+  return JSON.parse(encoded);
+}

package/src/shared/external-schedule-contract.ts

@@ -0,0 +1,60 @@
+const FIELD_BOUNDS = [
+  [0, 59],
+  [0, 23],
+  [1, 31],
+  [1, 12],
+  [0, 7],
+] as const;
+
+function integer(text: string, min: number, max: number): number {
+  if (!/^\d+$/.test(text)) throw new Error("invalid_cron");
+  const value = Number(text);
+  if (!Number.isSafeInteger(value) || value < min || value > max) throw new Error("invalid_cron");
+  return value;
+}
+
+function validateAtom(atom: string, min: number, max: number): void {
+  const [base, step, extra] = atom.split("/");
+  if (extra !== undefined || !base) throw new Error("invalid_cron");
+  if (step !== undefined) integer(step, 1, max - min + 1);
+  if (base === "*") return;
+  const range = base.split("-");
+  if (range.length === 1) {
+    integer(range[0], min, max);
+    return;
+  }
+  if (range.length !== 2) throw new Error("invalid_cron");
+  const start = integer(range[0], min, max);
+  const end = integer(range[1], min, max);
+  if (start > end) throw new Error("invalid_cron");
+}
+
+/** Strict five-field cron timing. It deliberately excludes commands, names,
+ * @aliases, a sixth seconds field and every control character. */
+export function parseManagedCronExpression(raw: unknown): string {
+  if (typeof raw !== "string" || raw.length < 5 || raw.length > 120) throw new Error("invalid_cron");
+  if (/[^\x20-\x7e]/.test(raw) || /[\r\n]/.test(raw)) throw new Error("invalid_cron");
+  const fields = raw.trim().split(/ +/);
+  if (fields.length !== 5) throw new Error("invalid_cron");
+  fields.forEach((field, index) => {
+    if (!field || !/^[0-9*/,-]+$/.test(field)) throw new Error("invalid_cron");
+    for (const atom of field.split(",")) validateAtom(atom, FIELD_BOUNDS[index][0], FIELD_BOUNDS[index][1]);
+  });
+  return fields.join(" ");
+}
+
+export type ExternalSchedulePatch = { enabled?: boolean; cron?: string };
+
+export function parseExternalSchedulePatch(raw: unknown): ExternalSchedulePatch {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) throw new Error("invalid_patch");
+  const obj = raw as Record<string, unknown>;
+  const keys = Object.keys(obj);
+  if (keys.length === 0 || keys.some((key) => key !== "enabled" && key !== "cron")) throw new Error("invalid_patch");
+  const patch: ExternalSchedulePatch = {};
+  if (obj.enabled !== undefined) {
+    if (typeof obj.enabled !== "boolean") throw new Error("invalid_enabled");
+    patch.enabled = obj.enabled;
+  }
+  if (obj.cron !== undefined) patch.cron = parseManagedCronExpression(obj.cron);
+  return patch;
+}

package/src/shared/node-name.test.ts

@@ -0,0 +1,62 @@
+import { describe, expect, test } from "bun:test";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import {
+  NODE_FOLDER_RE, NODE_NAME_CASES, LEGACY_NODE_NAME_RE,
+  checkNodeName, nodeDirNameFor, nodeFolderSlug, fnv1aHex,
+} from "./node-name.js";
+
+// Board #652 — one name rule for hub + daemon (+ the app's pinned copy).
+
+describe("#652 checkNodeName — shared vectors", () => {
+  for (const c of NODE_NAME_CASES) {
+    test(`${JSON.stringify(c.input).slice(0, 24)} → ${c.ok ? "ok" : c.error}`, () => {
+      const r = checkNodeName(c.input);
+      expect(r.ok).toBe(c.ok);
+      if (!r.ok) {
+        expect(r.error).toBe(c.error!);
+        expect(r.message.length).toBeGreaterThan(0);
+      }
+      if (c.slug !== undefined) expect(nodeFolderSlug(c.input)).toBe(c.slug);
+    });
+  }
+
+  test("the vector table really contains Chinese names that pass (old rule would refuse them)", () => {
+    const cjkOk = NODE_NAME_CASES.filter(c => c.ok && /\p{Script=Han}/u.test(c.input));
+    expect(cjkOk.length).toBeGreaterThan(0);
+    for (const c of cjkOk) expect(LEGACY_NODE_NAME_RE.test(c.input)).toBe(false);
+  });
+});
+
+describe("#652 folder slug", () => {
+  test("every slug — incl. every accepted vector — matches the ASCII folder rule", () => {
+    for (const c of NODE_NAME_CASES.filter(x => x.ok)) {
+      const s = nodeFolderSlug(c.input);
+      expect(NODE_FOLDER_RE.test(s)).toBe(true);
+      expect(/^[\x21-\x7e]+$/.test(s)).toBe(true);
+    }
+  });
+  test("non-ASCII → node-<6 hex>, deterministic", () => {
+    expect(nodeFolderSlug("测试")).toMatch(/^node-[0-9a-f]{6}$/);
+    expect(nodeFolderSlug("测试")).toBe(nodeFolderSlug(" 测试 "));
+    expect(nodeFolderSlug("测试")).not.toBe(nodeFolderSlug("测验"));
+  });
+  test("fnv1a known answers (pins the app reimplementation)", () => {
+    expect(fnv1aHex("")).toBe("811c9dc5");
+    expect(fnv1aHex("a")).toBe("e40c292c");
+    expect(fnv1aHex("foobar")).toBe("bf9cf968");
+  });
+  test("nodeDirNameFor keeps legacy names as-is (existing nodes never move)", () => {
+    for (const n of ["a", "demo-bot", "node_1", "my_agent"]) expect(nodeDirNameFor(n)).toBe(n);
+    expect(nodeDirNameFor("测试")).toBe(nodeFolderSlug("测试"));
+    expect(nodeDirNameFor("MyBot")).toBe("mybot");
+  });
+});
+
+describe("#652 hub/daemon node-name drift guard", () => {
+  test("byte-identical source files", () => {
+    const hub = readFileSync(join(import.meta.dir, "node-name.ts"), "utf-8");
+    const daemon = readFileSync(join(import.meta.dir, "..", "..", "..", "agent-node", "src", "shared", "node-name.ts"), "utf-8");
+    expect(daemon).toBe(hub);
+  });
+});

package/src/shared/node-name.ts

@@ -0,0 +1,161 @@
+// Board #652 — node name (= network alias) rules and the ASCII folder slug derived from it.
+//
+// Single source of truth for hub + daemon. This file is byte-identical in
+// server/src/shared/node-name.ts and agent-node/src/shared/node-name.ts
+// (node-name-drift.test.ts fails the build on any difference), and the app
+// (sleep2agi/agent-network-app) keeps a copy pinned to NODE_NAME_CASES below.
+//
+// Before #652 the name had to match /^[a-z][a-z0-9_-]{0,63}$/, so the app
+// wizard refused 「测试」 while the real fleet runs Chinese aliases started by
+// hand. House rule: the alias may be Chinese, the working directory may not.
+// So the name is now any Unicode letters/digits, and every directory derived
+// from it uses nodeFolderSlug() (or the legacy name, for names the old rule
+// already accepted — see nodeDirNameFor).
+
+/** The old rule. Every name it accepts keeps its old directory (nodeDirNameFor). */
+export const LEGACY_NODE_NAME_RE = /^[a-z][a-z0-9_-]{0,63}$/;
+
+/** Folder / slug rule: what a working directory or `.anet/nodes/<dir>` may be called. */
+export const NODE_FOLDER_RE = /^[a-z][a-z0-9-]{0,63}$/;
+
+export const NODE_NAME_MAX_CHARS = 64;
+
+// First char: a letter, a digit or `_` (never `-`: `anet node start -x` reads as a flag;
+// never `.`: hidden files, `..`). Rest: letters, digits, combining marks (Devanagari,
+// Thai… need them), `_`, `-`. Nothing else — no whitespace, `/ \ :`, `.`, quotes,
+// `$`, backticks, control characters: the name ends up in argv, tmux session names
+// (tmux rewrites `.` and `:`), JSON, logs and file names in the trash directory.
+const NODE_NAME_RE = /^[\p{L}\p{N}_][\p{L}\p{M}\p{N}_-]*$/u;
+
+export type NodeNameError =
+  | "empty"
+  | "too_long"
+  | "leading_dash"
+  | "forbidden_char"
+  | "not_nfc";
+
+export type NodeNameCheck =
+  | { ok: true; name: string }
+  | { ok: false; error: NodeNameError; char?: string; message: string };
+
+/** Trim + NFC. Callers store the returned `name`, not the raw input. */
+export function normalizeNodeName(raw: string): string {
+  return raw.trim().normalize("NFC");
+}
+
+function describeChar(ch: string): string {
+  const cp = ch.codePointAt(0) ?? 0;
+  if (cp < 0x20 || cp === 0x7f) return `U+${cp.toString(16).toUpperCase().padStart(4, "0")}`;
+  if (/\s/u.test(ch)) return "空格";
+  return ch;
+}
+
+/**
+ * Check a node name. `raw` is trimmed first; the trimmed, NFC form must be
+ * 1..64 characters (code points) of letters / digits / `_` / `-`, not starting with `-`.
+ */
+export function checkNodeName(raw: unknown): NodeNameCheck {
+  if (typeof raw !== "string") return { ok: false, error: "empty", message: "名字不能为空" };
+  const trimmed = raw.trim();
+  if (trimmed.length === 0) return { ok: false, error: "empty", message: "名字不能为空" };
+  const chars = [...trimmed];
+  if (chars.length > NODE_NAME_MAX_CHARS) {
+    return { ok: false, error: "too_long", message: `名字最多 ${NODE_NAME_MAX_CHARS} 个字符` };
+  }
+  if (trimmed !== trimmed.normalize("NFC")) {
+    return { ok: false, error: "not_nfc", message: "名字需要是 Unicode NFC 规范形式" };
+  }
+  if (chars[0] === "-") {
+    return { ok: false, error: "leading_dash", char: "-", message: "名字不能以 - 开头" };
+  }
+  if (!NODE_NAME_RE.test(trimmed)) {
+    const bad = chars.find((ch, i) => !(i === 0 ? /^[\p{L}\p{N}_]$/u : /^[\p{L}\p{M}\p{N}_-]$/u).test(ch)) ?? chars[0]!;
+    return {
+      ok: false,
+      error: "forbidden_char",
+      char: bad,
+      message: `名字里不能有「${describeChar(bad)}」：只能用文字、字母、数字、_ 和 -`,
+    };
+  }
+  return { ok: true, name: trimmed };
+}
+
+export function isValidNodeName(raw: unknown): boolean {
+  return checkNodeName(raw).ok;
+}
+
+/** FNV-1a 32-bit over the UTF-8 bytes, 8 hex digits. Tiny, dependency-free, and the
+ *  app reimplements it byte for byte (no crypto module needed in the browser / RN). */
+export function fnv1aHex(s: string): string {
+  const bytes = new TextEncoder().encode(s);
+  let h = 0x811c9dc5;
+  for (const b of bytes) {
+    h ^= b;
+    h = Math.imul(h, 0x01000193) >>> 0;
+  }
+  return h.toString(16).padStart(8, "0");
+}
+
+/**
+ * ASCII folder name for a node name. Pure-ASCII names are transliterated
+ * (lowercase, runs of anything outside [a-z0-9] become one `-`, trimmed, `node-`
+ * prefixed when they do not start with a letter); anything else — and anything the
+ * transliteration empties — becomes `node-<first 6 hex of fnv1a(name)>`.
+ * The result always matches NODE_FOLDER_RE.
+ */
+export function nodeFolderSlug(raw: string): string {
+  const name = normalizeNodeName(raw);
+  // eslint-disable-next-line no-control-regex
+  if (/^[\x00-\x7f]*$/.test(name)) {
+    let s = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+    if (s && !/^[a-z]/.test(s)) s = `node-${s}`;
+    s = s.slice(0, NODE_NAME_MAX_CHARS).replace(/-+$/, "");
+    if (NODE_FOLDER_RE.test(s)) return s;
+  }
+  return `node-${fnv1aHex(name).slice(0, 6)}`;
+}
+
+/**
+ * The directory under `.anet/nodes/` a daemon-created node lives in.
+ * Names the old rule accepted keep their old directory (= the name) so nothing that
+ * worked before #652 moves; every other name gets nodeFolderSlug(name).
+ */
+export function nodeDirNameFor(name: string): string {
+  return LEGACY_NODE_NAME_RE.test(name) ? name : nodeFolderSlug(name);
+}
+
+/** Shared test vectors — the app's copy must produce the same verdicts and slugs. */
+export const NODE_NAME_CASES: ReadonlyArray<{ input: string; ok: boolean; error?: NodeNameError; slug?: string }> = [
+  { input: "测试", ok: true, slug: "node-f78149" },
+  { input: "研发助手A", ok: true, slug: "node-1d348f" },
+  { input: "AB测试牛", ok: true, slug: "node-048250" },
+  { input: "my-bot", ok: true, slug: "my-bot" },
+  { input: "MyBot_2", ok: true, slug: "mybot-2" },
+  { input: "  spaced  ", ok: true, slug: "spaced" },
+  { input: "123", ok: true, slug: "node-123" },
+  { input: "_x", ok: true, slug: "x" },
+  { input: "Ünïcödé", ok: true, slug: "node-030667" },
+  { input: "a".repeat(64), ok: true, slug: "a".repeat(64) },
+  { input: "测".repeat(64), ok: true, slug: "node-50c3fb" },
+  { input: "", ok: false, error: "empty" },
+  { input: "   ", ok: false, error: "empty" },
+  { input: "a".repeat(65), ok: false, error: "too_long" },
+  { input: "测".repeat(65), ok: false, error: "too_long" },
+  { input: "-x", ok: false, error: "leading_dash" },
+  { input: "e\u0301", ok: false, error: "not_nfc" },
+  { input: ".hidden", ok: false, error: "forbidden_char" },
+  { input: "..", ok: false, error: "forbidden_char" },
+  { input: "a/b", ok: false, error: "forbidden_char" },
+  { input: "a\\b", ok: false, error: "forbidden_char" },
+  { input: "a:b", ok: false, error: "forbidden_char" },
+  { input: "a.b", ok: false, error: "forbidden_char" },
+  { input: "a b", ok: false, error: "forbidden_char" },
+  { input: "a\u0000b", ok: false, error: "forbidden_char" },
+  { input: "a\nb", ok: false, error: "forbidden_char" },
+  { input: "a$b", ok: false, error: "forbidden_char" },
+  { input: "a`b", ok: false, error: "forbidden_char" },
+  { input: "a'b", ok: false, error: "forbidden_char" },
+  { input: "a\"b", ok: false, error: "forbidden_char" },
+  { input: "a;b", ok: false, error: "forbidden_char" },
+  { input: "a*b", ok: false, error: "forbidden_char" },
+];

package/src/shared/provider-application.ts

@@ -0,0 +1,29 @@
+// #906 public application protocol. No paths, endpoints or credentials.
+export type ProviderApplicationSelection = {
+  node_id: string; node_revision: string; provider_id: string; auth_id: string;
+  model: string; confirm_restart: true;
+  account_id?: string;
+};
+const fields = (v: any, names: string[]) => v && typeof v === 'object' && !Array.isArray(v)
+  && Object.keys(v).length === names.length && Object.keys(v).every(k => names.includes(k));
+const id = (v: any) => typeof v === 'string' && /^[A-Za-z0-9][A-Za-z0-9._:/-]{0,199}$/.test(v);
+const hash = (v: any) => typeof v === 'string' && /^[a-f0-9]{64}$/.test(v);
+const account = (v: any) => typeof v === 'string' && /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/i.test(v);
+export function validProviderApplicationSelection(v: any): v is ProviderApplicationSelection {
+  return fields(v, ['node_id', 'node_revision', 'provider_id', 'auth_id', 'model', 'confirm_restart',
+    ...(v?.account_id !== undefined ? ['account_id'] : [])])
+    && (v.account_id === undefined || (v.provider_id === 'openai' && account(v.account_id)))
+    && id(v.node_id) && hash(v.node_revision) && id(v.provider_id) && id(v.auth_id) && id(v.model)
+    && v.confirm_restart === true;
+}
+export function validProviderApplicationReceipt(v: any, requestId: string, revision: number,
+  selection: ProviderApplicationSelection): boolean {
+  return fields(v, ['status', 'request_id', 'node_id', 'provider_id', 'auth_id', 'model', 'runtime_provider',
+    'node_revision', 'provider_revision', 'verification', 'applied_at', ...(selection.account_id ? ['account_id'] : [])])
+    && v.status === 'applied' && v.request_id === requestId && v.node_id === selection.node_id
+    && v.provider_id === selection.provider_id && v.auth_id === selection.auth_id && v.model === selection.model
+    && (selection.account_id ? v.runtime_provider === 'openai' && v.account_id === selection.account_id
+      : typeof v.runtime_provider === 'string' && /^anet_[a-f0-9]{20}$/.test(v.runtime_provider))
+    && hash(v.node_revision) && v.provider_revision === revision && v.verification === 'runtime_confirmed'
+    && Number.isSafeInteger(v.applied_at) && v.applied_at > 0 && v.applied_at <= Date.now() + 30_000;
+}

package/src/shared/provider-collection.ts

@@ -0,0 +1,14 @@
+// #906 intent contains identifiers only. API keys remain on the owning daemon.
+export type ProviderCollection = {
+  node_id: string; alias: string; node_revision: string;
+  provider_id: string; auth_id: string; label: string;
+};
+const id = (v: unknown) => typeof v === 'string' && /^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/.test(v);
+export function validProviderCollection(v: any): v is ProviderCollection {
+  return !!v && typeof v === 'object' && !Array.isArray(v)
+    && Object.keys(v).every(k => ['node_id', 'alias', 'node_revision', 'provider_id', 'auth_id', 'label'].includes(k))
+    && id(v.node_id) && id(v.provider_id) && id(v.auth_id)
+    && typeof v.alias === 'string' && /^[\p{L}\p{N}][\p{L}\p{N}_.-]{0,99}$/u.test(v.alias)
+    && typeof v.node_revision === 'string' && /^[a-f0-9]{64}$/.test(v.node_revision)
+    && typeof v.label === 'string' && !!v.label.trim() && v.label.length <= 100 && !/[\x00-\x1f\x7f]/.test(v.label);
+}

package/src/shared/provider-initialization.ts

@@ -0,0 +1,8 @@
+export type ProviderInitialization = { revision: number; provider_id: string; auth_id: string; model: string };
+export function validProviderInitialization(value: any): value is ProviderInitialization {
+  const id = (v: unknown) => typeof v === 'string' && /^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/.test(v);
+  return !!value && typeof value === 'object' && !Array.isArray(value)
+    && Object.keys(value).every(key => ['revision', 'provider_id', 'auth_id', 'model'].includes(key))
+    && Number.isSafeInteger(value.revision) && value.revision >= 0 && id(value.provider_id) && id(value.auth_id)
+    && typeof value.model === 'string' && /^[A-Za-z0-9][A-Za-z0-9._:-]{0,99}$/.test(value.model);
+}