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

package/src/node-id-alias.test.ts

@@ -0,0 +1,190 @@
+// #1281 — 子节点生命周期工具的参数名统一（node_id ⇄ child_node_id）。
+//
+// 分叉现状（origin/main 2976adb2）：stop_node / start_node / delete_node 用
+// `child_node_id`，restart_node / update_node_config 用 `node_id`，指向同一个
+// 子节点。调用方按一个工具的习惯给另一个传就吃 -32602。修复：5 个工具都同时
+// 接受两个名字（canonical = node_id，child_node_id 兼容 alias），解析收敛到一个
+// 模块级 helper resolveNodeIdArg。
+//
+// 两向 witnessed-red（本文件即判据）：
+//   · schema 层：每个工具的**历史用名**始终 parse 成功（证明没破已发布契约），
+//     **新增别名**在修复前 parse 失败（缺必填字段）、修复后成功。
+//   · handler 层：resolveNodeIdArg 纯函数 —— 二选一至少一必填、都传须相等。
+//   · 真实 handler 路径：stop_node 用 node_id / child_node_id 都能穿到
+//     resolveDaemonForChild（不再被 node_id_required 挡），都传冲突 → node_id_conflict。
+//
+// 对 pre-fix 见红的证明方式（评审可复现）：把 tools.ts 里任一工具的
+// `...NODE_ID_ALIAS_FIELDS` 还原成原来的单名字段（如 stop_node 的
+// `child_node_id: z.string()...regex(...)`），本文件对应工具的「新增别名 parse 成功」
+// 断言立即变红 —— 证明该断言有判别力，不是恒真。
+
+import { describe, expect, test, beforeAll } from "bun:test";
+import { mkdtempSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+
+process.env.COMMHUB_DB = process.env.COMMHUB_DB || (mkdtempSync(join(tmpdir(), "anet-1281-")) + "/commhub.db");
+
+import { z } from "zod/v4";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { registerTools, resolveNodeIdArg } from "./tools.js";
+
+type ToolHandler = (args: any) => Promise<{ content: { type: "text"; text: string }[] }>;
+
+// Capture BOTH the raw zod shape and the handler for every tool, so the
+// schema-layer assertions run against the exact object server.tool received.
+function buildCaptured() {
+  const schemas: Record<string, any> = {};
+  const handlers: Record<string, ToolHandler> = {};
+  const server = new McpServer({ name: "t1281", version: "0" }) as any;
+  const origTool = server.tool.bind(server);
+  server.tool = (name: string, _desc: string, schema: any, handler: ToolHandler) => {
+    schemas[name] = schema; handlers[name] = handler;
+    return origTool(name, _desc, schema, handler);
+  };
+  const origRegisterTool = server.registerTool?.bind(server);
+  if (origRegisterTool) {
+    server.registerTool = (name: string, cfg: any, handler: ToolHandler) => {
+      schemas[name] = cfg?.inputSchema ?? cfg; handlers[name] = handler;
+      return origRegisterTool(name, cfg, handler);
+    };
+  }
+  registerTools(server, undefined, null, "user_1281", null, false, null);
+  return { schemas, handlers };
+}
+
+let SCHEMAS: Record<string, any> = {};
+let HANDLERS: Record<string, ToolHandler> = {};
+beforeAll(() => { const c = buildCaptured(); SCHEMAS = c.schemas; HANDLERS = c.handlers; });
+
+async function call(name: string, args: any) {
+  const r = await HANDLERS[name](args);
+  return JSON.parse(r.content[0].text);
+}
+
+// Per tool: the historically-required id name, the newly-added alias, and
+// the OTHER required fields the shape needs so a safeParse isolates the id
+// field rather than tripping on an unrelated missing field.
+const TOOLS = [
+  { name: "stop_node",          historic: "child_node_id", added: "node_id",        extra: {} },
+  { name: "start_node",         historic: "child_node_id", added: "node_id",        extra: {} },
+  { name: "delete_node",        historic: "child_node_id", added: "node_id",        extra: { confirm_alias: "some-alias" } },
+  { name: "restart_node",       historic: "node_id",       added: "child_node_id",  extra: {} },
+  { name: "update_node_config", historic: "node_id",       added: "child_node_id",  extra: { base_revision: 0, patch: {} } },
+];
+
+const VALID_ID = "node_test_1281";
+
+describe("#1281 schema layer — every lifecycle tool accepts BOTH node_id and child_node_id", () => {
+  for (const t of TOOLS) {
+    test(`${t.name}: historic name '${t.historic}' still parses (published contract intact)`, () => {
+      const shape = z.object(SCHEMAS[t.name]);
+      const r = shape.safeParse({ [t.historic]: VALID_ID, ...t.extra });
+      expect(r.success).toBe(true);
+    });
+
+    test(`${t.name}: added alias '${t.added}' parses (was -32602 pre-#1281 → RED without the fix)`, () => {
+      const shape = z.object(SCHEMAS[t.name]);
+      const r = shape.safeParse({ [t.added]: VALID_ID, ...t.extra });
+      expect(r.success).toBe(true);
+    });
+
+    test(`${t.name}: both names present + equal parses (schema layer permissive; conflict caught in handler)`, () => {
+      const shape = z.object(SCHEMAS[t.name]);
+      const r = shape.safeParse({ node_id: VALID_ID, child_node_id: VALID_ID, ...t.extra });
+      expect(r.success).toBe(true);
+    });
+  }
+});
+
+describe("#1281 resolveNodeIdArg — the single resolution helper", () => {
+  test("node_id only → resolves to node_id", () => {
+    expect(resolveNodeIdArg({ node_id: "node_a" })).toEqual({ ok: true, node_id: "node_a" });
+  });
+  test("child_node_id only → resolves to it (back-compat)", () => {
+    expect(resolveNodeIdArg({ child_node_id: "node_b" })).toEqual({ ok: true, node_id: "node_b" });
+  });
+  test("both present + EQUAL → resolves (no conflict)", () => {
+    expect(resolveNodeIdArg({ node_id: "node_c", child_node_id: "node_c" })).toEqual({ ok: true, node_id: "node_c" });
+  });
+  test("both present + DIFFERENT → node_id_conflict (catches A/B fat-finger)", () => {
+    const r = resolveNodeIdArg({ node_id: "node_a", child_node_id: "node_b" });
+    expect(r.ok).toBe(false);
+    expect((r as any).error).toBe("node_id_conflict");
+  });
+  test("neither present → node_id_required", () => {
+    const r = resolveNodeIdArg({});
+    expect(r.ok).toBe(false);
+    expect((r as any).error).toBe("node_id_required");
+  });
+});
+
+describe("#1281 real handler path — stop_node routes both names to the same place", () => {
+  // stop_node calls resolveNodeIdArg FIRST, then resolveDaemonForChild. A
+  // fabricated id has no create-request row → daemon_not_resolvable. The
+  // point is that BOTH names get PAST the id gate to that same downstream
+  // error (proving the alias flows through), and the two error branches fire.
+  test("node_id (new name) flows through → daemon_not_resolvable, NOT node_id_required", async () => {
+    const r = await call("stop_node", { node_id: VALID_ID });
+    expect(r.ok).toBe(false);
+    expect(r.error).toBe("daemon_not_resolvable");
+  });
+  test("child_node_id (old name) flows through → daemon_not_resolvable (back-compat intact)", async () => {
+    const r = await call("stop_node", { child_node_id: VALID_ID });
+    expect(r.ok).toBe(false);
+    expect(r.error).toBe("daemon_not_resolvable");
+  });
+  test("neither → node_id_required (before any daemon resolution)", async () => {
+    const r = await call("stop_node", { force: true });
+    expect(r.ok).toBe(false);
+    expect(r.error).toBe("node_id_required");
+  });
+  test("both differ → node_id_conflict (before any daemon resolution)", async () => {
+    const r = await call("stop_node", { node_id: "node_a", child_node_id: "node_b" });
+    expect(r.ok).toBe(false);
+    expect(r.error).toBe("node_id_conflict");
+  });
+});
+
+describe("app#196 —— 「解析不到 daemon」的两种情况必须给不同的话", () => {
+  // 🔴 生产实测(2026-08-28):218 个节点里 207 个是 `n_…`(有人直接
+  //    `anet node start` 起的),它们**根本没有 daemon**。原先这两种情况
+  //    打印同一句 `pass daemon_node_id explicitly` —— 对那 207 个来说,
+  //    **这句建议的前提是假的**,照着做只会走进死路。
+  const HAND_STARTED = "n_73687f17";      // 手工起的节点,真实形状
+  const DAEMON_CHILD = "node_test_1281";  // daemon 建的子节点
+
+  test("手工起的节点 → not_daemon_managed,并且**不**建议传 daemon_node_id", async () => {
+    const r = await call("stop_node", { node_id: HAND_STARTED });
+    expect(r.ok).toBe(false);
+    expect(r.error).toBe("not_daemon_managed");
+    // 🔴 这一条是本组的核心:旧文案的那句建议**不能**再出现在这条路径上。
+    expect(r.message).not.toContain("pass daemon_node_id explicitly");
+    // 而且要告诉他真正能走的那条路。
+    expect(r.message).toContain("anet node stop");
+  });
+
+  test("daemon 建的子节点(无 create-request 行) → 仍是 daemon_not_resolvable", async () => {
+    const r = await call("stop_node", { node_id: DAEMON_CHILD });
+    expect(r.ok).toBe(false);
+    expect(r.error).toBe("daemon_not_resolvable");
+    // Board #625: an explicit daemon id no longer substitutes for authority.
+    expect(r.message).not.toContain("pass daemon_node_id explicitly");
+    expect(r.message).toContain("adopt this node");
+  });
+
+  test("delete_node 走同一条判别(两个调用点不能只改一个)", async () => {
+    const r = await call("delete_node", { node_id: HAND_STARTED, confirm_alias: "x" });
+    expect(r.ok).toBe(false);
+    expect(r.error).toBe("not_daemon_managed");
+  });
+
+  // 🔴 反向见证:两种情况必须**真的不同**。若有人把判别改成恒定一支,
+  //    上面三条里至少一条会红 —— 但那还不够明显,所以这里直接断言两者不等。
+  test("两种情况的 error 与 message 都不相同", async () => {
+    const a = await call("stop_node", { node_id: HAND_STARTED });
+    const b = await call("stop_node", { node_id: DAEMON_CHILD });
+    expect(a.error).not.toBe(b.error);
+    expect(a.message).not.toBe(b.message);
+  });
+});

package/src/node-identity-conflict-http.test.ts

@@ -0,0 +1,269 @@
+// #507 — two live copies of one node (directory copied verbatim: same node token,
+// same alias) used to hold two SSE subscriptions on `${net}:${alias}`. Every new
+// task was pushed to BOTH (each copy ran it), and either copy's shutdown
+// report_status(offline) took the node offline under the other → alias_offline.
+//
+// Pinned here, through the real HTTP entrances (GET /events/:alias with the node
+// token, POST /mcp report_status, POST /api/task, GET /api/stats/sse):
+//   1. newest connection wins: the older node stream gets node_connection_superseded
+//      (reason superseded_by_new_connection) and is closed; /api/stats/sse shows 1.
+//   2. a new task reaches exactly ONE node subscriber; a dashboard monitor on the
+//      same channel is untouched and still sees it.
+//   3. node_identity_conflict reaches the network observer stream and
+//      /api/stats/sse.identity_conflicts, with both remotes and no token.
+//   4. offline only when the last node connection leaves; tasks in between are
+//      delivered, not alias_offline.
+//   5. same instance id = a reconnect (replaced_by_reconnect, no conflict);
+//      different ids = instance_match "different"; another node's token watching
+//      this alias never supersedes it; a plain single-node stop is offline at once.
+//
+// 跑法:cd server && COMMHUB_DB=/tmp/x.db bun test src/node-identity-conflict-http.test.ts
+//       PG:COMMHUB_TEST_PG_URL=… COMMHUB_PG_EXPERIMENTAL=1(tests/test2123-hub-postgres-ladder 里注册)
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { createNetworkTokenForNode, register } from "./auth.js";
+import { db } from "./db.js";
+
+const dir = mkdtempSync(join(tmpdir(), "anet-node-conflict-"));
+const activeDbPath = process.env.COMMHUB_DB ?? (process.env.COMMHUB_TEST_PG_URL ? "postgres" : undefined);
+if (!activeDbPath) throw new Error("node-identity-conflict requires COMMHUB_DB (or COMMHUB_TEST_PG_URL) before module import");
+
+const stamp = Date.now();
+let server: any;
+let base = "";
+let ownerToken = "", ownerId = "", NET = "";
+const nodes: Record<string, { alias: string; nodeId: string; token: string }> = {};
+
+type Sub = { events: any[]; done: boolean; abort: () => void; ready: Promise<void> };
+
+function subscribe(path: string, token: string, headers: Record<string, string> = {}): Sub {
+  const ctrl = new AbortController();
+  const sub: Sub = { events: [], done: false, abort: () => ctrl.abort(), ready: Promise.resolve() };
+  let markReady!: () => void;
+  sub.ready = new Promise<void>((r) => { markReady = r; });
+  (async () => {
+    try {
+      const res = await fetch(`${base}${path}`, { headers: { Authorization: `Bearer ${token}`, Accept: "text/event-stream", ...headers }, signal: ctrl.signal });
+      if (!res.ok || !res.body) throw new Error(`subscribe ${path} → ${res.status}`);
+      const reader = res.body.getReader();
+      const dec = new TextDecoder();
+      let buf = "";
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buf += dec.decode(value, { stream: true });
+        const lines = buf.split("\n"); buf = lines.pop() || "";
+        for (const line of lines) {
+          if (!line.startsWith("data: ")) continue;
+          const ev = JSON.parse(line.slice(6));
+          sub.events.push(ev);
+          if (ev.type === "connected") markReady();
+        }
+      }
+    } catch { /* aborted */ }
+    sub.done = true;
+    markReady();
+  })();
+  return sub;
+}
+
+async function until(cond: () => boolean, what: string, ms = 3000) {
+  const t0 = Date.now();
+  while (!cond()) {
+    if (Date.now() - t0 > ms) throw new Error(`timed out waiting for: ${what}`);
+    await new Promise((r) => setTimeout(r, 20));
+  }
+}
+const settle = () => new Promise((r) => setTimeout(r, 150));
+
+async function api(token: string, method: string, path: string, body?: unknown) {
+  const res = await fetch(`${base}${path}`, {
+    method,
+    headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
+    body: body === undefined ? undefined : JSON.stringify(body),
+  });
+  return { status: res.status, body: await res.json().catch(() => null) as any };
+}
+
+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((x) => x.startsWith("data:"));
+  const payload = data.length ? JSON.parse(data.at(-1)!.slice(5).trim()) : JSON.parse(raw);
+  const text = payload.result.content[0].text;
+  if (!text.startsWith("{")) throw new Error(`${name}: ${text}`);
+  return JSON.parse(text);
+}
+
+const reportStatus = (n: { alias: string; nodeId: string; token: string }, status: string) =>
+  tool(n.token, "report_status", { resume_id: `sdk-${n.nodeId}`, alias: n.alias, status, node_id: n.nodeId, network_id: NET });
+const storedStatus = (alias: string) =>
+  db.get<{ status: string }>("SELECT status FROM sessions WHERE alias = ?1 AND network_id = ?2", alias, NET)?.status;
+let seq = 0;
+const sendTask = (alias: string) => api(ownerToken, "POST", "/api/task", { alias, task: `conflict task ${stamp} #${++seq}`, network_id: NET });
+const nodeStream = (n: { alias: string; token: string }, headers: Record<string, string> = {}) =>
+  subscribe(`/events/${encodeURIComponent(n.alias)}`, n.token, headers);
+const newTasks = (s: Sub) => s.events.filter((e) => e.type === "new_task");
+const sseCount = async (alias: string) => (await api(nodes.a.token, "GET", "/api/stats/sse")).body.sessions[`${NET}:${alias}`] ?? 0;
+
+beforeAll(async () => {
+  process.env.COMMHUB_UPLOADS_DIR = join(dir, "uploads");
+  process.env.HOST = "127.0.0.1";
+  const owner = register(`nic_owner_${stamp}`, "NodeConflictOwner123!", undefined, "seed");
+  ownerToken = owner.token!; ownerId = owner.user!.user_id; NET = owner.network_id!;
+  for (const key of ["a", "b", "c", "d", "e"]) {
+    const alias = `nic-${key}-${stamp}`;
+    const nodeId = `n_nic_${key}_${stamp}`;
+    const minted = createNetworkTokenForNode(ownerId, NET, alias, nodeId);
+    expect(minted.ok).toBe(true);
+    nodes[key] = { alias, nodeId, token: minted.token! };
+  }
+  const mod: any = await import("./server.js");
+  server = mod.bootServer({ port: 0, hostname: "127.0.0.1" });
+  base = `http://127.0.0.1:${server.port}`;
+  for (const n of Object.values(nodes)) expect((await reportStatus(n, "idle")).ok).toBe(true);
+}, 30_000);
+
+afterAll(() => {
+  try { server?.stop?.(true); } catch {}
+  try { rmSync(dir, { recursive: true, force: true }); } catch {}
+});
+
+describe("#507 two copies of one node (same token, same alias)", () => {
+  const subs: Record<string, Sub> = {};
+
+  test("newest connection wins: the older node stream is told why and closed", async () => {
+    const n = nodes.a;
+    subs.observer = subscribe(`/events/network/${NET}`, ownerToken);
+    subs.monitor = subscribe(`/events/${encodeURIComponent(n.alias)}?network_id=${NET}`, ownerToken);
+    await subs.observer.ready; await subs.monitor.ready;
+    subs.copyA = nodeStream(n, { "User-Agent": "copy-A" });
+    await subs.copyA.ready;
+    expect(await sseCount(n.alias)).toBe(2); // copy A + dashboard monitor
+
+    subs.copyB = nodeStream(n, { "User-Agent": "copy-B" });
+    await subs.copyB.ready;
+    await until(() => subs.copyA.done, "copy A's stream to be closed");
+    const notice = subs.copyA.events.find((e) => e.type === "node_connection_superseded");
+    expect(notice).toBeTruthy();
+    expect(notice.reason).toBe("superseded_by_new_connection");
+    expect(notice.instance_match).toBe("unknown");
+    expect(subs.copyB.done).toBe(false);
+    expect(subs.monitor.done).toBe(false); // a monitor is never superseded
+    expect(await sseCount(n.alias)).toBe(2); // copy B + monitor
+  });
+
+  test("a new task reaches exactly one node subscriber (the monitor still sees it)", async () => {
+    const r = await sendTask(nodes.a.alias);
+    expect(r.status).toBe(200);
+    expect(r.body.ok).toBe(true);
+    await until(() => newTasks(subs.copyB).length >= 1 && newTasks(subs.monitor).length >= 1, "new_task on copy B + monitor");
+    await settle();
+    expect(newTasks(subs.copyB).length).toBe(1);
+    expect(newTasks(subs.copyA).length).toBe(0);
+    expect(newTasks(subs.monitor).length).toBe(1);
+  });
+
+  test("node_identity_conflict reaches the observer stream and /api/stats/sse, with remotes and no token", async () => {
+    await until(() => subs.observer.events.some((e) => e.type === "node_identity_conflict"), "observer conflict event");
+    const ev = subs.observer.events.find((e) => e.type === "node_identity_conflict");
+    expect(ev.alias).toBe(nodes.a.alias);
+    expect(ev.node_id).toBe(nodes.a.nodeId);
+    expect(ev.policy).toBe("newest_connection_wins");
+    expect(ev.superseded.user_agent).toBe("copy-A");
+    expect(ev.current.user_agent).toBe("copy-B");
+    expect(ev.superseded.remote).toMatch(/^127\.0\.0\.1:\d+$/);
+    expect(ev.current.remote).toMatch(/^127\.0\.0\.1:\d+$/);
+    expect(ev.superseded.remote).not.toBe(ev.current.remote);
+    const stats = await api(nodes.a.token, "GET", "/api/stats/sse");
+    const mine = stats.body.identity_conflicts.filter((c: any) => c.alias === nodes.a.alias);
+    expect(mine.length).toBe(1);
+    expect(mine[0].network_id).toBe(NET);
+    const raw = JSON.stringify(stats.body) + JSON.stringify(ev);
+    expect(raw).not.toContain("ntok_");
+    expect(raw).not.toContain(nodes.a.token);
+    const audit = db.get<{ n: number }>("SELECT COUNT(*) AS n FROM audit_log WHERE action = 'node_identity_conflict' AND target_id = ?1", nodes.a.nodeId);
+    expect(audit?.n).toBe(1);
+  });
+
+  test("offline only when the last node connection leaves; tasks in between are delivered", async () => {
+    const n = nodes.a;
+    // Copy A (the superseded one) shuts down and says so.
+    const fromA = await reportStatus(n, "offline");
+    expect(fromA.ok).toBe(true);
+    expect(fromA.offline_deferred).toBe(true);
+    expect(storedStatus(n.alias)).not.toBe("offline");
+    const r = await sendTask(n.alias);
+    expect(r.status).toBe(200);
+    expect(r.body.ok).toBe(true);
+    expect(r.body.error).toBeUndefined();
+    await until(() => newTasks(subs.copyB).length >= 2, "second new_task on copy B");
+
+    // Copy B stops too: it reports offline while its stream is still open, then exits.
+    const fromB = await reportStatus(n, "offline");
+    expect(fromB.offline_deferred).toBe(true);
+    expect(storedStatus(n.alias)).not.toBe("offline");
+    subs.copyB.abort();
+    await until(() => storedStatus(n.alias) === "offline", "deferred offline applied once the last node stream closed");
+    expect((await sendTask(n.alias)).body.error).toBe("alias_offline");
+    subs.monitor.abort(); subs.observer.abort();
+  });
+});
+
+describe("#507 what is and is not a conflict", () => {
+  test("same instance id = a reconnect of the same process: replaced, no conflict recorded", async () => {
+    const n = nodes.b;
+    const first = nodeStream(n, { "X-Anet-Instance-Id": "inst-b-1" });
+    await first.ready;
+    const second = nodeStream(n, { "X-Anet-Instance-Id": "inst-b-1" });
+    await second.ready;
+    await until(() => first.done, "old stream replaced");
+    expect(first.events.find((e) => e.type === "node_connection_superseded")?.reason).toBe("replaced_by_reconnect");
+    const stats = await api(n.token, "GET", "/api/stats/sse");
+    expect(stats.body.identity_conflicts.filter((c: any) => c.alias === n.alias)).toEqual([]);
+    // No conflict → a stop is exactly as before: offline at once.
+    const r = await reportStatus(n, "offline");
+    expect(r.offline_deferred).toBeUndefined();
+    expect(storedStatus(n.alias)).toBe("offline");
+    second.abort();
+  });
+
+  test("different instance ids are reported as instance_match=different", async () => {
+    const n = nodes.c;
+    const first = nodeStream(n, { "X-Anet-Instance-Id": "inst-c-host1" });
+    await first.ready;
+    const second = subscribe(`/events/${encodeURIComponent(n.alias)}?instance_id=inst-c-host2`, n.token);
+    await second.ready;
+    await until(() => first.done, "old stream superseded");
+    const stats = await api(n.token, "GET", "/api/stats/sse");
+    const mine = stats.body.identity_conflicts.filter((c: any) => c.alias === n.alias);
+    expect(mine.length).toBe(1);
+    expect(mine[0].instance_match).toBe("different");
+    expect(mine[0].superseded.instance_id).toBe("inst-c-host1");
+    expect(mine[0].current.instance_id).toBe("inst-c-host2");
+    second.abort();
+  });
+
+  test("another node's token watching this alias never supersedes the node", async () => {
+    const n = nodes.d;
+    const own = nodeStream(n);
+    await own.ready;
+    const watcher = subscribe(`/events/${encodeURIComponent(n.alias)}`, nodes.e.token);
+    await watcher.ready;
+    await settle();
+    expect(own.done).toBe(false);
+    expect(own.events.some((e) => e.type === "node_connection_superseded")).toBe(false);
+    watcher.abort();
+    // And a plain single-node stop (no conflict) is offline immediately, as before.
+    const r = await reportStatus(n, "offline");
+    expect(r.offline_deferred).toBeUndefined();
+    expect(storedStatus(n.alias)).toBe("offline");
+    own.abort();
+  });
+});

package/src/node-identity-conflict.ts

@@ -0,0 +1,142 @@
+// #507 — two live processes holding the same node identity (a node directory
+// copied verbatim and started elsewhere: same node token, same alias).
+//
+// push.ts enforces "at most one node-scoped SSE subscriber per (network, alias)",
+// newest connection wins (policy + rationale next to enforceSingleNodeSubscriber).
+// This module is the Hub-side bookkeeping around that:
+//
+//   1. node_identity_conflict — every supersede between connections that are not
+//      provably the same process is logged, written to audit_log, pushed to the
+//      network observer stream (dashboard) and kept in a small ring that
+//      GET /api/stats/sse returns. Carries both connections' remote info; never
+//      a token.
+//
+//   2. offline while another copy is still connected — a copy's shutdown
+//      report_status(offline) used to mark the node offline even though the other
+//      copy was connected, so new tasks got alias_offline. While a conflict is
+//      recent for that alias and a node-scoped subscriber is still connected, the
+//      offline is DEFERRED: stored status stays as it was, and the offline is
+//      applied only when the last node-scoped subscriber leaves (or dropped when the
+//      surviving copy reports a fresh status). Outside a conflict window nothing
+//      changes: a normal single-node stop marks offline immediately, as before.
+
+import { db, logAudit } from "./db.js";
+import {
+  hasNodeSubscriber,
+  onNodeIdentityConflict,
+  onNodeSubscribersDrained,
+  pushEvent,
+  pushNetworkObserverEvent,
+  type NodeIdentityConflict,
+} from "./push.js";
+
+/** How long after a conflict an offline report is treated as "maybe the other copy". */
+export const CONFLICT_WINDOW_MS = 10 * 60 * 1000;
+const RING_MAX = 50;
+/** Observer/audit emission is rate-limited per alias (logs are not). A flapping
+ *  pair supersedes about once a second; one event a minute is enough to see it. */
+const EMIT_EVERY_MS = 60 * 1000;
+
+const ring: NodeIdentityConflict[] = [];
+const lastConflictAt = new Map<string, number>();
+const lastEmittedAt = new Map<string, number>();
+const pendingOffline = new Map<string, { resumeId: string; at: number }>();
+
+const k = (alias: string, networkId: string | null | undefined) => `${networkId || "global"}:${alias}`;
+
+function publicInfo(i: NodeIdentityConflict["current"]) {
+  return {
+    instance_id: i.instanceId,
+    remote: i.remote,
+    user_agent: i.userAgent,
+    connected_at: new Date(i.connectedAt).toISOString(),
+  };
+}
+
+export function conflictPayload(c: NodeIdentityConflict) {
+  return {
+    type: "node_identity_conflict",
+    alias: c.alias,
+    node_id: c.nodeId,
+    instance_match: c.instanceMatch,
+    policy: "newest_connection_wins",
+    superseded: publicInfo(c.superseded),
+    current: publicInfo(c.current),
+    at: new Date(c.at).toISOString(),
+  };
+}
+
+function handleConflict(c: NodeIdentityConflict): void {
+  const key = k(c.alias, c.networkId);
+  lastConflictAt.set(key, c.at);
+  ring.push(c);
+  if (ring.length > RING_MAX) ring.splice(0, ring.length - RING_MAX);
+  const payload = conflictPayload(c);
+  console.warn(`[node_identity_conflict] ${c.key} node_id=${c.nodeId ?? "?"} instance_match=${c.instanceMatch} ` +
+    `superseded=${c.superseded.remote ?? "?"}(${c.superseded.instanceId ?? "no-instance-id"}) ` +
+    `by=${c.current.remote ?? "?"}(${c.current.instanceId ?? "no-instance-id"}) — ` +
+    `two processes are using this node's identity (copied node directory?); newest connection kept`);
+  const last = lastEmittedAt.get(key) ?? 0;
+  if (c.at - last < EMIT_EVERY_MS) return;
+  lastEmittedAt.set(key, c.at);
+  pushNetworkObserverEvent(c.networkId, payload);
+  logAudit(null, null, "node_identity_conflict", "node", c.nodeId ?? c.alias, JSON.stringify(payload), c.current.remote ?? undefined, c.networkId ?? undefined);
+}
+
+function handleDrained(alias: string, networkId: string | null): void {
+  const key = k(alias, networkId);
+  const pending = pendingOffline.get(key);
+  if (!pending) return;
+  pendingOffline.delete(key);
+  try {
+    db.run(
+      "UPDATE sessions SET status = 'offline', updated_at = datetime('now') WHERE resume_id = ?1 AND alias = ?2 AND network_id = ?3",
+      [pending.resumeId, alias, networkId ?? "default"],
+    );
+    console.log(`[node_identity_conflict] ${key} last node connection gone → deferred offline applied`);
+    pushEvent(alias, { type: "status_update", alias, status: "offline", progress: null, host: null, process_telemetry: null }, networkId);
+  } catch (e: any) {
+    console.log(`[node_identity_conflict] deferred offline failed for ${key}: ${e?.message || e}`);
+  }
+}
+
+onNodeIdentityConflict(handleConflict);
+onNodeSubscribersDrained(handleDrained);
+
+/** report_status hook. Returns true when an offline report must NOT be stored now
+ *  (another copy of this node is still connected); it is then applied when the last
+ *  node-scoped subscriber leaves. Any non-offline report clears a pending offline. */
+export function deferOfflineIfAnotherCopyConnected(
+  alias: string,
+  networkId: string | null | undefined,
+  status: string,
+  resumeId: string,
+  now = Date.now(),
+): boolean {
+  const key = k(alias, networkId);
+  if (status !== "offline") {
+    pendingOffline.delete(key);
+    return false;
+  }
+  const conflictAt = lastConflictAt.get(key);
+  if (conflictAt === undefined || now - conflictAt > CONFLICT_WINDOW_MS) return false;
+  if (!hasNodeSubscriber(alias, networkId)) return false;
+  pendingOffline.set(key, { resumeId, at: now });
+  console.warn(`[node_identity_conflict] ${key} report_status(offline) deferred: a node connection is still open ` +
+    `and a second copy was seen ${Math.round((now - conflictAt) / 1000)}s ago`);
+  return true;
+}
+
+/** Recent conflicts, newest last, optionally limited to one network. */
+export function recentNodeIdentityConflicts(networkId?: string | null) {
+  return ring
+    .filter((c) => networkId === undefined || c.networkId === networkId)
+    .map((c) => ({ network_id: c.networkId, ...conflictPayload(c) }));
+}
+
+export function __resetNodeIdentityConflictsForTest(): void {
+  ring.length = 0;
+  lastConflictAt.clear();
+  lastEmittedAt.clear();
+  pendingOffline.clear();
+}