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

package/src/scheduled-offline.test.ts

@@ -0,0 +1,131 @@
+// Board #757 — an offline scheduled target produces an auditable skip, not a
+// doomed task; each offline episode warns its human/Agent creator once.
+// Run: COMMHUB_DB=/tmp/board757.db bun test src/scheduled-offline.test.ts
+// PG: registered in tests/test2123-hub-postgres-ladder/run.sh.
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { register } from "./auth.js";
+import { db } from "./db.js";
+import { dispatchScheduledOccurrence, getScheduleRow } from "./scheduled-tasks.js";
+import { SCHEDULE_TARGET_OFFLINE_NOTICE_KIND, scheduledTargetOffline } from "./scheduled-offline.js";
+
+const activeDbPath = process.env.COMMHUB_DB ?? (process.env.COMMHUB_TEST_PG_URL ? "postgres" : undefined);
+if (!activeDbPath) throw new Error("scheduled-offline requires COMMHUB_DB (or COMMHUB_TEST_PG_URL) before module import");
+
+const stamp = Date.now();
+const TARGET_ID = `n_offline_target_${stamp}`;
+const TARGET = `offline-target-${stamp}`;
+const CREATOR_ID = `n_offline_creator_${stamp}`;
+const CREATOR = `offline-creator-${stamp}`;
+let NET = "", USER = "", slot = 0;
+
+function seedSchedule(createdByNodeId: string | null = null): any {
+  const id = `sched_offline_${crypto.randomUUID()}`;
+  db.run(
+    `INSERT INTO scheduled_tasks
+       (schedule_id, network_id, created_by, created_by_node_id, name, target_node_id, target_alias,
+        task_content, priority, schedule_type, schedule_json, timezone, status, next_run_at)
+     VALUES (?1, ?2, ?3, ?4, '离线巡检', ?5, ?6, 'ping', 'normal', 'interval',
+             '{"type":"interval","every_seconds":60}', 'Asia/Shanghai', 'active', datetime('now', '+1 minute'))`,
+    [id, NET, USER, createdByNodeId, TARGET_ID, TARGET],
+  );
+  return getScheduleRow(id)!;
+}
+
+function fire(schedule: any) {
+  const at = new Date(Date.UTC(2026, 9, 8, 0, 0, 0) + (++slot) * 60_000).toISOString();
+  return dispatchScheduledOccurrence(schedule, at, false, new Date());
+}
+
+function setTarget(status: "idle" | "offline", minutesAgo = 0) {
+  const seen = new Date(Date.now() - minutesAgo * 60_000).toISOString().replace("T", " ").replace(/\.\d{3}Z$/, "");
+  db.run("UPDATE sessions SET status = ?1, updated_at = ?2, last_seen_at = ?2 WHERE node_id = ?3 AND network_id = ?4", [status, seen, TARGET_ID, NET]);
+}
+
+const taskCount = () => db.get<{ n: number }>("SELECT COUNT(*) AS n FROM tasks WHERE network_id = ?1 AND to_node_id = ?2", NET, TARGET_ID)!.n;
+const humanNotices = (scheduleId: string) => db.all<{ meta_json: string; content: string }>(
+  "SELECT meta_json, content FROM user_inbox WHERE network_id = ?1 AND user_id = ?2 AND kind = ?3 ORDER BY created_at, message_id",
+  NET, USER, SCHEDULE_TARGET_OFFLINE_NOTICE_KIND,
+).filter((row) => JSON.parse(row.meta_json).schedule_target_offline.schedule_id === scheduleId);
+const agentNotices = (scheduleId: string) => db.all<{ meta_json: string; content: string }>(
+  "SELECT meta_json, content FROM inbox WHERE network_id = ?1 AND node_id = ?2 AND from_session = 'hub' ORDER BY created_at, id",
+  NET, CREATOR_ID,
+).filter((row) => JSON.parse(row.meta_json).schedule_target_offline?.schedule_id === scheduleId);
+
+beforeAll(() => {
+  const owner = register(`offline_owner_${stamp}`, "OfflineOwner123!", undefined, "seed");
+  expect(owner.ok).toBe(true);
+  NET = owner.network_id!; USER = owner.user!.user_id;
+  db.run("INSERT INTO nodes (node_id, node_name, alias, runtime, network_id, owner_user_id) VALUES (?1, ?2, ?2, 'codex', ?3, ?4)", [TARGET_ID, TARGET, NET, USER]);
+  db.run("INSERT INTO nodes (node_id, node_name, alias, runtime, network_id, owner_user_id) VALUES (?1, ?2, ?2, 'codex', ?3, ?4)", [CREATOR_ID, CREATOR, NET, USER]);
+  db.run("INSERT INTO sessions (resume_id, alias, status, node_id, network_id, last_seen_at) VALUES (?1, ?2, 'idle', ?3, ?4, datetime('now'))", [`r_target_${stamp}`, TARGET, TARGET_ID, NET]);
+  db.run("INSERT INTO sessions (resume_id, alias, status, node_id, network_id, last_seen_at) VALUES (?1, ?2, 'idle', ?3, ?4, datetime('now'))", [`r_creator_${stamp}`, CREATOR, CREATOR_ID, NET]);
+});
+
+afterAll(() => {
+  db.run("DELETE FROM user_inbox WHERE network_id = ?1 AND kind = ?2", [NET, SCHEDULE_TARGET_OFFLINE_NOTICE_KIND]);
+});
+
+describe("#757 scheduled target offline", () => {
+  test("offline skips without a task, warns a human once, and online recovery dispatches normally", () => {
+    const schedule = seedSchedule();
+    const online = fire(schedule);
+    expect(online.status).toBe("delivered");
+    db.run("UPDATE tasks SET status = 'replied' WHERE task_id = ?1", [online.taskId]);
+
+    setTarget("offline");
+    const before = taskCount();
+    const first = fire(schedule), second = fire(schedule);
+    expect([first.status, second.status]).toEqual(["skipped", "skipped"]);
+    expect(taskCount()).toBe(before);
+    for (const run of [first, second]) {
+      expect(db.get("SELECT status, error_code, task_id FROM scheduled_task_runs WHERE run_id = ?1", run.runId))
+        .toEqual({ status: "skipped", error_code: "target_offline", task_id: null });
+    }
+    expect(humanNotices(schedule.schedule_id)).toHaveLength(1);
+    expect(humanNotices(schedule.schedule_id)[0].content).toContain("恢复在线后");
+
+    setTarget("idle");
+    const recovered = fire(schedule);
+    expect(recovered.status).toBe("delivered");
+    expect(recovered.taskId).toBeTruthy();
+    db.run("UPDATE tasks SET status = 'replied' WHERE task_id = ?1", [recovered.taskId]);
+
+    setTarget("offline");
+    expect(fire(schedule).status).toBe("skipped");
+    expect(humanNotices(schedule.schedule_id)).toHaveLength(2);
+  });
+
+  test("an Agent-created schedule warns the creator inbox, never the owner's user inbox", () => {
+    const schedule = seedSchedule(CREATOR_ID);
+    setTarget("offline");
+    expect(fire(schedule).status).toBe("skipped");
+    expect(fire(schedule).status).toBe("skipped");
+    expect(agentNotices(schedule.schedule_id)).toHaveLength(1);
+    expect(agentNotices(schedule.schedule_id)[0].content).toContain("不需要回复");
+    expect(humanNotices(schedule.schedule_id)).toHaveLength(0);
+  });
+
+  test("an idle session older than the existing five-minute cutoff is offline", () => {
+    const schedule = seedSchedule();
+    setTarget("idle", 6);
+    const before = taskCount();
+    const run = fire(schedule);
+    expect(run.status).toBe("skipped");
+    expect(taskCount()).toBe(before);
+    expect(db.get<{ error_code: string }>("SELECT error_code FROM scheduled_task_runs WHERE run_id = ?1", run.runId)?.error_code).toBe("target_offline");
+  });
+
+  test("recent SQLite and ISO timestamps all keep an idle target online", () => {
+    const now = Date.now();
+    const isoMs = new Date(now - 1_000).toISOString();
+    const values = [
+      isoMs.slice(0, 19).replace("T", " "),
+      `${isoMs.slice(0, 19)}Z`,
+      isoMs,
+    ];
+    for (const value of values) {
+      db.run("UPDATE sessions SET status = 'idle', last_seen_at = ?1 WHERE node_id = ?2 AND network_id = ?3", [value, TARGET_ID, NET]);
+      expect(scheduledTargetOffline(TARGET_ID, TARGET, NET, now)).toBe(false);
+    }
+  });
+});

package/src/scheduled-offline.ts

@@ -0,0 +1,66 @@
+import { sendAgentNotice } from "./agent-notice.js";
+import { db, uuidv4 } from "./db.js";
+import { parseDbTimestampMs } from "./db-timestamp.js";
+import { pendingInboxCount } from "./inbox-count.js";
+import { pushEvent } from "./push.js";
+
+export const SCHEDULE_TARGET_OFFLINE_NOTICE_KIND = "schedule_target_offline";
+const SESSION_STALE_MS = 5 * 60_000;
+
+type SessionRow = { status: string | null; updated_at: string | null; last_seen_at: string | null };
+
+/** Same status + five-minute timestamp rule as the existing task delivery resolver. */
+export function scheduledTargetOffline(nodeId: string, alias: string, networkId: string, nowMs = Date.now()): boolean {
+  const session = db.get<SessionRow>(
+    "SELECT status, updated_at, last_seen_at FROM sessions WHERE node_id = ?1 AND network_id = ?2 ORDER BY updated_at DESC LIMIT 1",
+    nodeId, networkId,
+  ) ?? db.get<SessionRow>(
+    "SELECT status, updated_at, last_seen_at FROM sessions WHERE alias = ?1 AND network_id = ?2 AND node_id IS NULL ORDER BY updated_at DESC LIMIT 1",
+    alias, networkId,
+  );
+  if (!session) return true;
+  const raw = session.last_seen_at || session.updated_at;
+  const seen = raw ? parseDbTimestampMs(raw) : 0;
+  return String(session.status || "").toLowerCase() === "offline" || !Number.isFinite(seen) || nowMs - seen > SESSION_STALE_MS;
+}
+
+export type OfflineNotice = {
+  scheduleId: string; scheduleName: string; networkId: string;
+  createdBy: string | null; createdByNodeId: string | null;
+  targetAlias: string;
+};
+
+function noticeText(n: OfflineNotice): string {
+  return `定时任务「${n.scheduleName}」的目标节点 ${n.targetAlias} 已离线，本轮已跳过且没有创建任务。节点恢复在线后，后续轮次会自动照常派发。`;
+}
+
+/** Post-commit delivery. The transaction has already claimed this offline episode. */
+export function sendOfflineNotice(n: OfflineNotice): string | null {
+  try {
+    const text = noticeText(n);
+    const meta = { schedule_target_offline: { schedule_id: n.scheduleId, target_alias: n.targetAlias, reason: "target_offline" } };
+    if (!n.createdByNodeId) {
+      if (!n.createdBy) return null;
+      return sendAgentNotice({
+        networkId: n.networkId, userId: n.createdBy, fromAlias: n.targetAlias,
+        kind: SCHEDULE_TARGET_OFFLINE_NOTICE_KIND, title: "定时任务目标节点离线", text,
+        severity: "warning", meta, idPrefix: "dm_sched_offline_",
+      });
+    }
+    const creator = db.get<{ alias: string | null }>(
+      "SELECT alias FROM nodes WHERE node_id = ?1 AND network_id = ?2", n.createdByNodeId, n.networkId,
+    );
+    if (!creator?.alias) return null;
+    const id = `sched_offline_${uuidv4()}`;
+    db.run(
+      `INSERT INTO inbox (id, session_name, node_id, type, priority, content, from_session, network_id, meta_json)
+       VALUES (?1, ?2, ?3, 'message', 'normal', ?4, 'hub', ?5, ?6)`,
+      [id, creator.alias, n.createdByNodeId, `[定时任务目标节点离线] ${text}\n(这是告警，不需要回复。)`, n.networkId, JSON.stringify(meta)],
+    );
+    pushEvent(creator.alias, { type: "new_message", inbox_count: pendingInboxCount(creator.alias, n.networkId), from: "hub", message_id: id }, n.networkId);
+    return id;
+  } catch (e: any) {
+    console.error(`[scheduled-tasks] offline notice failed schedule=${n.scheduleId}: ${e?.message || e}`);
+    return null;
+  }
+}

package/src/scheduled-reply-unread-http.test.ts

@@ -0,0 +1,212 @@
+// 定时任务的回复要进建排程那个人的未读(Vincent 2026-09-30「定时任务触发的…那个红点它是不显示的」)。
+//
+// scheduler 派的任务 from_name='scheduler',回复以前按 from_name 落进 inbox(session_name='scheduler'):
+// app 会话里看得到(会话取自 tasks 表),但 unread_by_agent 只数 session_name=用户名 的行 ⇒ 永远没红点。
+// 这里走真 Hub(bootServer)+ 真节点令牌回复路径(send_reply,callerTokenIsNetwork=true)。
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { addNetworkMember, createNetworkTokenForNode, register } from "./auth.js";
+import { db } from "./db.js";
+import { runDueScheduledTasks } from "./scheduled-tasks.js";
+import { registerTools } from "./tools.js";
+
+const activeDbPath = process.env.COMMHUB_DB ?? (process.env.COMMHUB_TEST_PG_URL ? "postgres" : undefined);
+if (!activeDbPath) throw new Error("scheduled-reply-unread requires COMMHUB_DB (or COMMHUB_TEST_PG_URL) before module import");
+
+let server: any;
+let base = "";
+let ownerToken = "";
+let ownerName = "";
+let memberToken = "";
+let memberName = "";
+let networkId = "";
+let ownerId = "";
+const stamp = Date.now();
+const ALIAS = `sched-reply-node-${stamp}`;
+const nodeId = `n_sched_reply_${stamp}`;
+
+async function api(token: string, path: string, init?: RequestInit) {
+  const res = await fetch(`${base}${path}`, {
+    ...init,
+    headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json", ...(init?.headers || {}) },
+  });
+  return { status: res.status, body: await res.json() as any };
+}
+
+/** 节点令牌身份调 send_reply(与真节点的 commhub_reply 同一个 handler、同一组归属校验)。 */
+async function nodeReply(args: Record<string, unknown>): Promise<any> {
+  const mcp = new McpServer({ name: "sched-reply", version: "0" }) as any;
+  const handlers: Record<string, (a: any) => Promise<any>> = {};
+  const original = mcp.tool.bind(mcp);
+  mcp.tool = (name: string, ...rest: any[]) => {
+    const handler = rest.at(-1);
+    if (typeof handler === "function") handlers[name] = handler;
+    return original(name, ...rest);
+  };
+  registerTools(mcp, undefined, networkId, ownerId, ALIAS, true, null);
+  const out = await handlers.send_reply(args);
+  return JSON.parse(out.content[0].text);
+}
+
+async function unreadFor(token: string): Promise<Record<string, number>> {
+  const res = await api(token, "/api/messages?scope=user&limit=50");
+  expect(res.status).toBe(200);
+  return res.body.unread_by_agent ?? {};
+}
+
+async function ackAgent(token: string) {
+  const res = await api(token, "/api/messages/ack", { method: "POST", body: JSON.stringify({ agent: ALIAS }) });
+  expect(res.status).toBe(200);
+  return res.body;
+}
+
+/** 建一个排程、让它立刻到期、跑一次,返回它派出的 task_id。 */
+async function fireSchedule(token: string, name: string): Promise<{ scheduleId: string; taskId: string }> {
+  const created = await api(token, "/api/scheduled-tasks", {
+    method: "POST",
+    body: JSON.stringify({
+      network_id: networkId, name, target_node_id: nodeId, task: `${name} tick`,
+      timezone: "UTC", schedule: { type: "interval", every_seconds: 120 },
+    }),
+  });
+  expect(created.status).toBe(201);
+  const scheduleId = created.body.schedule.schedule_id as string;
+  // 别的排程不许在这次 sweep 里一起跑
+  db.run("UPDATE scheduled_tasks SET next_run_at = ?1 WHERE schedule_id != ?2", [new Date(Date.now() + 24 * 3600_000).toISOString(), scheduleId]);
+  db.run("UPDATE scheduled_tasks SET next_run_at = ?1 WHERE schedule_id = ?2", [new Date(Date.now() - 60_000).toISOString(), scheduleId]);
+  await runDueScheduledTasks();
+  const run = db.get<{ task_id: string | null }>(
+    "SELECT task_id FROM scheduled_task_runs WHERE schedule_id = ?1 ORDER BY scheduled_for DESC LIMIT 1", scheduleId,
+  );
+  expect(run?.task_id).toBeTruthy();
+  const task = db.get<{ from_name: string }>("SELECT from_name FROM tasks WHERE task_id = ?1", run!.task_id!);
+  expect(task?.from_name).toBe("scheduler");
+  return { scheduleId, taskId: run!.task_id! };
+}
+
+function replyRow(taskId: string) {
+  return db.get<{ session_name: string; from_session: string; acked: number }>(
+    "SELECT session_name, from_session, acked FROM inbox WHERE type = 'reply' AND in_reply_to = ?1", taskId,
+  );
+}
+
+beforeAll(async () => {
+  ownerName = `sched_reply_owner_${stamp}`;
+  const owner = register(ownerName, "SchedReplyOwner123!", undefined, "seed");
+  expect(owner.ok).toBe(true);
+  ownerToken = owner.token!;
+  networkId = owner.network_id!;
+  ownerId = db.get<{ owner_id: string }>("SELECT owner_id FROM networks WHERE network_id = ?1", networkId)!.owner_id;
+
+  memberName = `sched_reply_member_${stamp}`;
+  const member = register(memberName, "SchedReplyMember123!", undefined, "seed");
+  expect(member.ok).toBe(true);
+  memberToken = member.token!;
+  const memberId = db.get<{ user_id: string }>("SELECT user_id FROM users WHERE username = ?1", memberName)!.user_id;
+  expect(addNetworkMember(networkId, memberId, "member", ownerId, { agentAccess: "all" }).ok).toBe(true);
+
+  expect(createNetworkTokenForNode(ownerId, networkId, ALIAS).ok).toBe(true);
+  db.run(
+    "INSERT INTO nodes (node_id, node_name, alias, runtime, network_id) VALUES (?1, ?2, ?2, 'claude-code', ?3)",
+    [nodeId, ALIAS, networkId],
+  );
+  db.run(
+    "INSERT INTO sessions (resume_id, alias, status, node_id, network_id) VALUES (?1, ?2, 'idle', ?3, ?4)",
+    [`r_sched_reply_${stamp}`, ALIAS, nodeId, networkId],
+  );
+  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}`;
+}, 30_000);
+
+afterAll(() => {
+  try { server?.stop?.(true); } catch {}
+});
+
+describe("scheduled-task replies reach the schedule creator's unread", () => {
+  test("a direct reply still lands on the sender and counts once", async () => {
+    await ackAgent(ownerToken);
+    const sent = await api(ownerToken, "/api/task", { method: "POST", body: JSON.stringify({ network_id: networkId, alias: ALIAS, task: "direct hello" }) });
+    expect(sent.status).toBe(200);
+    const taskId = sent.body.task_id as string;
+    const reply = await nodeReply({ in_reply_to: taskId, text: "direct answer", status: "replied" });
+    expect(reply.ok).toBe(true);
+    expect(replyRow(taskId)?.session_name).toBe(ownerName);
+    expect((await unreadFor(ownerToken))[ALIAS]).toBe(1);
+    await ackAgent(ownerToken);
+    expect((await unreadFor(ownerToken))[ALIAS]).toBeUndefined();
+  });
+
+  test("a scheduled-task reply counts for the creator, and ack-by-agent clears it", async () => {
+    await ackAgent(ownerToken);
+    const { taskId } = await fireSchedule(ownerToken, "owner-every-2m");
+    // 节点不带 alias(SDK 运行时)——收件人由 in_reply_to 推出
+    const reply = await nodeReply({ in_reply_to: taskId, text: "tick answer", status: "replied" });
+    expect(reply.ok).toBe(true);
+    expect(replyRow(taskId)).toEqual({ session_name: ownerName, from_session: ALIAS, acked: 0 });
+    expect(db.get<{ status: string; result: string }>("SELECT status, result FROM tasks WHERE task_id = ?1", taskId))
+      .toEqual({ status: "replied", result: "tick answer" });
+    expect((await unreadFor(ownerToken))[ALIAS]).toBe(1);
+
+    const acked = await ackAgent(ownerToken);
+    expect(acked.acked_inbox).toBe(1);
+    expect((await unreadFor(ownerToken))[ALIAS]).toBeUndefined();
+    expect(replyRow(taskId)?.acked).toBe(1);
+  });
+
+  test("a node that names alias='scheduler' explicitly is routed the same way", async () => {
+    await ackAgent(ownerToken);
+    const { taskId } = await fireSchedule(ownerToken, "owner-explicit-alias");
+    const reply = await nodeReply({ alias: "scheduler", in_reply_to: taskId, text: "explicit answer", status: "replied" });
+    expect(reply.ok).toBe(true);
+    expect(replyRow(taskId)?.session_name).toBe(ownerName);
+    expect((await unreadFor(ownerToken))[ALIAS]).toBe(1);
+    await ackAgent(ownerToken);
+  });
+
+  test("another member of the network does not get the owner's scheduled reply, and gets their own", async () => {
+    await ackAgent(ownerToken);
+    await ackAgent(memberToken);
+    const ownerRun = await fireSchedule(ownerToken, "owner-only");
+    expect((await nodeReply({ in_reply_to: ownerRun.taskId, text: "for owner", status: "replied" })).ok).toBe(true);
+    expect((await unreadFor(memberToken))[ALIAS]).toBeUndefined();
+    expect((await unreadFor(ownerToken))[ALIAS]).toBe(1);
+
+    const memberRun = await fireSchedule(memberToken, "member-only");
+    expect((await nodeReply({ in_reply_to: memberRun.taskId, text: "for member", status: "replied" })).ok).toBe(true);
+    expect(replyRow(memberRun.taskId)?.session_name).toBe(memberName);
+    expect((await unreadFor(memberToken))[ALIAS]).toBe(1);
+    expect((await unreadFor(ownerToken))[ALIAS]).toBe(1);
+    await ackAgent(ownerToken);
+    await ackAgent(memberToken);
+  });
+
+  test("a schedule with no creator falls back to 'scheduler'", async () => {
+    await ackAgent(ownerToken);
+    const { scheduleId, taskId } = await fireSchedule(ownerToken, "creatorless");
+    db.run("UPDATE scheduled_tasks SET created_by = NULL WHERE schedule_id = ?1", [scheduleId]);
+    expect((await nodeReply({ in_reply_to: taskId, text: "nobody's", status: "replied" })).ok).toBe(true);
+    expect(replyRow(taskId)?.session_name).toBe("scheduler");
+    expect((await unreadFor(ownerToken))[ALIAS]).toBeUndefined();
+  });
+
+  test("a creator whose username is also a node alias falls back to 'scheduler' (the collision guard)", async () => {
+    await ackAgent(ownerToken);
+    const { taskId } = await fireSchedule(ownerToken, "colliding-creator");
+    const clashNodeId = `n_clash_${stamp}`;
+    db.run(
+      "INSERT INTO nodes (node_id, node_name, alias, runtime, network_id) VALUES (?1, ?2, ?2, 'claude-code', ?3)",
+      [clashNodeId, ownerName, networkId],
+    );
+    try {
+      expect((await nodeReply({ in_reply_to: taskId, text: "not a todo", status: "replied" })).ok).toBe(true);
+      // 那个同名节点收不到这条(它不是节点的待办),用户名也拿不到(inbox 半边整体跳过)
+      expect(replyRow(taskId)?.session_name).toBe("scheduler");
+      expect(db.get<{ n: number }>(
+        "SELECT COUNT(*) AS n FROM inbox WHERE session_name = ?1 AND in_reply_to = ?2", ownerName, taskId,
+      )?.n).toBe(0);
+    } finally {
+      db.run("DELETE FROM nodes WHERE node_id = ?1", [clashNodeId]);
+    }
+  });
+});