@sleep2agi/commhub-server 0.9.0-preview.109 → 0.9.0-preview.111

package/src/node-lifecycle-read-http.test.ts

@@ -0,0 +1,203 @@
+import { beforeAll, afterAll, 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(), "lifecycle-read-"));
+process.env.COMMHUB_DB ||= join(dir, "hub.db");
+process.env.COMMHUB_AUTH_TOKEN ||= "lifecycle-read-master-fixture";
+let hub: ReturnType<typeof Bun.serve>, base: string;
+let db: any, a: any, b: any, limited: any, daemonToken: string;
+const ids = { active: "n_read_active", created: "node_read_created", manual: "node_read_manual", daemon: "n_read_daemon" };
+const get = async (path: string, token = a.token) => {
+  const res = await fetch(base + path, { headers: { Authorization: `Bearer ${token}` } });
+  return { status: res.status, body: await res.json() as any };
+};
+const query = (kind: string, selector: string) => `/api/node-lifecycle-requests?kind=${kind}&${selector}`;
+
+beforeAll(async () => {
+  ({ db } = await import("./db.js"));
+  const { register } = await import("./auth.js");
+  const suffix = Date.now();
+  a = register(`read_owner_${suffix}`, "ReadFixture-Strong1!");
+  b = register(`read_other_${suffix}`, "ReadFixture-Strong1!");
+  limited = register(`read_limited_${suffix}`, "ReadFixture-Strong1!");
+  expect(a.ok && b.ok && limited.ok).toBe(true);
+  for (const user of [a, b, limited]) 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,agent_access) VALUES(?1,?2,'viewer','granted')", [a.network_id, limited.user.user_id]);
+  for (const [key, id] of Object.entries(ids)) 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)",
+    [id, `read-${key}`, a.network_id, a.user.user_id, key === "daemon" ? JSON.stringify({ role: "host_supervisor", daemon_capabilities: { adopt_capable: true } }) : "{}"]);
+  for (const status of ["active", "pending", "refused", "revoked"]) {
+    const id = status === "active" ? ids.active : `n_read_${status}`;
+    if (status !== "active") db.run("INSERT INTO nodes(node_id,node_name,alias,network_id) VALUES(?1,?1,?2,?3)", [id, `read-${status}`, a.network_id]);
+    db.run(`INSERT INTO node_daemon_bindings(request_id,network_id,node_id,daemon_node_id,workdir,requested_by,status,error,created_at,updated_at)
+      VALUES(?1,?2,?3,?4,'/private/fixture',?5,?6,?7,1,2)`,
+      [`adopt_read_${status}`, a.network_id, id, ids.daemon, a.user.user_id, status, status === "refused" ? "adopt_start_evidence_missing" : null]);
+  }
+  db.run(`INSERT INTO node_create_requests(request_id,daemon_node_id,child_name,network_id,runtime,flags_json,env_keys,status,created_at,created_by_token)
+    VALUES('cr_read_created',?1,'created',?2,'codex-sdk','{}','[]','succeeded',1,'private-token')`, [ids.daemon, a.network_id]);
+  db.run(`INSERT INTO node_stop_requests(request_id,network_id,daemon_node_id,child_node_id,child_alias,action,created_by_token,status,error,created_at,acked_at)
+    VALUES('stop_read_failed',?1,?2,?3,'read-active','stop','private-token','stop_failed','adopt_explicit_private_socket_required',3,4)`, [a.network_id, ids.daemon, ids.active]);
+  db.run(`INSERT INTO node_start_requests(request_id,network_id,daemon_node_id,child_node_id,child_alias,created_by_token,status,error,created_at,acked_at)
+    VALUES('start_read_failed',?1,?2,?3,'read-active','private-token','start_failed','adopt_start_evidence_missing',5,6)`, [a.network_id, ids.daemon, ids.active]);
+  db.run("INSERT INTO sessions(resume_id,alias,node_id,network_id,status,last_seen_at) VALUES('read-daemon-session','read-daemon',?1,?2,'idle',datetime('now'))", [ids.daemon, a.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('read-daemon-token',?1,?2,'network','node:read-daemon',?3)", [a.user.user_id, a.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("public errors redact free text for granted viewers on every projection", async () => {
+  db.run("INSERT INTO network_member_agent_grants(network_id,user_id,node_id,can_message) VALUES(?1,?2,?3,0)", [a.network_id, limited.user.user_id, ids.active]);
+  try {
+    for (const error of [
+      "/private/fixture/secret on fixture-host",
+      "not_my_child: daemon has no local record of fixture-node (fixture-id) — no children-map entry and no config at /private/fixture/fixture-node/config.json; refusing to signal processes by alias.",
+      "bin: ENOENT: /private/fixture/bin/anet on fixture-host",
+      "adopt_unknown_secret", "adopt_start_timeout: /private/fixture", "", "adopt_start_timeout", null,
+      "adopted_node_delete_unsupported", "adopt_codex_readopt_required", "adopt_stop_receipt_changed",
+    ]) {
+      const expected = error === null || ["adopt_start_timeout", "adopted_node_delete_unsupported", "adopt_codex_readopt_required", "adopt_stop_receipt_changed"].includes(error) ? error : "lifecycle_error";
+      for (const [kind, table, request] of [
+        ["adopt", "node_daemon_bindings", "adopt_read_active"],
+        ["start", "node_start_requests", "start_read_failed"],
+        ["stop", "node_stop_requests", "stop_read_failed"],
+      ]) {
+        db.run(`UPDATE ${table} SET error=?1 WHERE request_id=?2`, [error, request]);
+        for (const selector of [`request_id=${request}`, `node_id=${ids.active}`]) {
+          const r = await get(query(kind, selector), limited.token);
+          expect(r.status).toBe(200);
+          expect(r.body.request.error).toBe(expected);
+        }
+      }
+      const nodes = (await get(`/api/nodes?network_id=${a.network_id}`, limited.token)).body.nodes;
+      expect(nodes[0].adoption.error).toBe(expected);
+    }
+  } finally {
+    db.run("DELETE FROM network_member_agent_grants WHERE user_id=?1 AND node_id=?2", [limited.user.user_id, ids.active]);
+    db.run("UPDATE node_daemon_bindings SET error=NULL WHERE request_id='adopt_read_active'");
+    db.run("UPDATE node_start_requests SET error='adopt_start_evidence_missing' WHERE request_id='start_read_failed'");
+    db.run("UPDATE node_stop_requests SET error='adopt_explicit_private_socket_required' WHERE request_id='stop_read_failed'");
+  }
+});
+
+test("created projection prefers recorded child id and only falls back for legacy null", async () => {
+  const read = async () => (await get(`/api/nodes?network_id=${a.network_id}`)).body.nodes;
+  try {
+    expect((await read()).find((n: any) => n.node_id === ids.created).managed).toBe("created");
+    db.run("UPDATE node_create_requests SET child_node_id=?1 WHERE request_id='cr_read_created'", [ids.manual]);
+    let nodes = await read();
+    expect(nodes.find((n: any) => n.node_id === ids.manual).managed).toBe("created");
+    expect(nodes.find((n: any) => n.node_id === ids.created).managed).toBe("none");
+    db.run("UPDATE node_create_requests SET child_node_id='missing-child' WHERE request_id='cr_read_created'");
+    expect((await read()).find((n: any) => n.node_id === ids.created).managed).toBe("none");
+    db.run("UPDATE node_create_requests SET child_node_id=?1,network_id=?2 WHERE request_id='cr_read_created'", [ids.manual, b.network_id]);
+    nodes = await read();
+    expect(nodes.find((n: any) => n.node_id === ids.manual).managed).toBe("none");
+  } finally {
+    db.run("UPDATE node_create_requests SET child_node_id=NULL,network_id=?1 WHERE request_id='cr_read_created'", [a.network_id]);
+  }
+});
+
+test("authenticated port-0 HTTP projects actual authority, never an id prefix", async () => {
+  const { status, body } = await get(`/api/nodes?network_id=${a.network_id}`);
+  expect(status).toBe(200);
+  const rows = body.nodes;
+  expect(rows.find((r: any) => r.node_id === ids.created)).toMatchObject({ managed: "created", adoption: null, lifecycle_controllable: true });
+  expect(rows.find((r: any) => r.node_id === ids.manual)).toMatchObject({ managed: "none", adoption: null, lifecycle_controllable: false });
+  expect(rows.find((r: any) => r.node_id === ids.active)).toMatchObject({ managed: "adopted", adoption: { status: "active", request_id: "adopt_read_active" }, lifecycle_controllable: true });
+  for (const status of ["pending", "refused", "revoked"]) expect(rows.find((r: any) => r.node_id === `n_read_${status}`)).toMatchObject({ managed: "none", adoption: { status } });
+});
+test("adopt query preserves all persisted states, request id and bounded projection", async () => {
+  for (const status of ["pending", "active", "refused", "revoked"]) {
+    const r = await get(query("adopt", `request_id=adopt_read_${status}`));
+    expect(r.status).toBe(200);
+    expect(r.body.request).toMatchObject({ kind: "adopt", status, request_id: `adopt_read_${status}` });
+    expect(r.body.request.workdir).toBeUndefined();
+    expect(r.body.request.requested_by).toBeUndefined();
+  }
+});
+test("start/stop returns daemon failure codes; node selector returns latest, not success fiction", async () => {
+  for (const [kind, error] of [["start", "adopt_start_evidence_missing"], ["stop", "adopt_explicit_private_socket_required"]]) {
+    const r = await get(query(kind, `node_id=${ids.active}`));
+    expect(r.status).toBe(200);
+    expect(r.body.request).toMatchObject({ status: `${kind}_failed`, error, node_id: ids.active });
+    expect(r.body.request.created_by_token).toBeUndefined();
+  }
+  expect((await get(query("start", `node_id=${ids.manual}`))).body.request).toBeNull();
+});
+test("cross-network request and node guesses do not disclose data", async () => {
+  for (const kind of ["adopt", "start", "stop"]) {
+    const id = kind === "adopt" ? "adopt_read_active" : `${kind}_read_failed`;
+    const denied = await get(query(kind, `request_id=${id}`), b.token);
+    expect(denied.status).toBe(404);
+    expect(denied.body).toEqual((await get(query(kind, "request_id=nonexistent"), b.token)).body);
+    expect((await get(query(kind, `node_id=${ids.active}`), b.token)).status).toBe(404);
+    expect((await get(query(kind, `request_id=${id}&network_id=${a.network_id}`), b.token)).status).toBe(403);
+  }
+});
+test("same-network restricted viewer without node grants cannot read requests", async () => {
+  for (const kind of ["adopt", "start", "stop"]) {
+    expect((await get(query(kind, `node_id=${ids.active}&network_id=${a.network_id}`), limited.token)).status).toBe(404);
+    const id = kind === "adopt" ? "adopt_read_active" : `${kind}_read_failed`;
+    expect((await get(query(kind, `request_id=${id}&network_id=${a.network_id}`), limited.token)).status).toBe(404);
+  }
+  expect((await get(`/api/nodes?network_id=${a.network_id}`, limited.token)).body.nodes).toEqual([]);
+});
+test("current node grant allows reads; revocation immediately closes them", async () => {
+  db.run("INSERT INTO network_member_agent_grants(network_id,user_id,node_id,can_message) VALUES(?1,?2,?3,0)", [a.network_id, limited.user.user_id, ids.active]);
+  try {
+    expect((await get(query("adopt", "request_id=adopt_read_active"), limited.token)).status).toBe(200);
+    const nodes = (await get(`/api/nodes?network_id=${a.network_id}`, limited.token)).body.nodes;
+    expect(nodes).toHaveLength(1);
+    expect(nodes[0].managed).toBe("adopted");
+  } finally { db.run("DELETE FROM network_member_agent_grants WHERE user_id=?1 AND node_id=?2", [limited.user.user_id, ids.active]); }
+  expect((await get(query("adopt", "request_id=adopt_read_active"), limited.token)).status).toBe(404);
+});
+test("daemon and legacy master do not gain the new user read surface", async () => {
+  for (const token of [daemonToken, process.env.COMMHUB_AUTH_TOKEN!]) {
+    expect((await get(query("adopt", "request_id=adopt_read_active"), token)).status).toBe(403);
+    const nodes = (await get(`/api/nodes?network_id=${a.network_id}`, token)).body.nodes;
+    expect(nodes.length).toBeGreaterThan(0);
+    expect(nodes.every((n: any) => !("managed" in n) && !("adoption" in n))).toBe(true);
+  }
+  expect((await get(query("adopt", "request_id=adopt_read_active"), "invalid")).status).toBe(401);
+  const queryOnly = await fetch(base + query("adopt", `request_id=adopt_read_active&token=${encodeURIComponent(a.token)}`));
+  expect([401, 403]).toContain(queryOnly.status);
+});
+test("host-supervisors capability respects user token and node visibility; absent stays absent", async () => {
+  const path = `/api/host-supervisors?network_id=${a.network_id}`;
+  expect((await get(path)).body.daemons.find((d: any) => d.daemon_node_id === ids.daemon).adopt_capable).toBe(true);
+  for (const token of [limited.token, daemonToken]) {
+    const r = await get(path, token);
+    expect((r.body.daemons ?? []).every((d: any) => !("adopt_capable" in d))).toBe(true);
+  }
+  db.run("UPDATE nodes SET config_snapshot=?1 WHERE node_id=?2", [JSON.stringify({ role: "host_supervisor", daemon_capabilities: { adopt_capable: false } }), ids.daemon]);
+  expect((await get(path)).body.daemons[0].adopt_capable).toBe(false);
+  db.run("UPDATE nodes SET config_snapshot=?1 WHERE node_id=?2", [JSON.stringify({ role: "host_supervisor" }), ids.daemon]);
+  expect((await get(path)).body.daemons[0].adopt_capable).toBeUndefined();
+});
+test("invalid selectors rejected rather than listing every lifecycle request", async () => {
+  for (const suffix of ["", "kind=adopt", "kind=other&node_id=x", "kind=start&request_id=x&node_id=y", "kind=stop&node_id=x&node_id=y", "kind=start&request_id=x&node_id=", "kind=adopt&node_id=%20"])
+    expect((await get(`/api/node-lifecycle-requests?${suffix}`)).status).toBe(400);
+});
+test("request state refresh exposes pending, completion and binding-missing failure without caching", async () => {
+  for (const [kind, statuses] of [["start", ["pending", "delivered", "started", "start_failed", "timeout"]], ["stop", ["pending", "delivered", "stopped", "stop_failed", "noop_not_my_child"]]] as const) {
+    for (const status of statuses) {
+      const error = status.endsWith("failed") ? "adopt_active_binding_required" : null;
+      db.run(`UPDATE node_${kind}_requests SET status=?1,error=?2 WHERE request_id=?3`, [status, error, `${kind}_read_failed`]);
+      expect((await get(query(kind, `request_id=${kind}_read_failed`))).body.request).toMatchObject({ status, error });
+    }
+  }
+});
+test("join refuses a request whose stored network disagrees with its target node", async () => {
+  db.run("UPDATE node_start_requests SET network_id=?1 WHERE request_id='start_read_failed'", [b.network_id]);
+  try {
+    expect((await get(query("start", "request_id=start_read_failed"))).status).toBe(404);
+    expect((await get(query("start", "request_id=start_read_failed"), b.token)).status).toBe(404);
+  } finally { db.run("UPDATE node_start_requests SET network_id=?1 WHERE request_id='start_read_failed'", [a.network_id]); }
+});

package/src/node-lifecycle-read.ts

@@ -0,0 +1,99 @@
+import { db } from "./db.js";
+import { addAgentNetworkScope, type RestNetworkScope } from "./network-scope.js";
+
+// Exact public codes only; daemon exception text must never reach node viewers.
+const publicLifecycleErrors = new Set([
+  "adopted_node_delete_unsupported", "adopt_codex_readopt_required", "adopt_stop_receipt_changed",
+  "adopt_active_binding_required", "adopt_binding_unavailable",
+  "adopt_binding_revoked_during_start", "adopt_explicit_private_socket_required",
+  "adopt_start_evidence_missing", "adopt_stop_evidence_missing",
+  "adopt_launch_mode_mismatch", "adopt_lifecycle_verification_failed",
+  "adopt_process_generation_changed", "adopt_process_still_running",
+  "adopt_process_stop_timeout", "adopt_process_tree_unstable",
+  "adopt_registry_identity_mismatch", "adopt_self_process_refused",
+  "adopt_start_timeout", "adopt_tmux_session_still_exists",
+  "adopt_local_verification_failed", "adopt_roots_not_configured",
+  "adopt_workdir_outside_roots", "adopt_workdir_not_absolute",
+  "adopt_alias_invalid", "adopt_alias_mismatch", "adopt_config_invalid",
+  "adopt_config_network_mismatch", "adopt_network_mismatch",
+  "adopt_hub_invalid", "adopt_hub_missing", "adopt_hub_mismatch",
+  "adopt_identity_ambiguous", "adopt_identity_not_found", "adopt_identity_changed",
+  "adopt_path_not_regular", "adopt_path_owner_mismatch", "adopt_path_writable_by_others",
+  "adopt_process_argv_mismatch", "adopt_process_home_mismatch",
+  "adopt_process_identity_mismatch", "adopt_process_changed",
+  "adopt_tmux_socket_mismatch", "adopt_pane_invalid", "adopt_pane_unverified",
+  "adopt_pane_process_mismatch", "adopt_socket_directory_unsafe", "adopt_socket_unsafe",
+  "adopt_pid_changed", "adopt_pid_invalid", "adopt_pidfile_unsafe",
+  "adopt_proc_invalid", "adopt_proc_unreadable", "adopt_platform_unsupported",
+  "adopt_registry_conflict", "adopt_registry_entry_invalid", "adopt_registry_invalid",
+  "adopt_registry_unsafe", "adopt_config_env_invalid", "adopt_env_file_invalid",
+  "adopt_env_file_unsafe", "adopt_request_mismatch", "adopt_ack_rejected",
+]);
+function publicLifecycleError(error: unknown): string | null {
+  return error == null ? null
+    : typeof error === "string" && publicLifecycleErrors.has(error) ? error : "lifecycle_error";
+}
+
+type Adoption = { request_id: string; daemon_node_id: string; status: string; error: string | null };
+export type LifecycleProjection = { managed: "created" | "adopted" | "none"; adoption: Adoption | null };
+const scopeNodes = (sql: string, params: any[], scope: RestNetworkScope) =>
+  addAgentNetworkScope(sql, params, scope, { network: "n.network_id", nodeId: "n.node_id", alias: "n.alias" });
+
+/** Called only for authenticated human readers. Same visibility as /api/nodes;
+ * constant query count, no id-prefix or host-name inference of authority. */
+export function lifecycleProjections(scope: RestNetworkScope): Map<string, LifecycleProjection> {
+  const result = new Map<string, LifecycleProjection>();
+  const bp: any[] = [];
+  const bindings = db.all<Adoption & { node_id: string }>(scopeNodes(
+    `SELECT b.node_id,b.request_id,b.daemon_node_id,b.status,b.error
+       FROM node_daemon_bindings b JOIN nodes n ON n.node_id=b.node_id AND n.network_id=b.network_id
+      WHERE 1=1`, bp, scope) + " ORDER BY b.created_at DESC,b.request_id DESC", ...bp);
+  for (const b of bindings) {
+    let projection = result.get(b.node_id);
+    if (!projection) {
+      projection = { managed: "none", adoption: { request_id: b.request_id, daemon_node_id: b.daemon_node_id, status: b.status, error: publicLifecycleError(b.error) } };
+      result.set(b.node_id, projection);
+    }
+    if (b.status === "active") projection.managed = "adopted";
+  }
+  const cp: any[] = [];
+  const created = db.all<{ node_id: string }>(scopeNodes(
+    `SELECT n.node_id FROM node_create_requests c JOIN nodes n
+       ON n.node_id=COALESCE(c.child_node_id, CASE WHEN substr(c.request_id,1,3)='cr_'
+         THEN 'node_' || substr(c.request_id,4) END) AND n.network_id=c.network_id
+      WHERE 1=1`, cp, scope), ...cp);
+  for (const n of created) result.set(n.node_id, { managed: "created", adoption: result.get(n.node_id)?.adoption ?? null });
+  return result;
+}
+
+/** Read-only, selector-bound lookup. Join the live node in the SAME network,
+ * then apply its current visibility (including restricted member grants).
+ * Result fields exclude credentials, PID and config; error values separately
+ * use the exact public-code allowlist (daemon text may contain workdir paths). */
+export function lifecycleRequestResponse(url: URL, scope: RestNetworkScope): Response {
+  const kind = url.searchParams.get("kind");
+  const requestId = url.searchParams.get("request_id"), nodeId = url.searchParams.get("node_id");
+  const fail = (error: string, status: number) => Response.json({ ok: false, error }, { status });
+  if (!["adopt", "start", "stop"].includes(kind ?? "")
+      || url.searchParams.has("request_id") === url.searchParams.has("node_id")
+      || !(requestId ?? nodeId ?? "").trim()
+      || ["kind", "request_id", "node_id"].some(k => url.searchParams.getAll(k).length > 1)
+      || (requestId ?? nodeId ?? "").length > 200) return fail("invalid_lifecycle_query", 400);
+  // The table and column names below come only from this closed enum.
+  const table = kind === "adopt" ? "node_daemon_bindings" : kind === "start" ? "node_start_requests" : "node_stop_requests";
+  const nodeColumn = kind === "adopt" ? "node_id" : "child_node_id";
+  // A node lookup with no request must distinguish 'no requests' from 'not visible'.
+  if (nodeId) {
+    const params: any[] = [nodeId];
+    if (!db.get(scopeNodes("SELECT n.node_id FROM nodes n WHERE n.node_id=?1", params, scope), ...params))
+      return fail("node_not_found", 404);
+  }
+  const params: any[] = [requestId ?? nodeId];
+  const sql = scopeNodes(`SELECT r.request_id,r.${nodeColumn} AS node_id,r.network_id,r.daemon_node_id,
+      r.status,r.error,r.created_at,${kind === "adopt" ? "r.updated_at" : "r.acked_at,r.delivered_at"}
+    FROM ${table} r JOIN nodes n ON n.node_id=r.${nodeColumn} AND n.network_id=r.network_id
+    WHERE r.${requestId ? "request_id" : nodeColumn}=?1${kind === "stop" ? " AND r.action='stop'" : ""}`, params, scope);
+  const row = db.get<Record<string, unknown>>(sql + " ORDER BY r.created_at DESC,r.request_id DESC LIMIT 1", ...params);
+  if (!row && requestId) return fail("request_not_found", 404);
+  return Response.json({ ok: true, request: row ? { kind, ...row, error: publicLifecycleError(row.error) } : null });
+}

package/src/node-token-ownership.ts

@@ -0,0 +1,36 @@
+import { db } from "./db.js";
+
+// Call inside the caller's transaction. Serialize registration and issuance for
+// this alias on PG; SQLite already serializes writes on its single connection.
+export function lockNodeAlias(network: string, alias: string, nodeId?: string): void {
+  if (db.dialect !== "postgres") return;
+  db.get("SELECT pg_advisory_xact_lock(hashtext(?1))", JSON.stringify([network, "alias", alias]));
+  if (nodeId) db.get("SELECT pg_advisory_xact_lock(hashtext(?1))", JSON.stringify([network, "id", nodeId]));
+}
+
+export function legacyNodeHolder(user: string, network: string, alias: string, nodeId: string): boolean {
+  return !!db.get(`SELECT token_id FROM api_tokens WHERE user_id=?1 AND network_id=?2
+    AND name=?3 AND revoked_at IS NULL AND (expires_at IS NULL OR expires_at > datetime('now'))
+    AND (bound_node_id=?4 OR (bound_node_id IS NULL AND node_identity_epoch=0)) LIMIT 1`,
+    user, network, `node:${alias}`, nodeId);
+}
+
+/** Resolve a name-only refresh to the existing identity, never claim its owner. */
+export function checkNodeTokenClaim(user: string, network: string, alias: string, nodeId?: string): string | undefined {
+  lockNodeAlias(network, alias, nodeId);
+  const rows = db.all<{node_id: string; owner_user_id: string | null}>(
+    "SELECT node_id, owner_user_id FROM nodes WHERE network_id=?1 AND alias=?2", network, alias);
+  if (rows.length > 1 || rows.some(row => nodeId && row.node_id !== nodeId)) throw Error("node_owner_mismatch");
+  const row = rows[0];
+  // Explicit-ID ownerless claims retain auth.ts's node_owner_unclaimed error;
+  // name-only requests need holder evidence before resolving to that ID.
+  if (row && (row.owner_user_id ? row.owner_user_id !== user : !nodeId && !legacyNodeHolder(user, network, alias, row.node_id))) {
+    throw Error("node_owner_mismatch");
+  }
+  if (!row && db.get(`SELECT token_id FROM api_tokens WHERE network_id=?1 AND name=?2
+    AND user_id<>?3 AND node_identity_epoch=2 AND revoked_at IS NULL
+    AND (expires_at IS NULL OR expires_at > datetime('now')) LIMIT 1`, network, `node:${alias}`, user)) {
+    throw Error("node_owner_mismatch");
+  }
+  return nodeId ?? row?.node_id;
+}

package/src/project-dir-warn-clear-http.test.ts

@@ -0,0 +1,132 @@
+// #667 — a restart from the right directory must clear the cwd warning the
+// previous process left on the same resume_id. Hub stores
+// `task = COALESCE(?11, sessions.task)`, so omitting task keeps the warning.
+// Register sends task: "" once. Later idle reports omit task, so the
+// description of a finished task stays. This boots a throwaway hub on
+// port 0 (never 9200).
+
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { reportedTask } from "../../agent-node/src/project-dir-mismatch.ts";
+
+const DIR = mkdtempSync(join(tmpdir(), "anet-667-clear-"));
+process.env.COMMHUB_DB = join(DIR, "hub.db");
+process.env.COMMHUB_UPLOADS_DIR = join(DIR, "uploads");
+process.env.HOST = "127.0.0.1";
+
+const PW = "ProjectDirWarn123!x";
+const stamp = Date.now();
+const ROOT = "/work";
+const NODE_DIR = "/work/.anet/nodes/demo-node";
+const CONFIG = `${NODE_DIR}/config.json`;
+
+let db: { get: (sql: string, ...params: unknown[]) => { task: string | null } | null };
+let hub: { port: number; stop: (close?: boolean) => void } | null = null;
+let BASE = "";
+let NET = "";
+let node: { alias: string; nodeId: string; token: string };
+
+async function tool(token: string, name: string, args: Record<string, unknown>) {
+  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: "tools/call", params: { name, arguments: args } }),
+  });
+  const raw = await res.text();
+  const data = raw.split("\n").filter((line) => line.startsWith("data:"));
+  const payload = data.length ? JSON.parse(data.at(-1)!.slice(5).trim()) : JSON.parse(raw);
+  return JSON.parse(payload.result.content[0].text);
+}
+
+function sessionTask(): string | null {
+  return db.get("SELECT task FROM sessions WHERE resume_id = ?1", `sdk-${node.nodeId}`)?.task ?? null;
+}
+
+beforeAll(async () => {
+  ({ db } = await import("./db.js"));
+  const { createNetworkTokenForNode, register } = await import("./auth.js");
+  const boss = register(`cwd_boss_${stamp}`, PW);
+  expect(boss.ok).toBe(true);
+  NET = boss.network_id!;
+  const alias = `demo-node-${stamp}`;
+  const nodeId = `n_cwd_${stamp}`;
+  const minted = createNetworkTokenForNode(boss.user!.user_id, NET, alias, nodeId);
+  expect(minted.ok).toBe(true);
+  node = { alias, nodeId, token: minted.token! };
+  const mod = await import("./server.js");
+  hub = mod.bootServer({ port: 0, hostname: "127.0.0.1" });
+  expect(hub.port).not.toBe(9200);
+  expect(hub.port).toBeGreaterThan(0);
+  BASE = `http://127.0.0.1:${hub.port}`;
+}, 30_000);
+
+afterAll(() => {
+  try { hub?.stop(true); } catch { /* already stopped */ }
+  try { rmSync(DIR, { recursive: true, force: true }); } catch { /* temp dir */ }
+});
+
+describe("#667 restart from the workspace root clears the cwd warning", () => {
+  test("wrong directory writes the warning; the right directory sends \"\" and the hub row is empty", async () => {
+    const resume = `sdk-${node.nodeId}`;
+    const wrong = reportedTask({ configPath: CONFIG, cwd: NODE_DIR, inFlight: 0, status: "idle" });
+    expect(wrong).toContain("目录不一致");
+    const started = await tool(node.token, "report_status", {
+      resume_id: resume, alias: node.alias, status: "idle", node_id: node.nodeId, network_id: NET, task: wrong,
+    });
+    expect(started.ok).toBe(true);
+    expect(sessionTask()).toBe(wrong);
+
+    const kept = await tool(node.token, "report_status", {
+      resume_id: resume, alias: node.alias, status: "idle", node_id: node.nodeId, network_id: NET,
+    });
+    expect(kept.ok).toBe(true);
+    expect(sessionTask()).toBe(wrong);
+
+    const idle = reportedTask({ configPath: CONFIG, cwd: ROOT, inFlight: 0, status: "idle" });
+    expect(idle).toBeUndefined();
+    const cleared = idle ?? "";
+    expect(cleared).toBe("");
+    const fixed = await tool(node.token, "report_status", {
+      resume_id: resume, alias: node.alias, status: "idle", node_id: node.nodeId, network_id: NET, task: cleared,
+    });
+    expect(fixed.ok).toBe(true);
+    expect(sessionTask()).toBe("");
+  });
+
+  test("after startup, a finished task's description stays on the hub", async () => {
+    const resume = `sdk-${node.nodeId}`;
+    const description = "BOARD667-FINISHED-TASK";
+    const startup = reportedTask({ configPath: CONFIG, cwd: ROOT, inFlight: 0, status: "idle" }) ?? "";
+    expect(startup).toBe("");
+    const registered = await tool(node.token, "report_status", {
+      resume_id: resume, alias: node.alias, status: "idle", node_id: node.nodeId, network_id: NET, task: startup,
+    });
+    expect(registered.ok).toBe(true);
+    expect(sessionTask()).toBe("");
+
+    const working = reportedTask({
+      configPath: CONFIG, cwd: ROOT, inFlight: 1, status: "working", task: description,
+    });
+    expect(working).toBe(description);
+    const ran = await tool(node.token, "report_status", {
+      resume_id: resume, alias: node.alias, status: "working", node_id: node.nodeId, network_id: NET, task: working,
+    });
+    expect(ran.ok).toBe(true);
+    expect(sessionTask()).toBe(description);
+
+    const finished = reportedTask({ configPath: CONFIG, cwd: ROOT, inFlight: 0, status: "idle" });
+    expect(finished).toBeUndefined();
+    const done = await tool(node.token, "report_status", {
+      resume_id: resume, alias: node.alias, status: "idle", node_id: node.nodeId, network_id: NET,
+    });
+    expect(done.ok).toBe(true);
+    expect(sessionTask()).toBe(description);
+  });
+});

package/src/requirement-events-http.test.ts

@@ -73,10 +73,21 @@ beforeAll(async () => {
   // 看全部任务,但一个 Agent 都没授权:所有节点对他隐去
   db.run("UPDATE network_members SET task_access = 'all', agent_access = 'granted' WHERE network_id = ?1 AND user_id = ?2", [NET, restricted.id]);
   NODE = `n_ev_${stamp}`;
-  db.run("INSERT INTO nodes (node_id, node_name, alias, network_id) VALUES (?1, ?2, ?3, ?4)", [NODE, "ev-node", "ev-node", NET]);
   const ntok = createNetworkTokenForNode(admin.id, NET, "ev-node");
   expect(ntok.ok).toBe(true);
   nodeToken = ntok.token!;
+  // Real legacy-client order: mint by name, then register; never fill owner.
+  const registration = await fetch(`${BASE}/mcp`, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${nodeToken}`, "Content-Type": "application/json", Accept: "application/json, text/event-stream" },
+    body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "tools/call", params: { name: "report_status", arguments: {
+      resume_id: `ev-session-${stamp}`, alias: "ev-node", status: "idle", node_id: NODE,
+    } } }),
+  });
+  expect(registration.status).toBe(200);
+  await registration.text();
+  expect(db.get<{owner_user_id: string | null}>("SELECT owner_user_id FROM nodes WHERE node_id=?1", NODE)?.owner_user_id).toBeNull();
+  expect(db.get<{bound_node_id: string | null}>("SELECT bound_node_id FROM api_tokens WHERE token_id=?1", ntok.token_id!)?.bound_node_id).toBe(NODE);
 }, 30_000);
 
 afterAll(() => {

package/src/requirements-last-event-http.test.ts

@@ -92,10 +92,15 @@ beforeAll(async () => {
   // 看全部任务,但一个 Agent 都没授权:所有节点对他隐去
   db.run("UPDATE network_members SET task_access = 'all', agent_access = 'granted' WHERE network_id = ?1 AND user_id = ?2", [NET, restricted.id]);
   NODE = `n_le_${stamp}`;
-  db.run("INSERT INTO nodes (node_id, node_name, alias, network_id) VALUES (?1, ?2, ?3, ?4)", [NODE, "le-node", "le-node", NET]);
   const ntok = createNetworkTokenForNode(admin.id, NET, "le-node");
   expect(ntok.ok).toBe(true);
   nodeToken = ntok.token!;
+  // Real legacy-client order, with no owner backfill or administrator claim.
+  expect((await mcp(nodeToken, "report_status", {
+    resume_id: `le-session-${stamp}`, alias: "le-node", status: "idle", node_id: NODE,
+  })).data.ok).toBe(true);
+  expect(db.get("SELECT owner_user_id FROM nodes WHERE node_id=?1", NODE).owner_user_id).toBeNull();
+  expect(db.get("SELECT bound_node_id FROM api_tokens WHERE token_id=?1", ntok.token_id).bound_node_id).toBe(NODE);
 }, 30_000);
 
 afterAll(() => {

package/src/scheduled-tasks.ts

@@ -1,4 +1,6 @@
 import { db, logTaskEvent } from "./db.js";
+import { sessionTaskOnDispatch } from "./session-task-on-dispatch.js";
+import { TASK_CONTENT_MAX, sessionTaskPreview } from "./shared/task-content-limit.js";
 import { assertNodeActive } from "./lifecycle-guard.js";
 import { assertNodeHealthy } from "./node-health-guard.js";
 import { addNetworkScope, canRestWriteNetwork, singleNetworkId, type RestNetworkScope } from "./network-scope.js";
@@ -366,7 +368,7 @@ export function dispatchScheduledOccurrence(row: ScheduledRow, scheduledFor: str
     // Dispatch is not completion. Keep the run open until the exact bound
     // task reaches replied/failed/cancelled/expired; db.ts owns that mirror.
     db.run("UPDATE scheduled_task_runs SET task_id = ?1, status = ?2, completed_at = NULL WHERE run_id = ?3", [taskId, deliveryState, runId]);
-    db.run("UPDATE sessions SET task = ?1, updated_at = datetime('now') WHERE node_id = ?2 AND network_id = ?3", [row.task_content.slice(0, 200), node.node_id, row.network_id]);
+    db.run(`UPDATE sessions SET task = ${sessionTaskOnDispatch("?1")}, updated_at = datetime('now') WHERE node_id = ?2 AND network_id = ?3`, [sessionTaskPreview(row.task_content), node.node_id, row.network_id]);
     db.run("UPDATE scheduled_tasks SET target_alias = ?1, last_run_at = ?2, updated_at = datetime('now') WHERE schedule_id = ?3", [node.alias, scheduledFor, row.schedule_id]);
     if (advanceSchedule) advance({ ...row, target_alias: node.alias }, scheduledFor, advanceAfter);
     createdTaskId = taskId;
@@ -517,7 +519,7 @@ export async function handleScheduledTaskRequest(ctx: ScheduledRequestContext):
       const name = typeof body.name === "string" ? body.name.trim() : "";
       const content = typeof body.task === "string" ? body.task.trim() : "";
       if (!name || name.length > 120) throw new Error("invalid_name");
-      if (!content || content.length > 10_000) throw new Error("invalid_task");
+      if (!content || content.length > TASK_CONTENT_MAX) throw new Error("invalid_task");
       const priority = typeof body.priority === "string" ? body.priority : "normal";
       if (!PRIORITIES.has(priority)) throw new Error("invalid_priority");
       const misfirePolicy = parseMisfirePolicy(body.misfire_policy);
@@ -604,7 +606,7 @@ export async function handleScheduledTaskRequest(ctx: ScheduledRequestContext):
       const content = body.task === undefined ? row.task_content : String(body.task).trim();
       const priority = body.priority === undefined ? row.priority : String(body.priority);
       if (!name || name.length > 120) throw new Error("invalid_name");
-      if (!content || content.length > 10_000) throw new Error("invalid_task");
+      if (!content || content.length > TASK_CONTENT_MAX) throw new Error("invalid_task");
       if (!PRIORITIES.has(priority)) throw new Error("invalid_priority");
       const target = body.target_node_id === undefined ? { node_id: row.target_node_id, alias: row.target_alias } : validateTarget(row.network_id, body.target_node_id);
       const parsed = body.schedule === undefined