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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sleep2agi/commhub-server",
-  "version": "0.9.0-preview.120",
+  "version": "0.9.0-preview.121",
   "description": "CommHub Server — AI Agent communication hub with MCP protocol, multi-network isolation, user auth, and MCP tools (17 collaboration-core + node/provider ops tools; authoritative list: docs-site/docs/api/mcp-tools.md).",
   "type": "module",
   "main": "src/index.ts",

package/src/adoption-candidates-http.test.ts

@@ -0,0 +1,137 @@
+import { afterAll, beforeAll, expect, test } from "bun:test";
+import { mkdtempSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+const dir = mkdtempSync(join(tmpdir(), "adoption-candidates-"));
+process.env.COMMHUB_DB ||= join(dir, "hub.db");
+process.env.COMMHUB_AUTH_TOKEN ||= "adoption-candidates-master-fixture";
+const WORKDIR = "/home/example/adoption-candidate-workdir-654";
+const SECRET = "ntok_should_not_surface";
+let hub: { stop: (closeActiveConnections?: boolean) => void; port: number }, base: string;
+let db: any, owner: any, member: any, nodeOwner: any, other: any, daemonToken: string;
+const ids = { daemon: "n_cand_daemon", hand: "n_cand_hand", foreign: "n_cand_foreign" };
+
+const get = async (path: string, token = owner.token) => {
+  const res = await fetch(base + path, { headers: { Authorization: `Bearer ${token}` } });
+  return { status: res.status, body: await res.json() as any, text: "" };
+};
+const raw = async (path: string, token = owner.token) => {
+  const res = await fetch(base + path, { headers: { Authorization: `Bearer ${token}` } });
+  const text = await res.text();
+  return { status: res.status, text, body: JSON.parse(text) };
+};
+
+function snapshot(candidates: unknown, adopt = true) {
+  return JSON.stringify({
+    role: "host_supervisor",
+    daemon_capabilities: { adopt_capable: adopt, adoption_candidates: candidates },
+  });
+}
+
+beforeAll(async () => {
+  ({ db } = await import("./db.js"));
+  const { register } = await import("./auth.js");
+  const suffix = Date.now();
+  owner = register(`cand_owner_${suffix}`, "CandFixture-Strong1!");
+  member = register(`cand_member_${suffix}`, "CandFixture-Strong1!");
+  nodeOwner = register(`cand_node_owner_${suffix}`, "CandFixture-Strong1!");
+  other = register(`cand_other_${suffix}`, "CandFixture-Strong1!");
+  expect(owner.ok && member.ok && nodeOwner.ok && other.ok).toBe(true);
+  for (const user of [owner, member, nodeOwner, other]) db.run("UPDATE users SET role='user' WHERE user_id=?1", [user.user.user_id]);
+  db.run("INSERT INTO network_members(network_id,user_id,role) VALUES(?1,?2,'member')", [owner.network_id, member.user.user_id]);
+  db.run("INSERT INTO network_members(network_id,user_id,role) VALUES(?1,?2,'member')", [owner.network_id, nodeOwner.user.user_id]);
+  const candidate = { node_id: ids.hand, alias: "hand-node", workdir: WORKDIR, runtime: "claude-agent-sdk", launch_hint: "tmux", token: SECRET, env: { API_KEY: SECRET } };
+  db.run("INSERT INTO nodes(node_id,node_name,alias,network_id,owner_user_id,hostname,config_snapshot) VALUES(?1,?2,?2,?3,?4,'fixture-host',?5)",
+    [ids.daemon, "cand-daemon", owner.network_id, owner.user.user_id, snapshot([candidate, { node_id: "n_missing", alias: "nope", workdir: "/tmp/nope", launch_hint: "bare" }])]);
+  db.run("INSERT INTO nodes(node_id,node_name,alias,network_id,owner_user_id,hostname,config_snapshot) VALUES(?1,?2,?2,?3,?4,'fixture-host','{}')",
+    [ids.hand, "hand-node", owner.network_id, nodeOwner.user.user_id]);
+  db.run("INSERT INTO nodes(node_id,node_name,alias,network_id,owner_user_id,hostname) VALUES(?1,?2,?2,?3,?4,'other-host')",
+    [ids.foreign, "foreign-node", other.network_id, other.user.user_id]);
+  db.run("INSERT INTO sessions(resume_id,alias,node_id,network_id,status,last_seen_at) VALUES('cand-daemon-session','cand-daemon',?1,?2,'idle',datetime('now'))",
+    [ids.daemon, owner.network_id]);
+  const { generateNetworkToken, hashToken } = await import("./db.js");
+  daemonToken = generateNetworkToken();
+  db.run("INSERT INTO api_tokens(token_id,user_id,network_id,scope,name,token_hash) VALUES('cand-daemon-token',?1,?2,'network','node:cand-daemon',?3)",
+    [owner.user.user_id, owner.network_id, hashToken(daemonToken)]);
+  const { bootServer } = await import("./server.js");
+  hub = bootServer({ port: 0, hostname: "127.0.0.1" });
+  base = `http://127.0.0.1:${hub.port}`;
+}, 30_000);
+afterAll(() => hub?.stop(true));
+
+test("owner and node owner see the candidate; the report token stays out", async () => {
+  for (const token of [owner.token, nodeOwner.token]) {
+    const r = await raw(`/api/adoption-candidates?network_id=${owner.network_id}`, token);
+    expect(r.status).toBe(200);
+    expect(r.body.count).toBe(1);
+    expect(r.body.candidates).toEqual([{
+      node_id: ids.hand, alias: "hand-node", daemon_node_id: ids.daemon, daemon_alias: "cand-daemon",
+      hostname: "fixture-host", workdir: WORKDIR, runtime: "claude-agent-sdk", launch_hint: "tmux",
+    }]);
+    expect(r.text).not.toContain(SECRET);
+    expect(r.text).toContain(WORKDIR);
+  }
+  const supervisors = await raw(`/api/host-supervisors?network_id=${owner.network_id}`);
+  expect(supervisors.body.daemons.find((d: any) => d.daemon_node_id === ids.daemon).adoption_discovery).toBe(true);
+  expect(supervisors.text).not.toContain(WORKDIR);
+  expect(supervisors.text).not.toContain(SECRET);
+  const nodes = await raw(`/api/nodes?network_id=${owner.network_id}`);
+  expect(nodes.text).not.toContain("adoption_candidate");
+  expect(nodes.text).not.toContain(WORKDIR);
+});
+
+test("member, other network, daemon token, and query token do not receive the workdir", async () => {
+  const memberRes = await raw(`/api/adoption-candidates?network_id=${owner.network_id}`, member.token);
+  expect(memberRes.status).toBe(200);
+  expect(memberRes.body.candidates).toEqual([]);
+  expect(memberRes.text).not.toContain(WORKDIR);
+  const otherRes = await raw(`/api/adoption-candidates?network_id=${owner.network_id}`, other.token);
+  expect(otherRes.status).toBe(403);
+  expect(otherRes.text).not.toContain(WORKDIR);
+  expect((await get("/api/adoption-candidates", daemonToken)).status).toBe(403);
+  expect((await get("/api/adoption-candidates", process.env.COMMHUB_AUTH_TOKEN!)).status).toBe(403);
+  const queryOnly = await fetch(base + `/api/adoption-candidates?network_id=${owner.network_id}&token=${encodeURIComponent(owner.token)}`);
+  expect([401, 403]).toContain(queryOnly.status);
+});
+
+test("offline, hostname, alias, binding, and created-node filters drop the hint", async () => {
+  const path = `/api/adoption-candidates?network_id=${owner.network_id}`;
+  db.run("UPDATE sessions SET last_seen_at='2000-01-01 00:00:00' WHERE alias='cand-daemon'");
+  expect((await get(path)).body.candidates).toEqual([]);
+  db.run("UPDATE sessions SET last_seen_at=datetime('now') WHERE alias='cand-daemon'");
+  expect((await get(path)).body.count).toBe(1);
+
+  db.run("UPDATE nodes SET hostname='elsewhere' WHERE node_id=?1", [ids.hand]);
+  expect((await get(path)).body.candidates).toEqual([]);
+  db.run("UPDATE nodes SET hostname='fixture-host' WHERE node_id=?1", [ids.hand]);
+
+  db.run("UPDATE nodes SET config_snapshot=?1 WHERE node_id=?2", [snapshot([{ node_id: ids.hand, alias: "other-name", workdir: WORKDIR, launch_hint: "stopped" }]), ids.daemon]);
+  expect((await get(path)).body.candidates).toEqual([]);
+  db.run("UPDATE nodes SET config_snapshot=?1 WHERE node_id=?2", [snapshot([{ node_id: ids.hand, alias: "hand-node", workdir: WORKDIR, runtime: "claude-agent-sdk", launch_hint: "tmux", token: SECRET }]), ids.daemon]);
+  expect((await get(path)).body.count).toBe(1);
+
+  db.run(`INSERT INTO node_daemon_bindings(request_id,network_id,node_id,daemon_node_id,workdir,requested_by,status,created_at,updated_at)
+    VALUES('adopt_cand_pending',?1,?2,?3,?4,?5,'pending',1,1)`, [owner.network_id, ids.hand, ids.daemon, WORKDIR, owner.user.user_id]);
+  expect((await get(path)).body.candidates).toEqual([]);
+  db.run("UPDATE node_daemon_bindings SET status='revoked' WHERE request_id='adopt_cand_pending'");
+  expect((await get(path)).body.count).toBe(1);
+
+  db.run(`INSERT INTO node_create_requests(request_id,daemon_node_id,child_node_id,child_name,network_id,runtime,flags_json,env_keys,status,created_at,created_by_token)
+    VALUES('cr_cand_hand',?1,?2,'hand-node',?3,'claude-agent-sdk','{}','[]','succeeded',1,'private')`, [ids.daemon, ids.hand, owner.network_id]);
+  expect((await get(path)).body.candidates).toEqual([]);
+  db.run("DELETE FROM node_create_requests WHERE request_id='cr_cand_hand'");
+  expect((await get(path)).body.count).toBe(1);
+});
+
+test("discovery flag is absent unless the daemon actually reported a list", async () => {
+  const path = `/api/host-supervisors?network_id=${owner.network_id}`;
+  db.run("UPDATE nodes SET config_snapshot=?1 WHERE node_id=?2", [JSON.stringify({ role: "host_supervisor", daemon_capabilities: { adopt_capable: true } }), ids.daemon]);
+  expect((await get(path)).body.daemons[0].adoption_discovery).toBeUndefined();
+  expect((await get(path)).body.daemons[0].adopt_capable).toBe(true);
+  db.run("UPDATE nodes SET config_snapshot=?1 WHERE node_id=?2", [snapshot([], true), ids.daemon]);
+  expect((await get(path)).body.daemons[0].adoption_discovery).toBe(true);
+  expect((await get(`/api/adoption-candidates?network_id=${owner.network_id}`)).body.candidates).toEqual([]);
+  const limited = await get(path, member.token);
+  expect(limited.body.daemons.find((d: any) => d.daemon_node_id === ids.daemon).adoption_discovery).toBe(true);
+});

package/src/adoption-candidates.ts

@@ -0,0 +1,158 @@
+// Board #654 — project daemon-reported hand-started adoption candidates.
+//
+// The daemon report is a hint, not authority. This module does not adopt,
+// bind, signal, start, or stop. Co-presence / three-stage nodes are not
+// part of the report contract: discovery on the daemon excludes them.
+// `GET /api/nodes` managed/adoption and `/api/node-lifecycle-requests`
+// stay records of requests that already exist; they are not this list.
+import { z } from "zod/v4";
+import { db } from "./db.js";
+import { getUserNetworkRole } from "./auth.js";
+import { parseDbTimestampMs } from "./db-timestamp.js";
+import { addAgentNetworkScope, addHumanNetworkScope, type RestNetworkScope } from "./network-scope.js";
+
+const HINTS = new Set(["bare", "tmux", "stopped", "unverified"]);
+const ONLINE_MS = 5 * 60_000;
+const MAX_PUBLIC = 64;
+
+export interface AdoptionCandidateReport {
+  node_id: string;
+  alias: string;
+  workdir: string;
+  runtime: string | null;
+  launch_hint: "bare" | "tmux" | "stopped" | "unverified";
+}
+
+export function sanitizeAdoptionCandidate(raw: unknown): AdoptionCandidateReport | null {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+  const row = raw as Record<string, unknown>;
+  const { node_id, alias, workdir, launch_hint } = row;
+  if (typeof node_id !== "string" || node_id.length < 1 || node_id.length > 128 || /[\x00-\x1f\x7f]/.test(node_id)) return null;
+  if (typeof alias !== "string" || alias.length < 1 || alias.length > 128 || /[\x00-\x1f\x7f/\\]/.test(alias)
+      || alias === "." || alias === ".." || alias.startsWith("-")) return null;
+  if (typeof workdir !== "string" || !workdir.startsWith("/") || workdir.length > 1024 || /[\x00-\x1f]/.test(workdir)) return null;
+  if (typeof launch_hint !== "string" || !HINTS.has(launch_hint)) return null;
+  let runtime: string | null = null;
+  if (row.runtime != null) {
+    if (typeof row.runtime !== "string" || row.runtime.length < 1 || row.runtime.length > 64 || !/^[A-Za-z0-9._-]+$/.test(row.runtime)) return null;
+    runtime = row.runtime;
+  }
+  return { node_id, alias, workdir, runtime, launch_hint: launch_hint as AdoptionCandidateReport["launch_hint"] };
+}
+
+const adoptionCandidateItemSchema = z.object({
+  node_id: z.string().min(1).max(128),
+  alias: z.string().min(1).max(128),
+  workdir: z.string().regex(/^\/[^\u0000-\u001f]{0,1023}$/),
+  runtime: z.string().min(1).max(64).nullable().optional(),
+  launch_hint: z.enum(["bare", "tmux", "stopped", "unverified"]),
+}).strip().catch(null);
+
+/** Ingest path for report_status. One bad item becomes null; a bad list never fails the heartbeat.
+ * No transform: tools/list JSON Schema cannot represent one. Readers drop nulls. */
+export const adoptionCandidatesReportSchema = z.array(adoptionCandidateItemSchema).max(32).optional().catch(undefined);
+
+function snapshotValue(snapshot: unknown): Record<string, any> | null {
+  try {
+    const parsed = typeof snapshot === "string" ? JSON.parse(snapshot) : snapshot;
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch { return null; }
+}
+
+export function snapshotReportsAdoptionDiscovery(snapshot: unknown): boolean {
+  const caps = snapshotValue(snapshot)?.daemon_capabilities;
+  return caps?.adopt_capable === true && Array.isArray(caps.adoption_candidates);
+}
+
+function reportedCandidates(snapshot: unknown): AdoptionCandidateReport[] {
+  const raw = snapshotValue(snapshot)?.daemon_capabilities?.adoption_candidates;
+  if (!Array.isArray(raw)) return [];
+  const out: AdoptionCandidateReport[] = [];
+  for (const item of raw) {
+    const clean = sanitizeAdoptionCandidate(item);
+    if (clean) out.push(clean);
+    if (out.length >= 32) break;
+  }
+  return out;
+}
+
+type NodeRow = {
+  node_id: string; alias: string; hostname: string | null; network_id: string;
+  owner_user_id?: string | null; config_snapshot?: string | null; last_seen_at?: string | null;
+};
+
+export function listAdoptionCandidates(
+  scope: RestNetworkScope,
+  viewer: { userId: string; isAdmin: boolean },
+  nowMs = Date.now(),
+): { ok: true; candidates: Array<AdoptionCandidateReport & { daemon_node_id: string; daemon_alias: string; hostname: string }>; count: number } {
+  const daemonParams: any[] = [];
+  let daemonSql = `SELECT n.node_id, n.alias, n.hostname, n.network_id, n.config_snapshot, s.last_seen_at
+    FROM nodes n
+    LEFT JOIN sessions s ON s.alias = n.alias AND (s.network_id = n.network_id OR s.network_id IS NULL)
+    WHERE EXISTS (
+      SELECT 1 FROM api_tokens t
+      WHERE t.network_id = n.network_id AND t.name = 'node:' || n.alias AND t.revoked_at IS NULL
+    )`;
+  daemonSql = addHumanNetworkScope(daemonSql, daemonParams, scope, "n.network_id");
+  const daemonRows = db.all<NodeRow>(daemonSql, ...daemonParams);
+  const daemons = new Map<string, NodeRow>();
+  for (const row of daemonRows) {
+    const prev = daemons.get(row.node_id);
+    if (!prev || parseDbTimestampMs(row.last_seen_at ?? "") > parseDbTimestampMs(prev.last_seen_at ?? "")) daemons.set(row.node_id, row);
+  }
+
+  const nodeParams: any[] = [];
+  let nodeSql = "SELECT n.node_id, n.alias, n.hostname, n.network_id, n.owner_user_id, n.config_snapshot FROM nodes n WHERE 1=1";
+  nodeSql = addAgentNetworkScope(nodeSql, nodeParams, scope, { network: "n.network_id", alias: "n.alias", nodeId: "n.node_id" });
+  const visible = new Map(db.all<NodeRow>(nodeSql, ...nodeParams).map((n) => [n.node_id, n]));
+
+  const managed = new Set<string>();
+  const bindingParams: any[] = [];
+  let bindingSql = `SELECT b.node_id FROM node_daemon_bindings b
+    JOIN nodes n ON n.node_id = b.node_id AND n.network_id = b.network_id
+    WHERE b.status IN ('pending','active')`;
+  bindingSql = addHumanNetworkScope(bindingSql, bindingParams, scope, "b.network_id");
+  for (const row of db.all<{ node_id: string }>(bindingSql, ...bindingParams)) managed.add(row.node_id);
+  const createdParams: any[] = [];
+  let createdSql = `SELECT COALESCE(c.child_node_id, CASE WHEN substr(c.request_id,1,3)='cr_' THEN 'node_' || substr(c.request_id,4) END) AS node_id
+    FROM node_create_requests c WHERE 1=1`;
+  createdSql = addHumanNetworkScope(createdSql, createdParams, scope, "c.network_id");
+  for (const row of db.all<{ node_id: string | null }>(createdSql, ...createdParams)) if (row.node_id) managed.add(row.node_id);
+
+  const roles = new Map<string, string | null>();
+  const maySee = (node: NodeRow) => {
+    if (viewer.isAdmin) return true;
+    if (node.owner_user_id && node.owner_user_id === viewer.userId) return true;
+    if (!roles.has(node.network_id)) roles.set(node.network_id, getUserNetworkRole(viewer.userId, node.network_id));
+    const role = roles.get(node.network_id);
+    return role === "owner" || role === "admin";
+  };
+
+  const candidates: Array<AdoptionCandidateReport & { daemon_node_id: string; daemon_alias: string; hostname: string }> = [];
+  const seen = new Set<string>();
+  for (const daemon of daemons.values()) {
+    const snap = snapshotValue(daemon.config_snapshot);
+    if (snap?.role !== "host_supervisor" || snap.daemon_capabilities?.adopt_capable !== true) continue;
+    if (!daemon.hostname) continue;
+    const seenAt = parseDbTimestampMs(daemon.last_seen_at ?? "");
+    if (!Number.isFinite(seenAt) || nowMs - seenAt > ONLINE_MS) continue;
+    for (const reported of reportedCandidates(daemon.config_snapshot)) {
+      if (candidates.length >= MAX_PUBLIC) break;
+      const node = visible.get(reported.node_id);
+      if (!node || node.network_id !== daemon.network_id || node.alias !== reported.alias) continue;
+      if (!node.hostname || node.hostname !== daemon.hostname) continue;
+      if (snapshotValue(node.config_snapshot)?.role === "host_supervisor") continue;
+      if (managed.has(node.node_id) || !maySee(node)) continue;
+      const key = `${daemon.node_id}\0${node.node_id}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      candidates.push({
+        node_id: node.node_id, alias: node.alias, daemon_node_id: daemon.node_id, daemon_alias: daemon.alias,
+        hostname: daemon.hostname, workdir: reported.workdir, runtime: reported.runtime, launch_hint: reported.launch_hint,
+      });
+    }
+  }
+  candidates.sort((a, b) => a.alias.localeCompare(b.alias) || a.node_id.localeCompare(b.node_id) || a.daemon_node_id.localeCompare(b.daemon_node_id));
+  return { ok: true, candidates, count: candidates.length };
+}

package/src/agent-acl-http.test.ts

@@ -255,7 +255,8 @@ describe("humans: restricted members can still see and DM other humans", () => {
     const r = await get(aliceToken, `/api/networks/${NET}/humans`);
     expect(r.status).toBe(200);
     expect(r.body.humans.map((h: any) => h.user_id).sort()).toEqual([adminId, aliceId, bobId].sort());
-    expect(Object.keys(r.body.humans[0]).sort()).toEqual(["display_name", "last_seen_at", "online", "user_id", "username"]);
+    expect(Object.keys(r.body.humans[0]).sort()).toEqual(["avatar_url", "display_name", "last_seen_at", "online", "user_id", "username"]);
+    expect(r.body.humans.every((h: any) => h.avatar_url === null)).toBe(true);
     // 非成员拿不到。
     const outsider = register(`acl_out_${Date.now()}`, PW);
     expect((await get(outsider.token!, `/api/networks/${NET}/humans`)).status).toBe(403);

package/src/api-host-supervisors-runtime-readiness.test.ts

@@ -104,6 +104,19 @@ describe("#622 sanitizeRuntimeReadiness(读取侧)", () => {
     expect(s.a.network).toBeUndefined();
     expect(s.a.auth).toBe("present");
   });
+  test("generation and accepted stay only on opencode-cli", () => {
+    const s = sanitizeRuntimeReadiness({
+      "opencode-cli": { ...READY, state: "unknown", ok: false, generation: "v2", accepted: false },
+      "claude-code-cli": { ...READY, generation: "v2", accepted: true },
+    })!;
+    expect(s["opencode-cli"].generation).toBe("v2");
+    expect(s["opencode-cli"].accepted).toBe(false);
+    expect(s["claude-code-cli"].generation).toBeUndefined();
+    expect(s["claude-code-cli"].accepted).toBeUndefined();
+    const lone = sanitizeRuntimeReadiness({ "opencode-cli": { ...READY, accepted: true, generation: "nope" } })!;
+    expect(lone["opencode-cli"].generation).toBeUndefined();
+    expect(lone["opencode-cli"].accepted).toBeUndefined();
+  });
 });
 
 let BASE = "";

package/src/auth.ts

@@ -35,6 +35,7 @@ export interface AuthUser {
   user_id: string;
   username: string;
   display_name: string | null;
+  avatar_url?: string | null;
   email: string | null;
   role: string;
 }
@@ -161,7 +162,7 @@ export function register(username: string, password: string, email?: string, dis
 
 export function login(username: string, password: string, client: SessionClientInfo = {}): AuthResult {
   const user = db.get<any>(
-    "SELECT user_id, username, password_hash, display_name, email, role, must_change_password FROM users WHERE username = ?1",
+    "SELECT user_id, username, password_hash, display_name, avatar_url, email, role, must_change_password FROM users WHERE username = ?1",
     username);
 
   if (!user) {
@@ -232,7 +233,7 @@ export function login(username: string, password: string, client: SessionClientI
 
   return {
     ok: true,
-    user: { user_id: user.user_id, username: user.username, display_name: user.display_name, email: user.email, role: user.role },
+    user: { user_id: user.user_id, username: user.username, display_name: user.display_name, avatar_url: user.avatar_url, email: user.email, role: user.role },
     token,
     token_id: tokenId,
     network_id: networkId,
@@ -384,7 +385,7 @@ function lookupToken(token: string): { row: any; rejected?: undefined } | { row?
   const cutoff = idleCutoffOffset();
   const row = db.get<any>(
     `SELECT t.token_id, t.user_id, t.network_id, t.scope, t.name AS token_name,
-            u.username, u.display_name, u.email, u.role,
+            u.username, u.display_name, u.avatar_url, u.email, u.role,
             CASE WHEN t.network_id IS NULL THEN 1
                  WHEN EXISTS (SELECT 1 FROM network_members nm WHERE nm.network_id = t.network_id AND nm.user_id = t.user_id) THEN 1
                  ELSE 0 END AS is_member
@@ -433,7 +434,7 @@ export function resolveToken(token: string): { user: AuthUser; networkId: string
   );
 
   return {
-    user: { user_id: row.user_id, username: row.username, display_name: row.display_name, email: row.email, role: row.role },
+    user: { user_id: row.user_id, username: row.username, display_name: row.display_name, avatar_url: row.avatar_url, email: row.email, role: row.role },
     networkId: row.network_id,
     tokenId: row.token_id || null,
     // tokenName carries the binding identity. For node-scoped ntok_, it's
@@ -702,7 +703,7 @@ export function resetUserPassword(targetUsername: string, callerIsHubAdmin: bool
 
 export function getNetworkMembers(networkId: string) {
   return db.all<any>(
-    `SELECT nm.user_id, nm.role, nm.joined_at, nm.invited_by, u.username, u.display_name,
+    `SELECT nm.user_id, nm.role, nm.joined_at, nm.invited_by, u.username, u.display_name, u.avatar_url,
             CASE WHEN u.role = 'admin' OR nm.role IN ('owner', 'admin') OR nm.agent_access = 'all' THEN 'all' ELSE 'granted' END AS agent_access,
             (SELECT COUNT(*) FROM network_member_agent_grants g WHERE g.network_id = nm.network_id AND g.user_id = nm.user_id) AS agent_grant_count,
             CASE WHEN u.role = 'admin' OR nm.role IN ('owner', 'admin') OR nm.task_access = 'all' THEN 'all' ELSE 'scoped' END AS task_access,
@@ -716,8 +717,8 @@ export function getNetworkMembers(networkId: string) {
 
 /** 网络里的人类成员(给受限成员也能看的通讯录):只有身份字段,不含角色与授权。 */
 export function getNetworkHumans(networkId: string) {
-  return db.all<{ user_id: string; username: string; display_name: string | null }>(
-    `SELECT u.user_id, u.username, u.display_name
+  return db.all<{ user_id: string; username: string; display_name: string | null; avatar_url: string | null }>(
+    `SELECT u.user_id, u.username, u.display_name, u.avatar_url
        FROM network_members nm JOIN users u ON nm.user_id = u.user_id
       WHERE nm.network_id = ?1 ORDER BY COALESCE(NULLIF(u.display_name, ''), u.username), u.user_id`,
     networkId);

package/src/codex-config-flags.ts

@@ -0,0 +1,77 @@
+/** Shared Codex node `flags.*` contract (create_node + update_node_config). */
+
+export const REASONING_EFFORT_VALUES = [
+  "none",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+] as const;
+
+export type ModelReasoningEffort = (typeof REASONING_EFFORT_VALUES)[number];
+
+export const CODEX_APPROVAL_POLICIES = [
+  "untrusted",
+  "on-failure",
+  "on-request",
+  "never",
+] as const;
+
+export const CODEX_SANDBOX_MODES = [
+  "read-only",
+  "workspace-write",
+  "danger-full-access",
+] as const;
+
+/** Runtimes that may carry Codex posture / reasoning flags. */
+export const CODEX_CONFIG_FLAG_RUNTIMES = new Set<string>(["codex-sdk", "codex-app-server"]);
+
+export const CODEX_CONFIG_ONLY_FLAG_KEYS = new Set<string>([
+  "approvalPolicy",
+  "sandboxMode",
+  "skipGitRepoCheck",
+  "copresenceFullAccess",
+  "modelReasoningEffort",
+]);
+
+export function isModelReasoningEffort(v: unknown): v is ModelReasoningEffort {
+  return typeof v === "string" && (REASONING_EFFORT_VALUES as readonly string[]).includes(v);
+}
+
+export function validateCodexConfigFlag(
+  key: string,
+  val: unknown,
+  runtime: string | null | undefined,
+): { field: string; reason: string } | null {
+  if (!CODEX_CONFIG_ONLY_FLAG_KEYS.has(key)) return null;
+  if (runtime && !CODEX_CONFIG_FLAG_RUNTIMES.has(runtime)) {
+    return { field: `flags.${key}`, reason: `only supported for codex-sdk / codex-app-server runtimes` };
+  }
+  if (key === "copresenceFullAccess" && runtime && runtime !== "codex-app-server") {
+    return { field: "flags.copresenceFullAccess", reason: "only supported when node runtime is codex-app-server" };
+  }
+  switch (key) {
+    case "approvalPolicy":
+      if (typeof val !== "string" || !(CODEX_APPROVAL_POLICIES as readonly string[]).includes(val)) {
+        return { field: "flags.approvalPolicy", reason: `must be one of ${CODEX_APPROVAL_POLICIES.join("/")}` };
+      }
+      return null;
+    case "sandboxMode":
+      if (typeof val !== "string" || !(CODEX_SANDBOX_MODES as readonly string[]).includes(val)) {
+        return { field: "flags.sandboxMode", reason: `must be one of ${CODEX_SANDBOX_MODES.join("/")}` };
+      }
+      return null;
+    case "skipGitRepoCheck":
+    case "copresenceFullAccess":
+      if (typeof val !== "boolean") return { field: `flags.${key}`, reason: "must be boolean" };
+      return null;
+    case "modelReasoningEffort":
+      if (!isModelReasoningEffort(val)) {
+        return { field: "flags.modelReasoningEffort", reason: `must be one of ${REASONING_EFFORT_VALUES.join("/")}` };
+      }
+      return null;
+    default:
+      return null;
+  }
+}

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

@@ -26,20 +26,28 @@ describe("ALLOWED_FLAGS — exact contract (no silent extension)", () => {
     // the BLOCKER 2 schema-mismatch issue. P2 to add a claude-code-cli
     // config-apply path.
     expect([...ALLOWED_FLAGS].sort()).toEqual([
+      "approvalPolicy",
       "budget",
+      "copresenceFullAccess",
       "dangerouslySkipPermissions",
       "maxTurns",
+      "modelReasoningEffort",
       "permissionMode",
+      "sandboxMode",
+      "skipGitRepoCheck",
       "timeout",
     ]);
   });
 });
 
 describe("SECURITY_SENSITIVE_FLAGS — privilege-elevation surface", () => {
-  test("contains the 2 privilege-elevation flags (teammateMode dropped — see ALLOWED_FLAGS comment)", () => {
+  test("contains privilege-elevation flags (teammateMode dropped — see ALLOWED_FLAGS comment)", () => {
     expect([...SECURITY_SENSITIVE_FLAGS].sort()).toEqual([
+      "approvalPolicy",
+      "copresenceFullAccess",
       "dangerouslySkipPermissions",
       "permissionMode",
+      "sandboxMode",
     ]);
   });
 
@@ -161,6 +169,10 @@ describe("computeApplyMode — tier classifier (RFC-024 §4)", () => {
     expect(computeApplyMode("gpt-5", { maxTurns: 50 })).toBe("restart");
   });
 
+  test("modelReasoningEffort flag alone → restart tier", () => {
+    expect(computeApplyMode(undefined, { modelReasoningEffort: "medium" })).toBe("restart");
+  });
+
   test("mixed (only hot flags) → hot", () => {
     expect(computeApplyMode(undefined, { maxTurns: 50, budget: 100 })).toBe("hot");
   });
@@ -359,3 +371,23 @@ describe("validatePatch — channels defensive gate", () => {
     expect(r?.field).toBe("channels");
   });
 });
+
+describe("Codex config flags (#815)", () => {
+  test("yolo bundle on codex-app-server passes", () => {
+    expect(validatePatch(undefined, {
+      approvalPolicy: "never",
+      sandboxMode: "danger-full-access",
+      skipGitRepoCheck: true,
+      copresenceFullAccess: true,
+      modelReasoningEffort: "low",
+    }, undefined, "codex-app-server")).toBeNull();
+  });
+  test("modelReasoningEffort invalid enum rejected", () => {
+    expect(validatePatch(undefined, { modelReasoningEffort: "max" }, undefined, "codex-app-server")?.field)
+      .toBe("flags.modelReasoningEffort");
+  });
+  test("codex flags on claude runtime rejected", () => {
+    expect(validatePatch(undefined, { modelReasoningEffort: "low" }, undefined, "claude-agent-sdk")?.field)
+      .toBe("flags.modelReasoningEffort");
+  });
+});

package/src/config-apply-validate.ts

@@ -6,6 +6,13 @@
 // caller identity, role gates).
 
 import { isValidTimeoutMs, TIMEOUT_MS_REASON } from "./create-node-validate.js";
+import {
+  REASONING_EFFORT_VALUES,
+  validateCodexConfigFlag,
+  type ModelReasoningEffort,
+} from "./codex-config-flags.js";
+
+export { REASONING_EFFORT_VALUES, type ModelReasoningEffort } from "./codex-config-flags.js";
 
 /**
  * Fields the dashboard may change. Anything not in this list is rejected
@@ -18,6 +25,12 @@ export const ALLOWED_FLAGS = new Set<string>([
   "maxTurns",
   "budget",
   "timeout",
+  // Codex (#815 / client): posture + co-presence grant + thinking level
+  "approvalPolicy",
+  "sandboxMode",
+  "skipGitRepoCheck",
+  "copresenceFullAccess",
+  "modelReasoningEffort",
 ]);
 // NB on teammateMode (dropped from P1 scope per #290 cross-agent
 // review): teammateMode is consumed ONLY by the claude-code-cli
@@ -45,6 +58,9 @@ export const ALLOWED_FLAGS = new Set<string>([
 export const SECURITY_SENSITIVE_FLAGS = new Set<string>([
   "permissionMode",
   "dangerouslySkipPermissions",
+  "approvalPolicy",
+  "sandboxMode",
+  "copresenceFullAccess",
 ]);
 
 /**
@@ -57,6 +73,11 @@ export const RESTART_REQUIRED_FLAGS = new Set<string>([
   "permissionMode",
   "dangerouslySkipPermissions",
   "timeout",
+  "approvalPolicy",
+  "sandboxMode",
+  "skipGitRepoCheck",
+  "copresenceFullAccess",
+  "modelReasoningEffort",
 ]);
 
 /**
@@ -186,6 +207,7 @@ export function validatePatch(
   model: string | undefined,
   flags: Record<string, unknown>,
   channels?: string[] | undefined,
+  nodeRuntime?: string | null,
 ): { field: string; reason: string } | null {
   if (model !== undefined) {
     if (typeof model !== "string" || model.length === 0 || model.length > 200) {
@@ -213,6 +235,8 @@ export function validatePatch(
     if (!ALLOWED_FLAGS.has(key)) {
       return { field: `flags.${key}`, reason: "not in allowlist" };
     }
+    const codexFail = validateCodexConfigFlag(key, val, nodeRuntime ?? null);
+    if (codexFail) return codexFail;
     switch (key) {
       case "permissionMode":
         if (

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

@@ -3,7 +3,7 @@ import {
   ValidationError,
   validateName, validateRuntime, validateModel, validateFlagValue, RUNTIMES,
   validateEnvRefs, validateChannelsP1, serializeEnvLocal, buildAnetArgs,
-  MAX_ENV_KEYS_PER_NODE, validateFlagsForRuntime, COPRESENCE_FLAG_RUNTIMES,
+  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;
@@ -216,6 +216,31 @@ 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",