@sleep2agi/commhub-server 0.9.0-preview.142 → 0.9.0-preview.144

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sleep2agi/commhub-server",
-  "version": "0.9.0-preview.142",
+  "version": "0.9.0-preview.144",
   "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/agent-department-http.test.ts

@@ -145,4 +145,20 @@ describe("Agent 显式归属部门", () => {
     const agents2 = [...(dir2.body.people ?? []).flatMap((p: any) => p.agents ?? []), ...(dir2.body.agents_without_owner ?? [])];
     expect(agents2.find((a: any) => a.node_id === NODE_A)?.department_id ?? null).toBeNull();
   });
+
+  // #1976 —— Agent 归属与人类部门是两个独立的结构。通讯录顶层要说明「这个 Hub 支持显式
+  // Agent 部门」,客户端据此把「行里没有 department_id」读成「没有显式归属」,
+  // 而不是从「负责人在哪个部门」推断出来。
+  test("通讯录声明支持显式 Agent 部门（与人类部门相互独立）", async () => {
+    const dir = await send(U.owner.token, "GET", `/api/requirements/people/directory?network_id=${NET}`);
+    expect(dir.status).toBe(200);
+    expect(dir.body.agent_department_supported).toBe(true);
+    // 行形状不变:没有显式归属的行**不带** department_id 这一格(旧客户端形状不变)。
+    const agents = [...(dir.body.people ?? []).flatMap((p: any) => p.agents ?? []), ...(dir.body.agents_without_owner ?? [])];
+    for (const a of agents) {
+      // 显式归属 ⇒ 带这一格且非空;没有显式归属 ⇒ **不带这一格**(旧客户端形状不变)。
+      if (a.department_id) expect(typeof a.department_id).toBe("string");
+      else expect(Object.prototype.hasOwnProperty.call(a, "department_id")).toBe(false);
+    }
+  });
 });

package/src/requirements-people.ts

@@ -72,8 +72,9 @@ export function peopleDirectory(networkId: string, hidden: HiddenNode, query: {
   const byOwner = new Map<string, DirectoryAgent[]>();
   const unowned: DirectoryAgent[] = [];
   for (const n of nodes) {
-    // 只在**显式**归属时带这一格:没设 = 沿用「按负责人的部门推断」的老口径,
-    // 也保证旧客户端拿到的行形状不变(多一个键会让严格要求形状的测试/客户端意外)。
+    // 只在**显式**归属时带这一格:没设 = 没有显式归属(顶层 agent_department_supported 告诉
+    // 客户端这一点)。行形状保持不变 —— 旧客户端拿到的行还是老样子(多一个键会让严格要求
+    // 形状的测试/客户端意外),只是新客户端不再把「负责人在哪个部门」当成 Agent 的部门。
     const agent = { node_id: n.node_id, alias: n.alias || n.node_name, ...(n.department_id ? { department_id: n.department_id } : {}) };
     if (n.owner_user_id && memberIds.has(n.owner_user_id)) {
       const list = byOwner.get(n.owner_user_id) ?? [];
@@ -104,6 +105,12 @@ export function peopleDirectory(networkId: string, hidden: HiddenNode, query: {
     network_id: networkId,
     total: people.length,
     people: page,
+    // #1976 —— 「Agent 归属」与「人类部门」是两个独立的结构。
+    // Agent 放哪个部门,只由**显式**设置(nodes.department_id)决定;**不再**从「负责人在哪个部门」推断。
+    // 这一格告诉客户端「这个 Hub 支持显式 Agent 部门」:客户端据此把「没有 department_id 这一行」
+    // 读成「没有显式归属 ⇒ 未归属」,而不是「按负责人部门推断」。
+    // 老 Hub 没有这一格 ⇒ 客户端保留旧的推断口径,行为不变。
+    agent_department_supported: true,
     ...(query.offset === 0 ? { agents_without_owner: unowned.filter(a => hit(a.alias)) } : {}),
     has_more: hasMore,
     next_offset: hasMore ? query.offset + query.limit : null,

package/src/rest-alias-network-fallback-http.test.ts

@@ -0,0 +1,123 @@
+// #1974 —— 多网络账号给「另一个网络里的 Agent」发消息,hub 侧也要能发出去。
+//
+// 起因(admin 2026-10-21 截图 + hub 拒绝日志):
+//   [15:55:54] tang → /api/task → tang02: REJECTED 404 alias_not_found (net=net_ac567b4ab74e)
+//
+// 客户端的 Agent 列表是跨网络的(GET /api/status?light=1 不带 network_id ⇒ 返回调用者所属的
+// 全部网络),发送却带着「登录时选的那一个网络」。这里用真实 HTTP + 临时库复现那个形状:
+//   * admin 拥有 NET_A,里面有 Agent `cross-agent`;
+//   * tang 注册 ⇒ 自己的个人网络 NET_B(owner),同时是 NET_A 的 admin 成员(agent_access 'all');
+//   * tang 用 NET_B 发给 `cross-agent` ⇒ 修之前 404 alias_not_found,修之后送达 NET_A。
+//
+// 三条红线各有断言:同名在两个网络都有 ⇒ 不猜(仍 404);没授权的网络 ⇒ 不去;不存在的 alias ⇒ 404。
+
+import { describe, expect, test, beforeAll, afterAll } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { addNetworkMember, register } from "./auth.js";
+import { db } from "./db.js";
+
+const DIR = mkdtempSync(join(tmpdir(), "anet-1974-alias-net-"));
+let BASE = "";
+let hub: any = null;
+const PW = "AliasNetPassw0rd!x";
+let NET_A = "";
+let NET_B = "";
+let tangToken = "";
+let tangUserId = "";
+
+const stamp = Date.now();
+
+let sessionSeq = 0;
+function insertSession(alias: string, networkId: string, nodeId: string | null = null) {
+  sessionSeq += 1;
+  db.run(
+    `INSERT INTO sessions (resume_id, alias, node_id, network_id, status, updated_at, last_seen_at)
+     VALUES (?1, ?2, ?3, ?4, 'idle', datetime('now'), datetime('now'))`,
+    [`resume_${alias}_${stamp}_${sessionSeq}`, alias, nodeId, networkId],
+  );
+}
+
+async function postTask(token: string, body: any) {
+  const res = await fetch(`${BASE}/api/task`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", Authorization: `Bearer ${token}` },
+    body: JSON.stringify(body),
+  });
+  const text = await res.text();
+  let json: any = text;
+  try { json = JSON.parse(text); } catch { /* keep text */ }
+  return { status: res.status, json };
+}
+
+beforeAll(async () => {
+  process.env.COMMHUB_DB ||= join(DIR, "hub.db");
+  process.env.COMMHUB_UPLOADS_DIR = join(DIR, "uploads");
+  process.env.HOST = "127.0.0.1";
+
+  const admin = register(`aliasnet_admin_${stamp}`, PW, undefined, "Admin");
+  expect(admin.ok).toBe(true);
+  NET_A = admin.network_id!;
+  db.run("UPDATE users SET role = 'admin' WHERE user_id = ?1", [admin.user!.user_id]);
+
+  // admin 名下的 Agent:只在 NET_A 里。
+  insertSession("cross-agent", NET_A, `node_cross_${stamp}`);
+
+  // tang:自己的个人网络 NET_B(owner)+ NET_A 的 admin 成员(两个网络 agent_access 都是 'all',
+  // 这正是现网 tang 的形状:owner 个人网络 + admin 团队网络)。
+  const tang = register(`aliasnet_tang_${stamp}`, PW, undefined, "Tang");
+  expect(tang.ok).toBe(true);
+  NET_B = tang.network_id!;
+  tangToken = tang.token!;
+  tangUserId = tang.user!.user_id;
+  expect(addNetworkMember(NET_A, tangUserId, "admin", admin.user!.user_id, { agentAccess: "all" }).ok).toBe(true);
+
+  // 同名 alias 在**请求的网络之外**的两个网络里都有 ⇒ 不猜。
+  // 需要第三个网络:另一个用户建自己的网络,tang 也是它的成员。
+  const third = register(`aliasnet_third_${stamp}`, PW, undefined, "Third");
+  expect(third.ok).toBe(true);
+  const NET_C = third.network_id!;
+  expect(addNetworkMember(NET_C, tangUserId, "member", third.user!.user_id, { agentAccess: "all" }).ok).toBe(true);
+  insertSession("twin-agent", NET_A, `node_twin_a_${stamp}`);
+  insertSession("twin-agent", NET_C, `node_twin_c_${stamp}`);
+
+  const mod: any = await import("./server.js");
+  hub = mod.bootServer({ port: 0, hostname: "127.0.0.1" });
+  BASE = `http://127.0.0.1:${hub.port}`;
+});
+
+afterAll(() => {
+  try { hub?.stop?.(); } catch { /* ignore */ }
+  try { rmSync(DIR, { recursive: true, force: true }); } catch { /* ignore */ }
+});
+
+describe("POST /api/task across the caller's own networks (#1974)", () => {
+  test("an alias in the caller's other network is delivered there, not 404", async () => {
+    const res = await postTask(tangToken, { alias: "cross-agent", task: "hi", network_id: NET_B });
+    expect(res.status).toBe(200);
+    expect(res.json.ok).toBe(true);
+    // 落在 NET_A(那个 alias 真正所在的网络),不是请求里带的 NET_B。
+    expect(res.json.actual_to?.network_id ?? res.json.actual_to?.networkId).toBe(NET_A);
+    const row = db.get<{ network_id: string }>("SELECT network_id FROM tasks WHERE task_id = ?1", [res.json.task_id]);
+    expect(row?.network_id).toBe(NET_A);
+  });
+
+  test("the same alias in two of the caller's networks is not guessed", async () => {
+    const res = await postTask(tangToken, { alias: "twin-agent", task: "hi", network_id: NET_B });
+    expect(res.status).toBe(404);
+    expect(res.json.error).toBe("alias_not_found");
+  });
+
+  test("an alias nobody has is still 404", async () => {
+    const res = await postTask(tangToken, { alias: "nowhere-agent", task: "hi", network_id: NET_B });
+    expect(res.status).toBe(404);
+    expect(res.json.error).toBe("alias_not_found");
+  });
+
+  test("the requested network still wins when it has the alias", async () => {
+    const res = await postTask(tangToken, { alias: "cross-agent", task: "hi2", network_id: NET_A });
+    expect(res.status).toBe(200);
+    expect(res.json.actual_to?.network_id ?? res.json.actual_to?.networkId).toBe(NET_A);
+  });
+});

package/src/rest-alias-network-fallback.test.ts

@@ -0,0 +1,60 @@
+// #1974 —— alias 不在请求的网络里、但在调用者另一个网络里(且唯一)时,发到那儿去。
+//
+// 三条红线各有���一条断言:只找调用者已加入的网络、同名不猜、没权限不换。
+import { describe, expect, test } from "bun:test";
+import { pickAliasNetwork } from "./rest-alias-network-fallback.js";
+
+const base = {
+  alias: "tang02",
+  requestedNetworkId: "net_own",
+  memberNetworkIds: ["net_own", "net_team"],
+  networksWithAlias: ["net_team"],
+  canWrite: () => true,
+  canMessage: () => true,
+};
+
+describe("pickAliasNetwork (#1974)", () => {
+  test("the alias lives in exactly one other member network ⇒ use it", () => {
+    expect(pickAliasNetwork({ ...base })).toBe("net_team");
+  });
+
+  test("the alias is in the requested network too ⇒ do not switch", () => {
+    expect(pickAliasNetwork({ ...base, networksWithAlias: ["net_own", "net_team"] })).toBeNull();
+  });
+
+  test("the same alias in two other networks ⇒ do not guess", () => {
+    expect(pickAliasNetwork({
+      ...base,
+      memberNetworkIds: ["net_own", "net_a", "net_b"],
+      networksWithAlias: ["net_a", "net_b"],
+    })).toBeNull();
+  });
+
+  test("a network the caller does not belong to is never used", () => {
+    expect(pickAliasNetwork({
+      ...base,
+      memberNetworkIds: ["net_own"],
+      networksWithAlias: ["net_team"],
+    })).toBeNull();
+  });
+
+  test("no write access in that network ⇒ keep the 404", () => {
+    expect(pickAliasNetwork({ ...base, canWrite: () => false })).toBeNull();
+  });
+
+  test("no message permission in that network ⇒ keep the 404", () => {
+    expect(pickAliasNetwork({ ...base, canMessage: () => false })).toBeNull();
+  });
+
+  test("the alias is nowhere ⇒ keep the 404", () => {
+    expect(pickAliasNetwork({ ...base, networksWithAlias: [] })).toBeNull();
+  });
+
+  test("no membership at all ⇒ keep the 404", () => {
+    expect(pickAliasNetwork({ ...base, memberNetworkIds: [] })).toBeNull();
+  });
+
+  test("an empty alias is never sent anywhere", () => {
+    expect(pickAliasNetwork({ ...base, alias: "   " })).toBeNull();
+  });
+});

package/src/rest-alias-network-fallback.ts

@@ -0,0 +1,65 @@
+// #1974 —— 「alias 不在请求的网络里」时,发到调用者**另一个**网络里那个 alias 所在的网络。
+//
+// 起因(admin 2026-10-21 截图 + hub 拒绝日志):
+//   [15:55:54] tang → /api/task → tang02: REJECTED 404 alias_not_found (net=net_ac567b4ab74e)
+//
+// 客户端的 Agent 列表是**跨网络**的:`GET /api/status?light=1` 不带 network_id,
+// hub 就按「调用者属于哪些网络」返回。tang 因此同时看到默认网络(net_399bdf86f528)的
+// tang02/03/04 和自己个人网络(net_ac567b4ab74e)里的 Agent。发送却带着「登录时选定的
+// 那一个网络」—— 多网络账号(自己网络的 owner + 团队网络的 admin)两个网络对它都是
+// agent_access='all',pickDefaultNetworkId 于是选中了自己的个人网络 ⇒ 给团队网络的
+// Agent 发消息一律 404 alias_not_found,客户端只显示「没有找到这个 Agent」+「未送达」。
+//
+// 客户端侧已有修法(用 alias 所在网络发),但那只在**新客户端**里生效;已经在用的旧客户端
+// 仍然发不出去。这里补 Hub 侧:alias 唯一地存在于调用者的另一个网络、且调用者在那个网络
+// 有写权限 ⇒ 就发到那儿去。旧客户端立刻受益,不用等升级。
+//
+// 三条红线:
+//   ① 只在调用者**已加入**的网络里找(不跨租户、不做 alias 探测);
+//   ② 同一个 alias 在调用者的多个网络里都存在 ⇒ **不猜**,保持 404;
+//   ③ 调用者在目标网络没有写权限(受限成员没被授权这个 Agent)⇒ 保持 404/403。
+//
+// 纯函数:不碰 db、不碰 http,好测。
+
+export interface AliasNetworkFallbackInput {
+  /** 请求里带的 alias(已按请求网络 canonical 化)。 */
+  alias: string;
+  /** 请求带/推出的那个网络。 */
+  requestedNetworkId: string | null;
+  /** 调用者所属的全部网络。 */
+  memberNetworkIds: readonly string[];
+  /** 上面这些网络里,真的存在这个 alias 的网络(去重后)。 */
+  networksWithAlias: readonly string[];
+  /** 调用者在这个网络能不能写。 */
+  canWrite: (networkId: string) => boolean;
+  /** 调用者能不能给这个 alias 发消息(受限成员的 Agent 授权)。 */
+  canMessage: (networkId: string) => boolean;
+}
+
+/**
+ * 该发到哪个网络?返回 null = 保持原来的 404。
+ *
+ * 只在「请求的网络里没有这个 alias」时才会换网络;请求网络里有 ⇒ 传 requestedNetworkId
+ * 之外一律不动(调用方只在 not_found 时才问这个函数)。
+ */
+export function pickAliasNetwork(input: AliasNetworkFallbackInput): string | null {
+  const alias = (input.alias ?? '').trim();
+  if (!alias) return null;
+  const requested = (input.requestedNetworkId ?? '').trim();
+  const members = new Set((input.memberNetworkIds ?? []).map(n => (n ?? '').trim()).filter(Boolean));
+  if (members.size === 0) return null;
+
+  // 请求的网络里本来就有这个 alias ⇒ 不换网络(它就在那儿,不用猜)。
+  const withAlias = [...new Set((input.networksWithAlias ?? []).map(n => (n ?? '').trim()).filter(Boolean))];
+  if (requested && withAlias.includes(requested)) return null;
+  // 候选 = 调用者所属、且真的有这个 alias 的网络;请求网络本身不算。
+  const candidates = withAlias.filter(n => n !== requested && members.has(n));
+  if (candidates.length === 0) return null;
+  // 多个网络都有同名 alias ⇒ 不猜(alias 探测的防线)。
+  if (candidates.length > 1) return null;
+
+  const only = candidates[0];
+  if (!input.canWrite(only)) return null;
+  if (!input.canMessage(only)) return null;
+  return only;
+}

package/src/server.ts

@@ -32,6 +32,7 @@ import { notifyExpiredTasks, type ExpiredTaskRow } from "./task-expiry-notice.js
 import { expireStaleOpenTasks } from "./task-stale-open.js";
 import { flagOrphanTasks } from "./task-orphan.js";
 import { addAgentNetworkScope, addHumanNetworkScope, addNetworkScope, addOwnTrafficScope, addAgentTimelineScope, canRestWriteNetwork, canRestWriteNetworkAsHuman, getUserNetworkIds, resolveRestNetworkScope, resolveRestWriteNetworkId, singleNetworkId, type RestNetworkScope } from "./network-scope.js";
+import { pickAliasNetwork } from "./rest-alias-network-fallback.js";
 import { lifecycleProjections, lifecycleRequestResponse } from "./node-lifecycle-read.js";
 import { listAdoptionCandidates, snapshotReportsAdoptionDiscovery } from "./adoption-candidates.js";
 import { restrictedMemberSeesFile, restrictedMemberAttachmentsDenied } from "./restricted-files.js";
@@ -3779,6 +3780,37 @@ return Bun.serve({
           message: "network_id is required when the user token has zero or multiple network memberships",
         }, { status: 400 })));
       }
+      // #1974 —— alias 不在请求的网络里、但在调用者**另一个**网络里(且唯一)⇒ 发到那儿去。
+      // 客户端的 Agent 列表是跨网络的(/api/status?light=1 不带 network_id),发送却带着
+      // 「登录时选的那一个网络」;多网络账号因此给别的网络里的 Agent 发消息一律 404
+      // (tang → tang02,2026-10-21)。旧客户端不改也能立刻受益。
+      // 找不到 / 多个网络同名 / 没权限 ⇒ 不动,保持原来的 404。
+      if (restAuth && taskNetId) {
+        const canonicalAlias = resolveCanonicalAlias(taskNetId, body.alias).alias;
+        const memberNets = getUserNetworkIds(restAuth.userId);
+        const netsWithAlias = memberNets.filter(n => !!db.get(
+          "SELECT 1 AS ok FROM sessions WHERE alias = ?1 AND network_id = ?2",
+          [canonicalAlias, n],
+        ));
+        const alt = pickAliasNetwork({
+          alias: canonicalAlias,
+          requestedNetworkId: taskNetId,
+          memberNetworkIds: memberNets,
+          networksWithAlias: netsWithAlias,
+          canWrite: (net) => canRestWriteNetwork(restAuth, net, isAdmin),
+          canMessage: (net) => {
+            if (isAgentRestricted(restAuth.userId, net)) {
+              const row = db.get<{ node_id: string | null }>(
+                "SELECT node_id FROM sessions WHERE alias = ?1 AND network_id = ?2",
+                [canonicalAlias, net],
+              );
+              return canMessageAgent(restAuth.userId, net, { alias: canonicalAlias, nodeId: row?.node_id ?? null });
+            }
+            return true;
+          },
+        });
+        if (alt) taskNetId = alt;
+      }
       // 多用户 Agent 权限:受限成员只能给授权且 can_message 的 Agent 发;
       // 目标不存在 / 没授权 / 只读授权 → 同一个 403,不留 alias 探测差异。发件人固定为自己的用户名。
       const restrictedSender = !!restAuth && !isAdmin && !restAuth.networkId && isAgentRestricted(restAuth.userId, taskNetId!);