@runfusion/fusion 0.43.1 → 0.45.0

package/dist/chunk-UXR5XZFZ.js

@@ -0,0 +1,409 @@
+import {
+  assertProjectRootDir,
+  require_dist
+} from "./chunk-RXMQ5OMY.js";
+import {
+  Database,
+  fromJson
+} from "./chunk-BMUXDSBF.js";
+import {
+  __toESM
+} from "./chunk-4VNS5WPM.js";
+
+// ../core/dist/routine-store.js
+var import_cron_parser = __toESM(require_dist(), 1);
+import { EventEmitter } from "events";
+import { randomUUID } from "crypto";
+
+// ../core/dist/routine.js
+function isCronTrigger(trigger) {
+  return trigger.type === "cron";
+}
+var MAX_ROUTINE_RUN_HISTORY = 50;
+
+// ../core/dist/routine-store.js
+var CRON_TIMEZONE = "UTC";
+var RoutineStore = class _RoutineStore extends EventEmitter {
+  rootDir;
+  /** SQLite database instance (lazy init). */
+  _db = null;
+  /** Per-routine promise chain for serializing writes. */
+  routineLocks = /* @__PURE__ */ new Map();
+  inMemoryDb;
+  constructor(rootDir, options) {
+    super();
+    this.rootDir = rootDir;
+    assertProjectRootDir(rootDir, "RoutineStore");
+    this.inMemoryDb = options?.inMemoryDb === true;
+  }
+  // ── Database Access ────────────────────────────────────────────────
+  /**
+   * Get the SQLite database, initializing it on first access.
+   */
+  get db() {
+    if (!this._db) {
+      const fusionDir = `${this.rootDir}/.fusion`;
+      this._db = new Database(fusionDir, { inMemory: this.inMemoryDb });
+      this._db.init();
+    }
+    return this._db;
+  }
+  /** Initialize the store (no-op, DB is lazily initialized). */
+  async init() {
+    const _ = this.db;
+  }
+  // ── Row Conversion ─────────────────────────────────────────────────
+  rowToRoutine(row) {
+    const triggerConfig = fromJson(row.triggerConfig);
+    let trigger;
+    switch (row.triggerType) {
+      case "cron":
+        trigger = {
+          type: "cron",
+          cronExpression: triggerConfig?.cronExpression ?? "0 * * * *",
+          timezone: triggerConfig?.timezone
+        };
+        break;
+      case "webhook":
+        trigger = {
+          type: "webhook",
+          webhookPath: triggerConfig?.webhookPath ?? "",
+          secret: triggerConfig?.secret
+        };
+        break;
+      case "api":
+        trigger = {
+          type: "api",
+          endpoint: triggerConfig?.endpoint ?? ""
+        };
+        break;
+      case "manual":
+      default:
+        trigger = { type: "manual" };
+        break;
+    }
+    return {
+      id: row.id,
+      agentId: row.agentId || "",
+      name: row.name,
+      description: row.description || void 0,
+      trigger,
+      command: row.command || void 0,
+      steps: fromJson(row.steps),
+      timeoutMs: row.timeoutMs ?? void 0,
+      catchUpPolicy: row.catchUpPolicy || "run_one",
+      executionPolicy: row.executionPolicy || "queue",
+      enabled: row.enabled === 1,
+      lastRunAt: row.lastRunAt || void 0,
+      lastRunResult: fromJson(row.lastRunResult),
+      nextRunAt: row.nextRunAt || void 0,
+      runCount: row.runCount || 0,
+      runHistory: fromJson(row.runHistory) || [],
+      catchUpLimit: row.catchUpLimit ?? 5,
+      cronExpression: isCronTrigger(trigger) ? trigger.cronExpression : void 0,
+      scope: row.scope || "project",
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt
+    };
+  }
+  upsertRoutine(routine) {
+    const trigger = routine.trigger;
+    let triggerConfig = {};
+    if (isCronTrigger(trigger)) {
+      triggerConfig = {
+        cronExpression: trigger.cronExpression,
+        timezone: trigger.timezone
+      };
+    } else if (trigger.type === "webhook") {
+      triggerConfig = {
+        webhookPath: trigger.webhookPath,
+        secret: trigger.secret
+      };
+    } else if (trigger.type === "api") {
+      triggerConfig = {
+        endpoint: trigger.endpoint
+      };
+    }
+    this.db.prepare(`
+      INSERT OR REPLACE INTO routines (
+        id, agentId, name, description, triggerType, triggerConfig,
+        command, steps, timeoutMs,
+        catchUpPolicy, executionPolicy, catchUpLimit, enabled,
+        lastRunAt, lastRunResult, nextRunAt,
+        runCount, runHistory, scope, createdAt, updatedAt
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(routine.id, routine.agentId, routine.name, routine.description ?? null, trigger.type, JSON.stringify(triggerConfig), routine.command ?? null, routine.steps ? JSON.stringify(routine.steps) : null, routine.timeoutMs ?? null, routine.catchUpPolicy, routine.executionPolicy, routine.catchUpLimit ?? 5, routine.enabled ? 1 : 0, routine.lastRunAt ?? null, routine.lastRunResult ? JSON.stringify(routine.lastRunResult) : null, routine.nextRunAt ?? null, routine.runCount || 0, JSON.stringify(routine.runHistory || []), routine.scope ?? "project", routine.createdAt, routine.updatedAt);
+    this.db.bumpLastModified();
+  }
+  // ── Locking ───────────────────────────────────────────────────────
+  /**
+   * Serialize all mutations to a given routine by chaining promises.
+   * Concurrent callers for the same ID will queue behind each other.
+   */
+  withRoutineLock(id, fn) {
+    const prev = this.routineLocks.get(id) ?? Promise.resolve();
+    let resolve;
+    const next = new Promise((r) => {
+      resolve = r;
+    });
+    this.routineLocks.set(id, next);
+    return prev.then(async () => {
+      try {
+        return await fn();
+      } finally {
+        if (this.routineLocks.get(id) === next) {
+          this.routineLocks.delete(id);
+        }
+        resolve();
+      }
+    });
+  }
+  // ── Cron Utilities ────────────────────────────────────────────────
+  /**
+   * Compute the next run time from a cron expression.
+   * @param cronExpression - A valid cron expression (5 fields).
+   * @param fromDate - The date to compute from. Defaults to now.
+   * @returns ISO-8601 timestamp of the next run.
+   */
+  computeNextRun(cronExpression, fromDate) {
+    const interval = import_cron_parser.CronExpressionParser.parse(cronExpression, {
+      currentDate: fromDate ?? /* @__PURE__ */ new Date(),
+      tz: CRON_TIMEZONE
+    });
+    const next = interval.next();
+    return new Date(next.getTime()).toISOString();
+  }
+  /**
+   * Validate a cron expression. Returns true if valid.
+   */
+  static isValidCron(cronExpression) {
+    try {
+      import_cron_parser.CronExpressionParser.parse(cronExpression);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  // ── CRUD ──────────────────────────────────────────────────────────
+  /**
+   * Create a new routine.
+   */
+  async createRoutine(input) {
+    if (!input.name?.trim()) {
+      throw new Error("Name is required and cannot be empty");
+    }
+    if (isCronTrigger(input.trigger)) {
+      if (!_RoutineStore.isValidCron(input.trigger.cronExpression)) {
+        throw new Error(`Invalid cron expression: "${input.trigger.cronExpression}"`);
+      }
+    }
+    const id = randomUUID();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const enabled = input.enabled !== void 0 ? input.enabled : true;
+    const routine = {
+      id,
+      agentId: input.agentId,
+      name: input.name.trim(),
+      description: input.description?.trim() || void 0,
+      trigger: input.trigger,
+      command: input.command?.trim() || void 0,
+      steps: input.steps && input.steps.length > 0 ? input.steps : void 0,
+      timeoutMs: input.timeoutMs,
+      catchUpPolicy: input.catchUpPolicy ?? "run_one",
+      executionPolicy: input.executionPolicy ?? "queue",
+      enabled,
+      runCount: 0,
+      runHistory: [],
+      scope: input.scope ?? "project",
+      createdAt: now,
+      updatedAt: now
+    };
+    if (enabled && isCronTrigger(routine.trigger)) {
+      routine.nextRunAt = this.computeNextRun(routine.trigger.cronExpression);
+    }
+    this.upsertRoutine(routine);
+    this.emit("routine:created", routine);
+    return routine;
+  }
+  /**
+   * Get a routine by ID.
+   */
+  async getRoutine(id) {
+    const row = this.db.prepare("SELECT * FROM routines WHERE id = ?").get(id);
+    if (!row) {
+      throw Object.assign(new Error(`Routine '${id}' not found`), { code: "ENOENT" });
+    }
+    return this.rowToRoutine(row);
+  }
+  /**
+   * List all routines.
+   */
+  async listRoutines() {
+    const rows = this.db.prepare("SELECT * FROM routines ORDER BY createdAt ASC").all();
+    return rows.map((row) => this.rowToRoutine(row));
+  }
+  /**
+   * Update an existing routine.
+   */
+  async updateRoutine(id, updates) {
+    return this.withRoutineLock(id, async () => {
+      const routine = await this.getRoutine(id);
+      if (updates.name !== void 0) {
+        if (!updates.name.trim())
+          throw new Error("Name cannot be empty");
+        routine.name = updates.name.trim();
+      }
+      if (updates.description !== void 0) {
+        routine.description = updates.description?.trim() || void 0;
+      }
+      if (updates.trigger !== void 0) {
+        if (isCronTrigger(updates.trigger)) {
+          if (!_RoutineStore.isValidCron(updates.trigger.cronExpression)) {
+            throw new Error(`Invalid cron expression: "${updates.trigger.cronExpression}"`);
+          }
+        }
+        routine.trigger = updates.trigger;
+      }
+      if (updates.command !== void 0) {
+        routine.command = updates.command?.trim() || void 0;
+      }
+      if (updates.steps !== void 0) {
+        routine.steps = updates.steps.length > 0 ? updates.steps : void 0;
+      }
+      if (updates.timeoutMs !== void 0) {
+        routine.timeoutMs = updates.timeoutMs;
+      }
+      if (updates.catchUpPolicy !== void 0) {
+        routine.catchUpPolicy = updates.catchUpPolicy;
+      }
+      if (updates.executionPolicy !== void 0) {
+        routine.executionPolicy = updates.executionPolicy;
+      }
+      if (updates.enabled !== void 0) {
+        routine.enabled = updates.enabled;
+      }
+      if (routine.enabled && isCronTrigger(routine.trigger)) {
+        routine.nextRunAt = this.computeNextRun(routine.trigger.cronExpression);
+      } else if (!routine.enabled || !isCronTrigger(routine.trigger)) {
+        routine.nextRunAt = void 0;
+      }
+      routine.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      this.upsertRoutine(routine);
+      this.emit("routine:updated", routine);
+      return routine;
+    });
+  }
+  /**
+   * Delete a routine.
+   */
+  async deleteRoutine(id) {
+    return this.withRoutineLock(id, async () => {
+      const routine = await this.getRoutine(id);
+      this.db.prepare("DELETE FROM routines WHERE id = ?").run(id);
+      this.db.bumpLastModified();
+      this.emit("routine:deleted", routine);
+      return routine;
+    });
+  }
+  // ── Run Tracking ─────────────────────────────────────────────────
+  /**
+   * Record a run result for a routine. Updates lastRunAt, lastRunResult,
+   * nextRunAt, runCount, and appends to runHistory.
+   */
+  async recordRun(id, result) {
+    return this.withRoutineLock(id, async () => {
+      const routine = await this.getRoutine(id);
+      routine.lastRunAt = result.startedAt;
+      routine.lastRunResult = result;
+      routine.runCount += 1;
+      routine.runHistory.unshift(result);
+      if (routine.runHistory.length > MAX_ROUTINE_RUN_HISTORY) {
+        routine.runHistory = routine.runHistory.slice(0, MAX_ROUTINE_RUN_HISTORY);
+      }
+      if (routine.enabled && isCronTrigger(routine.trigger)) {
+        routine.nextRunAt = this.computeNextRun(routine.trigger.cronExpression);
+      }
+      routine.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      this.upsertRoutine(routine);
+      this.emit("routine:run", { routine, result });
+      return routine;
+    });
+  }
+  /**
+   * Mark a routine execution as started (pre-run bookkeeping).
+   */
+  async startRoutineExecution(id, meta) {
+    await this.withRoutineLock(id, async () => {
+      const routine = await this.getRoutine(id);
+      routine.lastRunAt = meta.triggeredAt;
+      routine.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      this.upsertRoutine(routine);
+    });
+  }
+  /**
+   * Record the completion (success or failure) of a routine execution.
+   */
+  async completeRoutineExecution(id, meta) {
+    await this.withRoutineLock(id, async () => {
+      const routine = await this.getRoutine(id);
+      const result = {
+        routineId: id,
+        success: meta.success,
+        output: meta.output ?? (meta.success ? JSON.stringify(meta.resultJson ?? {}) : ""),
+        error: meta.error,
+        startedAt: routine.lastRunAt ?? meta.completedAt,
+        completedAt: meta.completedAt,
+        triggerType: meta.triggerType,
+        stepResults: meta.stepResults
+      };
+      routine.lastRunAt = result.startedAt;
+      routine.lastRunResult = result;
+      routine.runCount += 1;
+      routine.runHistory.unshift(result);
+      if (routine.runHistory.length > MAX_ROUTINE_RUN_HISTORY) {
+        routine.runHistory = routine.runHistory.slice(0, MAX_ROUTINE_RUN_HISTORY);
+      }
+      if (routine.enabled && isCronTrigger(routine.trigger)) {
+        routine.nextRunAt = this.computeNextRun(routine.trigger.cronExpression);
+      }
+      routine.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      this.upsertRoutine(routine);
+      this.emit("routine:run", { routine, result });
+    });
+  }
+  /**
+   * Cancel a routine execution (no result recorded, just reset state).
+   */
+  async cancelRoutineExecution(id) {
+    await this.withRoutineLock(id, async () => {
+      const routine = await this.getRoutine(id);
+      if (routine.enabled && isCronTrigger(routine.trigger)) {
+        routine.nextRunAt = this.computeNextRun(routine.trigger.cronExpression);
+      }
+      routine.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      this.upsertRoutine(routine);
+    });
+  }
+  /**
+   * Get all routines that are due to run (nextRunAt <= now and enabled).
+   * Filters by scope: "global" or "project".
+   */
+  async getDueRoutines(scope) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const rows = this.db.prepare("SELECT * FROM routines WHERE enabled = 1 AND nextRunAt IS NOT NULL AND nextRunAt <= ? AND scope = ?").all(now, scope);
+    return rows.map((row) => this.rowToRoutine(row));
+  }
+  /**
+   * Get all routines that are due to run (nextRunAt <= now and enabled) for both scopes.
+   * Returns routines from both "global" and "project" scopes.
+   */
+  async getDueRoutinesAllScopes() {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const rows = this.db.prepare("SELECT * FROM routines WHERE enabled = 1 AND nextRunAt IS NOT NULL AND nextRunAt <= ?").all(now);
+    return rows.map((row) => this.rowToRoutine(row));
+  }
+};
+
+export {
+  RoutineStore
+};