wispy-cli 0.9.0 → 1.1.0

package/bin/wispy.mjs

@@ -166,6 +166,299 @@ if (args[0] === "cron") {
   process.exit(0);
 }
 
+// ── audit / log sub-command ───────────────────────────────────────────────────
+if (args[0] === "audit" || args[0] === "log") {
+  const { AuditLog, WISPY_DIR } = await import(
+    path.join(__dirname, "..", "core", "index.mjs")
+  );
+  const { writeFile } = await import("node:fs/promises");
+
+  const audit = new AuditLog(WISPY_DIR);
+  const sub = args[1];
+
+  const dim = (s) => `\x1b[2m${s}\x1b[0m`;
+  const bold = (s) => `\x1b[1m${s}\x1b[0m`;
+  const cyan = (s) => `\x1b[36m${s}\x1b[0m`;
+  const green = (s) => `\x1b[32m${s}\x1b[0m`;
+  const yellow = (s) => `\x1b[33m${s}\x1b[0m`;
+  const red = (s) => `\x1b[31m${s}\x1b[0m`;
+
+  function formatEvent(evt) {
+    const ts = new Date(evt.timestamp).toLocaleTimeString();
+    const icons = {
+      tool_call: "🔧",
+      tool_result: "✅",
+      approval_requested: "⚠️ ",
+      approval_granted: "✅",
+      approval_denied: "❌",
+      message_sent: "🌿",
+      message_received: "👤",
+      error: "🚨",
+      subagent_spawned: "🤖",
+      subagent_completed: "🎉",
+      cron_executed: "🕐",
+    };
+    const icon = icons[evt.type] ?? "•";
+    let detail = "";
+    if (evt.tool) detail += ` ${cyan(evt.tool)}`;
+    if (evt.content) detail += ` ${dim(evt.content.slice(0, 60))}`;
+    if (evt.message) detail += ` ${dim(evt.message.slice(0, 60))}`;
+    if (evt.label) detail += ` ${dim(evt.label)}`;
+    const sid = evt.sessionId ? dim(` [${evt.sessionId.slice(-8)}]`) : "";
+    return `  ${dim(ts)} ${icon} ${evt.type}${detail}${sid}`;
+  }
+
+  if (sub === "replay" && args[2]) {
+    const sessionId = args[2];
+    const steps = await audit.getReplayTrace(sessionId);
+    if (steps.length === 0) {
+      console.log(dim(`No events found for session: ${sessionId}`));
+    } else {
+      console.log(`\n${bold("🎬 Replay:")} ${cyan(sessionId)}\n`);
+      for (const step of steps) {
+        const ts = new Date(step.timestamp).toLocaleTimeString();
+        const icons = {
+          user_message: "👤",
+          assistant_message: "🌿",
+          tool_call: "🔧",
+          tool_result: "✅",
+          approval_requested: "⚠️ ",
+          approval_granted: "✅",
+          approval_denied: "❌",
+          subagent_spawned: "🤖",
+          subagent_completed: "🎉",
+        };
+        const icon = icons[step.type] ?? "•";
+        let detail = "";
+        if (step.content) detail = dim(step.content.slice(0, 100));
+        if (step.tool) detail = `${cyan(step.tool)} ${dim(JSON.stringify(step.args ?? {}).slice(0, 60))}`;
+        console.log(`  ${bold(`Step ${step.step}`)} ${dim(ts)} ${icon} ${detail}`);
+      }
+    }
+    process.exit(0);
+  }
+
+  if (sub === "export") {
+    const format = args.includes("--format") ? args[args.indexOf("--format") + 1] : "json";
+    const outputIdx = args.indexOf("--output");
+    const output = outputIdx !== -1 ? args[outputIdx + 1] : null;
+
+    let content;
+    if (format === "md" || format === "markdown") {
+      content = await audit.exportMarkdown();
+    } else {
+      content = await audit.exportJson();
+    }
+
+    if (output) {
+      await writeFile(output, content, "utf8");
+      console.log(green(`✅ Exported to ${output}`));
+    } else {
+      console.log(content);
+    }
+    process.exit(0);
+  }
+
+  // Build filter from flags
+  const filter = {};
+  const sessionIdx = args.indexOf("--session");
+  if (sessionIdx !== -1) filter.sessionId = args[sessionIdx + 1];
+  const toolIdx = args.indexOf("--tool");
+  if (toolIdx !== -1) filter.tool = args[toolIdx + 1];
+  if (args.includes("--today")) filter.date = new Date().toISOString().slice(0, 10);
+  const limitIdx = args.indexOf("--limit");
+  filter.limit = limitIdx !== -1 ? parseInt(args[limitIdx + 1]) : 30;
+
+  const events = await audit.search(filter);
+
+  if (events.length === 0) {
+    console.log(dim("No audit events found."));
+  } else {
+    console.log(`\n${bold("📋 Audit Log")} ${dim(`(${events.length} events)`)}\n`);
+    for (const evt of events) {
+      console.log(formatEvent(evt));
+    }
+    console.log("");
+  }
+
+  if (!sub) {
+    console.log(dim(`
+  wispy audit                          — show recent events
+  wispy audit --session <id>           — filter by session
+  wispy audit --today                  — today's events
+  wispy audit --tool <name>            — filter by tool
+  wispy audit replay <sessionId>       — step-by-step replay
+  wispy audit export --format md       — export as markdown
+  wispy audit export --output file.md  — save to file
+`));
+  }
+
+  process.exit(0);
+}
+
+// ── server sub-command ────────────────────────────────────────────────────────
+if (args[0] === "server" || args.includes("--server")) {
+  const { WispyEngine, WispyServer } = await import(
+    path.join(__dirname, "..", "core", "index.mjs")
+  );
+
+  const portIdx = args.indexOf("--port");
+  const hostIdx = args.indexOf("--host");
+  const port = portIdx !== -1 ? parseInt(args[portIdx + 1]) : undefined;
+  const host = hostIdx !== -1 ? args[hostIdx + 1] : undefined;
+
+  console.log("🌿 Starting Wispy API server...");
+
+  const engine = new WispyEngine();
+  const initResult = await engine.init();
+  if (!initResult) {
+    console.error("❌ No AI provider configured. Run `wispy` first to set up.");
+    process.exit(1);
+  }
+
+  const server = new WispyServer(engine, { port, host });
+  await server.start();
+
+  process.on("SIGINT", () => { server.stop(); process.exit(0); });
+  process.on("SIGTERM", () => { server.stop(); process.exit(0); });
+
+  // Keep alive
+  setInterval(() => {}, 60_000);
+  await new Promise(() => {});
+}
+
+// ── node sub-command ──────────────────────────────────────────────────────────
+if (args[0] === "node") {
+  const { NodeManager, WISPY_DIR, CAPABILITIES } = await import(
+    path.join(__dirname, "..", "core", "index.mjs")
+  );
+  const { createInterface } = await import("node:readline");
+
+  const sub = args[1];
+  const nodes = new NodeManager(WISPY_DIR);
+
+  const dim = (s) => `\x1b[2m${s}\x1b[0m`;
+  const bold = (s) => `\x1b[1m${s}\x1b[0m`;
+  const cyan = (s) => `\x1b[36m${s}\x1b[0m`;
+  const green = (s) => `\x1b[32m${s}\x1b[0m`;
+  const red = (s) => `\x1b[31m${s}\x1b[0m`;
+  const yellow = (s) => `\x1b[33m${s}\x1b[0m`;
+
+  if (sub === "pair") {
+    const code = await nodes.generatePairCode();
+    console.log(`\n🔗 Pairing Code: ${bold(green(code))}\n`);
+    console.log(`  This code expires in 1 hour.`);
+    console.log(`\n  On the remote machine, run:`);
+    console.log(`  ${cyan(`wispy node connect ${code} --url http://localhost:18790`)}\n`);
+    process.exit(0);
+  }
+
+  if (sub === "connect" && args[2]) {
+    const code = args[2];
+    const urlIdx = args.indexOf("--url");
+    const serverUrl = urlIdx !== -1 ? args[urlIdx + 1] : "http://localhost:18790";
+
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const ask = (q) => new Promise(r => rl.question(q, r));
+
+    console.log(`\n🔗 Connecting to Wispy at ${serverUrl}\n`);
+    const name = (await ask("  Node name (e.g. my-laptop): ")).trim() || `node-${Date.now().toString(36)}`;
+
+    console.log(`\nAvailable capabilities:`);
+    const capList = Object.entries(CAPABILITIES);
+    capList.forEach(([k, v], i) => console.log(`  ${i + 1}. ${k.padEnd(15)} — ${dim(v)}`));
+    const capInput = (await ask("\n  Select capabilities (comma-separated numbers, e.g. 1,3): ")).trim();
+    rl.close();
+
+    const selectedCaps = capInput
+      ? capInput.split(",").map(n => capList[parseInt(n.trim()) - 1]?.[0]).filter(Boolean)
+      : [];
+
+    // Call server to confirm pair
+    try {
+      const tokenIdx = args.indexOf("--token");
+      const token = tokenIdx !== -1 ? args[tokenIdx + 1] : "";
+      const resp = await fetch(`${serverUrl}/api/nodes/pair`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...(token ? { "Authorization": `Bearer ${token}` } : {}) },
+        body: JSON.stringify({ code, name, capabilities: selectedCaps, host: "localhost", port: 18791 }),
+      });
+      if (!resp.ok) {
+        const err = await resp.json().catch(() => ({ error: resp.statusText }));
+        console.error(red(`❌ Pairing failed: ${err.error ?? resp.statusText}`));
+        process.exit(1);
+      }
+      const result = await resp.json();
+      console.log(green(`\n✅ Paired! Node ID: ${result.id}`));
+    } catch (err) {
+      console.error(red(`❌ Connection failed: ${err.message}`));
+      console.log(dim("  Make sure `wispy server` is running on the main machine."));
+      process.exit(1);
+    }
+    process.exit(0);
+  }
+
+  if (sub === "list") {
+    const nodeList = await nodes.list();
+    if (nodeList.length === 0) {
+      console.log(dim("No nodes registered. Use: wispy node pair"));
+    } else {
+      console.log(`\n${bold("🌐 Registered Nodes:")}\n`);
+      for (const n of nodeList) {
+        const caps = n.capabilities.join(", ") || dim("none");
+        const last = n.lastSeen ? dim(new Date(n.lastSeen).toLocaleString()) : dim("never");
+        console.log(`  ${green(n.id.slice(-12))}  ${bold(n.name.padEnd(20))}  ${n.host}:${n.port}`);
+        console.log(`    Caps: ${caps}   Last seen: ${last}`);
+        console.log("");
+      }
+    }
+    process.exit(0);
+  }
+
+  if (sub === "status") {
+    const nodeList = await nodes.list();
+    if (nodeList.length === 0) {
+      console.log(dim("No nodes registered."));
+      process.exit(0);
+    }
+    console.log(`\n${bold("📡 Node Status:")}\n`);
+    const results = await nodes.status();
+    for (const r of results) {
+      const statusIcon = r.alive ? green("●") : red("●");
+      const latency = r.latency ? dim(` ${r.latency}ms`) : "";
+      const err = r.error ? red(` (${r.error})`) : "";
+      console.log(`  ${statusIcon} ${r.name.padEnd(20)} ${r.host}:${r.port}${latency}${err}`);
+    }
+    console.log("");
+    process.exit(0);
+  }
+
+  if (sub === "remove" && args[2]) {
+    const id = args[2];
+    const nodeList = await nodes.list();
+    const match = nodeList.find(n => n.id === id || n.id.endsWith(id));
+    if (!match) {
+      console.error(red(`Node not found: ${id}`));
+      process.exit(1);
+    }
+    await nodes.remove(match.id);
+    console.log(green(`✅ Removed node: ${match.name} (${match.id})`));
+    process.exit(0);
+  }
+
+  // Help
+  console.log(`
+🌐 Wispy Node Commands:
+
+  wispy node pair                          — generate pairing code
+  wispy node connect <code> --url <url>   — connect as a node
+  wispy node list                          — show registered nodes
+  wispy node status                        — ping all nodes
+  wispy node remove <id>                  — unregister a node
+`);
+  process.exit(0);
+}
+
 // ── channel sub-command ───────────────────────────────────────────────────────
 if (args[0] === "channel") {
   const { channelSetup, channelList, channelTest } = await import(

package/core/audit.mjs

@@ -0,0 +1,322 @@
+/**
+ * core/audit.mjs — Audit Log & Replay for Wispy
+ *
+ * Storage: ~/.wispy/audit/YYYY-MM-DD.jsonl
+ * Auto-rotate: keep last 30 days
+ */
+
+import path from "node:path";
+import { readFile, writeFile, mkdir, readdir, unlink, appendFile, stat } from "node:fs/promises";
+
+import { WISPY_DIR } from "./config.mjs";
+
+const AUDIT_DIR = path.join(WISPY_DIR, "audit");
+const MAX_DAYS = 30;
+
+// Event types
+export const EVENT_TYPES = {
+  TOOL_CALL:           "tool_call",
+  TOOL_RESULT:         "tool_result",
+  APPROVAL_REQUESTED:  "approval_requested",
+  APPROVAL_GRANTED:    "approval_granted",
+  APPROVAL_DENIED:     "approval_denied",
+  MESSAGE_SENT:        "message_sent",
+  MESSAGE_RECEIVED:    "message_received",
+  ERROR:               "error",
+  SUBAGENT_SPAWNED:    "subagent_spawned",
+  SUBAGENT_COMPLETED:  "subagent_completed",
+  CRON_EXECUTED:       "cron_executed",
+};
+
+function todayString() {
+  return new Date().toISOString().slice(0, 10); // YYYY-MM-DD
+}
+
+function auditFilePath(dateStr) {
+  return path.join(AUDIT_DIR, `${dateStr}.jsonl`);
+}
+
+export class AuditLog {
+  constructor(wispyDir = WISPY_DIR) {
+    this.auditDir = path.join(wispyDir, "audit");
+    this._initialized = false;
+  }
+
+  async _init() {
+    if (this._initialized) return;
+    await mkdir(this.auditDir, { recursive: true });
+    this._initialized = true;
+    // Rotate old files in the background
+    this._rotate().catch(() => {});
+  }
+
+  // ── Log ─────────────────────────────────────────────────────────────────────
+
+  /**
+   * Log an audit event.
+   * @param {object} event - Event object (type required)
+   */
+  async log(event) {
+    await this._init();
+    const entry = {
+      timestamp: new Date().toISOString(),
+      ...event,
+    };
+    const line = JSON.stringify(entry) + "\n";
+    const filePath = path.join(this.auditDir, `${todayString()}.jsonl`);
+    await appendFile(filePath, line, "utf8");
+  }
+
+  // ── Query ────────────────────────────────────────────────────────────────────
+
+  /**
+   * Load all events from JSONL files matching filter.
+   * @param {object} filter - { date?, type?, sessionId?, tool?, limit? }
+   */
+  async search(filter = {}) {
+    await this._init();
+    const allFiles = await this._listFiles();
+    const events = [];
+
+    // Filter by date if provided
+    const targetFiles = filter.date
+      ? allFiles.filter(f => f.includes(filter.date))
+      : allFiles;
+
+    for (const file of targetFiles.slice(-30)) {
+      try {
+        const content = await readFile(path.join(this.auditDir, file), "utf8");
+        const lines = content.trim().split("\n").filter(Boolean);
+        for (const line of lines) {
+          try {
+            const evt = JSON.parse(line);
+            if (this._matchesFilter(evt, filter)) {
+              events.push(evt);
+            }
+          } catch {}
+        }
+      } catch {}
+    }
+
+    if (filter.limit) return events.slice(-filter.limit);
+    return events;
+  }
+
+  /**
+   * Get all events for a session.
+   */
+  async getSession(sessionId) {
+    return this.search({ sessionId });
+  }
+
+  /**
+   * Get recent events.
+   * @param {number} limit
+   */
+  async getRecent(limit = 20) {
+    return this.search({ limit });
+  }
+
+  /**
+   * Today's events.
+   */
+  async getToday() {
+    return this.search({ date: todayString() });
+  }
+
+  // ── Replay ───────────────────────────────────────────────────────────────────
+
+  /**
+   * Get replay trace for a session — ordered steps.
+   * @param {string} sessionId
+   * @returns {Step[]}
+   */
+  async getReplayTrace(sessionId) {
+    const events = await this.getSession(sessionId);
+    if (events.length === 0) return [];
+
+    const steps = [];
+    let stepIdx = 0;
+
+    for (const evt of events) {
+      let step = null;
+      switch (evt.type) {
+        case EVENT_TYPES.MESSAGE_RECEIVED:
+          step = {
+            step: ++stepIdx,
+            type: "user_message",
+            timestamp: evt.timestamp,
+            content: evt.content ?? evt.message,
+          };
+          break;
+        case EVENT_TYPES.MESSAGE_SENT:
+          step = {
+            step: ++stepIdx,
+            type: "assistant_message",
+            timestamp: evt.timestamp,
+            content: evt.content ?? evt.response,
+          };
+          break;
+        case EVENT_TYPES.TOOL_CALL:
+          step = {
+            step: ++stepIdx,
+            type: "tool_call",
+            timestamp: evt.timestamp,
+            tool: evt.tool,
+            args: evt.args,
+          };
+          break;
+        case EVENT_TYPES.TOOL_RESULT:
+          step = {
+            step: ++stepIdx,
+            type: "tool_result",
+            timestamp: evt.timestamp,
+            tool: evt.tool,
+            result: evt.result,
+            duration: evt.duration,
+          };
+          break;
+        case EVENT_TYPES.APPROVAL_REQUESTED:
+          step = {
+            step: ++stepIdx,
+            type: "approval_requested",
+            timestamp: evt.timestamp,
+            tool: evt.tool,
+            args: evt.args,
+          };
+          break;
+        case EVENT_TYPES.APPROVAL_GRANTED:
+        case EVENT_TYPES.APPROVAL_DENIED:
+          step = {
+            step: ++stepIdx,
+            type: evt.type,
+            timestamp: evt.timestamp,
+            tool: evt.tool,
+          };
+          break;
+        case EVENT_TYPES.SUBAGENT_SPAWNED:
+          step = {
+            step: ++stepIdx,
+            type: "subagent_spawned",
+            timestamp: evt.timestamp,
+            agentId: evt.agentId,
+            label: evt.label,
+          };
+          break;
+        case EVENT_TYPES.SUBAGENT_COMPLETED:
+          step = {
+            step: ++stepIdx,
+            type: "subagent_completed",
+            timestamp: evt.timestamp,
+            agentId: evt.agentId,
+            status: evt.status,
+          };
+          break;
+      }
+      if (step) steps.push(step);
+    }
+
+    return steps;
+  }
+
+  // ── Export ───────────────────────────────────────────────────────────────────
+
+  async exportJson(filter = {}) {
+    const events = await this.search(filter);
+    return JSON.stringify(events, null, 2);
+  }
+
+  async exportMarkdown(filter = {}) {
+    const events = await this.search(filter);
+    if (events.length === 0) return "# Wispy Audit Report\n\nNo events found.\n";
+
+    const lines = [
+      `# Wispy Audit Report`,
+      `Generated: ${new Date().toISOString()}`,
+      `Total events: ${events.length}`,
+      "",
+    ];
+
+    const bySession = {};
+    for (const evt of events) {
+      const sid = evt.sessionId ?? "unknown";
+      if (!bySession[sid]) bySession[sid] = [];
+      bySession[sid].push(evt);
+    }
+
+    for (const [sid, evts] of Object.entries(bySession)) {
+      lines.push(`## Session: ${sid}`, "");
+      for (const evt of evts) {
+        const ts = new Date(evt.timestamp).toLocaleString();
+        switch (evt.type) {
+          case EVENT_TYPES.MESSAGE_RECEIVED:
+            lines.push(`**[${ts}] 👤 User:** ${(evt.content ?? evt.message ?? "").slice(0, 200)}`);
+            break;
+          case EVENT_TYPES.MESSAGE_SENT:
+            lines.push(`**[${ts}] 🌿 Wispy:** ${(evt.content ?? evt.response ?? "").slice(0, 200)}`);
+            break;
+          case EVENT_TYPES.TOOL_CALL:
+            lines.push(`**[${ts}] 🔧 Tool:** \`${evt.tool}\` — ${JSON.stringify(evt.args ?? {}).slice(0, 100)}`);
+            break;
+          case EVENT_TYPES.APPROVAL_GRANTED:
+            lines.push(`**[${ts}] ✅ Approved:** \`${evt.tool}\``);
+            break;
+          case EVENT_TYPES.APPROVAL_DENIED:
+            lines.push(`**[${ts}] ❌ Denied:** \`${evt.tool}\``);
+            break;
+          case EVENT_TYPES.ERROR:
+            lines.push(`**[${ts}] 🚨 Error:** ${evt.message ?? ""}`);
+            break;
+          default:
+            lines.push(`**[${ts}] ${evt.type}**`);
+        }
+      }
+      lines.push("");
+    }
+
+    return lines.join("\n");
+  }
+
+  // ── Rotation ─────────────────────────────────────────────────────────────────
+
+  async _rotate() {
+    try {
+      const files = await this._listFiles();
+      if (files.length <= MAX_DAYS) return;
+      const toDelete = files.slice(0, files.length - MAX_DAYS);
+      for (const f of toDelete) {
+        await unlink(path.join(this.auditDir, f)).catch(() => {});
+      }
+    } catch {}
+  }
+
+  async _listFiles() {
+    try {
+      const files = await readdir(this.auditDir);
+      return files.filter(f => f.endsWith(".jsonl")).sort();
+    } catch {
+      return [];
+    }
+  }
+
+  // ── Internal filter ───────────────────────────────────────────────────────────
+
+  _matchesFilter(evt, filter) {
+    if (filter.type && evt.type !== filter.type) return false;
+    if (filter.sessionId && evt.sessionId !== filter.sessionId) return false;
+    if (filter.tool && evt.tool !== filter.tool) return false;
+    if (filter.since) {
+      const ts = new Date(evt.timestamp);
+      const since = new Date(filter.since);
+      if (ts < since) return false;
+    }
+    return true;
+  }
+}
+
+// Singleton
+let _defaultAudit = null;
+export function getAuditLog() {
+  if (!_defaultAudit) _defaultAudit = new AuditLog();
+  return _defaultAudit;
+}

package/core/cron.mjs

@@ -161,15 +161,19 @@ export class CronManager {
   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);
-        });
+      try {
+        if (!job.enabled) continue;
+        if (!job.nextRun) continue;
+
+        const nextRunMs = new Date(job.nextRun).getTime();
+        if (now >= nextRunMs) {
+          // Execute and update — errors must not crash the scheduler
+          this._executeJob(job).catch(err => {
+            console.error(`[wispy-cron] Job "${job.name}" error: ${err.message}`);
+          });
+        }
+      } catch (err) {
+        console.error(`[wispy-cron] Tick error for job "${job?.name}": ${err.message}`);
       }
     }
   }
@@ -181,16 +185,24 @@ export class CronManager {
     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;
+      // Run via engine with a 5-minute timeout to prevent runaway jobs
+      const JOB_TIMEOUT_MS = 300_000;
+      const response = await Promise.race([
+        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 🌿.`,
+        }),
+        new Promise((_, reject) =>
+          setTimeout(() => reject(new Error(`Job timed out after ${JOB_TIMEOUT_MS / 1000}s`)), JOB_TIMEOUT_MS)
+        ),
+      ]);
+      output = response?.content ?? "(no output)";
 
       // Deliver to channel if configured
       if (job.channel) {
-        await this._deliverToChannel(job.channel, job.name, output);
+        await this._deliverToChannel(job.channel, job.name, output).catch(err => {
+          console.error(`[wispy-cron] Channel delivery failed for job "${job.name}": ${err.message}`);
+        });
       }
     } catch (err) {
       status = "failed";