@desplega.ai/agent-swarm 1.149.1 → 1.151.0

package/dist/cli-7fehefdf.js

@@ -1,562 +0,0 @@
-import {
-  require_dist
-} from "./cli-qgm2pfpq.js";
-import {
-  getAutomationSetupStates,
-  getExecutorRegistry,
-  handleScheduleTrigger,
-  isNeedsSetupFailure,
-  notifyAutomationPreflightFailure,
-  preflightAutomation,
-  recordSchedulePreflightFailure,
-  renderAutomationTokens,
-  schedulePreflightInput,
-  startWorkflowExecution
-} from "./cli-ddfw1mc4.js";
-import {
-  buildScriptCredentialBindings,
-  getScript,
-  getScriptApiConnectionDescriptors,
-  getScriptMcpConnectionDescriptors,
-  runScript
-} from "./cli-svbrpf5q.js";
-import {
-  createTaskWithSiblingAwareness
-} from "./cli-ayvy5kde.js";
-import {
-  ensure
-} from "./cli-3sysyjve.js";
-import {
-  getDbClient,
-  getDueScheduledTasks,
-  getScheduledTaskById,
-  getUserById,
-  getWorkflow,
-  getWorkflowRun,
-  init_context_key,
-  init_db,
-  init_telemetry,
-  scheduleContextKey,
-  telemetry,
-  updateScheduledTask
-} from "./cli-qgd4sqz5.js";
-import {
-  init_event_bus,
-  workflowEventBus
-} from "./cli-f7kvq46p.js";
-import {
-  __toESM
-} from "./cli-bc05qbss.js";
-
-// src/scheduler/scheduler.ts
-var import_cron_parser = __toESM(require_dist(), 1);
-init_db();
-init_telemetry();
-
-// src/scheduler/deferred-task-waits.ts
-init_db();
-init_event_bus();
-
-// src/scheduler/schedule-task.ts
-init_db();
-init_context_key();
-async function createStandaloneScheduleTask(schedule, extraTags = []) {
-  if (!schedule.taskTemplate) {
-    throw new Error(`Schedule "${schedule.name}" has no taskTemplate (targetType=agent-task)`);
-  }
-  const task = await createTaskWithSiblingAwareness(schedule.taskTemplate, {
-    key: schedule.key,
-    creatorAgentId: schedule.createdByAgentId,
-    taskType: schedule.taskType,
-    tags: [...schedule.tags, "scheduled", `schedule:${schedule.name}`, ...extraTags],
-    priority: schedule.priority,
-    agentId: schedule.targetAgentId,
-    routingReason: schedule.targetAgentId ? "human_pinned" : undefined,
-    model: schedule.model,
-    modelTier: schedule.modelTier,
-    scheduleId: schedule.id,
-    source: "schedule",
-    requestedByUserId: schedule.createdBy,
-    contextKey: scheduleContextKey({ scheduleId: schedule.id }),
-    parentTaskId: schedule.parentTaskId
-  });
-  if (schedule.taskType === "deferred" && schedule.parentTaskId) {
-    await getDbClient().run("UPDATE deferred_task_waits SET taskId = ?, updated_at = ? WHERE status = 'pending' AND taskId = ?", [task.id, new Date().toISOString(), schedule.parentTaskId]);
-  }
-  return task;
-}
-
-// src/scheduler/deferred-task-waits.ts
-async function dispatchDeferredTaskWait(scheduleId, reason, extraTags = []) {
-  const client = getDbClient();
-  if (!await client.get("SELECT * FROM deferred_task_waits WHERE scheduleId = ?", [
-    scheduleId
-  ]))
-    return;
-  return client.transaction(async () => {
-    const wait = await client.get("SELECT * FROM deferred_task_waits WHERE scheduleId = ?", [scheduleId]);
-    if (!wait || wait.status !== "pending")
-      return {};
-    if (reason !== "ceiling" && wait.eventName !== "settled" && wait.eventName !== reason)
-      return {};
-    let schedule = await getScheduledTaskById(scheduleId);
-    if (!schedule?.enabled)
-      return {};
-    const now = new Date().toISOString();
-    const claimed = await client.run("UPDATE deferred_task_waits SET status = 'fired', firedBy = ?, resolvedAt = ?, updated_at = ? WHERE scheduleId = ? AND status = 'pending'", [reason, now, now, scheduleId]);
-    if (!claimed.changes)
-      return {};
-    if (schedule.createdBy && !await getUserById(schedule.createdBy)) {
-      schedule = { ...schedule, createdBy: undefined };
-    }
-    if (!schedule.taskTemplate)
-      throw new Error(`Schedule "${schedule.name}" has no taskTemplate`);
-    const cause = reason === "ceiling" ? "ceiling expired" : `${reason} for task ${wait.taskId}`;
-    const task = await createStandaloneScheduleTask({
-      ...schedule,
-      taskTemplate: `${schedule.taskTemplate}
-
-Wake-up cause: ${cause}.`
-    }, extraTags);
-    await client.run("UPDATE deferred_task_waits SET childTaskId = ? WHERE scheduleId = ?", [
-      task.id,
-      scheduleId
-    ]);
-    await updateScheduledTask(scheduleId, {
-      enabled: false,
-      nextRunAt: null,
-      lastRunAt: now,
-      lastUpdatedAt: now,
-      consecutiveErrors: 0,
-      lastErrorAt: null,
-      lastErrorMessage: null
-    });
-    return { task };
-  });
-}
-async function reconcileDeferredTaskWaits(taskId) {
-  const rows = await getDbClient().query(`SELECT w.*, t.status AS taskStatus FROM deferred_task_waits w
-     JOIN agent_tasks t ON t.id = w.taskId
-     JOIN scheduled_tasks s ON s.id = w.scheduleId
-     WHERE w.status = 'pending' AND s.enabled = 1 AND t.status IN ('completed', 'failed')
-       AND NOT EXISTS (
-         SELECT 1 FROM scheduled_tasks d
-         WHERE d.parentTaskId = t.id AND d.taskType = 'deferred' AND d.enabled = 1
-       )
-       AND (w.eventName = 'settled' OR w.eventName = 'task.' || t.status)
-       ${taskId ? "AND w.taskId = ?" : ""}`, taskId ? [taskId] : []);
-  for (const row of rows) {
-    try {
-      await dispatchDeferredTaskWait(row.scheduleId, `task.${row.taskStatus}`);
-    } catch (err) {
-      console.error(`[Scheduler] Deferred task wake failed for ${row.scheduleId}:`, err);
-    }
-  }
-}
-function onTaskTerminal(payload) {
-  if (!payload || typeof payload !== "object" || !("taskId" in payload) || typeof payload.taskId !== "string")
-    return;
-  reconcileDeferredTaskWaits(payload.taskId).catch((err) => {
-    console.error("[Scheduler] Deferred task event wake failed:", err);
-  });
-}
-async function initDeferredTaskWaits() {
-  stopDeferredTaskWaits();
-  workflowEventBus.on("task.completed", onTaskTerminal);
-  workflowEventBus.on("task.failed", onTaskTerminal);
-  await reconcileDeferredTaskWaits();
-}
-function stopDeferredTaskWaits() {
-  workflowEventBus.off("task.completed", onTaskTerminal);
-  workflowEventBus.off("task.failed", onTaskTerminal);
-}
-
-// src/scheduler/scheduler.ts
-var schedulerInterval = null;
-var isProcessing = false;
-var executorRegistry = null;
-function resolveExecutorRegistry() {
-  if (executorRegistry)
-    return executorRegistry;
-  try {
-    return getExecutorRegistry();
-  } catch {
-    return null;
-  }
-}
-async function executeScheduleScript(schedule) {
-  if (!schedule.scriptName) {
-    throw new Error(`Schedule "${schedule.name}" has no scriptName (targetType=script)`);
-  }
-  const script = await getScript({ name: schedule.scriptName, scope: "global" });
-  if (!script) {
-    throw new Error(`Script '${schedule.scriptName}' not found`);
-  }
-  const agentId = schedule.createdByAgentId ?? "schedule";
-  const output = await runScript({
-    source: script.source,
-    args: schedule.scriptArgs ?? {},
-    fsMode: "none",
-    agentId,
-    egressSecrets: await buildScriptCredentialBindings({ agentId }),
-    apiConnections: getScriptApiConnectionDescriptors({ agentId }),
-    mcpConnections: getScriptMcpConnectionDescriptors({ agentId }),
-    timeoutMs: 60000
-  });
-  if (output.exitCode !== 0 || output.error) {
-    throw new Error(output.stderr || `Script '${schedule.scriptName}' exited with code ${output.exitCode}${output.error ? ` (${output.error})` : ""}`);
-  }
-}
-
-class AutomationNeedsSetupError extends Error {
-  failureReason;
-  constructor(failureReason) {
-    super(failureReason);
-    this.failureReason = failureReason;
-    this.name = "AutomationNeedsSetupError";
-  }
-}
-async function withoutDeletedRequester(schedule) {
-  if (!schedule.createdBy || await getUserById(schedule.createdBy))
-    return schedule;
-  return { ...schedule, createdBy: undefined };
-}
-function renderScheduledTaskParams(schedule) {
-  return renderAutomationTokens(schedule, schedule.params ?? {});
-}
-async function dispatchScheduleTarget(schedule, extraTags = []) {
-  const deferred = await dispatchDeferredTaskWait(schedule.id, "ceiling", extraTags);
-  if (deferred)
-    return { triggeredWorkflows: false, ...deferred };
-  const preflight = preflightAutomation(schedulePreflightInput(schedule), await getAutomationSetupStates());
-  if (preflight.state === "needs_setup") {
-    const recorded = await recordSchedulePreflightFailure(schedule.id, preflight.failureReason);
-    if (recorded)
-      await notifyAutomationPreflightFailure(preflight);
-    throw new AutomationNeedsSetupError(preflight.failureReason);
-  }
-  schedule = renderScheduledTaskParams(schedule);
-  schedule = await withoutDeletedRequester(schedule);
-  switch (schedule.targetType) {
-    case "workflow": {
-      if (!schedule.workflowId) {
-        throw new Error(`Schedule "${schedule.name}" has no workflowId (targetType=workflow)`);
-      }
-      const workflow = await getWorkflow(schedule.workflowId);
-      if (!workflow) {
-        throw new Error(`Workflow ${schedule.workflowId} not found`);
-      }
-      if (!workflow.enabled) {
-        throw new Error(`Workflow ${schedule.workflowId} is disabled`);
-      }
-      const registry = resolveExecutorRegistry();
-      if (!registry) {
-        throw new Error("Workflow engine not initialized — cannot dispatch schedule to workflow");
-      }
-      const triggerData = {
-        scheduleId: schedule.id,
-        scheduleName: schedule.name,
-        firedAt: new Date().toISOString()
-      };
-      const runId = await startWorkflowExecution(workflow, triggerData, registry, {
-        triggerType: "schedule",
-        requestedByUserId: schedule.createdBy
-      });
-      await throwIfWorkflowNeedsSetup(schedule.id, [runId]);
-      console.log(`[Scheduler] Schedule "${schedule.name}" → triggered workflow "${workflow.name}"`);
-      return { triggeredWorkflows: true, workflowRunIds: [runId] };
-    }
-    case "script": {
-      await executeScheduleScript(schedule);
-      return { triggeredWorkflows: false };
-    }
-    default: {
-      let triggeredWorkflows = false;
-      let workflowRunIds;
-      const registry = resolveExecutorRegistry();
-      if (registry) {
-        const runIds = await handleScheduleTrigger(schedule.id, schedule, registry);
-        if (runIds.length > 0) {
-          await throwIfWorkflowNeedsSetup(schedule.id, runIds);
-          triggeredWorkflows = true;
-          workflowRunIds = runIds;
-          console.log(`[Scheduler] Schedule "${schedule.name}" → triggered ${runIds.length} workflow(s)`);
-        }
-      }
-      if (!triggeredWorkflows) {
-        const task = await getDbClient().transaction(async () => createStandaloneScheduleTask(schedule, extraTags));
-        return { triggeredWorkflows, task };
-      }
-      return { triggeredWorkflows, workflowRunIds };
-    }
-  }
-}
-async function throwIfWorkflowNeedsSetup(scheduleId, runIds) {
-  for (const runId of runIds) {
-    const run = await getWorkflowRun(runId);
-    if (!isNeedsSetupFailure(run?.error))
-      continue;
-    await recordSchedulePreflightFailure(scheduleId, run.error);
-    throw new AutomationNeedsSetupError(run.error);
-  }
-}
-async function advanceScheduleAfterNeedsSetup(schedule, now = new Date) {
-  schedule = renderScheduledTaskParams(schedule);
-  const timestamp = now.toISOString();
-  if (schedule.scheduleType === "one_time") {
-    await updateScheduledTask(schedule.id, {
-      nextRunAt: null,
-      lastUpdatedAt: timestamp
-    });
-    return;
-  }
-  await updateScheduledTask(schedule.id, {
-    nextRunAt: calculateNextRun(schedule.timezone?.includes("{{") ? { ...schedule, timezone: "UTC" } : schedule, now),
-    lastUpdatedAt: timestamp
-  });
-}
-async function recoverMissedSchedules() {
-  const now = new Date;
-  const dueSchedules = await getDueScheduledTasks();
-  for (const storedSchedule of dueSchedules) {
-    const schedule = renderScheduledTaskParams(storedSchedule);
-    if (!schedule.nextRunAt)
-      continue;
-    const missedBy = now.getTime() - new Date(schedule.nextRunAt).getTime();
-    if (missedBy < 15000)
-      continue;
-    console.log(`[Scheduler] Recovering missed schedule "${schedule.name}" ` + `(was due ${Math.round(missedBy / 1000)}s ago)`);
-    let triggeredWorkflows = false;
-    try {
-      ({ triggeredWorkflows } = await dispatchScheduleTarget(schedule, ["recovered"]));
-      if (schedule.scheduleType === "one_time") {
-        await updateScheduledTask(schedule.id, {
-          lastRunAt: now.toISOString(),
-          nextRunAt: null,
-          enabled: false,
-          lastUpdatedAt: now.toISOString()
-        });
-      } else {
-        const nextRun = calculateNextRun(schedule, now);
-        await updateScheduledTask(schedule.id, {
-          lastRunAt: now.toISOString(),
-          nextRunAt: nextRun,
-          lastUpdatedAt: now.toISOString()
-        });
-      }
-      if (schedule.scheduleType === "one_time") {
-        console.log(`[Scheduler] One-time schedule "${schedule.name}" recovered and auto-disabled`);
-      }
-      telemetry.schedule("executed", {
-        scheduleType: schedule.scheduleType,
-        triggeredWorkflows,
-        wasRecovered: true
-      });
-    } catch (err) {
-      if (err instanceof AutomationNeedsSetupError) {
-        await advanceScheduleAfterNeedsSetup(schedule, now);
-        telemetry.schedule("error", {
-          scheduleType: schedule.scheduleType,
-          triggeredWorkflows,
-          wasRecovered: true,
-          consecutiveErrors: schedule.consecutiveErrors ?? 0
-        });
-        continue;
-      }
-      telemetry.schedule("error", {
-        scheduleType: schedule.scheduleType,
-        triggeredWorkflows,
-        wasRecovered: true,
-        consecutiveErrors: schedule.consecutiveErrors ?? 0
-      });
-      console.error(`[Scheduler] Error recovering "${schedule.name}":`, err);
-    }
-  }
-}
-function calculateNextRun(schedule, fromTime = new Date) {
-  if (schedule.cronExpression) {
-    const interval = import_cron_parser.CronExpressionParser.parse(schedule.cronExpression, {
-      currentDate: fromTime,
-      tz: schedule.timezone || "UTC"
-    });
-    const nextDate = interval.next();
-    const isoString = nextDate.toISOString();
-    if (!isoString) {
-      throw new Error("Failed to calculate next run time from cron expression");
-    }
-    return isoString;
-  }
-  if (schedule.intervalMs) {
-    return new Date(fromTime.getTime() + schedule.intervalMs).toISOString();
-  }
-  throw new Error("Schedule must have cronExpression or intervalMs");
-}
-var ERROR_BACKOFF_MS = [
-  60000,
-  300000,
-  900000,
-  1800000,
-  3600000
-];
-var MAX_CONSECUTIVE_ERRORS = 5;
-function getBackoffMs(consecutiveErrors) {
-  const idx = Math.min(consecutiveErrors - 1, ERROR_BACKOFF_MS.length - 1);
-  return ERROR_BACKOFF_MS[Math.max(0, idx)] ?? ERROR_BACKOFF_MS[0];
-}
-async function executeSchedule(schedule) {
-  schedule = renderScheduledTaskParams(schedule);
-  let triggeredWorkflows = false;
-  try {
-    ({ triggeredWorkflows } = await dispatchScheduleTarget(schedule));
-    const now = new Date().toISOString();
-    if (schedule.scheduleType === "one_time") {
-      await updateScheduledTask(schedule.id, {
-        lastRunAt: now,
-        nextRunAt: null,
-        enabled: false,
-        lastUpdatedAt: now,
-        consecutiveErrors: 0,
-        lastErrorAt: null,
-        lastErrorMessage: null
-      });
-      console.log(`[Scheduler] Executed one-time schedule "${schedule.name}", auto-disabled`);
-    } else {
-      const nextRun = calculateNextRun(schedule, new Date);
-      await updateScheduledTask(schedule.id, {
-        lastRunAt: now,
-        nextRunAt: nextRun,
-        lastUpdatedAt: now,
-        consecutiveErrors: 0,
-        lastErrorAt: null,
-        lastErrorMessage: null
-      });
-      console.log(`[Scheduler] Executed schedule "${schedule.name}", next run: ${nextRun}`);
-    }
-    telemetry.schedule("executed", {
-      scheduleType: schedule.scheduleType,
-      triggeredWorkflows,
-      wasRecovered: false
-    });
-  } catch (err) {
-    if (err instanceof AutomationNeedsSetupError) {
-      await advanceScheduleAfterNeedsSetup(schedule);
-      telemetry.schedule("error", {
-        scheduleType: schedule.scheduleType,
-        triggeredWorkflows,
-        wasRecovered: false,
-        consecutiveErrors: schedule.consecutiveErrors ?? 0
-      });
-      return;
-    }
-    const errorCount = (schedule.consecutiveErrors ?? 0) + 1;
-    const now = new Date;
-    const errorMsg = err instanceof Error ? err.message : String(err);
-    console.error(`[Scheduler] Error executing "${schedule.name}" (${errorCount} consecutive):`, errorMsg);
-    const updates = {
-      consecutiveErrors: errorCount,
-      lastErrorAt: now.toISOString(),
-      lastErrorMessage: errorMsg.slice(0, 500),
-      lastUpdatedAt: now.toISOString()
-    };
-    if (schedule.scheduleType === "one_time") {
-      updates.enabled = false;
-      console.warn(`[Scheduler] One-time schedule "${schedule.name}" failed, auto-disabled: ${errorMsg}`);
-    } else if (errorCount >= MAX_CONSECUTIVE_ERRORS) {
-      updates.enabled = false;
-      console.warn(`[Scheduler] Auto-disabled "${schedule.name}" after ${errorCount} consecutive errors`);
-    } else {
-      const backoff = getBackoffMs(errorCount);
-      updates.nextRunAt = new Date(now.getTime() + backoff).toISOString();
-      console.log(`[Scheduler] Backing off "${schedule.name}" for ${backoff / 1000}s`);
-    }
-    await updateScheduledTask(schedule.id, updates);
-    telemetry.schedule("error", {
-      scheduleType: schedule.scheduleType,
-      triggeredWorkflows,
-      wasRecovered: false,
-      consecutiveErrors: errorCount
-    });
-  }
-}
-function startScheduler(registry, intervalMs = 1e4, opts) {
-  if (schedulerInterval) {
-    console.log("[Scheduler] Already running");
-    return;
-  }
-  executorRegistry = registry;
-  console.log(`[Scheduler] Starting with ${intervalMs}ms polling interval`);
-  initDeferredTaskWaits().then(() => recoverMissedSchedules()).then(() => processSchedules()).catch((err) => console.error("[Scheduler] Recovery failed:", err));
-  schedulerInterval = setInterval(async () => {
-    await processSchedules();
-  }, intervalMs);
-  ensure({
-    id: "scheduler_started",
-    flow: "api",
-    runId: opts?.runId ?? "",
-    depIds: ["listen"],
-    data: {},
-    filter: ({}, ctx) => {
-      const start = ctx.deps.find((d) => d.id === "listen");
-      return !!start && start.data?.capabilities?.includes("scheduling");
-    },
-    validator: ({}, ctx) => {
-      const start = ctx.deps.find((d) => d.id === "listen");
-      return !!start && start.data?.capabilities?.includes("scheduling");
-    },
-    conditions: [{ timeout_ms: 1e4 }]
-  });
-}
-async function processSchedules() {
-  if (isProcessing)
-    return;
-  isProcessing = true;
-  try {
-    await reconcileDeferredTaskWaits();
-    const dueSchedules = await getDueScheduledTasks();
-    for (const schedule of dueSchedules) {
-      try {
-        await executeSchedule(schedule);
-      } catch (err) {
-        console.error(`[Scheduler] Error executing "${schedule.name}":`, err);
-      }
-    }
-  } finally {
-    isProcessing = false;
-  }
-}
-function stopScheduler() {
-  stopDeferredTaskWaits();
-  if (schedulerInterval) {
-    clearInterval(schedulerInterval);
-    schedulerInterval = null;
-    isProcessing = false;
-    console.log("[Scheduler] Stopped");
-  }
-}
-async function runScheduleNow(scheduleId) {
-  const schedule = await getScheduledTaskById(scheduleId);
-  if (!schedule) {
-    throw new Error(`Schedule not found: ${scheduleId}`);
-  }
-  if (!schedule.enabled) {
-    throw new Error(`Schedule is disabled: ${schedule.name}`);
-  }
-  await dispatchScheduleTarget(schedule, ["manual-run"]);
-  const now = new Date().toISOString();
-  if (schedule.scheduleType === "one_time") {
-    await updateScheduledTask(schedule.id, {
-      lastRunAt: now,
-      nextRunAt: null,
-      enabled: false,
-      lastUpdatedAt: now
-    });
-    console.log(`[Scheduler] Manually executed one-time schedule "${schedule.name}", auto-disabled`);
-  } else {
-    await updateScheduledTask(schedule.id, {
-      lastRunAt: now,
-      lastUpdatedAt: now
-    });
-    console.log(`[Scheduler] Manually executed schedule "${schedule.name}"`);
-  }
-}
-export { reconcileDeferredTaskWaits, dispatchScheduleTarget, calculateNextRun, startScheduler, stopScheduler, runScheduleNow };