@sleep2agi/commhub-server 0.9.0-preview.117 → 0.9.0-preview.118

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sleep2agi/commhub-server",
-  "version": "0.9.0-preview.117",
+  "version": "0.9.0-preview.118",
   "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/node-permissions.ts

@@ -271,6 +271,7 @@ export const NODE_TOOL_CLASS: Readonly<Record<string, ToolClass>> = {
   // 定时任务(#733):在 schedule-agent.ts 里按排程判(范围 / 目标 = send_task 的 dispatchVerdict / 配额)
   schedule_list: "read", schedule_get: "read", schedule_runs: "read",
   schedule_create: "schedule", schedule_update: "schedule", schedule_cancel: "schedule", schedule_run_now: "schedule",
+  schedule_batch_interval: "schedule",
   // 写节点 / 技能 / 探测:只读、受限不行;正常由 RFC-036 等既有规则管
   update_node_config: "node_write", write_node_rules_file: "node_write", restart_node: "node_write", create_node: "node_write",
   stop_node: "node_write", delete_node: "node_write", start_node: "node_write", submit_skill: "node_write", probe_provider_model: "node_write",

package/src/schedule-agent-mcp-http.test.ts

@@ -161,6 +161,72 @@ describe("happy path from a node", () => {
   });
 });
 
+describe("batch interval updates (#816)", () => {
+  const batch = (token: string, schedule_ids: string[], every_seconds = 600) =>
+    mcp(token, "schedule_batch_interval", { schedule_ids, every_seconds });
+  const get = async (id: string) => (await mcp(node.b.token, "schedule_get", { schedule_id: id })).schedule;
+
+  test("two updates, deduplicated IDs, paused stays paused, unselected stays untouched", async () => {
+    const a = (await create("b")).schedule, b = (await create("b")).schedule;
+    const untouched = (await create("b")).schedule;
+    await mcp(node.b.token, "schedule_update", { schedule_id: b.schedule_id, status: "paused" });
+    const before = Date.now();
+    const result = await batch(node.b.token, [a.schedule_id, b.schedule_id, a.schedule_id]);
+    expect(result).toMatchObject({ ok: true, updated: 2, failed: 0 });
+    expect(result.results).toHaveLength(2);
+    expect(result.results[0]).toMatchObject({ schedule_id: a.schedule_id, every_seconds: 600, revision: a.revision + 1, status: "active" });
+    expect(Date.parse(result.results[0].next_run_at)).toBeGreaterThanOrEqual(before + 600_000);
+    expect(result.results[1]).toMatchObject({ status: "paused", next_run_at: null, every_seconds: 600 });
+    for (const original of [a, b]) {
+      expect(await get(original.schedule_id)).toMatchObject({ name: original.name, task_content: original.task_content, target_node_id: original.target_node_id, schedule: { type: "interval", every_seconds: 600 } });
+    }
+    expect(await get(untouched.schedule_id)).toEqual(untouched);
+  });
+
+  test("partial results preserve human, foreign-network, daily and cancelled schedules", async () => {
+    const own = (await create("b")).schedule;
+    const daily = (await create("b", { schedule: { type: "daily", time: "09:30" } })).schedule;
+    const cancelled = (await create("b")).schedule;
+    await mcp(node.b.token, "schedule_cancel", { schedule_id: cancelled.schedule_id });
+    const human = await rest(user.boss.token, "POST", "/api/scheduled-tasks", { network_id: net, name: "human batch", task: "t", target_node_id: node.b.id, schedule: EVERY_MIN });
+    const foreign = (await create("x")).schedule;
+    const ids = [human.body.schedule.schedule_id, foreign.schedule_id, "no-such-schedule", daily.schedule_id, cancelled.schedule_id, own.schedule_id];
+    const result = await batch(node.b.token, ids);
+    expect(result).toMatchObject({ ok: false, updated: 1, failed: 5 });
+    expect(result.results.map((r: any) => r.error ?? "ok")).toEqual(["not_schedule_creator", "schedule_not_found", "schedule_not_found", "not_interval_schedule", "schedule_cancelled", "ok"]);
+    expect((await get(ids[0])).schedule).toEqual(EVERY_MIN);
+    expect((await mcp(node.x.token, "schedule_get", { schedule_id: foreign.schedule_id })).schedule).toEqual(foreign);
+    expect(await get(daily.schedule_id)).toEqual(daily);
+    expect((await get(cancelled.schedule_id)).status).toBe("cancelled");
+  });
+
+  test("invalid interval or batch shape performs no writes; node-only and readonly gates remain", async () => {
+    const own = (await create("b")).schedule, ids = [own.schedule_id];
+    for (const seconds of [59, 60.5, 365 * 86400 + 1]) {
+      expect(await batch(node.b.token, ids, seconds)).toMatchObject({ ok: false, error: "invalid_interval" });
+    }
+    for (const invalid of [[], Array(101).fill(own.schedule_id), [""]]) {
+      expect((await batch(node.b.token, invalid)).ok).not.toBe(true);
+    }
+    expect((await batch(user.boss.token, ids)).error).toBe("network_token_required");
+    expect(await batch(node.ro.token, ids)).toMatchObject({ error: "node_permission_denied", reason: "mode_readonly" });
+    expect(await get(own.schedule_id)).toEqual(own);
+  });
+
+  test("creator still needs permission to reach the current target", async () => {
+    const own = (await create("b", { target_node_id: node.a.id })).schedule;
+    db.run("UPDATE nodes SET owner_user_id = ?1 WHERE node_id = ?2", [user.rst.id, node.b.id]);
+    try {
+      const result = await batch(node.b.token, [own.schedule_id]);
+      expect(result).toMatchObject({ ok: false, updated: 0, failed: 1 });
+      expect(result.results[0]).toMatchObject({ reason: "agent_not_granted_to_owner" });
+      expect(await get(own.schedule_id)).toEqual(own);
+    } finally {
+      db.run("UPDATE nodes SET owner_user_id = ?1 WHERE node_id = ?2", [user.boss.id, node.b.id]);
+    }
+  });
+});
+
 describe("denials", () => {
   test("another network: cannot target, see or touch it", async () => {
     const mine = (await create("a")).schedule.schedule_id;

package/src/schedule-agent.ts

@@ -23,7 +23,7 @@
 import { db } from "./db.js";
 import {
   cancelSchedule, decodeRowForAgent, dispatchScheduledOccurrence, getScheduleRow, insertSchedule, patchSchedule,
-  scheduleRuns, ScheduleInputError, validateScheduleCreate, type ScheduledRow,
+  scheduleRuns, ScheduleInputError, validateScheduleCreate, parseScheduleSpec, type ScheduledRow,
 } from "./scheduled-tasks.js";
 import { SCHEDULED_TASK_STORAGE_SELECT } from "./rest-projections.js";
 import { dispatchVerdict, nodePermissionDeniedBody, recordNodePermission, type NodeIdentity } from "./node-permissions.js";
@@ -145,6 +145,25 @@ export function agentUpdateSchedule(id: NodeIdentity, canWrite: boolean, schedul
   } catch (e) { return inputError(e); }
 }
 
+/** #816: partial success, one result per distinct ID; no change to existing write authority. */
+export function agentBatchScheduleInterval(id: NodeIdentity, canWrite: boolean, scheduleIds: string[], everySeconds: number): AgentScheduleResult {
+  const gate = writeGate(id, canWrite, "mcp:schedule_batch_interval");
+  if (gate) return gate;
+  const schedule = { type: "interval", every_seconds: everySeconds };
+  try { parseScheduleSpec(schedule, "UTC"); } catch (e) { return inputError(e); }
+  const results = [...new Set(scheduleIds)].map(schedule_id => {
+    const row = ownRow(id, schedule_id);
+    if (!isRow(row)) return { schedule_id, ...row };
+    if (row.schedule_type !== "interval") return { schedule_id, ok: false, error: "not_interval_schedule" };
+    const result = agentUpdateSchedule(id, canWrite, schedule_id, { schedule, base_revision: row.revision });
+    if (!result.ok) return { schedule_id, ...result };
+    const updated = result.schedule as ReturnType<typeof decodeRowForAgent>;
+    return { schedule_id, ok: true, every_seconds: everySeconds, next_run_at: updated.next_run_at, status: updated.status, revision: updated.revision };
+  });
+  const updated = results.filter(r => r.ok).length;
+  return { ok: updated === results.length, updated, failed: results.length - updated, results };
+}
+
 export function agentCancelSchedule(id: NodeIdentity, canWrite: boolean, scheduleId: string): AgentScheduleResult {
   const gate = writeGate(id, canWrite, "mcp:schedule_cancel");
   if (gate) return gate;

package/src/tool-audience-http.test.ts

@@ -43,6 +43,7 @@ const OVERRIDES: Record<string, Record<string, unknown>> = {
   mark_tasks_consumed: { task_ids: ["task_probe"] },
   upsert_network_secret: { key: "PROBE_KEY" },
   update_provider: { provider_id: "prov_probe" },
+  schedule_batch_interval: { schedule_ids: ["sched_probe"], every_seconds: 60 },
 };
 function fill(schema: any, key: string, ctx: Record<string, unknown>): unknown {
   if (!schema) return "probe";

package/src/tool-audience.ts

@@ -29,7 +29,7 @@ export const TOOL_AUDIENCE: Readonly<Record<string, ToolAudience>> = {
   report_status: "node", org_whoami: "node",
   // #733 定时任务:节点工具(用户令牌一律 network_token_required;人走 REST /api/scheduled-tasks)
   schedule_list: "node", schedule_get: "node", schedule_create: "node", schedule_update: "node",
-  schedule_cancel: "node", schedule_run_now: "node", schedule_runs: "node",
+  schedule_cancel: "node", schedule_run_now: "node", schedule_runs: "node", schedule_batch_interval: "node",
   // ── 协议:用户令牌一律 network_token_required / node_token_required / caller_not_a_daemon ──
   mark_tasks_runtime_submitted: "protocol", mark_tasks_consumed: "protocol",
   get_config_update: "protocol", ack_config_update: "protocol",

package/src/tools.ts

@@ -21,7 +21,7 @@ import { getUserNetworkRole, createNetworkTokenForNode } from "./auth.js";
 import { addAgentNetworkScope, addAgentTimelineScope, addNetworkScope, canRestWriteNetwork, canRestWriteNetworkAsHuman, getUserNetworkIds, resolveRestNetworkScope, singleNetworkId, type RestNetworkScope } from "./network-scope.js";
 import { canMessageAgent, restrictedNetworkIds, RESTRICTED_MEMBER_TOOLS, type AgentRef } from "./agent-access.js";
 import { listedToolFilter, scopeToolsList, type ToolCaller } from "./tool-audience.js";
-import { agentCancelSchedule, agentCreateSchedule, agentGetSchedule, agentListSchedules, agentRunScheduleNow, agentScheduleRuns, agentUpdateSchedule } from "./schedule-agent.js";
+import { agentBatchScheduleInterval, agentCancelSchedule, agentCreateSchedule, agentGetSchedule, agentListSchedules, agentRunScheduleNow, agentScheduleRuns, agentUpdateSchedule } from "./schedule-agent.js";
 import { broadcastVerdict, dispatchVerdict, humanOnlyVerdict, NODE_TOOL_CLASS, nodeDecide, nodeIdentity, nodePermissionDeniedBody, writeVerdict, type NodeIdentity, type Verdict } from "./node-permissions.js";
 import { restrictedMemberAttachmentsDenied } from "./restricted-files.js";
 import { errorBody } from "./requirements-errors.js";
@@ -6396,6 +6396,9 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
   server.tool("schedule_update", "Edit your schedule; status=paused|active.",
     { ...schedFields, schedule_id: schedId, base_revision: z.number().int().min(0).optional().describe("Reject if current revision differs."), name: z.string().optional(), task: z.string().optional(), schedule: z.any().optional(), status: z.string().optional() },
     async ({ schedule_id, ...rest }) => scheduleCall((id, w) => agentUpdateSchedule(id, w, schedule_id, rest as Record<string, unknown>)));
+  server.tool("schedule_batch_interval", "Batch interval edit; per-ID results.",
+    { schedule_ids: z.array(z.string()).min(1).max(100), every_seconds: z.number() },
+    async ({ schedule_ids, every_seconds }) => scheduleCall((id, w) => agentBatchScheduleInterval(id, w, schedule_ids, every_seconds)));
   server.tool("schedule_cancel", "Cancel your schedule.", { schedule_id: schedId },
     async ({ schedule_id }) => scheduleCall((id, w) => agentCancelSchedule(id, w, schedule_id)));
   server.tool("schedule_run_now", "Run your schedule now.", { schedule_id: schedId },