Skip to content

Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS

10.6 KB
Raw Blame
/**
 * Automation Scheduler Service
 *
 * Manages scheduled automation tasks for agent platform accounts.
 * Uses the eventScheduler pattern for reliable cron/interval/random scheduling.
 */

import { join } from 'path';
import { v4 as uuidv4 } from '../lib/uuid.js';
import EventEmitter from 'events';
import { PATHS, createCachedStore } from '../lib/fileUtils.js';
import * as eventScheduler from './eventScheduler.js';
import * as agentActivity from './agentActivity.js';
import { getUserTimezone } from './userTimezone.js';

const SCHEDULES_FILE = join(PATHS.agentPersonalities, 'schedules.json');
const store = createCachedStore(SCHEDULES_FILE, { schedules: {} }, { context: 'automation schedules' });
const loadSchedules = store.load;

// Event emitter for schedule changes
export const scheduleEvents = new EventEmitter();

// Track active scheduled events
const activeSchedules = new Map();

export const invalidateCache = store.invalidateCache;

export function notifyChanged(action = 'update', scheduleId = null) {
  scheduleEvents.emit('changed', { action, scheduleId, timestamp: Date.now() });
}

/**
 * Get all schedules
 */
export async function getAllSchedules() {
  const data = await loadSchedules();
  return Object.entries(data.schedules).map(([id, schedule]) => ({
    id,
    ...schedule,
    isActive: activeSchedules.has(id)
  }));
}

/**
 * Get schedules for a specific agent
 */
export async function getSchedulesByAgent(agentId) {
  const schedules = await getAllSchedules();
  return schedules.filter(schedule => schedule.agentId === agentId);
}

/**
 * Get schedules for a specific account
 */
export async function getSchedulesByAccount(accountId) {
  const schedules = await getAllSchedules();
  return schedules.filter(schedule => schedule.accountId === accountId);
}

/**
 * Get schedule by ID
 */
export async function getScheduleById(id) {
  const data = await loadSchedules();
  const schedule = data.schedules[id];
  return schedule ? {
    id,
    ...schedule,
    isActive: activeSchedules.has(id)
  } : null;
}

/**
 * Create a new schedule
 */
export async function createSchedule(scheduleData) {
  const id = uuidv4();
  const now = new Date().toISOString();

  const schedule = {
    agentId: scheduleData.agentId,
    accountId: scheduleData.accountId,
    action: {
      type: scheduleData.action.type,
      params: scheduleData.action.params || {}
    },
    schedule: {
      type: scheduleData.schedule.type,
      cron: scheduleData.schedule.cron,
      intervalMs: scheduleData.schedule.intervalMs,
      randomWindow: scheduleData.schedule.randomWindow
    },
    rateLimit: scheduleData.rateLimit || {},
    enabled: scheduleData.enabled === true,
    lastRun: null,
    runCount: 0,
    rolledIntervalMs: null,
    createdAt: now,
    updatedAt: now
  };

  await store.mutate((data) => { data.schedules[id] = schedule; });
  notifyChanged('create', id);

  // If enabled, activate the schedule
  if (schedule.enabled) {
    await activateSchedule(id, schedule);
  }

  console.log(`📅 Created schedule: ${schedule.action.type} (${id})`);
  return { id, ...schedule, isActive: schedule.enabled };
}

/**
 * Update an existing schedule
 */
export async function updateSchedule(id, updates) {
  let schedule = null;
  let wasEnabled = false;
  await store.mutate((data) => {
    if (!data.schedules[id]) return data;

    const { id: _id, createdAt: _createdAt, ...cleanUpdates } = updates;
    wasEnabled = data.schedules[id].enabled;

    schedule = {
      ...data.schedules[id],
      ...cleanUpdates,
      createdAt: data.schedules[id].createdAt,
      updatedAt: new Date().toISOString()
    };

    if (cleanUpdates.schedule) {
      schedule.rolledIntervalMs = null;
      if (schedule.schedule) {
        schedule.schedule.rolledIntervalMs = null;
      }
    }

    data.schedules[id] = schedule;
    return data;
  });

  if (!schedule) return null;
  notifyChanged('update', id);

  // Handle enable/disable
  if (wasEnabled && !schedule.enabled) {
    await deactivateSchedule(id);
  } else if (!wasEnabled && schedule.enabled) {
    await activateSchedule(id, schedule);
  } else if (schedule.enabled) {
    // Schedule config changed, restart it
    await deactivateSchedule(id);
    await activateSchedule(id, schedule);
  }

  console.log(`📝 Updated schedule: ${schedule.action.type} (${id})`);
  return { id, ...schedule, isActive: activeSchedules.has(id) };
}

/**
 * Delete a schedule
 */
export async function deleteSchedule(id) {
  let existed = false;
  await store.mutate((data) => {
    if (!data.schedules[id]) return data;
    existed = true;
    delete data.schedules[id];
    return data;
  });

  if (!existed) return false;

  // Deactivate if running
  await deactivateSchedule(id);
  notifyChanged('delete', id);

  console.log(`🗑️ Deleted schedule (${id})`);
  return true;
}

/**
 * Toggle schedule enabled status
 */
export async function toggleSchedule(id, enabled) {
  return updateSchedule(id, { enabled });
}

/**
 * Activate a schedule (start the timer)
 */
async function activateSchedule(id, schedule) {
  // Don't double-activate
  if (activeSchedules.has(id) && eventScheduler.getEvent(activeSchedules.get(id))) {
    return;
  }

  const eventId = `agent-schedule-${id}`;

  const handler = async () => {
    await executeScheduledAction(id);
  };

  // Build schedule config based on type
  const eventConfig = {
    id: eventId,
    handler,
    metadata: {
      scheduleId: id,
      agentId: schedule.agentId,
      accountId: schedule.accountId,
      actionType: schedule.action.type
    }
  };

  if (schedule.schedule.type === 'cron') {
    eventConfig.type = 'cron';
    eventConfig.cron = schedule.schedule.cron;
    eventConfig.timezone = await getUserTimezone();
  } else if (schedule.schedule.type === 'interval') {
    eventConfig.type = 'interval';
    eventConfig.intervalMs = schedule.schedule.intervalMs;
    if (schedule.lastRun) {
      eventConfig.lastRunAt = schedule.lastRun;
    }
  } else if (schedule.schedule.type === 'random') {
    // For random, use interval with randomized timing
    eventConfig.type = 'interval';
    const { minMs, maxMs } = schedule.schedule.randomWindow;
    let intervalMs = schedule.rolledIntervalMs ?? schedule.schedule?.rolledIntervalMs;
    if (!intervalMs || intervalMs < minMs || intervalMs > maxMs) {
      intervalMs = minMs + Math.random() * (maxMs - minMs);
      await store.mutate((data) => {
        if (data.schedules[id]) {
          data.schedules[id].rolledIntervalMs = intervalMs;
          if (data.schedules[id].schedule) {
            data.schedules[id].schedule.rolledIntervalMs = intervalMs;
          }
        }
      });
    }
    eventConfig.intervalMs = intervalMs;
    if (schedule.lastRun) {
      eventConfig.lastRunAt = schedule.lastRun;
    }
  }

  eventScheduler.schedule(eventConfig);
  activeSchedules.set(id, eventId);

  console.log(`▶️ Activated schedule: ${schedule.action.type} (${id})`);
}

/**
 * Deactivate a schedule (stop the timer)
 */
async function deactivateSchedule(id) {
  const eventId = activeSchedules.get(id);
  if (eventId) {
    eventScheduler.cancel(eventId);
    activeSchedules.delete(id);
    console.log(`⏸️ Deactivated schedule (${id})`);
  }
}

/**
 * Execute a scheduled action
 */
async function executeScheduledAction(scheduleId) {
  const schedule = await getScheduleById(scheduleId);
  if (!schedule || !schedule.enabled) {
    return;
  }

  const now = new Date().toISOString();

  // Check rate limits
  if (schedule.rateLimit) {
    const { maxPerDay, cooldownMs } = schedule.rateLimit;

    // Check cooldown
    if (cooldownMs && schedule.lastRun) {
      const lastRunTime = new Date(schedule.lastRun).getTime();
      const elapsed = Date.now() - lastRunTime;
      if (elapsed < cooldownMs) {
        console.log(`⏳ Rate limited: ${scheduleId} - cooldown not met`);
        return;
      }
    }

    // Check daily limit (simplified - would need activity tracking for accurate count)
    if (maxPerDay) {
      const todayCount = await agentActivity.getTodayActionCount(
        schedule.accountId,
        schedule.action.type
      );
      if (todayCount >= maxPerDay) {
        console.log(`⏳ Rate limited: ${scheduleId} - daily limit reached`);
        return;
      }
    }
  }

  // Execute the action
  console.log(`🚀 Executing scheduled action: ${schedule.action.type} (${scheduleId})`);

  // Log activity
  await agentActivity.logActivity({
    agentId: schedule.agentId,
    accountId: schedule.accountId,
    scheduleId,
    action: schedule.action.type,
    params: schedule.action.params,
    status: 'started',
    timestamp: now
  });

  // Update last run
  await store.mutate((data) => {
    if (data.schedules[scheduleId]) {
      data.schedules[scheduleId].lastRun = now;
      data.schedules[scheduleId].runCount = (data.schedules[scheduleId].runCount || 0) + 1;
      data.schedules[scheduleId].rolledIntervalMs = null;
      if (data.schedules[scheduleId].schedule) {
        data.schedules[scheduleId].schedule.rolledIntervalMs = null;
      }
    }
  });

  // Emit event for platform integration to pick up
  scheduleEvents.emit('execute', {
    scheduleId,
    schedule,
    timestamp: now
  });

  // For random schedules, reschedule with new random interval
  if (schedule.schedule.type === 'random') {
    await deactivateSchedule(scheduleId);
    const freshSchedule = await getScheduleById(scheduleId);
    if (freshSchedule && freshSchedule.enabled) {
      await activateSchedule(scheduleId, freshSchedule);
    }
  }
}

/**
 * Manually trigger a schedule to run now
 */
export async function runNow(scheduleId) {
  const schedule = await getScheduleById(scheduleId);
  if (!schedule) {
    return null;
  }

  await executeScheduledAction(scheduleId);
  return await getScheduleById(scheduleId);
}

/**
 * Initialize: Load and activate all enabled schedules
 */
export async function init() {
  const schedules = await getAllSchedules();
  let activatedCount = 0;

  for (const schedule of schedules) {
    if (schedule.enabled) {
      await activateSchedule(schedule.id, schedule);
      activatedCount++;
    }
  }

  if (activatedCount > 0) {
    console.log(`📅 Initialized ${activatedCount} agent schedules`);
  }
}

/**
 * Get schedule stats
 */
export async function getStats() {
  const schedules = await getAllSchedules();
  const byAction = {};
  let enabledCount = 0;
  let totalRuns = 0;

  for (const schedule of schedules) {
    if (schedule.enabled) enabledCount++;
    totalRuns += schedule.runCount || 0;
    byAction[schedule.action.type] = (byAction[schedule.action.type] || 0) + 1;
  }

  return {
    total: schedules.length,
    enabled: enabledCount,
    active: activeSchedules.size,
    totalRuns,
    byAction
  };
}