agent.libx.js 0.93.45 → 0.94.1

package/dist/cli.js

@@ -3496,6 +3496,253 @@ init_OverlayFilesystem();
 // src/index.ts
 init_tools();
 
+// src/scheduler.ts
+function parseCronField(field, min, max) {
+  const vals = /* @__PURE__ */ new Set();
+  for (const part of field.split(",")) {
+    const [rangeStr, stepStr] = part.split("/");
+    const step = stepStr ? parseInt(stepStr, 10) : 1;
+    if (isNaN(step) || step < 1) throw new Error(`invalid cron step: ${part}`);
+    let lo, hi;
+    if (rangeStr === "*") {
+      lo = min;
+      hi = max;
+    } else if (rangeStr.includes("-")) {
+      const [a, b] = rangeStr.split("-").map(Number);
+      if (isNaN(a) || isNaN(b)) throw new Error(`invalid cron range: ${part}`);
+      lo = a;
+      hi = b;
+    } else {
+      const n = parseInt(rangeStr, 10);
+      if (isNaN(n)) throw new Error(`invalid cron value: ${part}`);
+      lo = n;
+      hi = stepStr ? max : n;
+    }
+    for (let i = lo; i <= hi; i += step) vals.add(i);
+  }
+  return [...vals].sort((a, b) => a - b);
+}
+function parseCron(expr) {
+  const parts = expr.trim().split(/\s+/);
+  if (parts.length !== 5) throw new Error(`cron expression must have 5 fields (minute hour dom month dow), got ${parts.length}: "${expr}"`);
+  return {
+    minute: parseCronField(parts[0], 0, 59),
+    hour: parseCronField(parts[1], 0, 23),
+    dom: parseCronField(parts[2], 1, 31),
+    month: parseCronField(parts[3], 1, 12),
+    dow: parseCronField(parts[4], 0, 6)
+  };
+}
+function cronMatches(fields, date) {
+  return fields.minute.includes(date.getMinutes()) && fields.hour.includes(date.getHours()) && fields.dom.includes(date.getDate()) && fields.month.includes(date.getMonth() + 1) && fields.dow.includes(date.getDay());
+}
+function nextCronAfter(cron, after) {
+  const fields = parseCron(cron);
+  const d = new Date(after);
+  d.setSeconds(0, 0);
+  d.setMinutes(d.getMinutes() + 1);
+  const limit = after + 366 * 864e5;
+  while (d.getTime() <= limit) {
+    if (cronMatches(fields, d)) return d.getTime();
+    d.setMinutes(d.getMinutes() + 1);
+  }
+  return null;
+}
+var Scheduler = class {
+  jobs = /* @__PURE__ */ new Map();
+  seq = 0;
+  timer = null;
+  firing = false;
+  fire;
+  now;
+  tickMs;
+  constructor(opts) {
+    this.fire = opts.fire;
+    this.now = opts.now ?? Date.now;
+    this.tickMs = opts.tickMs ?? 15e3;
+    if (!opts.manual) this.start();
+  }
+  /** Start the tick timer. Idempotent. */
+  start() {
+    if (this.timer) return;
+    this.timer = setInterval(() => this.tick(), this.tickMs);
+    if (typeof this.timer === "object" && "unref" in this.timer) this.timer.unref();
+  }
+  /** Stop the tick timer. Does not clear jobs. */
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+  /** Add a scheduled job. Returns the job id. */
+  add(opts) {
+    if ("cron" in opts.trigger) parseCron(opts.trigger.cron);
+    if ("at" in opts.trigger && opts.trigger.at < this.now()) {
+    }
+    if ("everyMs" in opts.trigger && opts.trigger.everyMs < 1e3) {
+      throw new Error("interval must be >= 1000ms");
+    }
+    const id = `sched-${++this.seq}`;
+    this.jobs.set(id, {
+      id,
+      prompt: opts.prompt,
+      trigger: opts.trigger,
+      status: "active",
+      created: this.now(),
+      runs: 0,
+      label: opts.label
+    });
+    return id;
+  }
+  /** Cancel a job. Returns false if not found. */
+  cancel(id) {
+    const j = this.jobs.get(id);
+    if (!j) return false;
+    j.status = "done";
+    return true;
+  }
+  get(id) {
+    return this.jobs.get(id);
+  }
+  list() {
+    return [...this.jobs.values()];
+  }
+  active() {
+    return this.list().filter((j) => j.status === "active");
+  }
+  /** Compute when a job next fires (epoch ms), or null if done/unknown. */
+  nextFire(job) {
+    if (job.status !== "active") return null;
+    const t = job.trigger;
+    if ("at" in t) return t.at;
+    if ("everyMs" in t) return (job.lastRun ?? job.created) + t.everyMs;
+    if ("cron" in t) return nextCronAfter(t.cron, job.lastRun ?? job.created);
+    return null;
+  }
+  /** Check all active jobs and fire any that are due. Reentrant-safe. */
+  async tick() {
+    if (this.firing) return;
+    this.firing = true;
+    try {
+      const now5 = this.now();
+      for (const job of this.jobs.values()) {
+        if (job.status !== "active") continue;
+        const due = this.nextFire(job);
+        if (due == null || due > now5) continue;
+        job.lastRun = now5;
+        job.runs++;
+        if ("at" in job.trigger) job.status = "done";
+        try {
+          await this.fire(job);
+        } catch {
+        }
+      }
+    } finally {
+      this.firing = false;
+    }
+  }
+  /** Export all jobs for session persistence. */
+  snapshot() {
+    return this.list().filter((j) => j.status === "active").map((j) => ({ ...j }));
+  }
+  /** Restore jobs from a snapshot (e.g. on --resume). Clears existing jobs first. */
+  restore(snapshots) {
+    this.jobs.clear();
+    for (const s of snapshots) {
+      this.seq = Math.max(this.seq, parseInt(s.id.replace("sched-", ""), 10) || 0);
+      this.jobs.set(s.id, { ...s });
+    }
+  }
+  /** Number of active jobs. */
+  get size() {
+    return this.active().length;
+  }
+  destroy() {
+    this.stop();
+    this.jobs.clear();
+  }
+};
+function makeScheduleTools(scheduler) {
+  return [
+    {
+      name: "ScheduleTask",
+      description: 'Schedule a prompt to fire automatically while this session is alive.\nModes:\n  \u2022 One-off:   {at: <epoch_ms>}        \u2014 fires once at that time, then done.\n  \u2022 Interval:  {everyMs: <ms>}          \u2014 fires repeatedly (\u22651s).\n  \u2022 Cron:      {cron: "min hr dom mon dow"} \u2014 standard 5-field cron.\nReturns the job id. Jobs only fire while the CLI session is running \u2014 they do NOT survive quitting.',
+      parameters: {
+        type: "object",
+        required: ["prompt", "trigger"],
+        properties: {
+          prompt: { type: "string", description: "The prompt to inject when the job fires." },
+          trigger: {
+            type: "object",
+            description: 'One of: {at: epoch_ms}, {everyMs: ms}, {cron: "5-field expr"}.',
+            properties: {
+              at: { type: "number" },
+              everyMs: { type: "number" },
+              cron: { type: "string" }
+            }
+          },
+          label: { type: "string", description: "Short label for display (optional)." }
+        }
+      },
+      async run({ prompt, trigger, label }) {
+        try {
+          const id = scheduler.add({ prompt, trigger, label });
+          const job = scheduler.get(id);
+          const next = scheduler.nextFire(job);
+          return `Scheduled ${id}${label ? ` (${label})` : ""}. Next fire: ${next ? new Date(next).toLocaleString() : "now"}.`;
+        } catch (e) {
+          return `Error: ${e?.message ?? e}`;
+        }
+      }
+    },
+    {
+      name: "ScheduleList",
+      description: "List all scheduled jobs and their next fire time.",
+      parameters: { type: "object", properties: {} },
+      async run() {
+        const jobs = scheduler.list();
+        if (!jobs.length) return "(no scheduled jobs)";
+        return jobs.map((j) => {
+          const next = scheduler.nextFire(j);
+          const trig = "at" in j.trigger ? `once @ ${new Date(j.trigger.at).toLocaleString()}` : "everyMs" in j.trigger ? `every ${(j.trigger.everyMs / 1e3).toFixed(0)}s` : `cron: ${j.trigger.cron}`;
+          return `${j.id}  ${j.status}  ${trig}  runs:${j.runs}  next:${next ? new Date(next).toLocaleTimeString() : "\u2014"}${j.label ? "  " + j.label : ""}`;
+        }).join("\n");
+      }
+    },
+    {
+      name: "ScheduleCancel",
+      description: "Cancel a scheduled job by id.",
+      parameters: { type: "object", required: ["id"], properties: { id: { type: "string" } } },
+      async run({ id }) {
+        return scheduler.cancel(String(id)) ? `Cancelled ${id}.` : `Error: no scheduled job '${id}'. Use ScheduleList to see jobs.`;
+      }
+    },
+    {
+      name: "Wakeup",
+      description: 'Self-pacing: schedule a one-off re-invocation of the agent after a delay.\nUse this to resume work later in the session (e.g. "check back in 5 minutes").\nThe prompt fires once, while the session is alive. Equivalent to ScheduleTask with {at: now + delayMs}.',
+      parameters: {
+        type: "object",
+        required: ["delayMs", "prompt"],
+        properties: {
+          delayMs: { type: "number", description: "Delay in milliseconds (minimum 5000)." },
+          prompt: { type: "string", description: "The prompt to inject when waking up." },
+          label: { type: "string" }
+        }
+      },
+      async run({ delayMs, prompt, label }) {
+        const delay = Math.max(5e3, Number(delayMs) || 5e3);
+        try {
+          const id = scheduler.add({ prompt, trigger: { at: Date.now() + delay }, label: label ?? "wakeup" });
+          return `Wakeup ${id} in ${(delay / 1e3).toFixed(0)}s.`;
+        } catch (e) {
+          return `Error: ${e?.message ?? e}`;
+        }
+      }
+    }
+  ];
+}
+
 // src/presets.ts
 init_tools();
 import { MemFilesystem } from "@livx.cc/wcli/core";
@@ -8985,6 +9232,21 @@ async function repl(args, ai, cfg, cwd) {
   if (args.voice && !args.duplex) agent.options.tools = [...agent.options.tools ?? [], exitSessionTool(() => {
     exitRequested = true;
   })];
+  const scheduleQueue = [];
+  let scheduleTurn;
+  const scheduler = new Scheduler({
+    fire: (job) => {
+      if (!activeTurn && scheduleTurn) {
+        err(dim(`  \u23F0 scheduled \u203A ${job.prompt.slice(0, 60)}${job.prompt.length > 60 ? "\u2026" : ""}
+`));
+        void scheduleTurn(job.prompt).then(() => editorRef?.redrawNow());
+      } else {
+        scheduleQueue.push(job.prompt);
+      }
+    },
+    tickMs: 15e3
+  });
+  agent.options.tools = [...agent.options.tools ?? [], ...makeScheduleTools(scheduler)];
   const duplex = args.duplex;
   let dx;
   let voiceIO;
@@ -9303,6 +9565,11 @@ async function repl(args, ai, cfg, cwd) {
   installCancelGuards(mounted);
   const store = new SessionStore(cwd);
   let session = startSession(args, store, face, cwd);
+  if (session.meta.scheduledJobs?.length) {
+    scheduler.restore(session.meta.scheduledJobs);
+    err(dim(`  \u23F0 ${scheduler.size} scheduled job(s) re-armed
+`));
+  }
   const checkpoints = args.vfs || args.boddb ? new CheckpointStack(agent.options.fs) : new GitCheckpoints({ workTree: cwd, gitDir: join9(cwd, ".agent", "checkpoints.git"), addDirs: args.addDirs, sessionId: session.meta.id });
   const cpHooks = checkpoints.hooks?.();
   if (cpHooks) work.hooks = composeHooks(work.hooks, cpHooks);
@@ -9356,6 +9623,11 @@ async function repl(args, ai, cfg, cwd) {
     goalTurns = m.goalTurns ?? 0;
     goalTokens = m.goalTokens ?? 0;
     goalLastReason = m.goalLastReason;
+    if (m.scheduledJobs?.length) {
+      scheduler.restore(m.scheduledJobs);
+      err(dim(`  \u23F0 ${scheduler.size} scheduled job(s) re-armed
+`));
+    }
     err(dim(`  resumed ${data.meta.id} (${data.meta.turns} turns)${data.meta.title ? " \u2014 " + data.meta.title : ""}
 `));
     if (goalCondition) err(dim(`  \u25CE goal active: ${goalCondition} (${goalTurns} turns)
@@ -9441,6 +9713,7 @@ async function repl(args, ai, cfg, cwd) {
     }
     return r;
   };
+  scheduleTurn = turn;
   const runSkill = async (sk, extra = "") => {
     try {
       const body = await fs.readFile(sk.path);
@@ -10417,6 +10690,7 @@ ${extra}` : body);
       if (r && r !== "off") parts.push(`reasoning:${r}`);
       if (verboseOutput) parts.push("verbose");
       if (goalCondition) parts.push(`\u25CE goal (${goalTurns} turns)`);
+      if (scheduler.size) parts.push(`\u23F0 ${scheduler.size} scheduled`);
       if (inputStash.length) parts.push(`${inputStash.length} stashed (\u2303S to pop)`);
       const taskLines = [];
       if (dx) {
@@ -10485,8 +10759,20 @@ ${extra}` : body);
 `));
       quit = await dispatchLine(next) === "quit";
     }
+    while (!quit && scheduleQueue.length) {
+      const prompt = scheduleQueue.shift();
+      err(dim(`  \u23F0 scheduled \u203A ${prompt.slice(0, 60)}${prompt.length > 60 ? "\u2026" : ""}
+`));
+      await turn(prompt);
+    }
+    session.meta.scheduledJobs = scheduler.snapshot();
+    try {
+      store.save(session);
+    } catch {
+    }
     if (quit) break;
   }
+  scheduler.destroy();
   voiceIO?.stop();
   if (dx) {
     const running = [...dx.tasks.values()].filter((t) => t.status === "running");