wispy-cli 0.7.0 → 0.9.0

package/bin/wispy.mjs

@@ -22,6 +22,150 @@ const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
 const args = process.argv.slice(2);
 
+// ── cron sub-command ──────────────────────────────────────────────────────────
+if (args[0] === "cron") {
+  const { WispyEngine, CronManager, WISPY_DIR } = await import(
+    path.join(__dirname, "..", "core", "index.mjs")
+  );
+  const { createInterface } = await import("node:readline");
+
+  const sub = args[1];
+
+  // Init engine for cron commands that need it
+  const engine = new WispyEngine();
+  await engine.init({ skipMcp: true });
+  const cron = new CronManager(WISPY_DIR, engine);
+  await cron.init();
+
+  if (!sub || sub === "list") {
+    const jobs = cron.list();
+    if (jobs.length === 0) {
+      console.log("No cron jobs configured. Use: wispy cron add");
+    } else {
+      console.log(`\n🕐 Cron Jobs (${jobs.length}):\n`);
+      for (const j of jobs) {
+        const status = j.enabled ? "✅" : "⏸️ ";
+        const schedStr = j.schedule.kind === "cron" ? j.schedule.expr
+          : j.schedule.kind === "every" ? `every ${j.schedule.ms / 60000}min`
+          : `at ${j.schedule.time}`;
+        console.log(`  ${status} ${j.id.slice(0, 8)} ${j.name.padEnd(20)} ${schedStr}`);
+        console.log(`       Task: ${j.task.slice(0, 60)}${j.task.length > 60 ? "..." : ""}`);
+        if (j.channel) console.log(`       Channel: ${j.channel}`);
+        if (j.nextRun) console.log(`       Next run: ${new Date(j.nextRun).toLocaleString()}`);
+        console.log("");
+      }
+    }
+    process.exit(0);
+  }
+
+  if (sub === "add") {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const ask = (q) => new Promise(r => rl.question(q, r));
+
+    console.log("\n🕐 Add Cron Job\n");
+    const name = await ask("  Job name: ");
+    const task = await ask("  Task (what to do): ");
+    const schedKind = await ask("  Schedule type (cron/every/at) [cron]: ") || "cron";
+    let schedule = { kind: schedKind };
+
+    if (schedKind === "cron") {
+      const expr = await ask("  Cron expression (e.g. '0 9 * * *'): ");
+      const tz = await ask("  Timezone [Asia/Seoul]: ") || "Asia/Seoul";
+      schedule = { kind: "cron", expr: expr.trim(), tz: tz.trim() };
+    } else if (schedKind === "every") {
+      const mins = await ask("  Interval in minutes: ");
+      schedule = { kind: "every", ms: parseFloat(mins) * 60_000 };
+    } else if (schedKind === "at") {
+      const time = await ask("  Run at (ISO datetime, e.g. 2025-01-01T09:00:00): ");
+      schedule = { kind: "at", time: time.trim() };
+    }
+
+    const channel = await ask("  Channel (e.g. telegram:12345, or leave empty): ");
+    rl.close();
+
+    const job = await cron.add({
+      name: name.trim(),
+      task: task.trim(),
+      schedule,
+      channel: channel.trim() || null,
+      enabled: true,
+    });
+
+    console.log(`\n✅ Job created: ${job.id}`);
+    console.log(`   Next run: ${job.nextRun ? new Date(job.nextRun).toLocaleString() : "N/A"}`);
+    process.exit(0);
+  }
+
+  if (sub === "remove" && args[2]) {
+    const id = args[2];
+    // Support partial ID match
+    const all = cron.list();
+    const match = all.find(j => j.id === id || j.id.startsWith(id));
+    if (!match) {
+      console.error(`Job not found: ${id}`);
+      process.exit(1);
+    }
+    await cron.remove(match.id);
+    console.log(`✅ Removed job: ${match.name} (${match.id})`);
+    process.exit(0);
+  }
+
+  if (sub === "run" && args[2]) {
+    const id = args[2];
+    const all = cron.list();
+    const match = all.find(j => j.id === id || j.id.startsWith(id));
+    if (!match) {
+      console.error(`Job not found: ${id}`);
+      process.exit(1);
+    }
+    console.log(`🌿 Running job: ${match.name}...`);
+    const result = await cron.runNow(match.id);
+    console.log(result.output ?? result.error);
+    process.exit(0);
+  }
+
+  if (sub === "history" && args[2]) {
+    const id = args[2];
+    const all = cron.list();
+    const match = all.find(j => j.id === id || j.id.startsWith(id));
+    if (!match) {
+      console.error(`Job not found: ${id}`);
+      process.exit(1);
+    }
+    const history = await cron.getHistory(match.id);
+    console.log(`\n📋 History for "${match.name}" (last ${history.length} runs):\n`);
+    for (const h of history) {
+      const icon = h.status === "success" ? "✅" : "❌";
+      console.log(`  ${icon} ${new Date(h.startedAt).toLocaleString()}`);
+      console.log(`     ${h.output?.slice(0, 100) ?? h.error ?? ""}`);
+      console.log("");
+    }
+    if (history.length === 0) console.log("  No runs yet.");
+    process.exit(0);
+  }
+
+  if (sub === "start") {
+    console.log("🌿 Starting cron scheduler... (Ctrl+C to stop)\n");
+    cron.start();
+    process.on("SIGINT", () => { cron.stop(); process.exit(0); });
+    process.on("SIGTERM", () => { cron.stop(); process.exit(0); });
+    setInterval(() => {}, 60_000);
+    await new Promise(() => {});
+  }
+
+  console.log(`
+🕐 Wispy Cron Commands:
+
+  wispy cron list              — list all jobs
+  wispy cron add               — interactive job creation
+  wispy cron remove <id>       — delete a job
+  wispy cron run <id>          — trigger immediately
+  wispy cron history <id>      — show past runs
+  wispy cron start             — start scheduler (foreground)
+`);
+  process.exit(0);
+}
+
 // ── channel sub-command ───────────────────────────────────────────────────────
 if (args[0] === "channel") {
   const { channelSetup, channelList, channelTest } = await import(
@@ -77,9 +221,35 @@ if (serveMode || telegramMode || discordMode || slackMode) {
 
   await manager.startAll(only);
 
+  // Start cron scheduler if in serve mode
+  let cronManager = null;
+  if (serveMode) {
+    try {
+      const { WispyEngine, CronManager, WISPY_DIR } = await import(
+        path.join(__dirname, "..", "core", "index.mjs")
+      );
+      const engine = new WispyEngine();
+      await engine.init({ skipMcp: true });
+      cronManager = new CronManager(WISPY_DIR, engine);
+      await cronManager.init();
+      cronManager.start();
+      console.error("[wispy] Cron scheduler started");
+    } catch (err) {
+      console.error("[wispy] Failed to start cron scheduler:", err.message);
+    }
+  }
+
   // Keep process alive and stop cleanly on Ctrl+C
-  process.on("SIGINT",  async () => { await manager.stopAll(); process.exit(0); });
-  process.on("SIGTERM", async () => { await manager.stopAll(); process.exit(0); });
+  process.on("SIGINT",  async () => {
+    if (cronManager) cronManager.stop();
+    await manager.stopAll();
+    process.exit(0);
+  });
+  process.on("SIGTERM", async () => {
+    if (cronManager) cronManager.stop();
+    await manager.stopAll();
+    process.exit(0);
+  });
 
   // Prevent Node from exiting
   setInterval(() => {}, 60_000);

package/core/cron.mjs

@@ -0,0 +1,346 @@
+/**
+ * core/cron.mjs — Task scheduler for Wispy
+ *
+ * Manages scheduled jobs stored in ~/.wispy/cron/jobs.json
+ * History stored in ~/.wispy/cron/history/<jobId>.json
+ *
+ * Schedule types:
+ * - cron: standard 5-field cron expression (uses cron-parser)
+ * - every: interval in ms (e.g., 1800000 for 30 minutes)
+ * - at: one-shot at specific ISO datetime
+ */
+
+import path from "node:path";
+import { readFile, writeFile, mkdir, readdir } from "node:fs/promises";
+
+const MAX_HISTORY_PER_JOB = 50;
+const TICK_INTERVAL_MS = 30_000; // Check every 30 seconds
+
+export class CronManager {
+  constructor(wispyDir, engine) {
+    this.cronDir = path.join(wispyDir, "cron");
+    this.jobsFile = path.join(this.cronDir, "jobs.json");
+    this.historyDir = path.join(this.cronDir, "history");
+    this.engine = engine;
+    this._jobs = [];
+    this._timer = null;
+    this._running = false;
+    this._cronParser = null; // lazy-loaded
+  }
+
+  /**
+   * Initialize: load jobs from disk
+   */
+  async init() {
+    await mkdir(this.cronDir, { recursive: true });
+    await mkdir(this.historyDir, { recursive: true });
+    await this._loadJobs();
+    return this;
+  }
+
+  /**
+   * Lazy-load cron-parser
+   */
+  async _getCronParser() {
+    if (!this._cronParser) {
+      try {
+        const mod = await import("cron-parser");
+        // v5 API: CronExpressionParser.parse(expr, { tz })
+        // v4 API: parseExpression(expr, { tz })
+        this._cronParser = mod.CronExpressionParser ?? mod.default ?? mod;
+      } catch {
+        this._cronParser = null;
+      }
+    }
+    return this._cronParser;
+  }
+
+  // ── Job Management ────────────────────────────────────────────────────────
+
+  async add(jobDef) {
+    const { randomUUID } = await import("node:crypto");
+    const job = {
+      id: jobDef.id ?? randomUUID(),
+      name: jobDef.name ?? "unnamed",
+      schedule: jobDef.schedule,
+      task: jobDef.task,
+      channel: jobDef.channel ?? null,
+      enabled: jobDef.enabled !== false,
+      createdAt: new Date().toISOString(),
+      lastRun: null,
+      nextRun: null,
+    };
+
+    // Compute next run time
+    job.nextRun = await this._computeNextRun(job);
+
+    this._jobs.push(job);
+    await this._saveJobs();
+    return job;
+  }
+
+  async remove(id) {
+    const before = this._jobs.length;
+    this._jobs = this._jobs.filter(j => j.id !== id);
+    if (this._jobs.length < before) {
+      await this._saveJobs();
+      return true;
+    }
+    return false;
+  }
+
+  async update(id, patch) {
+    const idx = this._jobs.findIndex(j => j.id === id);
+    if (idx === -1) return null;
+    this._jobs[idx] = { ...this._jobs[idx], ...patch };
+    // Recompute next run if schedule changed
+    if (patch.schedule) {
+      this._jobs[idx].nextRun = await this._computeNextRun(this._jobs[idx]);
+    }
+    await this._saveJobs();
+    return this._jobs[idx];
+  }
+
+  list() {
+    return [...this._jobs];
+  }
+
+  get(id) {
+    return this._jobs.find(j => j.id === id) ?? null;
+  }
+
+  // ── Scheduler ─────────────────────────────────────────────────────────────
+
+  /**
+   * Start the scheduler loop
+   */
+  start() {
+    if (this._running) return;
+    this._running = true;
+    this._tick();
+    this._timer = setInterval(() => this._tick(), TICK_INTERVAL_MS);
+    console.error(`[wispy-cron] Scheduler started (checking every ${TICK_INTERVAL_MS / 1000}s)`);
+  }
+
+  /**
+   * Stop the scheduler
+   */
+  stop() {
+    this._running = false;
+    if (this._timer) {
+      clearInterval(this._timer);
+      this._timer = null;
+    }
+    console.error("[wispy-cron] Scheduler stopped");
+  }
+
+  /**
+   * Manually trigger a job right now
+   */
+  async runNow(id) {
+    const job = this.get(id);
+    if (!job) return { success: false, error: "Job not found" };
+    return this._executeJob(job);
+  }
+
+  // ── History ───────────────────────────────────────────────────────────────
+
+  async getHistory(id, limit = 20) {
+    const histFile = path.join(this.historyDir, `${id}.json`);
+    try {
+      const raw = await readFile(histFile, "utf8");
+      const history = JSON.parse(raw);
+      return history.slice(-limit);
+    } catch {
+      return [];
+    }
+  }
+
+  // ── Internal ──────────────────────────────────────────────────────────────
+
+  async _tick() {
+    const now = Date.now();
+    for (const job of this._jobs) {
+      if (!job.enabled) continue;
+      if (!job.nextRun) continue;
+
+      const nextRunMs = new Date(job.nextRun).getTime();
+      if (now >= nextRunMs) {
+        // Execute and update
+        this._executeJob(job).catch(err => {
+          console.error(`[wispy-cron] Job "${job.name}" error:`, err.message);
+        });
+      }
+    }
+  }
+
+  async _executeJob(job) {
+    const startedAt = new Date().toISOString();
+    let output = "";
+    let status = "success";
+    let error = null;
+
+    try {
+      // Run via engine
+      const response = await this.engine.processMessage(null, job.task, {
+        noSave: true,
+        systemPrompt: `You are Wispy 🌿, running a scheduled task. Task name: "${job.name}". Execute the task and provide a concise summary. Always end with 🌿.`,
+      });
+      output = response.content;
+
+      // Deliver to channel if configured
+      if (job.channel) {
+        await this._deliverToChannel(job.channel, job.name, output);
+      }
+    } catch (err) {
+      status = "failed";
+      error = err.message;
+      output = `Error: ${err.message}`;
+    }
+
+    const runRecord = {
+      jobId: job.id,
+      startedAt,
+      completedAt: new Date().toISOString(),
+      status,
+      output: output.slice(0, 2000),
+      error,
+    };
+
+    // Save to history
+    await this._appendHistory(job.id, runRecord);
+
+    // Update job metadata
+    const idx = this._jobs.findIndex(j => j.id === job.id);
+    if (idx !== -1) {
+      this._jobs[idx].lastRun = startedAt;
+      this._jobs[idx].nextRun = await this._computeNextRun(this._jobs[idx]);
+      await this._saveJobs();
+    }
+
+    return { success: status === "success", output, error };
+  }
+
+  async _deliverToChannel(channel, jobName, output) {
+    const [type, id] = channel.split(":");
+    const message = `🌿 **${jobName}**\n\n${output}`;
+
+    try {
+      switch (type) {
+        case "telegram": {
+          const cfg = await this._loadChannelConfig("telegram");
+          if (!cfg?.token) return;
+          const url = `https://api.telegram.org/bot${cfg.token}/sendMessage`;
+          await fetch(url, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ chat_id: id, text: message.slice(0, 4096) }),
+          });
+          break;
+        }
+        case "discord": {
+          // Discord webhook format
+          const cfg = await this._loadChannelConfig("discord");
+          if (!cfg?.webhookUrl) return;
+          await fetch(cfg.webhookUrl, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ content: message.slice(0, 2000) }),
+          });
+          break;
+        }
+        default:
+          console.error(`[wispy-cron] Unknown channel type: ${type}`);
+      }
+    } catch (err) {
+      console.error(`[wispy-cron] Channel delivery failed: ${err.message}`);
+    }
+  }
+
+  async _loadChannelConfig(name) {
+    try {
+      const channelsPath = path.join(path.dirname(this.cronDir), "channels.json");
+      const raw = await readFile(channelsPath, "utf8");
+      const cfg = JSON.parse(raw);
+      return cfg[name] ?? null;
+    } catch {
+      return null;
+    }
+  }
+
+  async _computeNextRun(job) {
+    const schedule = job.schedule;
+    if (!schedule) return null;
+
+    const now = new Date();
+
+    try {
+      if (schedule.kind === "at") {
+        const t = new Date(schedule.time);
+        // One-shot: if in the future, return it; if past, return null (disable)
+        return t > now ? t.toISOString() : null;
+      }
+
+      if (schedule.kind === "every") {
+        const intervalMs = schedule.ms ?? schedule.interval ?? 60_000;
+        // If lastRun exists, add interval to it; otherwise start from now
+        const base = job.lastRun ? new Date(job.lastRun).getTime() : Date.now();
+        return new Date(base + intervalMs).toISOString();
+      }
+
+      if (schedule.kind === "cron") {
+        const parser = await this._getCronParser();
+        if (!parser) {
+          console.error("[wispy-cron] cron-parser not available, skipping cron schedule");
+          return null;
+        }
+
+        const tz = schedule.tz ?? "UTC";
+        let interval;
+        // Support both v4 (parseExpression) and v5 (CronExpressionParser.parse) APIs
+        if (typeof parser.parse === "function") {
+          // v5: CronExpressionParser.parse(expr, options)
+          interval = parser.parse(schedule.expr, { currentDate: now, tz });
+        } else if (typeof parser.parseExpression === "function") {
+          // v4: module.parseExpression(expr, options)
+          interval = parser.parseExpression(schedule.expr, { currentDate: now, tz });
+        } else {
+          console.error("[wispy-cron] cron-parser API not recognized");
+          return null;
+        }
+        return interval.next().toISOString();
+      }
+    } catch (err) {
+      console.error(`[wispy-cron] Failed to compute next run: ${err.message}`);
+    }
+
+    return null;
+  }
+
+  async _appendHistory(jobId, record) {
+    const histFile = path.join(this.historyDir, `${jobId}.json`);
+    let history = [];
+    try {
+      history = JSON.parse(await readFile(histFile, "utf8"));
+    } catch {}
+    history.push(record);
+    if (history.length > MAX_HISTORY_PER_JOB) {
+      history = history.slice(-MAX_HISTORY_PER_JOB);
+    }
+    await writeFile(histFile, JSON.stringify(history, null, 2) + "\n", "utf8");
+  }
+
+  async _loadJobs() {
+    try {
+      const raw = await readFile(this.jobsFile, "utf8");
+      this._jobs = JSON.parse(raw);
+    } catch {
+      this._jobs = [];
+    }
+  }
+
+  async _saveJobs() {
+    await mkdir(this.cronDir, { recursive: true });
+    await writeFile(this.jobsFile, JSON.stringify(this._jobs, null, 2) + "\n", "utf8");
+  }
+}