@aurora-foundation/obsidian-next 0.4.7 → 0.4.9

package/dist/chunk-ZEQ3EBBN.js

@@ -0,0 +1,214 @@
+import {
+  auditLog
+} from "./chunk-WFEVQISK.js";
+import {
+  context
+} from "./chunk-EMBMLZFE.js";
+import {
+  bus
+} from "./chunk-WQM6FFSD.js";
+import {
+  db
+} from "./chunk-FNLWB54Z.js";
+
+// src/core/scheduler.ts
+import cronParser from "cron-parser";
+var parseExpression = cronParser.parseExpression || cronParser.default?.parseExpression || cronParser.parse || cronParser.default?.parse;
+var MAX_CONSECUTIVE_FAILURES = 3;
+var Scheduler = class _Scheduler {
+  static instance;
+  abilities = /* @__PURE__ */ new Map();
+  timer = null;
+  isRunning = false;
+  failureCounts = /* @__PURE__ */ new Map();
+  constructor() {
+  }
+  static getInstance() {
+    if (!_Scheduler.instance) {
+      _Scheduler.instance = new _Scheduler();
+    }
+    return _Scheduler.instance;
+  }
+  /**
+   * Initialize the scheduler loop
+   */
+  start() {
+    if (this.isRunning) return;
+    this.isRunning = true;
+    this.tick().catch((err) => bus.emitAgent({ type: "error", message: `[Scheduler] Initial tick failed: ${err instanceof Error ? err.message : String(err)}` }));
+    this.timer = setInterval(() => this.tick(), 1e4);
+    bus.emitAgent({ type: "thought", content: "[Obsidian] Started background task monitor [Active Heartbeat]" });
+  }
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    this.isRunning = false;
+  }
+  /**
+   * Register a new ability that can be scheduled
+   */
+  registerAbility(name, func) {
+    this.abilities.set(name, func);
+  }
+  /**
+   * Get list of registered abilities
+   */
+  getAbilities() {
+    return Array.from(this.abilities.keys());
+  }
+  /**
+   * Schedule a new task
+   */
+  async scheduleTask(cronExpression, abilityName, params = {}) {
+    try {
+      parseExpression(cronExpression);
+    } catch (err) {
+      throw new Error(`Invalid cron expression: ${cronExpression}`);
+    }
+    if (!this.abilities.has(abilityName)) {
+      throw new Error(`Unknown ability: ${abilityName}`);
+    }
+    const id = `task_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`;
+    const sessionId = context.get().session_id;
+    const task = {
+      id,
+      session_id: sessionId,
+      cron_expression: cronExpression,
+      command: abilityName,
+      params: JSON.stringify(params),
+      last_run_at: Date.now(),
+      active: 1
+    };
+    db.getDb().prepare(`
+            INSERT INTO scheduled_tasks (id, session_id, cron_expression, command, params, last_run_at, active)
+            VALUES (?, ?, ?, ?, ?, ?, ?)
+        `).run(task.id, task.session_id, task.cron_expression, task.command, task.params, task.last_run_at, task.active);
+    bus.emitAgent({ type: "thought", content: `[Scheduler] Scheduled ${abilityName} (${cronExpression})` });
+    return task;
+  }
+  /**
+   * List all active tasks
+   */
+  listTasks() {
+    const tasks = db.getDb().prepare(`
+            SELECT * FROM scheduled_tasks WHERE active = 1
+        `).all();
+    return tasks.map((t) => {
+      try {
+        const interval = parseExpression(t.cron_expression);
+        t.next_run_at = interval.next().getTime();
+      } catch {
+        t.next_run_at = 0;
+      }
+      return t;
+    });
+  }
+  /**
+   * Main execution loop
+   */
+  async tick() {
+    const tasks = this.listTasks();
+    const now = Date.now();
+    for (const task of tasks) {
+      try {
+        const baseline = task.last_run_at || now - 61e3;
+        let taskParams = {};
+        try {
+          taskParams = task.params ? JSON.parse(task.params) : {};
+        } catch {
+        }
+        if (taskParams.__once && taskParams.__target) {
+          if (now >= taskParams.__target) {
+            await this.executeTask(task);
+          }
+          continue;
+        }
+        const interval = parseExpression(task.cron_expression, {
+          currentDate: baseline
+        });
+        const nextRun = interval.next().getTime();
+        if (nextRun <= now) {
+          await this.executeTask(task);
+        }
+      } catch (error) {
+        bus.emitAgent({ type: "error", message: `[Scheduler] Error checking task ${task.id}: ${error instanceof Error ? error.message : String(error)}` });
+      }
+    }
+  }
+  async executeTask(task) {
+    const ability = this.abilities.get(task.command);
+    if (!ability) {
+      bus.emitAgent({ type: "error", message: `[Scheduler] Ability "${task.command}" not found. Disabling task ${task.id}.` });
+      db.getDb().prepare("UPDATE scheduled_tasks SET active = 0 WHERE id = ?").run(task.id);
+      return;
+    }
+    bus.emitAgent({
+      type: "scheduler_task_started",
+      taskId: task.id,
+      command: task.command
+    });
+    try {
+      let params = {};
+      if (task.params) {
+        try {
+          params = JSON.parse(task.params);
+        } catch {
+        }
+      }
+      await ability(params);
+      bus.emitAgent({
+        type: "scheduler_task_completed",
+        taskId: task.id,
+        command: task.command
+      });
+      this.failureCounts.delete(task.id);
+      if (params.__once) {
+        db.getDb().prepare(`UPDATE scheduled_tasks SET active = 0 WHERE id = ?`).run(task.id);
+        bus.emitAgent({ type: "thought", content: `[Scheduler] One-time task ${task.id} completed and deactivated.` });
+      }
+    } catch (error) {
+      await auditLog.logSystemEvent("scheduler_error", { taskId: task.id, error: error.message });
+      bus.emitAgent({ type: "scheduler_task_failed", taskId: task.id, command: task.command, error: error.message });
+      const failures = (this.failureCounts.get(task.id) || 0) + 1;
+      this.failureCounts.set(task.id, failures);
+      if (failures >= MAX_CONSECUTIVE_FAILURES) {
+        db.getDb().prepare("UPDATE scheduled_tasks SET active = 0 WHERE id = ?").run(task.id);
+        this.failureCounts.delete(task.id);
+        bus.emitAgent({
+          type: "error",
+          message: `[Scheduler] Task ${task.id} (${task.command}) disabled after ${MAX_CONSECUTIVE_FAILURES} consecutive failures.`
+        });
+      } else {
+        bus.emitAgent({
+          type: "error",
+          message: `[Scheduler] Task ${task.id} (${task.command}) failed: ${error.message} (${failures}/${MAX_CONSECUTIVE_FAILURES} before auto-disable)`
+        });
+      }
+    } finally {
+      db.getDb().prepare(`
+                UPDATE scheduled_tasks SET last_run_at = ? WHERE id = ?
+            `).run(Date.now(), task.id);
+    }
+  }
+  /**
+   * Remove (deactivate) a scheduled task
+   */
+  async removeTask(taskId) {
+    const result = db.getDb().prepare(`
+            UPDATE scheduled_tasks SET active = 0 WHERE id = ?
+        `).run(taskId);
+    if (result.changes && result.changes > 0) {
+      bus.emitAgent({ type: "thought", content: `[Scheduler] Deactivated task: ${taskId}` });
+      return true;
+    }
+    return false;
+  }
+};
+var scheduler = Scheduler.getInstance();
+
+export {
+  Scheduler,
+  scheduler
+};

package/dist/chunk-ZIWLQSLK.js

@@ -0,0 +1,42 @@
+import {
+  session
+} from "./chunk-KY22FIT3.js";
+import {
+  bus
+} from "./chunk-WQM6FFSD.js";
+
+// src/commands/resume.ts
+async function resumeCommand(args) {
+  if (args.length > 0) {
+    const sessionId = args[0];
+    try {
+      const result = await session.restore(sessionId);
+      if (result.success) {
+        bus.emitAgent({
+          type: "thought",
+          content: `Resumed session: ${sessionId}`
+        });
+      } else {
+        bus.emitAgent({
+          type: "error",
+          message: `Failed to resume session: ${result.error}`
+        });
+      }
+    } catch (err) {
+      bus.emitAgent({
+        type: "error",
+        message: `Error resuming session: ${err}`
+      });
+    }
+    return;
+  }
+  bus.emitAgent({
+    type: "view_request",
+    viewId: "sessions",
+    command: "resume"
+  });
+}
+
+export {
+  resumeCommand
+};