@mndrk/agx 2.0.42 → 2.0.44

package/cloud-runtime/standalone/src/automations/types.ts

@@ -0,0 +1,134 @@
+import type { GraphSchedule } from "@/src/graph/types";
+import type {
+  CatchUpPolicy,
+  OverlapPolicy,
+  PromptJob,
+  RunStatus,
+} from "@/src/prompt-scheduler/types";
+
+export type AutomationState = "active" | "paused" | "stopped";
+export type AutomationTriggerType = "scheduled" | "condition";
+export type AutomationTargetType = "prompt_job" | "execution_graph";
+
+export interface ScheduledAutomationTrigger {
+  type: "scheduled";
+  cadence?: string;
+  cronExpr?: string;
+  intervalMs?: number;
+}
+
+export interface ConditionAutomationTrigger {
+  type: "condition";
+  condition: string;
+  checkEveryMs: number;
+}
+
+export type AutomationTrigger = ScheduledAutomationTrigger | ConditionAutomationTrigger;
+
+export interface AutomationExecution {
+  overlapPolicy?: OverlapPolicy;
+  catchUpPolicy?: CatchUpPolicy;
+  cancelCheckSec?: number;
+  maxRuns?: number;
+  maxConsecutiveFailures?: number;
+  activeUntil?: string;
+}
+
+export interface PromptJobAutomationTarget {
+  type: "prompt_job";
+  agentId?: string;
+  provider?: string;
+  model?: string;
+  cliArgs?: string;
+  prompt?: string;
+}
+
+export interface ExecutionGraphAutomationTarget {
+  type: "execution_graph";
+  graphId?: string;
+  taskId?: string;
+  resetNodeIds?: string[];
+  rootMessageId?: string;
+}
+
+export type AutomationTarget = PromptJobAutomationTarget | ExecutionGraphAutomationTarget;
+
+export interface AutomationDefinition {
+  id: string;
+  name: string;
+  description?: string;
+  projectId?: string;
+  state: AutomationState;
+  trigger: AutomationTrigger;
+  execution?: AutomationExecution;
+  target: AutomationTarget;
+  createdAt?: string;
+  body?: string;
+}
+
+export interface AutomationRuntimeState {
+  scheduleHash: string;
+  nextRunAt?: number | null;
+  lastRunAt?: number | null;
+  lastOutcome?: RunStatus | "skipped" | null;
+  lastError?: string | null;
+  updatedAt: string;
+  runCount?: number;
+  consecutiveFailures?: number;
+  tickInProgress?: boolean;
+  archivedAt?: string | null;
+}
+
+export interface AutomationRecord {
+  definition: AutomationDefinition;
+  runtimeState: AutomationRuntimeState;
+  filePath: string;
+  archived: boolean;
+}
+
+export interface AutomationListFilter {
+  includeArchived?: boolean;
+  state?: AutomationState;
+  targetType?: AutomationTargetType;
+  projectId?: string;
+  ids?: string[];
+  graphId?: string;
+  taskId?: string;
+  rootMessageId?: string;
+}
+
+export type AutomationUpdatePatch = Partial<
+  Omit<AutomationDefinition, "trigger" | "execution" | "target">
+> & {
+  description?: string | null;
+  projectId?: string | null;
+  trigger?: Partial<ScheduledAutomationTrigger> | Partial<ConditionAutomationTrigger>;
+  execution?: Partial<AutomationExecution> | null;
+  target?: Partial<PromptJobAutomationTarget> | Partial<ExecutionGraphAutomationTarget>;
+  body?: string;
+};
+
+export type AutomationStatePatch = Partial<
+  Omit<AutomationRuntimeState, "scheduleHash" | "updatedAt">
+> & {
+  updatedAt?: string;
+};
+
+export const DEFAULT_OVERLAP_POLICY: OverlapPolicy = "skip";
+export const DEFAULT_CATCH_UP_POLICY: CatchUpPolicy = "fire_once";
+export const DEFAULT_CANCEL_CHECK_SEC = 5;
+export const DEFAULT_CONDITION_CHECK_EVERY_MS = 300_000;
+export const DEFAULT_GRAPH_INTERVAL_MS = 60_000;
+
+export interface LegacyGraphAutomationRow {
+  graphId: string;
+  taskId: string;
+  schedule: GraphSchedule;
+  createdAt: string;
+  updatedAt: string;
+  executionState?: string;
+}
+
+export interface LegacyPromptJobLike extends PromptJob {
+  updatedAt: string;
+}

package/cloud-runtime/standalone/src/automations/validation.ts

@@ -0,0 +1,337 @@
+import { CronExpressionParser } from "cron-parser";
+
+import { parseNaturalSchedule } from "@/src/graph/nl-schedule";
+
+import {
+  DEFAULT_CANCEL_CHECK_SEC,
+  DEFAULT_CATCH_UP_POLICY,
+  DEFAULT_CONDITION_CHECK_EVERY_MS,
+  DEFAULT_OVERLAP_POLICY,
+  type AutomationDefinition,
+  type AutomationExecution,
+  type AutomationState,
+  type AutomationTarget,
+  type AutomationTrigger,
+  type ConditionAutomationTrigger,
+  type ExecutionGraphAutomationTarget,
+  type PromptJobAutomationTarget,
+  type ScheduledAutomationTrigger,
+} from "./types";
+
+function asTrimmedString(value: unknown): string | undefined {
+  if (value instanceof Date && !Number.isNaN(value.getTime())) {
+    return value.toISOString();
+  }
+  if (typeof value !== "string") {
+    return undefined;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : undefined;
+}
+
+function asPositiveInteger(value: unknown): number | undefined {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return undefined;
+  }
+  const normalized = Math.trunc(value);
+  return normalized > 0 ? normalized : undefined;
+}
+
+function asStringArray(value: unknown): string[] | undefined {
+  if (!Array.isArray(value)) {
+    return undefined;
+  }
+  const items = value
+    .map((item) => asTrimmedString(item))
+    .filter((item): item is string => Boolean(item));
+  return items.length > 0 ? items : undefined;
+}
+
+function asRecord(value: unknown): Record<string, unknown> {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return {};
+  }
+  return value as Record<string, unknown>;
+}
+
+function isValidIsoTimestamp(value: string | undefined): boolean {
+  if (!value) {
+    return true;
+  }
+  const parsed = Date.parse(value);
+  return !Number.isNaN(parsed);
+}
+
+function normalizeState(value: unknown): AutomationState {
+  if (value === "active" || value === "paused" || value === "stopped") {
+    return value;
+  }
+  throw new Error('Automation state must be one of "active", "paused", or "stopped".');
+}
+
+function validateCronExpr(expr: string): void {
+  try {
+    CronExpressionParser.parse(expr);
+  } catch {
+    throw new Error(`Invalid cron expression: "${expr}"`);
+  }
+}
+
+function normalizeScheduledTrigger(value: unknown): ScheduledAutomationTrigger {
+  const raw = asRecord(value);
+  const cadence = asTrimmedString(raw.cadence);
+  let cronExpr = asTrimmedString(raw.cronExpr);
+  let intervalMs = asPositiveInteger(raw.intervalMs);
+
+  if (!cronExpr && cadence) {
+    try {
+      validateCronExpr(cadence);
+      cronExpr = cadence;
+    } catch {
+      const parsed = parseNaturalSchedule(cadence);
+      if (!parsed) {
+        throw new Error(`Could not parse schedule cadence: "${cadence}"`);
+      }
+
+      if (parsed.intervalMs && parsed.intervalMs < 60_000) {
+        intervalMs = parsed.intervalMs;
+      } else if (parsed.cronExpr) {
+        cronExpr = parsed.cronExpr;
+      }
+    }
+  }
+
+  if (!cronExpr && !cadence && intervalMs === undefined) {
+    throw new Error("Scheduled trigger requires at least one of cronExpr, cadence, or intervalMs.");
+  }
+
+  if (cronExpr) {
+    validateCronExpr(cronExpr);
+  }
+
+  return {
+    type: "scheduled",
+    ...(cadence ? { cadence } : {}),
+    ...(cronExpr ? { cronExpr } : {}),
+    ...(intervalMs !== undefined ? { intervalMs } : {}),
+  };
+}
+
+function normalizeConditionTrigger(value: unknown): ConditionAutomationTrigger {
+  const raw = asRecord(value);
+  const condition = asTrimmedString(raw.condition);
+  const checkEveryMs = asPositiveInteger(raw.checkEveryMs) ?? DEFAULT_CONDITION_CHECK_EVERY_MS;
+
+  if (!condition) {
+    throw new Error("Condition trigger requires a non-empty condition.");
+  }
+
+  if (checkEveryMs < 60_000) {
+    throw new Error("Condition trigger requires checkEveryMs >= 60000.");
+  }
+
+  return {
+    type: "condition",
+    condition,
+    checkEveryMs,
+  };
+}
+
+function normalizeTrigger(value: unknown): AutomationTrigger {
+  const raw = asRecord(value);
+  if (raw.type !== "scheduled" && raw.type !== "condition") {
+    throw new Error('Automation trigger.type must be "scheduled" or "condition".');
+  }
+  const type = raw.type;
+  return type === "condition"
+    ? normalizeConditionTrigger(raw)
+    : normalizeScheduledTrigger(raw);
+}
+
+function normalizeExecution(value: unknown): AutomationExecution | undefined {
+  if (value === null || value === undefined) {
+    return undefined;
+  }
+
+  const raw = asRecord(value);
+  const execution: AutomationExecution = {};
+
+  if (raw.overlapPolicy === "skip" || raw.overlapPolicy === "queue" || raw.overlapPolicy === "allow") {
+    execution.overlapPolicy = raw.overlapPolicy;
+  }
+  if (
+    raw.catchUpPolicy === "fire_once"
+    || raw.catchUpPolicy === "replay_all"
+    || raw.catchUpPolicy === "skip"
+  ) {
+    execution.catchUpPolicy = raw.catchUpPolicy;
+  }
+
+  const cancelCheckSec = asPositiveInteger(raw.cancelCheckSec);
+  if (cancelCheckSec !== undefined) {
+    if (cancelCheckSec < 1) {
+      throw new Error("execution.cancelCheckSec must be >= 1.");
+    }
+    execution.cancelCheckSec = cancelCheckSec;
+  }
+
+  const maxRuns = asPositiveInteger(raw.maxRuns);
+  if (maxRuns !== undefined) {
+    execution.maxRuns = maxRuns;
+  }
+
+  const maxConsecutiveFailures = asPositiveInteger(raw.maxConsecutiveFailures);
+  if (maxConsecutiveFailures !== undefined) {
+    execution.maxConsecutiveFailures = maxConsecutiveFailures;
+  }
+
+  const activeUntil = asTrimmedString(raw.activeUntil);
+  if (activeUntil) {
+    if (!isValidIsoTimestamp(activeUntil)) {
+      throw new Error(`Invalid execution.activeUntil timestamp: "${activeUntil}"`);
+    }
+    execution.activeUntil = new Date(activeUntil).toISOString();
+  }
+
+  return Object.keys(execution).length > 0 ? execution : undefined;
+}
+
+function normalizePromptTarget(value: unknown): PromptJobAutomationTarget {
+  const raw = asRecord(value);
+  const target: PromptJobAutomationTarget = { type: "prompt_job" };
+
+  const agentId = asTrimmedString(raw.agentId);
+  const provider = asTrimmedString(raw.provider);
+  const model = asTrimmedString(raw.model);
+  const cliArgs = asTrimmedString(raw.cliArgs);
+  const prompt = typeof raw.prompt === "string" && raw.prompt.length > 0
+    ? raw.prompt
+    : undefined;
+
+  if (!provider && !agentId) {
+    throw new Error("Prompt-job target requires provider or agentId.");
+  }
+
+  if (agentId) target.agentId = agentId;
+  if (provider) target.provider = provider;
+  if (model) target.model = model;
+  if (cliArgs !== undefined) target.cliArgs = cliArgs;
+  if (prompt !== undefined) target.prompt = prompt;
+  return target;
+}
+
+function normalizeExecutionGraphTarget(value: unknown): ExecutionGraphAutomationTarget {
+  const raw = asRecord(value);
+  const graphId = asTrimmedString(raw.graphId);
+  const taskId = asTrimmedString(raw.taskId);
+  const resetNodeIds = asStringArray(raw.resetNodeIds);
+  const rootMessageId = asTrimmedString(raw.rootMessageId);
+
+  if (!graphId && !taskId) {
+    throw new Error("Execution-graph target requires graphId or taskId.");
+  }
+
+  return {
+    type: "execution_graph",
+    ...(graphId ? { graphId } : {}),
+    ...(taskId ? { taskId } : {}),
+    ...(resetNodeIds ? { resetNodeIds } : {}),
+    ...(rootMessageId ? { rootMessageId } : {}),
+  };
+}
+
+function normalizeTarget(value: unknown): AutomationTarget {
+  const raw = asRecord(value);
+  if (raw.type !== "prompt_job" && raw.type !== "execution_graph") {
+    throw new Error('Automation target.type must be "prompt_job" or "execution_graph".');
+  }
+  return raw.type === "execution_graph"
+    ? normalizeExecutionGraphTarget(raw)
+    : normalizePromptTarget(raw);
+}
+
+export function resolvePromptFromDefinition(definition: AutomationDefinition): string | null {
+  if (definition.target.type !== "prompt_job") {
+    return null;
+  }
+  const body = typeof definition.body === "string" ? definition.body : "";
+  if (body.trim().length > 0) {
+    return body;
+  }
+  const targetPrompt = definition.target.prompt;
+  return typeof targetPrompt === "string" && targetPrompt.length > 0
+    ? targetPrompt
+    : null;
+}
+
+export function normalizeAutomationDefinition(value: unknown): AutomationDefinition {
+  const raw = asRecord(value);
+  const id = asTrimmedString(raw.id);
+  const name = asTrimmedString(raw.name);
+  const description = asTrimmedString(raw.description);
+  const projectId = asTrimmedString(raw.projectId);
+  const createdAt = asTrimmedString(raw.createdAt);
+  const body = typeof raw.body === "string" ? raw.body : "";
+
+  if (!id) {
+    throw new Error("Automation id is required.");
+  }
+  if (!name) {
+    throw new Error("Automation name is required.");
+  }
+  if (createdAt && !isValidIsoTimestamp(createdAt)) {
+    throw new Error(`Invalid createdAt timestamp: "${createdAt}"`);
+  }
+
+  const trigger = normalizeTrigger(raw.trigger);
+  const execution = normalizeExecution(raw.execution);
+  const target = normalizeTarget(raw.target);
+
+  if (target.type === "prompt_job") {
+    const prompt = resolvePromptFromDefinition({
+      id,
+      name,
+      description,
+      projectId,
+      state: normalizeState(raw.state),
+      trigger,
+      execution,
+      target,
+      createdAt,
+      body,
+    });
+
+    if (!prompt) {
+      throw new Error("Prompt-job automation requires prompt text in body or target.prompt.");
+    }
+
+    const cancelCheckSec = execution?.cancelCheckSec ?? DEFAULT_CANCEL_CHECK_SEC;
+    if (cancelCheckSec < 1) {
+      throw new Error("Prompt-job execution.cancelCheckSec must be >= 1.");
+    }
+  }
+
+  return {
+    id,
+    name,
+    ...(description ? { description } : {}),
+    ...(projectId ? { projectId } : {}),
+    state: normalizeState(raw.state),
+    trigger,
+    ...(execution ? { execution } : {}),
+    target,
+    ...(createdAt ? { createdAt: new Date(createdAt).toISOString() } : {}),
+    body,
+  };
+}
+
+export function getExecutionWithDefaults(
+  definition: AutomationDefinition,
+): Required<Pick<AutomationExecution, "overlapPolicy" | "catchUpPolicy" | "cancelCheckSec">> & AutomationExecution {
+  return {
+    overlapPolicy: definition.execution?.overlapPolicy ?? DEFAULT_OVERLAP_POLICY,
+    catchUpPolicy: definition.execution?.catchUpPolicy ?? DEFAULT_CATCH_UP_POLICY,
+    cancelCheckSec: definition.execution?.cancelCheckSec ?? DEFAULT_CANCEL_CHECK_SEC,
+    ...(definition.execution ?? {}),
+  };
+}

package/cloud-runtime/standalone/src/graph/schedule-runner.ts

@@ -1,5 +1,10 @@
-import type { DatabaseSync } from 'node:sqlite';
 import { getSQLiteDb } from '@/lib/sqlite-query-adapter';
+import {
+  automationRecordToGraphSchedule,
+  getAutomationRepository,
+  isAutomationDualReadEnabled,
+  isAutomationFrontmatterEnabled,
+} from '@/src/automations';
 import { scheduleTickIfDue, completeScheduleTick, isScheduleTickComplete } from './schedule';
 import { schedulerTick } from './scheduler';
 import { executeNode, type ExecutorContext } from './executor';
@@ -33,6 +38,7 @@ export interface SchedulePollResult {
  * Fetches all graphs with active schedules from the database.
  */
 export function getGraphsWithActiveSchedules(): Array<{ taskId: string; graphId: string; schedule: GraphSchedule }> {
+  const recordsByGraphId = new Map<string, { taskId: string; graphId: string; schedule: GraphSchedule }>();
   const db = getSQLiteDb();
   const rows = db.prepare(`
     SELECT task_id, id, schedule
@@ -40,12 +46,44 @@ export function getGraphsWithActiveSchedules(): Array<{ taskId: string; graphId:
     WHERE schedule IS NOT NULL
       AND json_extract(schedule, '$.state') = 'active'
   `).all() as Array<{ task_id: string; id: string; schedule: string }>;
+  const rowByGraphId = new Map(rows.map((row) => [row.id, row]));
+
+  if (isAutomationFrontmatterEnabled()) {
+    for (const record of getAutomationRepository().listVisibleAutomations({
+      targetType: 'execution_graph',
+      state: 'active',
+    })) {
+      if (record.definition.target.type !== 'execution_graph') {
+        continue;
+      }
 
-  return rows.map((row) => ({
-    taskId: row.task_id,
-    graphId: row.id,
-    schedule: JSON.parse(row.schedule) as GraphSchedule,
-  }));
+      const graphId = record.definition.target.graphId ?? record.definition.id;
+      const taskId = record.definition.target.taskId ?? rowByGraphId.get(graphId)?.task_id ?? graphId;
+      recordsByGraphId.set(graphId, {
+        taskId,
+        graphId,
+        schedule: automationRecordToGraphSchedule(record, rowByGraphId.get(graphId)
+          ? JSON.parse(rowByGraphId.get(graphId)!.schedule) as GraphSchedule
+          : undefined),
+      });
+    }
+
+    if (!isAutomationDualReadEnabled()) {
+      return [...recordsByGraphId.values()];
+    }
+  }
+
+  for (const row of rows) {
+    if (!recordsByGraphId.has(row.id)) {
+      recordsByGraphId.set(row.id, {
+        taskId: row.task_id,
+        graphId: row.id,
+        schedule: JSON.parse(row.schedule) as GraphSchedule,
+      });
+    }
+  }
+
+  return [...recordsByGraphId.values()];
 }
 
 /**
@@ -354,4 +392,4 @@ export async function executeScheduleTick(
   });
 
   return { fired: true, graph: finalGraph };
-}
+}