0agent 1.0.28 → 1.0.29

package/bin/chat.js

@@ -189,6 +189,13 @@ function handleWsEvent(event) {
       lineBuffer += event.token;
       break;
     }
+    case 'schedule.fired': {
+      // Show when a scheduled job fires — even if user is idle
+      const ts = new Date().toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit' });
+      process.stdout.write(`\n  ${fmt(C.magenta, '⏰')} [${ts}] Scheduled: ${fmt(C.bold, event.job_name)} — ${event.task}\n`);
+      if (!streaming) rl.prompt(true);
+      break;
+    }
     case 'session.completed': {
       spinner.stop();
       if (streaming) { process.stdout.write('\n'); streaming = false; }
@@ -380,6 +387,78 @@ async function handleCommand(input) {
     }
 
     // /skills
+    // /schedule — cron-like job scheduler
+    case '/schedule': {
+      const schedArgs = parts.slice(1);
+      const subCmd = schedArgs[0]?.toLowerCase() ?? 'list';
+
+      if (subCmd === 'list' || schedArgs.length === 0) {
+        const res = await fetch(`${BASE_URL}/api/schedule`).catch(() => null);
+        const jobs = res?.ok ? await res.json().catch(() => []) : [];
+        if (!Array.isArray(jobs) || jobs.length === 0) {
+          console.log('\n  No scheduled jobs. Add one:\n  ' +
+            fmt(C.dim, '/schedule add "run /retro" every Friday at 5pm') + '\n');
+        } else {
+          console.log('\n  Scheduled jobs:\n');
+          for (const j of jobs) {
+            const status = j.enabled ? fmt(C.green, '●') : fmt(C.dim, '○');
+            const next = j.next_run_human ?? 'unknown';
+            console.log(`  ${status} ${fmt(C.bold, j.id)}  ${j.name}`);
+            console.log(`     ${fmt(C.dim, j.schedule_human + ' · next: ' + next)}`);
+          }
+          console.log();
+        }
+      } else if (subCmd === 'add') {
+        // /schedule add "<task>" <schedule...>
+        // Parse: extract quoted task, rest is schedule
+        const rest = parts.slice(2).join(' ');
+        const quoted = rest.match(/^"([^"]+)"\s+(.+)$/) || rest.match(/^'([^']+)'\s+(.+)$/);
+        if (!quoted) {
+          console.log(`  ${fmt(C.dim, 'Usage: /schedule add "<task>" <schedule>')}`);
+          console.log(`  ${fmt(C.dim, 'Examples:')}`);
+          console.log(`  ${fmt(C.cyan, '  /schedule add "run /retro" every Friday at 5pm')}`);
+          console.log(`  ${fmt(C.cyan, '  /schedule add "run /review" every day at 9am')}`);
+          console.log(`  ${fmt(C.cyan, '  /schedule add "check the build" in 2 hours')}\n`);
+        } else {
+          const task = quoted[1];
+          const schedule = quoted[2];
+          const res = await fetch(`${BASE_URL}/api/schedule`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ task, schedule }),
+          }).catch(() => null);
+          const data = res?.ok ? await res.json().catch(() => null) : null;
+          if (data?.id) {
+            console.log(`  ${fmt(C.green, '✓')} Scheduled: ${fmt(C.bold, data.name)}`);
+            console.log(`  ${fmt(C.dim, data.schedule_human + ' · next: ' + data.next_run_human)}\n`);
+          } else {
+            console.log(`  ${fmt(C.red, '✗')} ${data?.error ?? 'Failed to create schedule'}\n`);
+          }
+        }
+      } else if (subCmd === 'delete' || subCmd === 'remove') {
+        const id = schedArgs[1];
+        if (!id) { console.log('  Usage: /schedule delete <id>\n'); break; }
+        const res = await fetch(`${BASE_URL}/api/schedule/${id}`, { method: 'DELETE' }).catch(() => null);
+        const data = res?.ok ? await res.json().catch(() => null) : null;
+        console.log(data?.ok
+          ? `  ${fmt(C.green, '✓')} Deleted ${id}\n`
+          : `  ${fmt(C.red, '✗')} ${data?.error ?? 'Not found'}\n`);
+      } else if (subCmd === 'pause') {
+        const id = schedArgs[1];
+        if (!id) { console.log('  Usage: /schedule pause <id>\n'); break; }
+        await fetch(`${BASE_URL}/api/schedule/${id}/pause`, { method: 'POST' });
+        console.log(`  ${fmt(C.green, '✓')} Paused ${id}\n`);
+      } else if (subCmd === 'resume') {
+        const id = schedArgs[1];
+        if (!id) { console.log('  Usage: /schedule resume <id>\n'); break; }
+        await fetch(`${BASE_URL}/api/schedule/${id}/resume`, { method: 'POST' });
+        console.log(`  ${fmt(C.green, '✓')} Resumed ${id}\n`);
+      } else {
+        console.log('  Usage: /schedule list | add "<task>" <schedule> | delete <id> | pause <id> | resume <id>\n');
+      }
+      break;
+    }
+
     case '/skills': {
       try {
         const skills = await fetch(`${BASE_URL}/api/skills`).then(r => r.json());
@@ -442,6 +521,7 @@ const rl = createInterface({
   historySize: 100,
   completer: (line) => {
     const commands = ['/model', '/key', '/status', '/skills', '/graph', '/clear', '/help',
+      '/schedule', '/schedule list', '/schedule add',
       '/review', '/build', '/debug', '/qa', '/research', '/refactor', '/test-writer', '/retro'];
     const hits = commands.filter(c => c.startsWith(line));
     return [hits.length ? hits : commands, line];
@@ -569,7 +649,7 @@ rl.on('line', async (input) => {
   const line = input.trim();
   if (!line) { rl.prompt(); return; }
 
-  if (line.startsWith('/') || ['/model','/key','/status','/skills','/graph','/clear','/help'].some(c => line.startsWith(c))) {
+  if (line.startsWith('/') || ['/model','/key','/status','/skills','/graph','/clear','/help','/schedule'].some(c => line.startsWith(c))) {
     await handleCommand(line);
     rl.prompt();
   } else {

package/dist/daemon.mjs

@@ -4748,7 +4748,7 @@ var SkillRegistry = class {
 };
 
 // packages/daemon/src/HTTPServer.ts
-import { Hono as Hono12 } from "hono";
+import { Hono as Hono13 } from "hono";
 import { serve } from "@hono/node-server";
 import { readFileSync as readFileSync8 } from "node:fs";
 import { resolve as resolve7, dirname as dirname3 } from "node:path";
@@ -5137,6 +5137,398 @@ function codespaceRoutes(deps) {
   return app;
 }
 
+// packages/daemon/src/routes/schedule.ts
+import { Hono as Hono12 } from "hono";
+
+// packages/daemon/src/SchedulerManager.ts
+var DAYS = {
+  sunday: 0,
+  sun: 0,
+  monday: 1,
+  mon: 1,
+  tuesday: 2,
+  tue: 2,
+  tues: 2,
+  wednesday: 3,
+  wed: 3,
+  thursday: 4,
+  thu: 4,
+  thur: 4,
+  thurs: 4,
+  friday: 5,
+  fri: 5,
+  saturday: 6,
+  sat: 6
+};
+function parseTime(s) {
+  if (!s) return { hour: 9, minute: 0 };
+  const m = s.trim().match(/^(\d{1,2})(?::(\d{2}))?\s*(am|pm)?$/i);
+  if (!m) throw new Error(`Cannot parse time: "${s}". Use format like "9am", "5:30pm", "14:00"`);
+  let hour = parseInt(m[1], 10);
+  const minute = parseInt(m[2] ?? "0", 10);
+  const ampm = m[3]?.toLowerCase();
+  if (ampm === "pm" && hour !== 12) hour += 12;
+  if (ampm === "am" && hour === 12) hour = 0;
+  return { hour, minute };
+}
+function parseSchedule(text) {
+  const t = text.trim().toLowerCase();
+  const inMatch = t.match(/^in\s+(\d+)\s+(hour|hours|hr|hrs|minute|minutes|min|mins)$/);
+  if (inMatch) {
+    const n = parseInt(inMatch[1], 10);
+    const isHours = inMatch[2].startsWith("h");
+    const at = Date.now() + n * (isHours ? 36e5 : 6e4);
+    return { spec: { type: "once", at }, human: text.trim() };
+  }
+  const tomorrowMatch = t.match(/^(?:tomorrow|tom)\s+at\s+(.+)$/);
+  if (tomorrowMatch) {
+    const { hour, minute } = parseTime(tomorrowMatch[1]);
+    const d = /* @__PURE__ */ new Date();
+    d.setDate(d.getDate() + 1);
+    d.setHours(hour, minute, 0, 0);
+    return { spec: { type: "once", at: d.getTime() }, human: text.trim() };
+  }
+  if (t === "every hour") return { spec: { type: "hourly", minute: 0 }, human: "every hour" };
+  const everyMinsMatch = t.match(/^every\s+(\d+)\s+minutes?$/);
+  if (everyMinsMatch) {
+    const interval = parseInt(everyMinsMatch[1], 10);
+    return { spec: { type: "interval_minutes", interval }, human: `every ${interval} minutes` };
+  }
+  const DEFAULT_TIMES = {
+    morning: "9am",
+    evening: "6pm",
+    night: "10pm",
+    noon: "12pm",
+    midnight: "12am"
+  };
+  const dailyMatch = t.match(/^every\s+(day|daily|morning|evening|night|noon|midnight)\s*(?:at\s+(.+))?$/);
+  if (dailyMatch) {
+    const period = dailyMatch[1];
+    const timeStr = dailyMatch[2] ?? DEFAULT_TIMES[period] ?? "9am";
+    const { hour, minute } = parseTime(timeStr);
+    const human = `every ${period}${dailyMatch[2] ? " at " + dailyMatch[2] : ""}`;
+    return { spec: { type: "daily", hour, minute }, human };
+  }
+  const weeklyMatch = t.match(/^every\s+(\w+)\s*(?:at\s+(.+))?$/);
+  if (weeklyMatch && DAYS[weeklyMatch[1]] !== void 0) {
+    const day = DAYS[weeklyMatch[1]];
+    const { hour, minute } = parseTime(weeklyMatch[2] ?? "9am");
+    const human = `every ${weeklyMatch[1]}${weeklyMatch[2] ? " at " + weeklyMatch[2] : ""}`;
+    return { spec: { type: "weekly", day, hour, minute }, human };
+  }
+  throw new Error(
+    `Could not understand schedule: "${text}"
+Try: "every Friday at 5pm" \xB7 "every day at 9am" \xB7 "every morning" \xB7 "in 2 hours" \xB7 "every 30 minutes"`
+  );
+}
+function scheduleToHuman(spec) {
+  const pad = (n) => String(n).padStart(2, "0");
+  const hhmm = (h, m) => {
+    const ampm = h >= 12 ? "pm" : "am";
+    const h12 = h === 0 ? 12 : h > 12 ? h - 12 : h;
+    return m === 0 ? `${h12}${ampm}` : `${h12}:${pad(m)}${ampm}`;
+  };
+  const DAYS_REV = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+  switch (spec.type) {
+    case "once":
+      return `once at ${new Date(spec.at).toLocaleString()}`;
+    case "hourly":
+      return `every hour`;
+    case "interval_minutes":
+      return `every ${spec.interval} minutes`;
+    case "daily":
+      return `every day at ${hhmm(spec.hour, spec.minute)}`;
+    case "weekly":
+      return `every ${DAYS_REV[spec.day]} at ${hhmm(spec.hour, spec.minute)}`;
+    case "monthly":
+      return `monthly on the ${spec.date}th at ${hhmm(spec.hour, spec.minute)}`;
+    default:
+      return "unknown schedule";
+  }
+}
+function nextRunAt(spec, now = Date.now()) {
+  const d = new Date(now);
+  const next = new Date(now);
+  switch (spec.type) {
+    case "once":
+      return spec.at;
+    case "hourly": {
+      next.setMinutes(spec.minute, 0, 0);
+      if (next.getTime() <= now) next.setTime(next.getTime() + 36e5);
+      return next.getTime();
+    }
+    case "interval_minutes": {
+      const minsUntil = spec.interval - d.getMinutes() % spec.interval;
+      return now + minsUntil * 6e4;
+    }
+    case "daily": {
+      next.setHours(spec.hour, spec.minute, 0, 0);
+      if (next.getTime() <= now) next.setDate(next.getDate() + 1);
+      return next.getTime();
+    }
+    case "weekly": {
+      const daysUntil = (spec.day - d.getDay() + 7) % 7 || 7;
+      next.setDate(d.getDate() + daysUntil);
+      next.setHours(spec.hour, spec.minute, 0, 0);
+      if (next.getTime() <= now) next.setDate(next.getDate() + 7);
+      return next.getTime();
+    }
+    case "monthly": {
+      next.setDate(spec.date);
+      next.setHours(spec.hour, spec.minute, 0, 0);
+      if (next.getTime() <= now) next.setMonth(next.getMonth() + 1);
+      return next.getTime();
+    }
+  }
+}
+var DDL = `
+  CREATE TABLE IF NOT EXISTS scheduled_jobs (
+    id            TEXT PRIMARY KEY,
+    name          TEXT NOT NULL,
+    task          TEXT NOT NULL,
+    skill         TEXT,
+    schedule_json TEXT NOT NULL,
+    schedule_human TEXT NOT NULL,
+    enabled       INTEGER NOT NULL DEFAULT 1,
+    last_run_at   INTEGER,
+    next_run_at   INTEGER NOT NULL,
+    run_count     INTEGER NOT NULL DEFAULT 0,
+    created_at    INTEGER NOT NULL
+  );
+  CREATE INDEX IF NOT EXISTS idx_jobs_next ON scheduled_jobs(next_run_at, enabled);
+`;
+var SchedulerStore = class {
+  constructor(adapter) {
+    this.adapter = adapter;
+  }
+  initialised = false;
+  init() {
+    if (this.initialised) return;
+    const db = this.adapter.db;
+    db.exec(DDL);
+    this.initialised = true;
+  }
+  save(job) {
+    this.init();
+    const db = this.adapter.db;
+    db.prepare(`
+      INSERT OR REPLACE INTO scheduled_jobs
+        (id, name, task, skill, schedule_json, schedule_human, enabled, last_run_at, next_run_at, run_count, created_at)
+      VALUES (?,?,?,?,?,?,?,?,?,?,?)
+    `).run(
+      job.id,
+      job.name,
+      job.task,
+      job.skill ?? null,
+      JSON.stringify(job.schedule),
+      job.schedule_human,
+      job.enabled ? 1 : 0,
+      job.last_run_at ?? null,
+      job.next_run_at,
+      job.run_count,
+      job.created_at
+    );
+  }
+  delete(id) {
+    this.init();
+    const db = this.adapter.db;
+    db.prepare("DELETE FROM scheduled_jobs WHERE id = ?").run(id);
+  }
+  list() {
+    this.init();
+    const db = this.adapter.db;
+    const rows = db.prepare("SELECT * FROM scheduled_jobs ORDER BY next_run_at ASC").all();
+    return rows.map(this.rowToJob);
+  }
+  getDue(now) {
+    this.init();
+    const db = this.adapter.db;
+    const rows = db.prepare(
+      "SELECT * FROM scheduled_jobs WHERE enabled = 1 AND next_run_at <= ?"
+    ).all(now);
+    return rows.map(this.rowToJob);
+  }
+  rowToJob(row) {
+    return {
+      id: row.id,
+      name: row.name,
+      task: row.task,
+      skill: row.skill,
+      schedule: JSON.parse(row.schedule_json),
+      schedule_human: row.schedule_human,
+      enabled: row.enabled === 1,
+      last_run_at: row.last_run_at,
+      next_run_at: row.next_run_at,
+      run_count: row.run_count,
+      created_at: row.created_at
+    };
+  }
+};
+var SchedulerManager = class {
+  constructor(adapter, sessions, eventBus) {
+    this.sessions = sessions;
+    this.eventBus = eventBus;
+    this.store = new SchedulerStore(adapter);
+    this.store.init();
+  }
+  store;
+  timer = null;
+  start() {
+    if (this.timer) return;
+    this.timer = setInterval(() => this.tick(), 3e4);
+    if (this.timer && typeof this.timer === "object" && "unref" in this.timer) {
+      this.timer.unref();
+    }
+    const init = setTimeout(() => this.tick(), 5e3);
+    if (typeof init === "object" && "unref" in init) init.unref();
+  }
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+  /** Add a new scheduled job. */
+  add(params) {
+    const { spec, human } = parseSchedule(params.schedule);
+    const now = Date.now();
+    const job = {
+      id: crypto.randomUUID().slice(0, 8),
+      // short ID for easy reference
+      name: params.name ?? params.task.slice(0, 40),
+      task: params.task,
+      skill: params.skill,
+      schedule: spec,
+      schedule_human: human,
+      enabled: true,
+      next_run_at: nextRunAt(spec, now),
+      run_count: 0,
+      created_at: now
+    };
+    this.store.save(job);
+    return job;
+  }
+  /** Pause/resume a job. */
+  setPaused(id, paused) {
+    const jobs = this.store.list();
+    const job = jobs.find((j) => j.id === id);
+    if (!job) return false;
+    job.enabled = !paused;
+    this.store.save(job);
+    return true;
+  }
+  /** Delete a job. */
+  remove(id) {
+    const jobs = this.store.list();
+    const exists = jobs.some((j) => j.id === id);
+    if (!exists) return false;
+    this.store.delete(id);
+    return true;
+  }
+  /** List all jobs. */
+  list() {
+    return this.store.list();
+  }
+  // ─── Tick ─────────────────────────────────────────────────────────────────
+  async tick() {
+    const now = Date.now();
+    const due = this.store.getDue(now);
+    for (const job of due) {
+      if (job.last_run_at && now - job.last_run_at < 5e4) continue;
+      await this.fire(job);
+    }
+  }
+  async fire(job) {
+    job.last_run_at = Date.now();
+    job.run_count++;
+    if (job.schedule.type === "once") {
+      job.enabled = false;
+    } else {
+      job.next_run_at = nextRunAt(job.schedule, Date.now() + 6e4);
+    }
+    this.store.save(job);
+    this.eventBus.emit({
+      type: "schedule.fired",
+      job_id: job.id,
+      job_name: job.name,
+      task: job.task,
+      run_count: job.run_count
+    });
+    try {
+      const session = this.sessions.createSession({ task: job.task, skill: job.skill });
+      this.sessions.runExistingSession(session.id, { task: job.task, skill: job.skill }).then(() => {
+        this.eventBus.emit({ type: "schedule.completed", job_id: job.id, session_id: session.id });
+      }).catch((err) => {
+        this.eventBus.emit({ type: "schedule.error", job_id: job.id, error: String(err) });
+      });
+    } catch (err) {
+      this.eventBus.emit({ type: "schedule.error", job_id: job.id, error: String(err) });
+    }
+  }
+};
+
+// packages/daemon/src/routes/schedule.ts
+function scheduleRoutes(deps) {
+  const app = new Hono12();
+  const getScheduler = (c) => {
+    if (!deps.scheduler) {
+      return { error: c.json({ error: "Scheduler not available" }, 503) };
+    }
+    return { scheduler: deps.scheduler };
+  };
+  app.get("/", (c) => {
+    const { scheduler, error } = getScheduler(c);
+    if (error) return error;
+    const jobs = scheduler.list().map((j) => ({
+      ...j,
+      schedule_human: j.schedule_human || scheduleToHuman(j.schedule),
+      next_run_human: new Date(j.next_run_at).toLocaleString()
+    }));
+    return c.json(jobs);
+  });
+  app.post("/", async (c) => {
+    const { scheduler, error } = getScheduler(c);
+    if (error) return error;
+    const body = await c.req.json();
+    if (!body.task || !body.schedule) {
+      return c.json({ error: "task and schedule are required" }, 400);
+    }
+    try {
+      const job = scheduler.add({
+        task: body.task,
+        schedule: body.schedule,
+        name: body.name,
+        skill: body.skill
+      });
+      return c.json({
+        ...job,
+        next_run_human: new Date(job.next_run_at).toLocaleString()
+      }, 201);
+    } catch (err) {
+      return c.json({ error: err instanceof Error ? err.message : String(err) }, 400);
+    }
+  });
+  app.delete("/:id", (c) => {
+    const { scheduler, error } = getScheduler(c);
+    if (error) return error;
+    const ok = scheduler.remove(c.req.param("id"));
+    return ok ? c.json({ ok: true }) : c.json({ error: "Job not found" }, 404);
+  });
+  app.post("/:id/pause", (c) => {
+    const { scheduler, error } = getScheduler(c);
+    if (error) return error;
+    const ok = scheduler.setPaused(c.req.param("id"), true);
+    return ok ? c.json({ ok: true }) : c.json({ error: "Job not found" }, 404);
+  });
+  app.post("/:id/resume", (c) => {
+    const { scheduler, error } = getScheduler(c);
+    if (error) return error;
+    const ok = scheduler.setPaused(c.req.param("id"), false);
+    return ok ? c.json({ ok: true }) : c.json({ error: "Job not found" }, 404);
+  });
+  return app;
+}
+
 // packages/daemon/src/HTTPServer.ts
 function findGraphHtml() {
   const candidates = [
@@ -5162,7 +5554,7 @@ var HTTPServer = class {
   deps;
   constructor(deps) {
     this.deps = deps;
-    this.app = new Hono12();
+    this.app = new Hono13();
     this.app.route("/api/health", healthRoutes({ getStatus: deps.getStatus }));
     this.app.route("/api/sessions", sessionRoutes({ sessions: deps.sessions }));
     this.app.route("/api/graph", graphRoutes({ graph: deps.graph }));
@@ -5173,6 +5565,7 @@ var HTTPServer = class {
     this.app.route("/api/insights", insightsRoutes({ proactiveSurface: deps.proactiveSurface ?? null }));
     this.app.route("/api/memory", memoryRoutes({ getSync: deps.getMemorySync ?? (() => null) }));
     this.app.route("/api/llm", llmRoutes());
+    this.app.route("/api/schedule", scheduleRoutes({ scheduler: deps.scheduler ?? null }));
     this.app.route("/api/codespace", codespaceRoutes({
       getManager: deps.getCodespaceManager ?? (() => null),
       setup: deps.setupCodespace ?? (async () => ({ started: false, error: "Not configured" }))
@@ -6045,6 +6438,7 @@ var ZeroAgentDaemon = class {
   memorySyncTimer = null;
   proactiveSurfaceInstance = null;
   codespaceManager = null;
+  schedulerManager = null;
   startedAt = 0;
   pidFilePath;
   constructor() {
@@ -6144,6 +6538,8 @@ var ZeroAgentDaemon = class {
       proactiveSurface = new ProactiveSurface2(this.graph, this.eventBus, cwd);
     } catch {
     }
+    this.schedulerManager = new SchedulerManager(this.adapter, this.sessionManager, this.eventBus);
+    this.schedulerManager.start();
     this.backgroundWorkers = new BackgroundWorkers({
       graph: this.graph,
       traceStore: this.traceStore,
@@ -6168,6 +6564,7 @@ var ZeroAgentDaemon = class {
       getMemorySync: () => memSyncRef,
       proactiveSurface,
       getCodespaceManager: () => this.codespaceManager,
+      scheduler: this.schedulerManager,
       setupCodespace: async () => {
         if (!this.codespaceManager) return { started: false, error: "GitHub memory not configured. Run: 0agent memory connect github" };
         try {
@@ -6213,6 +6610,8 @@ var ZeroAgentDaemon = class {
       this.memorySyncTimer = null;
     }
     this.githubMemorySync = null;
+    this.schedulerManager?.stop();
+    this.schedulerManager = null;
     this.codespaceManager?.closeTunnel();
     this.codespaceManager = null;
     this.sessionManager = null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "0agent",
-  "version": "1.0.28",
+  "version": "1.0.29",
   "description": "A persistent, learning AI agent that runs on your machine. An agent that learns.",
   "private": false,
   "license": "Apache-2.0",