kernelbot 1.0.26 → 1.0.28

package/src/automation/automation-manager.js

@@ -0,0 +1,377 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { Automation } from './automation.js';
+import { scheduleNext, cancel } from './scheduler.js';
+import { getLogger } from '../utils/logger.js';
+
+const DATA_DIR = join(homedir(), '.kernelbot');
+const DATA_FILE = join(DATA_DIR, 'automations.json');
+
+const DEFAULT_MAX_PER_CHAT = 10;
+const DEFAULT_MIN_INTERVAL = 5; // minutes
+
+export class AutomationManager {
+  constructor() {
+    /** @type {Map<string, Automation>} id → Automation */
+    this.automations = new Map();
+    /** @type {Map<string, any>} id → timer ID */
+    this.timers = new Map();
+    /** @type {Map<string, Promise>} chatId → execution chain (serialize per chat) */
+    this._chatLocks = new Map();
+
+    // Injected via init()
+    this._sendMessage = null;
+    this._sendChatAction = null;
+    this._agentFactory = null;
+    this._config = null;
+
+    this._load();
+  }
+
+  /**
+   * Initialize with bot context. Called after bot is created.
+   * @param {object} opts
+   * @param {Function} opts.sendMessage - (chatId, text, opts?) => Promise
+   * @param {Function} opts.sendChatAction - (chatId, action) => Promise
+   * @param {Function} opts.agentFactory - (chatId) => { agent, onUpdate, sendPhoto }
+   * @param {object} opts.config
+   */
+  init({ sendMessage, sendChatAction, agentFactory, config }) {
+    this._sendMessage = sendMessage;
+    this._sendChatAction = sendChatAction;
+    this._agentFactory = agentFactory;
+    this._config = config;
+  }
+
+  /** Arm all enabled automations (called on startup). */
+  startAll() {
+    const logger = getLogger();
+    let armed = 0;
+    for (const auto of this.automations.values()) {
+      if (auto.enabled) {
+        this._arm(auto);
+        armed++;
+      }
+    }
+    if (armed > 0) {
+      logger.info(`[AutomationManager] Armed ${armed} automation(s) on startup`);
+    }
+  }
+
+  /** Cancel all timers (called on shutdown). */
+  shutdown() {
+    for (const timerId of this.timers.values()) {
+      cancel(timerId);
+    }
+    this.timers.clear();
+  }
+
+  // ── CRUD ──────────────────────────────────────────────────────────
+
+  /**
+   * Create a new automation.
+   * @param {string} chatId
+   * @param {object} data - { name, description, schedule }
+   * @returns {Automation}
+   */
+  create(chatId, data) {
+    const logger = getLogger();
+
+    // Enforce limits
+    const chatAutos = this.listForChat(chatId);
+    const maxPerChat = this._config?.automation?.max_per_chat || DEFAULT_MAX_PER_CHAT;
+    if (chatAutos.length >= maxPerChat) {
+      throw new Error(`Maximum automations per chat (${maxPerChat}) reached.`);
+    }
+
+    this._validateSchedule(data.schedule);
+
+    const auto = new Automation({
+      chatId,
+      name: data.name,
+      description: data.description,
+      schedule: data.schedule,
+    });
+
+    this.automations.set(auto.id, auto);
+    this._arm(auto);
+    this._save();
+
+    logger.info(`[AutomationManager] Created automation ${auto.id} "${auto.name}" for chat ${chatId}`);
+    return auto;
+  }
+
+  /** List all automations for a chat. */
+  listForChat(chatId) {
+    const id = String(chatId);
+    return [...this.automations.values()].filter((a) => a.chatId === id);
+  }
+
+  /** List all automations across all chats. */
+  listAll() {
+    return [...this.automations.values()];
+  }
+
+  /** Get a single automation by ID. */
+  get(id) {
+    return this.automations.get(id) || null;
+  }
+
+  /**
+   * Update an automation.
+   * @param {string} id
+   * @param {object} changes - partial fields to update
+   * @returns {Automation|null}
+   */
+  update(id, changes) {
+    const logger = getLogger();
+    const auto = this.automations.get(id);
+    if (!auto) return null;
+
+    if (changes.name !== undefined) auto.name = changes.name;
+    if (changes.description !== undefined) auto.description = changes.description;
+
+    if (changes.schedule !== undefined) {
+      this._validateSchedule(changes.schedule);
+      auto.schedule = changes.schedule;
+    }
+
+    if (changes.enabled !== undefined) {
+      auto.enabled = changes.enabled;
+      if (auto.enabled) {
+        this._arm(auto);
+      } else {
+        this._disarm(auto);
+      }
+    }
+
+    // Re-arm if schedule changed while enabled
+    if (changes.schedule !== undefined && auto.enabled) {
+      this._arm(auto);
+    }
+
+    this._save();
+    logger.info(`[AutomationManager] Updated automation ${id}: ${JSON.stringify(changes)}`);
+    return auto;
+  }
+
+  /**
+   * Delete an automation.
+   * @param {string} id
+   * @returns {boolean}
+   */
+  delete(id) {
+    const logger = getLogger();
+    const auto = this.automations.get(id);
+    if (!auto) return false;
+
+    this._disarm(auto);
+    this.automations.delete(id);
+    this._save();
+
+    logger.info(`[AutomationManager] Deleted automation ${id} "${auto.name}"`);
+    return true;
+  }
+
+  /**
+   * Trigger an automation immediately (manual run).
+   * @param {string} id
+   */
+  async runNow(id) {
+    const auto = this.automations.get(id);
+    if (!auto) throw new Error(`Automation ${id} not found.`);
+    await this._executeAutomation(auto);
+  }
+
+  // ── Timer management ──────────────────────────────────────────────
+
+  /** Arm (or re-arm) a timer for an automation. */
+  _arm(auto) {
+    const logger = getLogger();
+
+    // Cancel existing timer if any
+    this._disarm(auto);
+
+    const { timerId, nextRun } = scheduleNext(auto, () => {
+      this._onTimerFire(auto);
+    });
+
+    auto.nextRun = nextRun;
+    this.timers.set(auto.id, timerId);
+
+    logger.debug(`[AutomationManager] Armed ${auto.id} "${auto.name}" — next: ${new Date(nextRun).toLocaleString()}`);
+  }
+
+  /** Cancel an automation's timer. */
+  _disarm(auto) {
+    const timerId = this.timers.get(auto.id);
+    if (timerId != null) {
+      cancel(timerId);
+      this.timers.delete(auto.id);
+      auto.nextRun = null;
+    }
+  }
+
+  /** Called when a timer fires. */
+  _onTimerFire(auto) {
+    const logger = getLogger();
+
+    // Guard: automation may have been deleted or disabled while timer was pending
+    const current = this.automations.get(auto.id);
+    if (!current || !current.enabled) {
+      logger.debug(`[AutomationManager] Timer fired for ${auto.id} but automation is disabled/deleted — skipping`);
+      return;
+    }
+
+    // Serialize execution per chat to prevent conversation history corruption
+    this._enqueueExecution(current);
+  }
+
+  /** Enqueue automation execution into per-chat chain. */
+  _enqueueExecution(auto) {
+    const chatId = auto.chatId;
+    const prev = this._chatLocks.get(chatId) || Promise.resolve();
+    const next = prev.then(() => this._executeAutomation(auto)).catch(() => {});
+    this._chatLocks.set(chatId, next);
+  }
+
+  /** Execute an automation run. */
+  async _executeAutomation(auto) {
+    const logger = getLogger();
+
+    // Convert chatId back to number to match Telegram's format
+    // (Automation stores as string for JSON safety, but conversationManager uses number keys)
+    const chatId = Number(auto.chatId);
+
+    logger.info(`[AutomationManager] Executing automation ${auto.id} "${auto.name}" for chat ${chatId}`);
+
+    // Update run stats
+    auto.lastRun = Date.now();
+    auto.runCount++;
+    this._save();
+
+    try {
+      // Notify user
+      if (this._sendChatAction) {
+        await this._sendChatAction(chatId, 'typing').catch(() => {});
+      }
+      if (this._sendMessage) {
+        await this._sendMessage(chatId, `⏰ Running: **${auto.name}**...`).catch(() => {});
+      }
+
+      // Get agent context for this chat
+      if (!this._agentFactory) {
+        throw new Error('AutomationManager not initialized — no agentFactory');
+      }
+
+      const { agent, onUpdate, sendPhoto } = this._agentFactory(chatId);
+      const prompt = `[AUTOMATION: ${auto.name}] ${auto.description}`;
+
+      // Run through the orchestrator like a normal user message
+      const reply = await agent.processMessage(
+        chatId,
+        prompt,
+        { id: 'automation', username: 'automation' },
+        onUpdate,
+        sendPhoto,
+      );
+
+      // Send the response
+      if (reply && this._sendMessage) {
+        await this._sendMessage(chatId, reply).catch(() => {});
+      }
+
+      auto.lastError = null;
+      logger.info(`[AutomationManager] Automation ${auto.id} completed — reply: "${(reply || '').slice(0, 150)}"`);
+    } catch (err) {
+      auto.lastError = err.message;
+      logger.error(`[AutomationManager] Automation ${auto.id} failed: ${err.message}`);
+
+      if (this._sendMessage) {
+        await this._sendMessage(
+          chatId,
+          `⚠️ Automation **${auto.name}** failed: ${err.message}`,
+        ).catch(() => {});
+      }
+    }
+
+    // Re-arm for next execution (regardless of success/failure)
+    const current = this.automations.get(auto.id);
+    if (current && current.enabled) {
+      this._arm(current);
+      this._save();
+    }
+  }
+
+  // ── Validation ────────────────────────────────────────────────────
+
+  _validateSchedule(schedule) {
+    if (!schedule || !schedule.type) {
+      throw new Error('Schedule must have a type (cron, interval, or random).');
+    }
+
+    const minInterval = this._config?.automation?.min_interval_minutes || DEFAULT_MIN_INTERVAL;
+
+    switch (schedule.type) {
+      case 'cron':
+        if (!schedule.expression) {
+          throw new Error('Cron schedule requires an expression field.');
+        }
+        break;
+
+      case 'interval':
+        if (!schedule.minutes || schedule.minutes < minInterval) {
+          throw new Error(`Interval must be at least ${minInterval} minutes.`);
+        }
+        break;
+
+      case 'random':
+        if (!schedule.minMinutes || !schedule.maxMinutes) {
+          throw new Error('Random schedule requires minMinutes and maxMinutes.');
+        }
+        if (schedule.minMinutes < minInterval) {
+          throw new Error(`Minimum random interval must be at least ${minInterval} minutes.`);
+        }
+        if (schedule.maxMinutes <= schedule.minMinutes) {
+          throw new Error('maxMinutes must be greater than minMinutes.');
+        }
+        break;
+
+      default:
+        throw new Error(`Unknown schedule type: ${schedule.type}. Use cron, interval, or random.`);
+    }
+  }
+
+  // ── Persistence ───────────────────────────────────────────────────
+
+  _load() {
+    const logger = getLogger();
+    try {
+      if (existsSync(DATA_FILE)) {
+        const raw = readFileSync(DATA_FILE, 'utf-8');
+        const data = JSON.parse(raw);
+        for (const item of data) {
+          const auto = Automation.fromJSON(item);
+          this.automations.set(auto.id, auto);
+        }
+        logger.info(`[AutomationManager] Loaded ${this.automations.size} automation(s) from disk`);
+      }
+    } catch (err) {
+      logger.error(`[AutomationManager] Failed to load automations: ${err.message}`);
+    }
+  }
+
+  _save() {
+    try {
+      if (!existsSync(DATA_DIR)) {
+        mkdirSync(DATA_DIR, { recursive: true });
+      }
+      const data = [...this.automations.values()].map((a) => a.toJSON());
+      writeFileSync(DATA_FILE, JSON.stringify(data, null, 2), 'utf-8');
+    } catch (err) {
+      const logger = getLogger();
+      logger.error(`[AutomationManager] Failed to save automations: ${err.message}`);
+    }
+  }
+}

package/src/automation/automation.js

@@ -0,0 +1,79 @@
+import { randomBytes } from 'crypto';
+
+/**
+ * A single recurring automation — a scheduled task that the orchestrator runs.
+ */
+export class Automation {
+  constructor({ chatId, name, description, schedule }) {
+    this.id = randomBytes(4).toString('hex');
+    this.chatId = String(chatId);
+    this.name = name;
+    this.description = description; // the task prompt
+    this.schedule = schedule;       // { type, expression?, minutes?, minMinutes?, maxMinutes? }
+    this.enabled = true;
+    this.lastRun = null;
+    this.nextRun = null;
+    this.runCount = 0;
+    this.lastError = null;
+    this.createdAt = Date.now();
+  }
+
+  /** Human-readable one-line summary. */
+  toSummary() {
+    const status = this.enabled ? '🟢' : '⏸️';
+    const scheduleStr = formatSchedule(this.schedule);
+    const nextStr = this.nextRun
+      ? `next: ${new Date(this.nextRun).toLocaleString()}`
+      : 'not scheduled';
+    const runs = this.runCount > 0 ? ` | ${this.runCount} runs` : '';
+    return `${status} \`${this.id}\` **${this.name}** — ${scheduleStr} (${nextStr}${runs})`;
+  }
+
+  /** Serialize for persistence. */
+  toJSON() {
+    return {
+      id: this.id,
+      chatId: this.chatId,
+      name: this.name,
+      description: this.description,
+      schedule: this.schedule,
+      enabled: this.enabled,
+      lastRun: this.lastRun,
+      nextRun: this.nextRun,
+      runCount: this.runCount,
+      lastError: this.lastError,
+      createdAt: this.createdAt,
+    };
+  }
+
+  /** Deserialize from persistence. */
+  static fromJSON(data) {
+    const auto = Object.create(Automation.prototype);
+    auto.id = data.id;
+    auto.chatId = String(data.chatId);
+    auto.name = data.name;
+    auto.description = data.description;
+    auto.schedule = data.schedule;
+    auto.enabled = data.enabled;
+    auto.lastRun = data.lastRun;
+    auto.nextRun = data.nextRun;
+    auto.runCount = data.runCount;
+    auto.lastError = data.lastError;
+    auto.createdAt = data.createdAt;
+    return auto;
+  }
+}
+
+/** Format a schedule object for display. */
+function formatSchedule(schedule) {
+  switch (schedule.type) {
+    case 'cron':
+      return `cron: \`${schedule.expression}\``;
+    case 'interval':
+      return `every ${schedule.minutes}m`;
+    case 'random':
+      return `random ${schedule.minMinutes}–${schedule.maxMinutes}m`;
+    default:
+      return schedule.type;
+  }
+}

package/src/automation/index.js

@@ -0,0 +1,2 @@
+export { Automation } from './automation.js';
+export { AutomationManager } from './automation-manager.js';

package/src/automation/scheduler.js

@@ -0,0 +1,141 @@
+/**
+ * Pure timer engine for automations — cron, interval, and random schedules.
+ * Uses setTimeout (no new dependencies).
+ */
+
+/**
+ * Calculate the next fire time for an automation.
+ * @param {object} schedule - { type, expression?, minutes?, minMinutes?, maxMinutes? }
+ * @param {number|null} lastRun - timestamp of last execution
+ * @returns {number} next fire timestamp
+ */
+export function getNextFireTime(schedule, lastRun) {
+  const now = Date.now();
+
+  switch (schedule.type) {
+    case 'cron':
+      return nextCronTime(schedule.expression, now);
+
+    case 'interval': {
+      const intervalMs = schedule.minutes * 60 * 1000;
+      if (lastRun) {
+        const next = lastRun + intervalMs;
+        return next > now ? next : now + 1000; // if overdue, fire soon
+      }
+      return now + intervalMs;
+    }
+
+    case 'random': {
+      const minMs = schedule.minMinutes * 60 * 1000;
+      const maxMs = schedule.maxMinutes * 60 * 1000;
+      const delayMs = minMs + Math.random() * (maxMs - minMs);
+      return now + delayMs;
+    }
+
+    default:
+      throw new Error(`Unknown schedule type: ${schedule.type}`);
+  }
+}
+
+/**
+ * Schedule a timer for an automation. Returns the timer ID.
+ * @param {object} automation - Automation instance
+ * @param {Function} callback - called when timer fires
+ * @returns {{ timerId: any, nextRun: number }}
+ */
+export function scheduleNext(automation, callback) {
+  const nextRun = getNextFireTime(automation.schedule, automation.lastRun);
+  const delay = Math.max(nextRun - Date.now(), 1000); // at least 1s
+
+  const timerId = setTimeout(callback, delay);
+  return { timerId, nextRun };
+}
+
+/**
+ * Cancel a scheduled timer.
+ * @param {any} timerId
+ */
+export function cancel(timerId) {
+  if (timerId != null) clearTimeout(timerId);
+}
+
+// ── Cron parser ────────────────────────────────────────────────────────
+
+/**
+ * Parse a 5-field cron expression and compute the next occurrence after `after`.
+ * Fields: minute hour dayOfMonth month dayOfWeek
+ * Supports: numbers, ranges (1-5), steps (star/5), lists (1,3,5), star
+ */
+function nextCronTime(expression, after) {
+  const fields = expression.trim().split(/\s+/);
+  if (fields.length !== 5) {
+    throw new Error(`Invalid cron expression (need 5 fields): ${expression}`);
+  }
+
+  const [minuteF, hourF, domF, monthF, dowF] = fields;
+  const minutes = parseField(minuteF, 0, 59);
+  const hours = parseField(hourF, 0, 23);
+  const doms = parseField(domF, 1, 31);
+  const months = parseField(monthF, 1, 12);
+  const dows = parseField(dowF, 0, 6); // 0=Sunday
+
+  const start = new Date(after + 60_000); // start from next minute
+  start.setSeconds(0, 0);
+
+  // Search up to 366 days ahead
+  const limit = 366 * 24 * 60;
+  for (let i = 0; i < limit; i++) {
+    const candidate = new Date(start.getTime() + i * 60_000);
+    const m = candidate.getMinutes();
+    const h = candidate.getHours();
+    const dom = candidate.getDate();
+    const mon = candidate.getMonth() + 1; // 1-based
+    const dow = candidate.getDay();
+
+    if (
+      minutes.has(m) &&
+      hours.has(h) &&
+      doms.has(dom) &&
+      months.has(mon) &&
+      dows.has(dow)
+    ) {
+      return candidate.getTime();
+    }
+  }
+
+  // Fallback: 24h from now
+  return after + 24 * 60 * 60 * 1000;
+}
+
+/**
+ * Parse a single cron field into a Set of valid values.
+ */
+function parseField(field, min, max) {
+  const values = new Set();
+
+  for (const part of field.split(',')) {
+    if (part === '*') {
+      for (let i = min; i <= max; i++) values.add(i);
+    } else if (part.includes('/')) {
+      const [range, stepStr] = part.split('/');
+      const step = parseInt(stepStr, 10);
+      let start = min;
+      let end = max;
+      if (range !== '*') {
+        if (range.includes('-')) {
+          [start, end] = range.split('-').map(Number);
+        } else {
+          start = parseInt(range, 10);
+        }
+      }
+      for (let i = start; i <= end; i += step) values.add(i);
+    } else if (part.includes('-')) {
+      const [s, e] = part.split('-').map(Number);
+      for (let i = s; i <= e; i++) values.add(i);
+    } else {
+      values.add(parseInt(part, 10));
+    }
+  }
+
+  return values;
+}