@sleep2agi/dsh-anet 0.0.0-stage → 0.1.0-preview.26

package/src/node-loop.mjs

@@ -0,0 +1,185 @@
+// The CommHub node loop, independent of DSH: heartbeat, SSE doorbell with
+// reconnect/backoff, inbox drain, exactly-once reply per task id.
+import { randomUUID } from "node:crypto";
+import { hostname } from "node:os";
+
+export const REPLY_MAX_CHARS = 10_000; // hub send_reply text limit
+
+export function truncateReply(text) {
+  const s = String(text ?? "");
+  if (s.length <= REPLY_MAX_CHARS) return s;
+  const note = "\n\n[dsh-commhub: reply truncated to the hub's 10000-character limit]";
+  return s.slice(0, REPLY_MAX_CHARS - note.length) + note;
+}
+
+const isTerminalAlready = (err) => /reply_task_terminal|already terminal/i.test(String(err?.message ?? err));
+// The inbox row outlived its task/message record (expired, purged, or already
+// deleted). There is nothing left to address, so retrying forever is wrong.
+const isReplyTargetGone = (err) => /reply_target_unresolved|task not found|message not found/i.test(String(err?.message ?? err));
+
+/**
+ * @param {{client: ReturnType<import('./hub-client.mjs').createHubClient>, alias: string,
+ *   runTurn: (prompt: string, task: object) => Promise<string>, ledger: ReturnType<import('./ledger.mjs').createLedger>,
+ *   log?: (m: string) => void, heartbeatMs?: number, pollMs?: number, turnTimeoutMs?: number,
+ *   backoff?: {initialMs: number, maxMs: number}, version?: string}} opts
+ */
+export function createCommhubNode(opts) {
+  const { client, alias, runTurn, ledger } = opts;
+  const log = opts.log ?? (() => {});
+  const resumeId = `dsh-${randomUUID()}`;
+  const heartbeatMs = opts.heartbeatMs ?? 30_000;
+  const pollMs = opts.pollMs ?? 60_000;
+  const turnTimeoutMs = opts.turnTimeoutMs ?? 30 * 60_000;
+  const backoff = opts.backoff ?? { initialMs: 1_000, maxMs: 30_000 };
+  let stopped = true;
+  let sseAbort = null;
+  let timers = [];
+  let draining = null;
+  let drainAgain = false;
+  let status = "idle";
+  let currentTask;
+  const stats = { connects: 0, drains: 0, replies: 0, failures: 0 };
+
+  const heartbeat = (next, task) => {
+    if (next) status = next;
+    currentTask = task;
+    return client.call("report_status", {
+      resume_id: resumeId, alias, status, ...(task ? { task: task.slice(0, 200) } : {}),
+      agent: "dsh", hostname: hostname(), project_dir: process.cwd(), version: opts.version ?? "dsh-commhub",
+    }).catch((e) => log(`report_status failed: ${e.message}`));
+  };
+
+  async function sendReply(id, text, replyStatus) {
+    try {
+      await client.call("send_reply", { in_reply_to: id, text: truncateReply(text), status: replyStatus, from_session: alias });
+    } catch (e) {
+      if (isTerminalAlready(e)) {
+        log(`task ${id.slice(0, 8)} already terminal on the hub; not replying again`);
+      } else if (isReplyTargetGone(e)) {
+        log(`task ${id.slice(0, 8)} no longer exists on the hub; dropping the stale inbox row`);
+      } else {
+        throw e;
+      }
+    }
+    ledger.set(id, { state: "done", status: replyStatus });
+    replyStatus === "replied" ? stats.replies++ : stats.failures++;
+  }
+
+  async function withTimeout(promise, ms) {
+    let t;
+    try {
+      return await Promise.race([promise, new Promise((_, rej) => { t = setTimeout(() => rej(new Error(`turn exceeded ${Math.round(ms / 1000)}s`)), ms); })]);
+    } finally { clearTimeout(t); }
+  }
+
+  async function handleTask(msg) {
+    const id = String(msg.task_id || msg.id);
+    const seen = ledger.get(id);
+    if (seen?.state === "done") { log(`task ${id.slice(0, 8)} already replied; ack only`); return; }
+    if (seen?.state === "answered") {
+      log(`task ${id.slice(0, 8)} answered earlier but reply not delivered; resending`);
+      await sendReply(id, seen.text, seen.status);
+      return;
+    }
+    if (seen?.state === "started") {
+      // The previous plugin process died mid-turn. Say so instead of silently re-running.
+      await sendReply(id, "dsh-commhub: the node restarted before this task finished; nothing was returned. Please resend the task.", "failed");
+      return;
+    }
+    ledger.set(id, { state: "started" });
+    const content = String(msg.content ?? "");
+    log(`task ${id.slice(0, 8)} from ${msg.from_session ?? "?"}: ${content.slice(0, 60)}`);
+    await heartbeat("working", content);
+    let text; let replyStatus = "replied";
+    try {
+      text = await withTimeout(runTurn(`[来自 ${msg.from_session ?? "unknown"}] ${content}`, msg), turnTimeoutMs);
+      if (!String(text ?? "").trim()) { text = "dsh-commhub: the agent finished without any text answer."; replyStatus = "failed"; }
+    } catch (e) {
+      text = `dsh-commhub: the agent turn failed: ${e?.message ?? e}`;
+      replyStatus = "failed";
+    }
+    ledger.set(id, { state: "answered", text: String(text), status: replyStatus });
+    await sendReply(id, String(text), replyStatus);
+    log(`task ${id.slice(0, 8)} → ${replyStatus} (${String(text).length} chars)`);
+  }
+
+  async function drainOnce() {
+    stats.drains++;
+    const { messages = [] } = await client.call("get_inbox", { alias, limit: 10 });
+    for (const msg of messages) {
+      if (stopped) return;
+      try {
+        if (msg.type === "task") await handleTask(msg);
+        else log(`skip ${msg.type ?? "message"} ${String(msg.id).slice(0, 8)} from ${msg.from_session ?? "?"}`);
+        await client.call("ack_inbox", { alias, message_id: msg.id });
+      } catch (e) {
+        // Leave the row unacked so the next drain retries it; the ledger prevents a double reply.
+        log(`inbox row ${String(msg.id).slice(0, 8)} not finished: ${e.message}`);
+      }
+    }
+    if (messages.length > 0) await heartbeat("idle");
+  }
+
+  function drain() {
+    if (stopped) return Promise.resolve();
+    if (draining) { drainAgain = true; return draining; }
+    draining = (async () => {
+      do {
+        drainAgain = false;
+        try { await drainOnce(); } catch (e) { log(`drain failed: ${e.message}`); }
+      } while (drainAgain && !stopped);
+    })().finally(() => { draining = null; });
+    return draining;
+  }
+
+  async function sseLoop() {
+    let delay = backoff.initialMs;
+    while (!stopped) {
+      sseAbort = new AbortController();
+      try {
+        for await (const ev of client.events(alias, sseAbort.signal)) {
+          if (ev.type === "connected") {
+            stats.connects++;
+            delay = backoff.initialMs;
+            log(stats.connects === 1 ? "SSE connected" : "SSE reconnected; re-registering and draining");
+            if (stats.connects > 1) void heartbeat();
+            void drain();
+          } else if (ev.type === "new_task" || ev.type === "new_message") {
+            void drain();
+          }
+        }
+        if (!stopped) log("SSE stream ended");
+      } catch (e) {
+        if (stopped) return;
+        log(`SSE error: ${e.message}`);
+      }
+      if (stopped) return;
+      await new Promise((r) => { const t = setTimeout(r, delay); timers.push(t); });
+      delay = Math.min(delay * 2, backoff.maxMs);
+    }
+  }
+
+  return {
+    resumeId,
+    stats,
+    drain,
+    async start() {
+      if (!stopped) return;
+      stopped = false;
+      await heartbeat("idle");
+      timers.push(setInterval(() => void heartbeat(undefined, currentTask), heartbeatMs));
+      timers.push(setInterval(() => void drain(), pollMs));
+      void sseLoop();
+      log(`node started alias=${alias}`);
+    },
+    async stop() {
+      if (stopped) return;
+      stopped = true;
+      sseAbort?.abort();
+      for (const t of timers) { clearInterval(t); clearTimeout(t); }
+      timers = [];
+      if (draining) await draining.catch(() => {});
+      await heartbeat("offline");
+    },
+  };
+}

package/src/nodes.mjs

@@ -0,0 +1,107 @@
+// Durable node registry: one record per ANet node (name/alias + hub + token +
+// project directory + dedicated DSH session). Stored 0600 next to the legacy
+// single-node config so existing installs migrate on first load.
+import { randomUUID } from "node:crypto";
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+
+export function registryPath(env = process.env) {
+  return expandHome(env.DSH_ANET_NODES ?? join(homedir(), ".anet", "dsh", "nodes.json"));
+}
+
+export function legacyConfigPath(env = process.env) {
+  return expandHome(env.DSH_COMMHUB_CONFIG ?? join(homedir(), ".anet", "dsh", "config.json"));
+}
+
+/** Pre-rename locations, read once during migration. */
+function oldRegistryPaths(env) {
+  return [
+    expandHome(env.DSH_COMMHUB_CONFIG_REGISTRY ?? join(homedir(), ".dsh-commhub", "nodes.json")),
+    expandHome(join(homedir(), ".dsh-anet", "nodes.json")),
+  ];
+}
+
+function oldConfigPaths(env) {
+  return [
+    expandHome(join(homedir(), ".dsh-commhub", "config.json")),
+    expandHome(join(homedir(), ".dsh-commhub", "nodes.json")),
+    expandHome(join(homedir(), ".dsh-anet", "config.json")),
+  ];
+}
+
+export function expandHome(path) {
+  return path.startsWith("~/") ? join(homedir(), path.slice(2)) : path;
+}
+
+const slug = (name) => name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 24) || "node";
+
+export function newNodeId() {
+  return `node_${randomUUID().slice(0, 10)}`;
+}
+
+export function newSessionId(name) {
+  return `anet-${slug(name)}-${randomUUID().slice(0, 8)}`;
+}
+
+export function normalizeNode(draft, { id, sessionId, projectDir } = {}) {
+  const name = String(draft.name ?? draft.alias ?? "").trim();
+  return {
+    id: id ?? newNodeId(),
+    name,
+    hub: String(draft.hub ?? "").trim().replace(/\/+$/, ""),
+    networkId: String(draft.networkId ?? "").trim(),
+    token: String(draft.token ?? "").trim(),
+    projectDir: resolve(projectDir ?? draft.projectDir ?? process.cwd()),
+    sessionId: sessionId ?? draft.sessionId ?? newSessionId(name),
+    createdAt: draft.createdAt ?? new Date().toISOString(),
+  };
+}
+
+export function validateNode(node, nodes = []) {
+  if (!node.name) return "节点名称不能为空";
+  if (node.name.length > 200) return "节点名称过长";
+  if (nodes.some((other) => other.name === node.name && other.id !== node.id)) return `节点名称 "${node.name}" 已存在`;
+  if (!/^https?:\/\//.test(node.hub)) return "Hub 必须是 http(s) 地址";
+  if (!/^ntok_/.test(node.token)) return "Node Token 必须是 ntok_ 开头";
+  if (!node.projectDir || !node.projectDir.startsWith("/")) return "项目目录必须是绝对路径";
+  return undefined;
+}
+
+/** Load nodes, migrating the pre-UI single config once. */
+export function loadNodes(env = process.env) {
+  const path = registryPath(env);
+  for (const candidate of [path, ...oldRegistryPaths(env)]) {
+    if (!existsSync(candidate)) continue;
+    try {
+      const parsed = JSON.parse(readFileSync(candidate, "utf8"));
+      if (Array.isArray(parsed?.nodes)) {
+        const nodes = parsed.nodes.map((n) => normalizeNode(n, { id: n.id, sessionId: n.sessionId, projectDir: n.projectDir }));
+        if (candidate !== path) saveNodes(nodes, { path });
+        return { path, nodes };
+      }
+    } catch { /* try the next candidate */ }
+  }
+  let nodes = [];
+  for (const candidate of [legacyConfigPath(env), ...oldConfigPaths(env)]) {
+    try {
+      const legacy = JSON.parse(readFileSync(candidate, "utf8"));
+      if (legacy?.alias && legacy?.hub && legacy?.token) {
+        nodes = [normalizeNode({ ...legacy, name: legacy.alias, projectDir: process.cwd() })];
+        break;
+      }
+    } catch { /* no legacy config here */ }
+  }
+  saveNodes(nodes, { path });
+  return { path, nodes };
+}
+
+export function saveNodes(nodes, { path = registryPath(), env = process.env } = {}) {
+  mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+  writeFileSync(path, `${JSON.stringify({ version: 1, nodes }, null, 2)}\n`, { mode: 0o600 });
+  chmodSync(path, 0o600);
+}
+
+export function findNodeBySession(nodes, sessionId) {
+  return nodes.find((node) => node.sessionId === sessionId);
+}

package/src/plugin.mjs

@@ -0,0 +1,324 @@
+// DSH plugin: exposes one or more DSH sessions as Agent Network (CommHub) nodes.
+// Each node has its own name, hub, token, project directory and dedicated
+// session; tasks for a node run in that node's session so context is preserved.
+import { randomUUID } from "node:crypto";
+import { chmodSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, join } from "node:path";
+import { installModelSelection } from "@deepseek-ai/dsh-agent";
+import { createUserMessage } from "@deepseek-ai/dsh-llm";
+import { defineTool } from "@deepseek-ai/dsh-tools";
+import { createHubClient } from "./hub-client.mjs";
+import { createLedger } from "./ledger.mjs";
+import { createCommhubNode } from "./node-loop.mjs";
+import { commhubToolSpecs } from "./tools.mjs";
+import { summarizeTurn, turnFailure } from "./turn.mjs";
+import { findNodeBySession, loadNodes, normalizeNode, registryPath, saveNodes, validateNode } from "./nodes.mjs";
+import { startConfigServer } from "./ui-server.mjs";
+
+export { summarizeTurn } from "./turn.mjs";
+
+export const name = "anet";
+export const inject = ["agents", "agentDefaultModel", "sessions", "tools"];
+
+const VERSION = "dsh-anet@0.1.0-preview.26";
+
+function agentSetup(ctx) {
+  const selection = ctx.agentDefaultModel.currentSelection();
+  return {
+    selection,
+    agentOptions: { provider: selection.provider, model: selection.model },
+    setup: (agentCtx) => { installModelSelection(agentCtx, { current: selection, assembled: void 0 }); },
+  };
+}
+
+async function ensureAgent(ctx, node) {
+  const live = ctx.agents.get(node.sessionId);
+  if (live !== undefined) { await live.whenIdle(); return live; }
+  const { agentOptions, setup } = agentSetup(ctx);
+  const persistence = ctx.get("sessionPersistence");
+  let stored;
+  if (persistence !== undefined) {
+    try { stored = (await persistence.list()).find((header) => header.id === node.sessionId); } catch { /* no persistence yet */ }
+  }
+  const handle = stored !== undefined
+    ? await ctx.agents.resume({ resumeSessionId: node.sessionId, agentOptions, setup })
+    : await ctx.agents.create({ sessionId: node.sessionId, meta: { cwd: node.projectDir }, agentOptions, setup });
+  await handle.agent.whenIdle();
+  return handle.agent;
+}
+
+async function runNodeTurn(ctx, node, prompt) {
+  const agent = await ensureAgent(ctx, node);
+  const firstSeq = agent.session.seq;
+  agent.followup(createUserMessage({ content: [{ type: "text", text: prompt }], source: { kind: "user" } }));
+  await agent.whenIdle();
+  await ctx.sessions.flush(agent.session);
+  const { text, reason, errors } = summarizeTurn(agent.session, firstSeq);
+  if (!text && reason && typeof reason === "object" && reason.kind && reason.kind !== "completed") {
+    throw new Error(turnFailure(reason, errors));
+  }
+  return text;
+}
+
+export function apply(ctx, config) {
+  const log = (m) => console.log(`[anet] ${new Date().toISOString().slice(11, 19)} ${m}`);
+  const registry = loadNodes();
+  const nodes = registry.nodes;
+  const runtimes = new Map();
+  let timer = null;
+
+  if (config?.alias && nodes.length === 0) {
+    nodes.push(normalizeNode({ ...config, name: config.alias, projectDir: config.projectDir ?? process.cwd() }));
+    saveNodes(nodes, { path: registry.path });
+  }
+
+  function publicNode(node) {
+    return {
+      id: node.id, name: node.name, hub: node.hub, networkId: node.networkId, token: node.token,
+      projectDir: node.projectDir, sessionId: node.sessionId, createdAt: node.createdAt,
+      status: runtimes.has(node.id) ? runtimes.get(node.id).status : "stopped",
+      lastError: runtimes.get(node.id)?.lastError ?? null,
+    };
+  }
+
+  function stopNode(id) {
+    const runtime = runtimes.get(id);
+    if (!runtime) return;
+    runtimes.delete(id);
+    void runtime.loop.stop().catch(() => {});
+  }
+
+  function startNode(node) {
+    stopNode(node.id);
+    const client = createHubClient({ hub: node.hub, token: node.token, networkId: node.networkId || undefined, clientVersion: VERSION });
+    const ledgerPath = join(dirname(registry.path), "nodes", node.id, "ledger.json");
+    const runtime = { node, client, status: "starting", lastError: null };
+    const loop = createCommhubNode({
+      client, alias: node.name, ledger: createLedger(ledgerPath), log,
+      version: VERSION,
+      runTurn: (prompt) => runNodeTurn(ctx, node, prompt),
+    });
+    runtime.loop = loop;
+    runtimes.set(node.id, runtime);
+    loop.start().then(() => { runtime.status = "running"; log(`node ${node.name} connected to ${node.hub}`); },
+      (error) => { runtime.status = "error"; runtime.lastError = error?.message ?? String(error); log(`node ${node.name} failed: ${runtime.lastError}`); });
+    log(`node ${node.name} started → ${node.hub}`);
+  }
+
+  function restartAll() {
+    for (const id of [...runtimes.keys()]) stopNode(id);
+    for (const node of nodes) startNode(node);
+  }
+
+  function requireNode(id) {
+    const node = nodes.find((candidate) => candidate.id === id);
+    if (!node) throw new Error(`节点不存在: ${id}`);
+    return node;
+  }
+
+  function writeNode(next) {
+    const existing = nodes.find((candidate) => candidate.id === next.id);
+    const failure = validateNode(next, nodes);
+    if (failure) throw new Error(failure);
+    if (existing) Object.assign(existing, next);
+    else nodes.push(next);
+    saveNodes(nodes, { path: registry.path });
+    startNode(existing ?? next);
+    return publicNode(existing ?? next);
+  }
+
+  async function mintNodeToken(hub, userToken, networkId, name) {
+    const res = await fetch(`${hub}/api/auth/node-token`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Authorization: `Bearer ${userToken}` },
+      body: JSON.stringify({ network_id: networkId, node_name: name }),
+      signal: AbortSignal.timeout(30_000),
+    });
+    const body = await res.json().catch(() => ({}));
+    if (!res.ok || body.ok === false || !body.token) throw new Error(body.error ?? `创建节点 token 失败 (HTTP ${res.status})`);
+    if (!String(body.token).startsWith("ntok_")) throw new Error("hub 返回了非 ntok_ token");
+    return String(body.token);
+  }
+
+  async function login(draft) {
+    const hub = String(draft.hub ?? "").trim().replace(/\/+$/, "");
+    if (!/^https?:\/\//.test(hub)) throw new Error("Hub 必须是 http(s) 地址");
+    if (!draft.username || !draft.password) throw new Error("用户名和密码不能为空");
+    const res = await fetch(`${hub}/api/auth/login`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ username: draft.username, password: draft.password, client_label: "dsh-anet" }),
+      signal: AbortSignal.timeout(30_000),
+    });
+    const body = await res.json().catch(() => ({}));
+    if (!res.ok || body.ok === false || !body.token) throw new Error(body.error ?? `登录失败 (HTTP ${res.status})`);
+    account = { hub, userToken: String(body.token), user: body.user ?? null, networkId: body.network_id ?? "" };
+    saveAccount(account);
+    return publicAccount();
+  }
+
+  const accountPath = (process.env.DSH_ANET_ACCOUNT ?? join(homedir(), ".anet", "dsh", "account.json"));
+  function loadAccount() {
+    try { return JSON.parse(readFileSync(accountPath, "utf8")); } catch { return null; }
+  }
+  function saveAccount(value) {
+    mkdirSync(dirname(accountPath), { recursive: true, mode: 0o700 });
+    writeFileSync(accountPath, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 });
+    chmodSync(accountPath, 0o600);
+  }
+  let account = loadAccount();
+  function publicAccount() {
+    return account
+      ? { loggedIn: true, hub: account.hub, username: account.user?.username ?? account.username ?? "", networkId: account.networkId ?? "" }
+      : { loggedIn: false };
+  }
+
+  async function listProjects() {
+    const seen = new Map();
+    const add = (path, label) => {
+      if (!path || typeof path !== "string" || seen.has(path)) return;
+      seen.set(path, { path, label: label || basename(path) || path });
+    };
+    for (const home of [process.env.DSH_HOME, join(homedir(), "Library", "Application Support", "DeepSeek Harness Desktop", "kernel-home")]) {
+      if (!home) continue;
+      try {
+        const stored = JSON.parse(readFileSync(join(home, "storages", "workspace.json"), "utf8"));
+        for (const workspace of Object.values(stored?.tables?.workspaces ?? {})) add(workspace.path, workspace.title);
+      } catch { /* no workspace storage here */ }
+    }
+    const persistence = ctx.get("sessionPersistence");
+    if (persistence !== undefined) {
+      try { for (const header of await persistence.list()) add(header.cwd ?? header.meta?.cwd); } catch { /* no sessions yet */ }
+    }
+    add(process.cwd(), "当前目录");
+    const projects = [...seen.values()].slice(0, 50);
+    return { projects, defaultProject: projects[0]?.path ?? process.cwd() };
+  }
+
+  async function listSessions() {
+    const persistence = ctx.get("sessionPersistence");
+    const sessions = [];
+    if (persistence !== undefined) {
+      try {
+        for (const header of await persistence.list()) {
+          sessions.push({ id: header.id, cwd: header.cwd ?? header.meta?.cwd ?? "", createdAt: header.createdAt ?? null });
+        }
+      } catch { /* no persisted sessions */ }
+    }
+    sessions.sort((a, b) => (b.createdAt ?? 0) - (a.createdAt ?? 0));
+    return { sessions: sessions.slice(0, 200) };
+  }
+
+  async function sessionById(id) {
+    return (await listSessions()).sessions.find((session) => session.id === id);
+  }
+
+  function logout() {
+    account = null;
+    try { unlinkSync(accountPath); } catch { /* already gone */ }
+    return { loggedIn: false };
+  }
+
+  async function createNode(draft) {
+    let projectDir = draft.projectDir;
+    if (draft.sessionId) {
+      const session = await sessionById(String(draft.sessionId));
+      if (!session) throw new Error(`session 不存在: ${draft.sessionId}`);
+      if (nodes.some((node) => node.sessionId === session.id)) throw new Error("这个 session 已经是另一个节点了");
+      if (session.cwd) projectDir = session.cwd;
+    }
+    const base = normalizeNode({ ...draft, projectDir, token: draft.token ?? "" });
+    if (!base.token) {
+      const userToken = draft.userToken || (account && account.hub === base.hub ? account.userToken : undefined);
+      if (!userToken) throw new Error("请先登录人类账号，或提供 Node Token");
+      base.token = await mintNodeToken(base.hub, userToken, base.networkId, base.name);
+    }
+    mkdirSync(base.projectDir, { recursive: true });
+    return writeNode(base);
+  }
+
+  async function updateNode(id, draft) {
+    const node = requireNode(id);
+    let sessionId = node.sessionId;
+    let projectDir = String(draft.projectDir ?? node.projectDir);
+    if (draft.sessionId !== undefined && String(draft.sessionId) !== node.sessionId) {
+      const session = await sessionById(String(draft.sessionId));
+      if (!session) throw new Error(`session 不存在: ${draft.sessionId}`);
+      if (nodes.some((other) => other.id !== id && other.sessionId === session.id)) throw new Error("这个 session 已经是另一个节点了");
+      sessionId = session.id;
+      if (session.cwd) projectDir = session.cwd;
+    }
+    return writeNode({
+      ...node, ...draft, id: node.id,
+      name: String(draft.name ?? node.name).trim(),
+      hub: String(draft.hub ?? node.hub).trim().replace(/\/+$/, ""),
+      networkId: String(draft.networkId ?? node.networkId).trim(),
+      token: String(draft.token ?? node.token).trim(),
+      projectDir,
+      sessionId,
+    });
+  }
+
+  async function deleteNode(id) {
+    const node = requireNode(id);
+    const runtime = runtimes.get(id);
+    runtimes.delete(id);
+    if (runtime) await runtime.loop.stop().catch(() => {});
+    nodes.splice(nodes.indexOf(node), 1);
+    saveNodes(nodes, { path: registry.path });
+    return { nodes: nodes.map(publicNode) };
+  }
+
+  function callerNode() {
+    const initiator = ctx.agents.currentInitiator?.();
+    const sessionId = initiator?.session?.id;
+    const bound = sessionId === undefined ? undefined : findNodeBySession(nodes, sessionId);
+    return bound ?? nodes[0];
+  }
+
+  for (const spec of commhubToolSpecs(
+    () => { const node = callerNode(); return node ? runtimes.get(node.id)?.client ?? null : null; },
+    () => callerNode()?.name ?? "",
+  )) {
+    ctx.tools.register(defineTool({
+      name: spec.name,
+      description: spec.description,
+      parameters: spec.parameters,
+      output: {
+        schema: { type: "object", additionalProperties: true, properties: {
+          ok: { type: "boolean", required: true }, id: { type: "string", required: true } } },
+        render: (_args, value) => [{ type: "text", text: spec.render(value) }],
+      },
+      async execute(args) {
+        const out = await spec.handler(args);
+        log(`tool ${spec.name}${args?.alias ? ` → ${args.alias}` : ""}: ${out.id}`);
+        return out;
+      },
+    }));
+  }
+
+  const ui = startConfigServer({
+    listNodes: () => ({ nodes: nodes.map(publicNode) }),
+    createNode,
+    updateNode,
+    deleteNode,
+    login,
+    logout,
+    account: publicAccount,
+    projects: listProjects,
+    sessions: listSessions,
+    defaults: () => ({ projectDir: process.cwd(), hub: nodes[0]?.hub ?? "http://127.0.0.1:9200" }),
+    log,
+  });
+
+  ctx.effect(() => {
+    log(`plugin loaded (${nodes.length} node${nodes.length === 1 ? "" : "s"})`);
+    timer = setTimeout(() => { timer = null; restartAll(); }, 300);
+    return () => {
+      if (timer !== null) clearTimeout(timer);
+      for (const id of [...runtimes.keys()]) stopNode(id);
+      void ui.close();
+    };
+  }, "anet.lifecycle");
+}

package/src/tools.mjs

@@ -0,0 +1,52 @@
+// Tool specs the plugin exposes to the DSH agent. Kept DSH-independent so the
+// handlers can be unit-tested; plugin.mjs wraps them with defineTool().
+
+export function commhubToolSpecs(clientOrGet, aliasOrGet) {
+  const getClient = typeof clientOrGet === "function" ? clientOrGet : () => clientOrGet;
+  const getAlias = typeof aliasOrGet === "function" ? aliasOrGet : () => aliasOrGet;
+  const client = () => {
+    const c = getClient();
+    if (!c) throw new Error("ANet 未配置：请在 Settings → Plugins → ANet 中填写 Hub、Alias 和 Node Token");
+    return c;
+  };
+  return [
+    {
+      name: "commhub_send_task",
+      description: "Send a task to another agent on the Agent Network (CommHub) by alias. The target will reply later; returns the task id.",
+      parameters: {
+        alias: { type: "string", required: true, description: "Target agent alias (use commhub_get_all_status to list)" },
+        task: { type: "string", required: true, description: "Task text" },
+      },
+      async handler(args) {
+        const r = await client().call("send_task", { alias: args.alias, task: args.task, priority: "normal", from_session: getAlias() });
+        return { ok: true, id: String(r.message_id ?? r.task_id ?? ""), queued: r.queued === true };
+      },
+      render: (v) => (v.queued ? `task queued ${v.id} (target offline; delivered when it reconnects)` : `task sent ${v.id}`),
+    },
+    {
+      name: "commhub_send_message",
+      description: "Send an informational message to another agent by alias (no reply expected). Returns the message id.",
+      parameters: {
+        alias: { type: "string", required: true, description: "Target agent alias" },
+        message: { type: "string", required: true, description: "Message text" },
+      },
+      async handler(args) {
+        const r = await client().call("send_message", { alias: args.alias, message: args.message, from_session: getAlias() });
+        return { ok: true, id: String(r.message_id ?? r.id ?? ""), queued: r.queued === true };
+      },
+      render: (v) => (v.queued ? `message queued ${v.id} (target offline; delivered when it reconnects)` : `message sent ${v.id}`),
+    },
+    {
+      name: "commhub_get_all_status",
+      description: "List agents on the Agent Network with their status, so you can pick a real alias before sending.",
+      parameters: {},
+      async handler() {
+        const r = await client().call("get_all_status", {});
+        const rows = Array.isArray(r) ? r : (r.sessions ?? r.agents ?? []);
+        const agents = rows.slice(0, 200).map((s) => ({ alias: String(s.alias ?? ""), status: String(s.status ?? ""), agent: String(s.agent ?? "") }));
+        return { ok: true, id: `${agents.length}`, agents };
+      },
+      render: (v) => (v.agents ?? []).map((a) => `${a.alias} (${a.status})`).join("\n") || "no agents",
+    },
+  ];
+}