@sleep2agi/commhub-server 0.9.0-preview.46 → 0.9.0-preview.48

package/package.json

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

package/src/blocked-exit-on-reply.test.ts

@@ -0,0 +1,122 @@
+import { afterAll, beforeEach, describe, expect, test } from "bun:test";
+import { db } from "./db.js";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { registerTools } from "./tools.js";
+
+// #1548 —— 一个活着、能收发任务的节点可以在名册里永远显示 `blocked`:
+// 只有 report_completion 会把 sessions.status 拉回 idle,而现在大多数 agent 用
+// send_reply(终态)结束任务、用 send_task 派活 —— 这两条路径此前都不碰 sessions.status。
+// 「它刚回了我一条终态消息 / 刚派了一条任务」本身就是最强的活性证据。
+// 只出 `blocked`;`working` 可能真在忙别的任务,不碰(保守)。
+const NET_ID = "net_1548_blocked";
+const USER_ID = "u_1548";
+const NODE_ID = "node_1548_agent";
+const AGENT_ALIAS = "agent-1548";
+const DISPATCHER_NODE_ID = "node_1548_dispatcher";
+const DISPATCHER_ALIAS = "dispatcher-1548";
+const AGENT_TOK_ID = "tok_1548";
+
+type ToolHandler = (args: any, extra?: any) => Promise<{ content: Array<{ type: "text"; text: string }> }>;
+
+function cleanup() {
+  for (const [sql, params] of [
+    ["DELETE FROM tasks WHERE network_id = ?1", [NET_ID]],
+    ["DELETE FROM inbox WHERE network_id = ?1", [NET_ID]],
+    ["DELETE FROM task_events WHERE network_id = ?1", [NET_ID]],
+    ["DELETE FROM sessions WHERE network_id = ?1", [NET_ID]],
+    ["DELETE FROM nodes WHERE network_id = ?1", [NET_ID]],
+    ["DELETE FROM api_tokens WHERE network_id = ?1", [NET_ID]],
+    ["DELETE FROM network_members WHERE network_id = ?1", [NET_ID]],
+    ["DELETE FROM networks WHERE network_id = ?1", [NET_ID]],
+    ["DELETE FROM users WHERE user_id = ?1", [USER_ID]],
+  ] as const) {
+    try { db.run(sql, params as any); } catch {}
+  }
+}
+beforeEach(cleanup);
+afterAll(cleanup);
+
+function seed(agentStatus: string) {
+  db.run(`INSERT INTO users (user_id, username, password_hash, role, created_at) VALUES (?1, ?2, 'x', 'user', datetime('now'))`, [USER_ID, USER_ID]);
+  db.run(`INSERT INTO networks (network_id, network_name, owner_id, created_at) VALUES (?1, ?2, ?3, datetime('now'))`, [NET_ID, NET_ID, USER_ID]);
+  db.run(
+    `INSERT INTO network_members (user_id, network_id, role, joined_at)
+     VALUES (?1, ?2, 'owner', datetime('now'))`,
+    [USER_ID, NET_ID],
+  );
+  for (const [nodeId, alias] of [[DISPATCHER_NODE_ID, DISPATCHER_ALIAS], [NODE_ID, AGENT_ALIAS]] as const) {
+    db.run(
+      `INSERT INTO nodes (node_id, node_name, alias, network_id, hostname, created_at, updated_at, lifecycle_state)
+       VALUES (?1, ?2, ?3, ?4, ?5, datetime('now'), datetime('now'), 'active')`,
+      [nodeId, alias, alias, NET_ID, `host-${alias}`],
+    );
+  }
+  db.run(
+    `INSERT INTO sessions (resume_id, alias, status, node_id, network_id, updated_at, last_seen_at)
+     VALUES (?1, ?2, 'idle', ?3, ?4, datetime('now'), datetime('now'))`,
+    [`res_${DISPATCHER_ALIAS}`, DISPATCHER_ALIAS, DISPATCHER_NODE_ID, NET_ID],
+  );
+  db.run(
+    `INSERT INTO sessions (resume_id, alias, status, node_id, network_id, updated_at, last_seen_at)
+     VALUES (?1, ?2, ?3, ?4, ?5, datetime('now'), datetime('now'))`,
+    [`res_${AGENT_ALIAS}`, AGENT_ALIAS, agentStatus, NODE_ID, NET_ID],
+  );
+  db.run(
+    `INSERT INTO api_tokens (token_id, user_id, network_id, scope, name, token_hash, expires_at, revoked_at)
+     VALUES (?1, ?2, ?3, 'network', ?4, ?5, NULL, NULL)`,
+    [AGENT_TOK_ID, USER_ID, NET_ID, `node:${AGENT_ALIAS}`, `hash_${AGENT_TOK_ID}`],
+  );
+}
+function makeTask(): string {
+  const id = "t_" + Math.random().toString(36).slice(2, 14);
+  db.run(
+    `INSERT INTO tasks (task_id, from_name, to_name, to_node_id, priority, status, content, requires_response, created_at, network_id)
+     VALUES (?1, ?2, ?3, ?4, 'normal', 'delivered', 'test', 'reply', datetime('now'), ?5)`,
+    [id, DISPATCHER_ALIAS, AGENT_ALIAS, NODE_ID, NET_ID],
+  );
+  return id;
+}
+function buildHandlers(): Record<string, ToolHandler> {
+  const server = new McpServer({ name: "test", version: "0" }) as any;
+  const tools: Record<string, ToolHandler> = {};
+  const origTool = server.tool.bind(server);
+  server.tool = (name: string, _desc: string, _schema: any, handler: ToolHandler) => { tools[name] = handler; return origTool(name, _desc, _schema, handler); };
+  const origRegisterTool = server.registerTool?.bind(server);
+  if (origRegisterTool) {
+    server.registerTool = (name: string, _cfg: any, handler: ToolHandler) => { tools[name] = handler; return origRegisterTool(name, _cfg, handler); };
+  }
+  registerTools(server, undefined, NET_ID, USER_ID, AGENT_ALIAS, true, AGENT_TOK_ID);
+  return tools;
+}
+async function call(handler: ToolHandler, args: any): Promise<any> {
+  const r = await handler(args);
+  return JSON.parse(r.content[0]!.text);
+}
+function agentStatus(): string {
+  return (db.get("SELECT status FROM sessions WHERE alias = ?1 AND network_id = ?2", [AGENT_ALIAS, NET_ID]) as { status: string }).status;
+}
+
+describe("#1548 blocked has an exit: a terminal reply or an outbound task proves the agent is alive", () => {
+  test("terminal send_reply from a blocked agent puts it back to idle", async () => {
+    seed("blocked");
+    const tools = buildHandlers();
+    const taskId = makeTask();
+    const r = await call(tools.send_reply!, { text: "done", in_reply_to: taskId, status: "replied", from_session: AGENT_ALIAS, network_id: NET_ID });
+    expect(r.ok, JSON.stringify(r)).toBe(true);
+    expect(agentStatus()).toBe("idle");
+  });
+  test("send_task from a blocked agent puts it back to idle", async () => {
+    seed("blocked");
+    const tools = buildHandlers();
+    const r = await call(tools.send_task!, { alias: DISPATCHER_ALIAS, task: "ping", priority: "normal", from_session: AGENT_ALIAS, network_id: NET_ID });
+    expect(r.ok, JSON.stringify(r)).toBe(true);
+    expect(agentStatus()).toBe("idle");
+  });
+  test("a working agent is left alone (it may be busy with another task)", async () => {
+    seed("working");
+    const tools = buildHandlers();
+    const taskId = makeTask();
+    await call(tools.send_reply!, { text: "done", in_reply_to: taskId, status: "replied", from_session: AGENT_ALIAS, network_id: NET_ID });
+    expect(agentStatus()).toBe("working");
+  });
+});

package/src/serve-error.test.ts

@@ -0,0 +1,38 @@
+import { describe, expect, test } from "bun:test";
+import { buildServeErrorResponse, serveErrorBody } from "./serve-error.js";
+
+// 注:「没有 error 回调时 Bun 回默认非 JSON 500」这一半没法在 bun test 里当用例:
+// 运行器会把 fetch 里抛出的异常当成未处理错误直接判这条用例失败(实测),证据在 #695 末评。
+describe("#695 fetch exceptions become JSON with the exception's own message", () => {
+  test("body carries THE message, both JSON-RPC-shaped and REST-shaped", () => {
+    const b = serveErrorBody(new Error("boom-695: sqlite is locked"));
+    expect(b.error.code).toBe(-32603);
+    expect(b.error.message).toBe("boom-695: sqlite is locked");
+    expect(b.message).toBe("boom-695: sqlite is locked");
+    expect(b.ok).toBe(false);
+    // 不是固定 JSON:换一个异常,message 跟着变
+    expect(serveErrorBody(new Error("other")).error.message).toBe("other");
+    expect(serveErrorBody("plain string").error.message).toBe("plain string");
+    expect(serveErrorBody(new Error("")).error.message).toBe("internal error");
+  });
+
+  test("real Bun.serve: a throwing fetch answers 500 + application/json + the message (was a non-JSON default page)", async () => {
+    const server = Bun.serve({
+      port: 0,
+      fetch() { throw new Error("boom-695-live"); },
+      error: (err) => buildServeErrorResponse(err),
+    });
+    try {
+      const res = await fetch(`http://127.0.0.1:${server.port}/mcp`, { method: "POST", body: "{}" });
+      expect(res.status).toBe(500);
+      expect(res.headers.get("content-type") ?? "").toContain("application/json");
+      const json = await res.json() as { error: { code: number; message: string }; ok: boolean };
+      expect(json.error.code).toBe(-32603);
+      expect(json.error.message).toBe("boom-695-live");
+      expect(json.ok).toBe(false);
+    } finally {
+      server.stop(true);
+    }
+  });
+
+});

package/src/serve-error.ts

@@ -0,0 +1,27 @@
+// #695 —— Bun.serve 没注册 `error` 回调时,fetch 处理器抛出的异常会变成 Bun 的默认 500,
+// body 不是 JSON;MCP 客户端于是只能报一个泛化的 -32603,拿不到任何一句人话。
+// 这里把异常变成一个带 message 的 JSON 响应:/mcp 的客户端按 JSON-RPC 形状读 error.message,
+// REST 客户端按本仓其它路由的 { ok:false, error, message } 形状读。
+// 🔴 判据(#695 末评):同一个异常,响应里要带**那个异常的 message**,不是一个固定 JSON。
+
+export interface ServeErrorBody {
+  jsonrpc: "2.0";
+  id: null;
+  error: { code: -32603; message: string };
+  ok: false;
+  message: string;
+}
+
+export function serveErrorBody(err: unknown): ServeErrorBody {
+  const raw = err instanceof Error ? err.message : String(err);
+  const message = (raw && raw.trim()) ? raw.trim().slice(0, 500) : "internal error";
+  return { jsonrpc: "2.0", id: null, error: { code: -32603, message }, ok: false, message };
+}
+
+export function buildServeErrorResponse(err: unknown): Response {
+  const body = serveErrorBody(err);
+  return new Response(JSON.stringify(body), {
+    status: 500,
+    headers: { "content-type": "application/json; charset=utf-8", "cache-control": "no-store" },
+  });
+}

package/src/server.ts

@@ -1,3 +1,4 @@
+import { buildServeErrorResponse } from "./serve-error.js";
 import { redactMessageRow } from "./redact-tokens.js";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { parseDbTimestampMs } from "./db-timestamp.js";
@@ -786,6 +787,9 @@ return Bun.serve({
   // route. Default Bun ceiling is 128 MiB which is too permissive for
   // a hub now exposed to the public internet.
   maxRequestBodySize: MAX_REQUEST_CONTENT_LENGTH,
+  // #695 —— fetch 处理器抛出时不要让 Bun 回默认的非 JSON 500;带上异常 message,
+  //   /mcp 客户端按 JSON-RPC 读 error.message,REST 客户端按 { ok:false, message } 读。
+  error: (err) => buildServeErrorResponse(err),
 
   async fetch(req, server) {
     const url = new URL(req.url, `http://localhost:${PORT}`);

package/src/tools.ts

@@ -362,6 +362,19 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
     return sql;
   };
 
+  /** #1548 —— 把一个还标着 blocked 的会话拉回 idle。只在「它刚发出终态回复 / 刚派了任务」这两个活性证据处调用。 */
+  const releaseBlockedSession = (alias: string | null | undefined, networkId: string | null | undefined): void => {
+    if (!alias) return;
+    const params: any[] = [alias];
+    let sql = "UPDATE sessions SET status = 'idle', updated_at = datetime('now') WHERE alias = ?1 AND status = 'blocked'";
+    sql = addScope(sql, params, networkId ?? null);
+    try {
+      db.run(sql, params);
+    } catch {
+      // 展示层的一次修正失败不能影响主路径。
+    }
+  };
+
   type ReadScope = { networkId?: string | null; networkIds?: string[] | null; denied?: string };
 
   // Delegates to the shared membership query (network-scope.ts) — was a
@@ -1598,6 +1611,8 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
         let touchSql = "UPDATE sessions SET task = ?1, updated_at = datetime('now') WHERE alias = ?2";
         touchSql = addScope(touchSql, touchParams, effectiveNetId);
         db.run(touchSql, touchParams);
+        // #1548 —— 能派活的发送方不可能真的 blocked;此处出 blocked → idle。
+        releaseBlockedSession(from_session, effectiveNetId);
       });
       logTaskEvent(id, null, "delivered", from_session, parentTaskId ? `→ ${targetAlias} (parent=${parentTaskId.slice(0,8)})` : `→ ${targetAlias}`);
       // Only stamp the dedup index after the inbox/tasks transaction
@@ -1938,6 +1953,9 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
             throw new Error(`reply_atomic_cas_failed:${in_reply_to}`);
           }
           syncScheduledRunForTask(in_reply_to, effectiveNetId);
+          // #1548 —— 终态回复是最强的活性证据:一个还标着 blocked 的发送方在此回到 idle。
+          //   只出 blocked;working 可能真在忙别的任务,不碰。
+          releaseBlockedSession(from_session, effectiveNetId);
           return { ok: true as const, replyLogged: true };
         }
         return { ok: true as const, replyLogged: false };