volute 0.48.0 → 0.50.0

package/dist/chunk-7FDWPQCU.js

@@ -0,0 +1,289 @@
+#!/usr/bin/env node
+import {
+  buildMindBaseEnv,
+  clearJsonMap,
+  generateMindToken,
+  getMindToken,
+  loadJsonMap,
+  saveJsonMapAsync
+} from "./chunk-ALIVXDM4.js";
+import {
+  deliverEvent
+} from "./chunk-7OZWKHA3.js";
+import {
+  isSandboxEnabled,
+  wrapForSandbox
+} from "./chunk-ZUG76D3P.js";
+import {
+  readVoluteConfig,
+  writeVoluteConfig
+} from "./chunk-WCFSBH33.js";
+import {
+  exec
+} from "./chunk-AJWFDIEY.js";
+import {
+  loadMergedEnv
+} from "./chunk-7UWXAJMK.js";
+import {
+  logger_default
+} from "./chunk-QUSMYGNQ.js";
+import {
+  findMind,
+  mindDir,
+  mindTmpDir,
+  mindTmpEnv,
+  stateDir,
+  voluteSystemDir
+} from "./chunk-CAIYV33P.js";
+
+// packages/daemon/src/lib/daemon/scheduler.ts
+import { resolve } from "path";
+import { CronExpressionParser } from "cron-parser";
+var slog = logger_default.child("scheduler");
+var CATCHUP_STALE_MINUTES = 10;
+var Scheduler = class {
+  schedules = /* @__PURE__ */ new Map();
+  mindDirs = /* @__PURE__ */ new Map();
+  // mindName → dir override
+  interval = null;
+  lastFired = /* @__PURE__ */ new Map();
+  // "mind:scheduleId" → epoch minute
+  get statePath() {
+    return resolve(voluteSystemDir(), "scheduler-state.json");
+  }
+  start() {
+    this.loadState();
+    this.interval = setInterval(() => {
+      this.tick().catch((err) => slog.error("scheduler tick failed", logger_default.errorData(err)));
+    }, 6e4);
+  }
+  stop() {
+    if (this.interval) clearInterval(this.interval);
+  }
+  loadState() {
+    this.lastFired = loadJsonMap(this.statePath);
+  }
+  async saveState() {
+    await saveJsonMapAsync(this.statePath, this.lastFired);
+  }
+  clearState() {
+    clearJsonMap(this.statePath, this.lastFired);
+  }
+  loadSchedules(mindName, dir) {
+    if (dir) this.mindDirs.set(mindName, dir);
+    const resolvedDir = this.mindDirs.get(mindName) ?? mindDir(mindName);
+    const config = readVoluteConfig(resolvedDir);
+    if (!config) return;
+    const schedules = config.schedules ?? [];
+    if (schedules.length > 0) {
+      this.schedules.set(mindName, schedules);
+    } else {
+      this.schedules.delete(mindName);
+    }
+    const epochMinute = Math.floor(Date.now() / 6e4);
+    const validKeys = new Set(schedules.map((s) => `${mindName}:${s.id}`));
+    let changed = false;
+    for (const key of this.lastFired.keys()) {
+      if (key.startsWith(`${mindName}:`) && !validKeys.has(key)) {
+        this.lastFired.delete(key);
+        changed = true;
+      }
+    }
+    for (const key of validKeys) {
+      if (!this.lastFired.has(key)) {
+        this.lastFired.set(key, epochMinute);
+        changed = true;
+      }
+    }
+    if (changed) {
+      this.saveState().catch(
+        (err) => slog.warn(`failed to persist scheduler state for ${mindName}`, logger_default.errorData(err))
+      );
+    }
+  }
+  unloadSchedules(mindName) {
+    this.schedules.delete(mindName);
+    this.mindDirs.delete(mindName);
+  }
+  async tick() {
+    const now = /* @__PURE__ */ new Date();
+    const epochMinute = Math.floor(now.getTime() / 6e4);
+    const cronCache = /* @__PURE__ */ new Map();
+    let anyFired = false;
+    for (const [mind, schedules] of this.schedules) {
+      for (const schedule of schedules) {
+        if (!schedule.enabled) continue;
+        if (this.shouldFire(schedule, epochMinute, mind, cronCache)) {
+          anyFired = true;
+          this.fire(mind, schedule);
+        }
+      }
+    }
+    if (anyFired) await this.saveState();
+  }
+  shouldFire(schedule, epochMinute, mind, cronCache) {
+    const key = `${mind}:${schedule.id}`;
+    if (this.lastFired.get(key) === epochMinute) return false;
+    if (schedule.fireAt) {
+      const fireTime = Math.floor(new Date(schedule.fireAt).getTime() / 6e4);
+      if (epochMinute >= fireTime) {
+        this.lastFired.set(key, epochMinute);
+        return true;
+      }
+      return false;
+    }
+    if (!schedule.cron) return false;
+    let prevMinute = cronCache.get(schedule.cron);
+    if (prevMinute === void 0) {
+      try {
+        const interval = CronExpressionParser.parse(schedule.cron);
+        const prev = interval.prev().toDate();
+        prevMinute = Math.floor(prev.getTime() / 6e4);
+        cronCache.set(schedule.cron, prevMinute);
+      } catch (err) {
+        slog.warn(`invalid cron "${schedule.cron}" for ${mind}:${schedule.id}`, logger_default.errorData(err));
+        return false;
+      }
+    }
+    const lastFired = this.lastFired.get(key) ?? epochMinute;
+    if (prevMinute <= lastFired) return false;
+    this.lastFired.set(key, prevMinute);
+    if (epochMinute - prevMinute > CATCHUP_STALE_MINUTES) {
+      slog.info(`skipping stale catch-up fire for ${key} (${epochMinute - prevMinute}min late)`);
+      return false;
+    }
+    return true;
+  }
+  async fire(mindName, schedule) {
+    try {
+      let text;
+      if (schedule.script) {
+        const homeDir = resolve(this.mindDirs.get(mindName) ?? mindDir(mindName), "home");
+        try {
+          const output = await this.runScript(schedule.script, homeDir, mindName);
+          if (!output.trim()) {
+            slog.info(`fired script "${schedule.id}" for ${mindName} (no output)`);
+            return;
+          }
+          text = output;
+        } catch (err) {
+          const stderr = err.stderr ?? "";
+          text = `[script error] ${err.message}${stderr ? `
+${stderr}` : ""}`;
+          slog.warn(`script "${schedule.id}" failed for ${mindName}`, logger_default.errorData(err));
+        }
+      } else if (Array.isArray(schedule.messages) && schedule.messages.length > 0) {
+        const pick = schedule.messages[Math.floor(Math.random() * schedule.messages.length)];
+        if (typeof pick !== "string" || !pick.trim()) {
+          slog.warn(`schedule "${schedule.id}" for ${mindName} has a malformed messages pool`);
+          return;
+        }
+        text = pick;
+      } else if (schedule.message) {
+        text = schedule.message;
+      } else {
+        slog.warn(`schedule "${schedule.id}" for ${mindName} has no message, messages, or script`);
+        return;
+      }
+      const { id, delivered } = await this.deliverSystem(mindName, schedule.id, text, {
+        // Default schedule fires to "queue" while asleep so an unadorned cron
+        // schedule doesn't inherit the DM wake-trigger fallback and wake the mind.
+        whileSleeping: schedule.whileSleeping ?? "queue",
+        thread: schedule.thread
+      });
+      slog.info(`fired "${schedule.id}" for ${mindName}${delivered ? "" : " (event pending)"}`);
+      if (schedule.fireAt && id != null) {
+        this.removeSchedule(mindName, schedule.id);
+      }
+    } catch (err) {
+      slog.warn(`failed to fire "${schedule.id}" for ${mindName}`, logger_default.errorData(err));
+    }
+  }
+  removeSchedule(mindName, scheduleId) {
+    const memSchedules = this.schedules.get(mindName);
+    if (memSchedules) {
+      const filtered = memSchedules.filter((s) => s.id !== scheduleId);
+      if (filtered.length > 0) {
+        this.schedules.set(mindName, filtered);
+      } else {
+        this.schedules.delete(mindName);
+      }
+    }
+    try {
+      const dir = this.mindDirs.get(mindName) ?? mindDir(mindName);
+      const config = readVoluteConfig(dir);
+      if (!config?.schedules) return;
+      config.schedules = config.schedules.filter((s) => s.id !== scheduleId);
+      if (config.schedules.length === 0) config.schedules = void 0;
+      writeVoluteConfig(dir, config);
+      slog.info(`removed one-time schedule "${scheduleId}" for ${mindName}`);
+    } catch (err) {
+      slog.error(
+        `failed to persist removal of schedule "${scheduleId}" for ${mindName} (removed from memory)`,
+        logger_default.errorData(err)
+      );
+    }
+  }
+  async runScript(script, cwd, mindName) {
+    const env = await this.buildScriptEnv(mindName);
+    if (isSandboxEnabled()) {
+      const dir = this.mindDirs.get(mindName) ?? mindDir(mindName);
+      const [cmd, args] = await wrapForSandbox("bash", ["-c", script], dir, mindName, [
+        dir,
+        mindTmpDir(dir)
+      ]);
+      return exec(cmd, args, { cwd, env });
+    }
+    return exec("bash", ["-c", script], { cwd, mindName, env });
+  }
+  /**
+   * Build the environment for a scheduled script — mirrors the mind process env
+   * (allowlisted base + merged mind env + VOLUTE_* runtime vars), authenticated
+   * with the mind's own per-mind, non-admin token. Reuses the running mind's
+   * token when present; otherwise mints one (stable across fires, regenerated on
+   * next mind start). The daemon admin token is never included.
+   */
+  async buildScriptEnv(mindName) {
+    const dir = this.mindDirs.get(mindName) ?? mindDir(mindName);
+    const entry = await findMind(mindName);
+    const token = getMindToken(mindName) ?? generateMindToken(mindName);
+    const mindLocalBin = resolve(dir, "home", ".local", "bin");
+    const currentPath = process.env.PATH ?? "";
+    return {
+      ...buildMindBaseEnv(),
+      ...loadMergedEnv(mindName),
+      VOLUTE_MIND: mindName,
+      VOLUTE_STATE_DIR: stateDir(mindName),
+      VOLUTE_MIND_DIR: dir,
+      VOLUTE_MIND_PORT: entry ? String(entry.port) : void 0,
+      VOLUTE_MIND_TOKEN: token,
+      ...mindTmpEnv(dir),
+      PATH: `${mindLocalBin}:${currentPath}`
+    };
+  }
+  async deliverSystem(mindName, scheduleId, text, opts) {
+    return deliverEvent(mindName, {
+      type: "schedule",
+      body: text,
+      meta: { scheduleId },
+      thread: opts?.thread,
+      whileSleeping: opts?.whileSleeping
+    });
+  }
+};
+var instance = null;
+function initScheduler() {
+  if (instance) throw new Error("Scheduler already initialized");
+  instance = new Scheduler();
+  return instance;
+}
+function getScheduler() {
+  if (!instance) throw new Error("Scheduler not initialized \u2014 call initScheduler() first");
+  return instance;
+}
+
+export {
+  Scheduler,
+  initScheduler,
+  getScheduler
+};