@desplega.ai/agent-swarm 1.112.0 → 1.114.0

package/src/tests/schedule-target-type.test.ts

@@ -288,6 +288,56 @@ describe("dispatchScheduleTarget — script target", () => {
     expect(result.task).toBeUndefined();
   }, 15_000);
 
+  test("scheduled script runs receive ctx.api and ctx.mcp connections", async () => {
+    const { upsertScriptConnection } = await import("../be/script-connections");
+    await upsertScriptConnection({
+      slug: "schedgql",
+      kind: "graphql",
+      scope: "global",
+      baseUrl: "https://gql.vendor.test/graphql",
+      allowedHosts: ["gql.vendor.test"],
+      agentId,
+    });
+    const mcpRow = {
+      id: crypto.randomUUID(),
+      serverId: crypto.randomUUID(),
+      runtime: { slug: "schedmcp", kind: "mcp", connectionId: "", tools: [{ name: "ping" }] },
+    };
+    mcpRow.runtime.connectionId = mcpRow.id;
+    getDb()
+      .prepare(
+        `INSERT INTO mcp_servers (id, name, transport, scope, url, createdAt, lastUpdatedAt)
+         VALUES (?, ?, 'http', 'global', 'http://mcp.invalid.test/mcp', datetime('now'), datetime('now'))`,
+      )
+      .run(mcpRow.serverId, `sched-mcp-${mcpRow.serverId.slice(0, 8)}`);
+    getDb()
+      .prepare(
+        `INSERT INTO script_connections
+           (id, slug, kind, scope, allowed_hosts_json, mcp_server_id, generated_runtime_json)
+         VALUES (?, 'schedmcp', 'mcp', 'global', '[]', ?, ?)`,
+      )
+      .run(mcpRow.id, mcpRow.serverId, JSON.stringify(mcpRow.runtime));
+
+    await saveGlobalScript(
+      "schedule-target-type-ctx-connections",
+      `export default async (args, ctx) => {
+        if (!ctx.api || !("schedgql" in ctx.api)) throw new Error("ctx.api missing schedgql");
+        if (!ctx.mcp || !("schedmcp" in ctx.mcp)) throw new Error("ctx.mcp missing schedmcp");
+        return { ok: true };
+      };`,
+    );
+    const schedule = createScheduledTask({
+      name: `dispatch-script-ctx-${crypto.randomUUID()}`,
+      intervalMs: 60_000,
+      targetType: "script",
+      scriptName: "schedule-target-type-ctx-connections",
+      createdByAgentId: agentId,
+    });
+
+    const result = await dispatchScheduleTarget(schedule);
+    expect(result.triggeredWorkflows).toBe(false);
+  }, 15_000);
+
   test("throws a clear error when the script does not exist", async () => {
     const schedule = createScheduledTask({
       name: `dispatch-script-missing-${crypto.randomUUID()}`,

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

@@ -4,11 +4,13 @@ import {
   closeDb,
   createAgent,
   createScheduledTask,
+  createUser,
   deleteScheduledTask,
   getDb,
   getScheduledTaskById,
   getScheduledTaskByName,
   getScheduledTasks,
+  getTaskById,
   initDb,
   updateScheduledTask,
 } from "../be/db";
@@ -195,6 +197,40 @@ describe("Scheduled Tasks Integration", () => {
       expect(disabledOnly.every((s) => !s.enabled)).toBe(true);
     });
 
+    test("should filter scheduled tasks by triage error fields", () => {
+      const ok = createScheduledTask({
+        name: "test-filter-last-run-ok",
+        intervalMs: 60000,
+        taskTemplate: "Healthy task",
+      });
+      const failing = createScheduledTask({
+        name: "test-filter-last-run-failed",
+        intervalMs: 60000,
+        taskTemplate: "Failing task",
+      });
+      updateScheduledTask(ok.id, {
+        lastRunAt: new Date(Date.now() - 120000).toISOString(),
+        consecutiveErrors: 0,
+      });
+      updateScheduledTask(failing.id, {
+        lastRunAt: new Date(Date.now() - 60000).toISOString(),
+        consecutiveErrors: 3,
+        lastErrorAt: new Date().toISOString(),
+        lastErrorMessage: "boom",
+      });
+
+      const failingOnly = getScheduledTasks({
+        lastRunStatus: "failed",
+        consecutiveErrorsMin: 2,
+      });
+      const succeededOnly = getScheduledTasks({ lastRunStatus: "succeeded" });
+
+      expect(failingOnly.some((s) => s.id === failing.id)).toBe(true);
+      expect(failingOnly.some((s) => s.id === ok.id)).toBe(false);
+      expect(succeededOnly.some((s) => s.id === ok.id)).toBe(true);
+      expect(succeededOnly.some((s) => s.id === failing.id)).toBe(false);
+    });
+
     test("should filter scheduled tasks by name", () => {
       createScheduledTask({
         name: "unique-name-xyz-123",
@@ -281,6 +317,44 @@ describe("Scheduled Tasks Integration", () => {
       expect(afterRun?.lastRunAt).toBeDefined();
     });
 
+    test("fired task inherits the schedule's createdBy as requestedByUserId", async () => {
+      const requester = createUser({ name: "Schedule Requester", email: "sched-req@example.com" });
+      const schedule = createScheduledTask({
+        name: "test-manual-run-createdby",
+        cronExpression: "0 9 * * *",
+        taskTemplate: "Task carrying schedule provenance",
+        createdByAgentId: testAgent.id,
+        createdBy: requester.id,
+        enabled: true,
+      });
+
+      await runScheduleNow(schedule.id);
+
+      const createdTask = getDb()
+        .query("SELECT id FROM agent_tasks WHERE task = ? ORDER BY createdAt DESC LIMIT 1")
+        .get(schedule.taskTemplate) as { id: string };
+      const task = getTaskById(createdTask.id);
+      expect(task?.requestedByUserId).toBe(requester.id);
+    });
+
+    test("fired task has no requestedByUserId when the schedule's createdBy is unset (first-ever schedules)", async () => {
+      const schedule = createScheduledTask({
+        name: "test-manual-run-no-createdby",
+        cronExpression: "0 9 * * *",
+        taskTemplate: "Task with no schedule provenance",
+        createdByAgentId: testAgent.id,
+        enabled: true,
+      });
+
+      await runScheduleNow(schedule.id);
+
+      const createdTask = getDb()
+        .query("SELECT id FROM agent_tasks WHERE task = ? ORDER BY createdAt DESC LIMIT 1")
+        .get(schedule.taskTemplate) as { id: string };
+      const task = getTaskById(createdTask.id);
+      expect(task?.requestedByUserId ?? null).toBeNull();
+    });
+
     test("should throw error for non-existent schedule", async () => {
       await expect(runScheduleNow("non-existent-schedule-id")).rejects.toThrow(
         "Schedule not found",