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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sleep2agi/commhub-server",
-  "version": "0.9.0-preview.140",
+  "version": "0.9.0-preview.142",
   "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/db.ts

@@ -1734,6 +1734,14 @@ try { db.exec("ALTER TABLE scheduled_task_runs ADD COLUMN blocked_by_state TEXT"
 // Board #733 — schedules an Agent created over MCP name the creating node. NULL = created by a person
 // (REST / Dashboard) or a row from before this column; old rows keep NULL and old code never reads it.
 try { db.exec("ALTER TABLE scheduled_tasks ADD COLUMN created_by_node_id TEXT"); } catch {}
+
+try { db.exec(`CREATE TABLE IF NOT EXISTS scheduled_task_watchers (
+  schedule_id TEXT NOT NULL,
+  user_id TEXT NOT NULL,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  PRIMARY KEY (schedule_id, user_id)
+)`); } catch {}
+try { db.exec("CREATE INDEX IF NOT EXISTS idx_scheduled_task_watchers_user ON scheduled_task_watchers(user_id)"); } catch {}
 try { db.exec("CREATE INDEX IF NOT EXISTS idx_scheduled_tasks_creator_node ON scheduled_tasks(network_id, created_by_node_id)"); } catch {}
 // #523 — consecutive-failure alert bookkeeping (scheduled-failures.ts). Additive and nullable:
 // an older Hub never reads them, so rolling back is safe. failure_alert_at = ISO time of the last

package/src/rest-explicit-columns-http.test.ts

@@ -76,7 +76,7 @@ const GOLDEN_RESPONSE_KEYS = {
     "schedule_id", "network_id", "name", "target_node_id", "target_alias",
     "task_content", "priority", "schedule_type", "timezone", "overlap_policy",
     "misfire_policy", "status", "next_run_at", "last_run_at", "revision",
-    "created_at", "updated_at", "schedule",
+    "created_at", "updated_at", "schedule", "watchers", "is_watcher", "can_edit", "can_manage_watchers",
   ],
 } as const;
 

package/src/scheduled-tasks-http.test.ts

@@ -635,4 +635,45 @@ describe("Hub scheduled task API and dispatcher", () => {
     const runs = await api(ownerToken, `/api/scheduled-tasks/${scheduleId}/runs?network_id=${encodeURIComponent(networkId)}`);
     expect(runs.body.runs.length).toBeGreaterThanOrEqual(4);
   });
+
+  test("a watcher can edit the schedule but cannot cancel it or change watchers", async () => {
+    const viewerId = db.get<{ user_id: string }>("SELECT user_id FROM network_members WHERE network_id = ?1 AND role = 'viewer'", networkId)!.user_id;
+    const schedule = await createSchedule(`watchers-${Date.now()}`);
+    const bound = await api(ownerToken, `/api/scheduled-tasks/${schedule.schedule_id}?network_id=${encodeURIComponent(networkId)}`, {
+      method: "PATCH",
+      body: JSON.stringify({ revision: schedule.revision, watchers: [viewerId] }),
+    });
+    expect(bound.status).toBe(200);
+    expect(bound.body.schedule.watchers.map((w: { user_id: string }) => w.user_id)).toEqual([viewerId]);
+    expect(bound.body.schedule.can_manage_watchers).toBe(true);
+
+    const listed = await api(viewerToken, `/api/scheduled-tasks?network_id=${encodeURIComponent(networkId)}`);
+    const row = listed.body.schedules.find((item: { schedule_id: string }) => item.schedule_id === schedule.schedule_id);
+    expect(row?.is_watcher).toBe(true);
+    expect(row?.can_edit).toBe(true);
+    expect(row?.can_manage_watchers).toBe(false);
+
+    const edited = await api(viewerToken, `/api/scheduled-tasks/${schedule.schedule_id}?network_id=${encodeURIComponent(networkId)}`, {
+      method: "PATCH",
+      body: JSON.stringify({ revision: row.revision, name: "edited by watcher" }),
+    });
+    expect(edited.status).toBe(200);
+    expect(edited.body.schedule.name).toBe("edited by watcher");
+
+    const manage = await api(viewerToken, `/api/scheduled-tasks/${schedule.schedule_id}?network_id=${encodeURIComponent(networkId)}`, {
+      method: "PATCH",
+      body: JSON.stringify({ revision: edited.body.schedule.revision, watchers: [] }),
+    });
+    expect(manage.status).toBe(403);
+    expect(manage.body.error).toBe("watcher_cannot_manage_watchers");
+
+    const cancel = await api(viewerToken, `/api/scheduled-tasks/${schedule.schedule_id}/cancel?network_id=${encodeURIComponent(networkId)}`, { method: "POST", body: "{}" });
+    expect(cancel.status).toBe(403);
+    expect(cancel.body.error).toBe("watcher_cannot_cancel");
+
+    const runNow = await api(viewerToken, `/api/scheduled-tasks/${schedule.schedule_id}/run-now?network_id=${encodeURIComponent(networkId)}`, { method: "POST", body: "{}" });
+    expect(runNow.status).toBe(403);
+    expect(runNow.body.error).toBe("watcher_cannot_run");
+  });
+
 });

package/src/scheduled-tasks.ts

@@ -735,6 +735,63 @@ function writeAllowed(ctx: ScheduledRequestContext, networkId: string | null): b
   return !ctx.isNodeToken && canRestWriteNetwork(ctx.auth, networkId, ctx.isAdmin);
 }
 
+
+type WatcherPublic = { user_id: string; username: string; display_name: string };
+
+function scheduleWatchers(scheduleId: string): WatcherPublic[] {
+  return db.all<{ user_id: string; username: string; display_name: string | null }>(
+    `SELECT w.user_id, u.username, u.display_name
+     FROM scheduled_task_watchers w JOIN users u ON u.user_id = w.user_id
+     WHERE w.schedule_id = ?1 ORDER BY u.username`,
+    [scheduleId],
+  ).map(row => ({ user_id: row.user_id, username: row.username, display_name: row.display_name ?? "" }));
+}
+
+function userInNetwork(userId: string, networkId: string): boolean {
+  if (db.get("SELECT 1 AS ok FROM network_members WHERE network_id = ?1 AND user_id = ?2", [networkId, userId])) return true;
+  return !!db.get("SELECT 1 AS ok FROM networks WHERE network_id = ?1 AND owner_id = ?2", [networkId, userId]);
+}
+
+function replaceScheduleWatchers(scheduleId: string, networkId: string, raw: unknown): void {
+  if (!Array.isArray(raw) || raw.length > 20) throw new ScheduleInputError("invalid_watchers", 400);
+  const ids: string[] = [];
+  for (const item of raw) {
+    const id = typeof item === "string" ? item : item && typeof item === "object" && typeof (item as { user_id?: unknown }).user_id === "string" ? (item as { user_id: string }).user_id : "";
+    if (!id || id.length > 200) throw new ScheduleInputError("invalid_watchers", 400);
+    if (!ids.includes(id)) ids.push(id);
+  }
+  for (const id of ids) {
+    if (!userInNetwork(id, networkId)) throw new ScheduleInputError("watcher_not_in_network", 400, { user_id: id });
+  }
+  db.run("DELETE FROM scheduled_task_watchers WHERE schedule_id = ?1", [scheduleId]);
+  for (const id of ids) db.run("INSERT INTO scheduled_task_watchers (schedule_id, user_id) VALUES (?1, ?2)", [scheduleId, id]);
+}
+
+function watchingSchedule(scheduleId: string, userId: string | null): boolean {
+  if (!userId) return false;
+  return !!db.get("SELECT 1 AS ok FROM scheduled_task_watchers WHERE schedule_id = ?1 AND user_id = ?2", [scheduleId, userId]);
+}
+
+function canManageWatchers(row: ScheduledRow, ctx: ScheduledRequestContext): boolean {
+  const uid = ctx.auth?.userId ?? null;
+  if (ctx.isAdmin) return true;
+  if (uid && row.created_by === uid) return true;
+  return !row.created_by && writeAllowed(ctx, row.network_id);
+}
+
+function decorateSchedule(row: ScheduledRow, ctx: ScheduledRequestContext): Record<string, unknown> {
+  const watchers = scheduleWatchers(row.schedule_id);
+  const uid = ctx.auth?.userId ?? null;
+  const isWatcher = !!uid && watchers.some(w => w.user_id === uid);
+  return {
+    ...decodeRow(row),
+    watchers,
+    is_watcher: isWatcher,
+    can_edit: writeAllowed(ctx, row.network_id) || isWatcher,
+    can_manage_watchers: canManageWatchers(row, ctx),
+  };
+}
+
 export async function handleScheduledTaskRequest(ctx: ScheduledRequestContext): Promise<Response | null> {
   const { req, url } = ctx;
   if (url.pathname !== "/api/scheduled-tasks" && !url.pathname.startsWith("/api/scheduled-tasks/")) return null;
@@ -747,7 +804,7 @@ export async function handleScheduledTaskRequest(ctx: ScheduledRequestContext):
     const status = url.searchParams.get("status");
     if (status) { sql += ` AND status = ?${params.length + 1}`; params.push(status); }
     sql += " ORDER BY updated_at DESC LIMIT 500";
-    return Response.json({ ok: true, schedules: db.all<ScheduledRow>(sql, ...params).map(decodeRow) });
+    return Response.json({ ok: true, schedules: db.all<ScheduledRow>(sql, ...params).map(row => decorateSchedule(row, ctx)) });
   }
 
   if (url.pathname === "/api/scheduled-tasks" && req.method === "POST") {
@@ -758,8 +815,10 @@ export async function handleScheduledTaskRequest(ctx: ScheduledRequestContext):
     if (!writeAllowed(ctx, networkId)) return jsonError("permission_denied", 403);
     try {
       const created = insertSchedule(networkId, ctx.auth?.userId ?? null, null, validateScheduleCreate(networkId, body));
-      return Response.json({ ok: true, schedule: decodeRow(created) }, { status: 201 });
+      if (body.watchers !== undefined) replaceScheduleWatchers(created.schedule_id, networkId, body.watchers);
+      return Response.json({ ok: true, schedule: decorateSchedule(getScheduleRow(created.schedule_id)!, ctx) }, { status: 201 });
     } catch (e: any) {
+      if (e instanceof ScheduleInputError) return jsonError(e.code, e.status, e.extra);
       const code = String(e?.message || "invalid_schedule");
       const status = code === "target_node_not_found" ? 404 : 400;
       return jsonError(code, status);
@@ -777,8 +836,12 @@ export async function handleScheduledTaskRequest(ctx: ScheduledRequestContext):
     const limit = Math.max(1, Math.min(200, Number(url.searchParams.get("limit")) || 50));
     return Response.json({ ok: true, ...scheduleRuns(row, limit) });
   }
-  if (!sub && req.method === "GET") return Response.json({ ok: true, schedule: decodeRow(row) });
-  if (!writeAllowed(ctx, row.network_id)) return jsonError("permission_denied", 403);
+  if (!sub && req.method === "GET") return Response.json({ ok: true, schedule: decorateSchedule(row, ctx) });
+  const watcher = watchingSchedule(row.schedule_id, ctx.auth?.userId ?? null);
+  const writer = writeAllowed(ctx, row.network_id);
+  if (!writer && !watcher) return jsonError("permission_denied", 403);
+  if (!writer && (sub === "cancel" || (!sub && req.method === "DELETE"))) return jsonError("watcher_cannot_cancel", 403);
+  if (!writer && sub === "run-now") return jsonError("watcher_cannot_run", 403);
 
   if (sub === "run-now" && req.method === "POST") {
     if (row.status === "cancelled") return jsonError("schedule_cancelled", 409);
@@ -808,8 +871,11 @@ export async function handleScheduledTaskRequest(ctx: ScheduledRequestContext):
   if (!sub && req.method === "PATCH") {
     let body: Record<string, unknown>;
     try { body = await bodyObject(req); } catch { return jsonError("invalid_json", 400); }
+    if (body.watchers !== undefined && !canManageWatchers(row, ctx)) return jsonError("watcher_cannot_manage_watchers", 403);
     try {
-      return Response.json({ ok: true, schedule: decodeRow(patchSchedule(row, body, ctx.auth?.userId ?? null)) });
+      const updated = patchSchedule(row, body, ctx.auth?.userId ?? null);
+      if (body.watchers !== undefined) replaceScheduleWatchers(updated.schedule_id, updated.network_id, body.watchers);
+      return Response.json({ ok: true, schedule: decorateSchedule(getScheduleRow(updated.schedule_id)!, ctx) });
     } catch (e: any) {
       if (e instanceof ScheduleInputError) return jsonError(e.code, e.status, e.extra);
       throw e;

package/src/stop-delete-node.test.ts

@@ -961,6 +961,65 @@ describe("RFC-027 PR1.2a — restart_node resets lifecycle_state to 'active'", (
   });
 });
 
+// ── #1511 — restart_node 在途任务默认拒绝（只提示，不自动重启） ──────
+//
+// 节点侧 exit-75 的 drain 只等 60 秒，超时会硬打断当前回合；所以「正在跑
+// 任务」时 Hub 端在派发前就拒绝，计数规则与 stop_node 完全同一份
+// （#2022/#2029 修订版，实现在 countInFlightTasks）。客户端语义：保存密钥
+// 后若节点忙，不安排重启，只提示等任务完成或去节点机器上手动重启。
+describe("restart_node — in-flight default-refuse (#1511)", () => {
+  test("live task row → node_busy_in_flight, no dispatch row, state untouched", async () => {
+    setupAlphaNetwork();
+    seedTaskWithInbox(NET_A, CHILD_A_ALIAS, { task_id: "task_1511_live", status: "delivered" });
+    const r = await call(buildHandlers(USER_A_ID).restart_node, { node_id: CHILD_A_ID, network_id: NET_A });
+    expect(r.ok).toBe(false);
+    expect(r.error).toBe("node_busy_in_flight");
+    expect(r.in_flight_count).toBe(1);
+    expect(typeof r.hint).toBe("string");
+    const rows = db.all<{ update_id: string }>(`SELECT update_id FROM node_config_updates WHERE node_id = ?1`, [CHILD_A_ID]);
+    expect(rows.length).toBe(0);
+    expect(readNode(CHILD_A_ID)?.lifecycle_state).toBe("active");
+  });
+
+  test("unacked legacy inbox rows count too — same rule as stop", async () => {
+    setupAlphaNetwork();
+    seedInbox(NET_A, CHILD_A_ALIAS, 2);
+    const r = await call(buildHandlers(USER_A_ID).restart_node, { node_id: CHILD_A_ID, network_id: NET_A });
+    expect(r.ok).toBe(false);
+    expect(r.error).toBe("node_busy_in_flight");
+    expect(r.in_flight_count).toBe(2);
+  });
+
+  test("terminal-only rows → restart dispatches (parity with #2022 stop rule)", async () => {
+    setupAlphaNetwork();
+    seedTaskWithInbox(NET_A, CHILD_A_ALIAS, { task_id: "task_1511_replied", status: "replied" });
+    const r = await call(buildHandlers(USER_A_ID).restart_node, { node_id: CHILD_A_ID, network_id: NET_A });
+    expect(r.ok).toBe(true);
+    expect(r.apply_mode).toBe("restart_only");
+  });
+
+  test("2h-old live task is never aged out — status wins over age (same as stop)", async () => {
+    setupAlphaNetwork();
+    seedTaskWithInbox(NET_A, CHILD_A_ALIAS, {
+      task_id: "task_1511_running_120m", status: "running",
+      task_age: "-120 minutes", inbox_age: "-120 minutes", expires_in: "-60 minutes",
+    });
+    const r = await call(buildHandlers(USER_A_ID).restart_node, { node_id: CHILD_A_ID, network_id: NET_A });
+    expect(r.ok).toBe(false);
+    expect(r.error).toBe("node_busy_in_flight");
+  });
+
+  test("stopped node + live-row corpse → restart still dispatches (un-stop must not be blocked)", async () => {
+    setupAlphaNetwork();
+    db.run(`UPDATE nodes SET lifecycle_state = 'stopped' WHERE node_id = ?1`, [CHILD_A_ID]);
+    seedTaskWithInbox(NET_A, CHILD_A_ALIAS, { task_id: "task_1511_corpse", status: "delivered" });
+    const r = await call(buildHandlers(USER_A_ID).restart_node, { node_id: CHILD_A_ID, network_id: NET_A });
+    expect(r.ok).toBe(true);
+    expect(r.apply_mode).toBe("restart_only");
+    expect(readNode(CHILD_A_ID)?.lifecycle_state).toBe("active");
+  });
+});
+
 // ── #1286 stale-deleting 重派出口 ──────────────────────────────────
 //
 // 修复前 daemon 丢 ack 会让行永远停在 deleting：重发被挡、force 也一样。

package/src/tools.ts

@@ -4160,6 +4160,28 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
   );
 
 
+  // #1511 — stop_node（§4.3 D4）与 restart_node 共用的「在途任务」计数。
+  // 计数规则见 stop_node 内的长注释（#2022/#2029 修订：能成为「本节点正在做的
+  // 工作」的行才算——tasks 行按状态判、终态不算且不设龄上限；无状态行按 60 分钟
+  // 龄判）。抽成一处后，两个闸门共享同一份 SQL，不再各自漂移。
+  const IN_FLIGHT_MAX_AGE_MINUTES = 60;
+  function countInFlightTasks(alias: string, networkId: string | null): number {
+    const row = db.get<{ n: number }>(
+      `SELECT COUNT(*) AS n FROM inbox i
+         LEFT JOIN tasks t
+           ON i.type = 'task'
+          AND t.task_id = COALESCE(i.task_id, i.id)
+        WHERE i.session_name = ?1 AND i.acked = 0
+          AND COALESCE(i.network_id, ?2) = ?2
+          AND ((t.task_id IS NOT NULL
+                AND t.status NOT IN ('replied', 'failed', 'cancelled', 'expired'))
+            OR (t.task_id IS NULL
+                AND i.created_at >= datetime('now', ?3)))`,
+      alias, networkId, `-${IN_FLIGHT_MAX_AGE_MINUTES} minutes`,
+    );
+    return row?.n ?? 0;
+  }
+
   server.tool(
     "restart_node",
     "Trigger a node restart without changing config. RFC-024 Vincent 2026-06-28 increment. Network-scoped (SEC-1); member+ role suffices (lifecycle ops are not privilege elevation).",
@@ -4189,6 +4211,27 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
         return { content: [{ type: "text" as const, text: JSON.stringify({ ok: false,
           error: "adopted_restart_requires_daemon", message: "Use Stop, then Start for this adopted node." }) }] };
       }
+      // #1511 — 正在跑任务时不自动重启，只提示。节点侧 exit-75 的 drain 只等
+      // 60 秒、超时会硬打断当前回合（agent-node cli.ts drainInFlightThink），
+      // 所以 Hub 端在派发前就按 stop_node 同一条在途计数规则拒绝，客户端拿到
+      // 明确二选一：等任务完成后重试，或到节点所在机器手动重启。
+      //
+      // 只对 active 节点生效。stopped 节点的进程已死、任务不可能正在跑，其
+      // unacked 行是 stop 留下的尸体；restart_node 在 stopped 节点上是把
+      // lifecycle 翻回 active 的出口，不能用尸体行把这条路堵死。
+      // lifecycle_state 需单独取：resolveTargetNode 的 SELECT 不含该列。
+      const restartLifecycle = db.get<{ lifecycle_state: string | null }>(
+        "SELECT lifecycle_state FROM nodes WHERE node_id = ?1", nodeId,
+      )?.lifecycle_state ?? null;
+      if (restartLifecycle === "active") {
+        const busyCount = countInFlightTasks(node.alias, node.network_id);
+        if (busyCount > 0) {
+          return { content: [{ type: "text" as const, text: JSON.stringify({
+            ok: false, error: "node_busy_in_flight", in_flight_count: busyCount,
+            hint: "节点正在执行任务，本次未安排重启；等它完成后再试，或到节点所在机器手动重启",
+          }) }] };
+        }
+      }
       // F-B reaper: same stale-supersede semantics as update_node_config,
       // with same acked_at-anchored liveness clock (see update_node_config
       // for the 通信龙 polish reasoning).
@@ -5449,21 +5492,8 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
     //      ever retire them, so they get the age ceiling
     //      IN_FLIGHT_MAX_AGE_MINUTES on inbox.created_at.
     // The count stays a per-alias inbox count: one PK join per row.
-    const IN_FLIGHT_MAX_AGE_MINUTES = 60;
-    const inFlightRow = db.get<{ n: number }>(
-      `SELECT COUNT(*) AS n FROM inbox i
-         LEFT JOIN tasks t
-           ON i.type = 'task'
-          AND t.task_id = COALESCE(i.task_id, i.id)
-        WHERE i.session_name = ?1 AND i.acked = 0
-          AND COALESCE(i.network_id, ?2) = ?2
-          AND ((t.task_id IS NOT NULL
-                AND t.status NOT IN ('replied', 'failed', 'cancelled', 'expired'))
-            OR (t.task_id IS NULL
-                AND i.created_at >= datetime('now', ?3)))`,
-      node.alias, node.network_id, `-${IN_FLIGHT_MAX_AGE_MINUTES} minutes`,
-    );
-    const inFlight = inFlightRow?.n ?? 0;
+    // 计数实现在上方 countInFlightTasks。#1511 让 restart_node 共用同一份规则，判据本身未变。
+    const inFlight = countInFlightTasks(node.alias, node.network_id);
     if (inFlight > 0 && !args.force) {
       return { ok: false, error: "node_busy_in_flight", in_flight_count: inFlight, hint: "set force=true to override (audit logged)" };
     }