macro-agent 0.2.4 → 0.2.6

package/src/trigger/sources/cron/scheduler.ts

@@ -1,344 +0,0 @@
-/**
- * Cron Schedule Utilities
- *
- * Functions for computing next run times for various schedule types.
- *
- * @module trigger/sources/cron/scheduler
- */
-
-import type { CronSchedule, CronJob } from "./types.js";
-
-// =============================================================================
-// Cron Expression Parsing
-// =============================================================================
-
-/**
- * Field ranges for cron expressions
- */
-const CRON_FIELDS = {
-  minute: { min: 0, max: 59 },
-  hour: { min: 0, max: 23 },
-  dayOfMonth: { min: 1, max: 31 },
-  month: { min: 1, max: 12 },
-  dayOfWeek: { min: 0, max: 6 }, // 0 = Sunday
-};
-
-/**
- * Parse a cron field into a set of valid values
- */
-function parseCronField(
-  field: string,
-  min: number,
-  max: number
-): Set<number> {
-  const values = new Set<number>();
-
-  // Handle wildcards
-  if (field === "*") {
-    for (let i = min; i <= max; i++) {
-      values.add(i);
-    }
-    return values;
-  }
-
-  // Split by comma for multiple values
-  const parts = field.split(",");
-
-  for (const part of parts) {
-    // Handle step values (*/5 or 1-10/2)
-    const stepMatch = part.match(/^(.+)\/(\d+)$/);
-    if (stepMatch) {
-      const [, range, stepStr] = stepMatch;
-      const step = parseInt(stepStr, 10);
-      let start = min;
-      let end = max;
-
-      if (range !== "*") {
-        const rangeMatch = range.match(/^(\d+)-(\d+)$/);
-        if (rangeMatch) {
-          start = parseInt(rangeMatch[1], 10);
-          end = parseInt(rangeMatch[2], 10);
-        } else {
-          start = parseInt(range, 10);
-        }
-      }
-
-      for (let i = start; i <= end; i += step) {
-        if (i >= min && i <= max) {
-          values.add(i);
-        }
-      }
-      continue;
-    }
-
-    // Handle ranges (1-5)
-    const rangeMatch = part.match(/^(\d+)-(\d+)$/);
-    if (rangeMatch) {
-      const start = parseInt(rangeMatch[1], 10);
-      const end = parseInt(rangeMatch[2], 10);
-      for (let i = start; i <= end; i++) {
-        if (i >= min && i <= max) {
-          values.add(i);
-        }
-      }
-      continue;
-    }
-
-    // Single value
-    const value = parseInt(part, 10);
-    if (!isNaN(value) && value >= min && value <= max) {
-      values.add(value);
-    }
-  }
-
-  return values;
-}
-
-/**
- * Parse a cron expression into field sets
- */
-function parseCronExpression(expr: string): {
-  minutes: Set<number>;
-  hours: Set<number>;
-  daysOfMonth: Set<number>;
-  months: Set<number>;
-  daysOfWeek: Set<number>;
-} | null {
-  const parts = expr.trim().split(/\s+/);
-
-  // Support both 5-field and 6-field (with seconds) formats
-  // We ignore seconds if present
-  const fields = parts.length === 6 ? parts.slice(1) : parts;
-
-  if (fields.length !== 5) {
-    return null;
-  }
-
-  try {
-    return {
-      minutes: parseCronField(fields[0], CRON_FIELDS.minute.min, CRON_FIELDS.minute.max),
-      hours: parseCronField(fields[1], CRON_FIELDS.hour.min, CRON_FIELDS.hour.max),
-      daysOfMonth: parseCronField(fields[2], CRON_FIELDS.dayOfMonth.min, CRON_FIELDS.dayOfMonth.max),
-      months: parseCronField(fields[3], CRON_FIELDS.month.min, CRON_FIELDS.month.max),
-      daysOfWeek: parseCronField(fields[4], CRON_FIELDS.dayOfWeek.min, CRON_FIELDS.dayOfWeek.max),
-    };
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Get next matching time for a cron expression
- */
-function getNextCronTime(
-  expr: string,
-  afterMs: number,
-  timezone?: string
-): number | null {
-  const parsed = parseCronExpression(expr);
-  if (!parsed) {
-    return null;
-  }
-
-  // Start from the next minute
-  const startDate = new Date(afterMs);
-  startDate.setSeconds(0, 0);
-  startDate.setMinutes(startDate.getMinutes() + 1);
-
-  // Search up to 2 years ahead
-  const maxIterations = 365 * 24 * 60 * 2;
-  let iterations = 0;
-
-  while (iterations < maxIterations) {
-    iterations++;
-
-    const minute = startDate.getMinutes();
-    const hour = startDate.getHours();
-    const dayOfMonth = startDate.getDate();
-    const month = startDate.getMonth() + 1; // 1-indexed
-    const dayOfWeek = startDate.getDay();
-
-    // Check if all fields match
-    const monthMatch = parsed.months.has(month);
-    const dayOfWeekMatch = parsed.daysOfWeek.has(dayOfWeek);
-    const dayOfMonthMatch = parsed.daysOfMonth.has(dayOfMonth);
-    const hourMatch = parsed.hours.has(hour);
-    const minuteMatch = parsed.minutes.has(minute);
-
-    // Day matching: if both dayOfMonth and dayOfWeek are specified (not *),
-    // they are OR'd together. Otherwise, they are AND'd.
-    const dayMatch =
-      parsed.daysOfMonth.size === 31 || parsed.daysOfWeek.size === 7
-        ? dayOfMonthMatch && dayOfWeekMatch
-        : dayOfMonthMatch || dayOfWeekMatch;
-
-    if (monthMatch && dayMatch && hourMatch && minuteMatch) {
-      return startDate.getTime();
-    }
-
-    // Advance to next minute
-    startDate.setMinutes(startDate.getMinutes() + 1);
-  }
-
-  return null;
-}
-
-// =============================================================================
-// Schedule Computation
-// =============================================================================
-
-/**
- * Compute next run time for a schedule
- */
-export function computeNextRunTime(
-  schedule: CronSchedule,
-  afterMs: number = Date.now()
-): number | null {
-  switch (schedule.kind) {
-    case "at": {
-      // One-shot: only return if it's in the future
-      return schedule.atMs > afterMs ? schedule.atMs : null;
-    }
-
-    case "every": {
-      // Recurring interval
-      const { everyMs, anchorMs } = schedule;
-
-      if (anchorMs !== undefined) {
-        // Align to anchor
-        const elapsed = afterMs - anchorMs;
-        const periods = Math.ceil(elapsed / everyMs);
-        return anchorMs + periods * everyMs;
-      }
-
-      // No anchor - next interval from now
-      return afterMs + everyMs;
-    }
-
-    case "cron": {
-      // Cron expression
-      return getNextCronTime(schedule.expr, afterMs, schedule.tz);
-    }
-  }
-}
-
-/**
- * Compute next run time for a job
- */
-export function computeJobNextRunTime(
-  job: CronJob,
-  afterMs: number = Date.now()
-): number | null {
-  if (!job.enabled) {
-    return null;
-  }
-
-  return computeNextRunTime(job.schedule, afterMs);
-}
-
-/**
- * Find the next job to run across all jobs
- */
-export function findNextJob(
-  jobs: CronJob[],
-  nowMs: number = Date.now()
-): { job: CronJob; runAtMs: number } | null {
-  let nextJob: CronJob | null = null;
-  let nextRunAt: number | null = null;
-
-  for (const job of jobs) {
-    if (!job.enabled) continue;
-    if (job.state.runningAtMs) continue; // Already running
-
-    const nextRun = job.state.nextRunAtMs ?? computeJobNextRunTime(job, nowMs);
-    if (nextRun === null) continue;
-
-    if (nextRunAt === null || nextRun < nextRunAt) {
-      nextRunAt = nextRun;
-      nextJob = job;
-    }
-  }
-
-  return nextJob && nextRunAt ? { job: nextJob, runAtMs: nextRunAt } : null;
-}
-
-/**
- * Find all jobs that are due to run
- */
-export function findDueJobs(
-  jobs: CronJob[],
-  nowMs: number = Date.now()
-): CronJob[] {
-  return jobs.filter((job) => {
-    if (!job.enabled) return false;
-    if (job.state.runningAtMs) return false; // Already running
-
-    const nextRun = job.state.nextRunAtMs;
-    return typeof nextRun === "number" && nowMs >= nextRun;
-  });
-}
-
-// =============================================================================
-// Schedule Validation
-// =============================================================================
-
-/**
- * Validate a schedule specification
- */
-export function validateSchedule(
-  schedule: CronSchedule
-): { valid: boolean; error?: string } {
-  switch (schedule.kind) {
-    case "at": {
-      if (typeof schedule.atMs !== "number" || schedule.atMs < 0) {
-        return { valid: false, error: "Invalid timestamp" };
-      }
-      return { valid: true };
-    }
-
-    case "every": {
-      if (typeof schedule.everyMs !== "number" || schedule.everyMs <= 0) {
-        return { valid: false, error: "Interval must be positive" };
-      }
-      if (schedule.everyMs < 1000) {
-        return { valid: false, error: "Interval must be at least 1 second" };
-      }
-      return { valid: true };
-    }
-
-    case "cron": {
-      const parsed = parseCronExpression(schedule.expr);
-      if (!parsed) {
-        return { valid: false, error: "Invalid cron expression" };
-      }
-      return { valid: true };
-    }
-  }
-}
-
-/**
- * Format a schedule for display
- */
-export function formatSchedule(schedule: CronSchedule): string {
-  switch (schedule.kind) {
-    case "at": {
-      return `at ${new Date(schedule.atMs).toISOString()}`;
-    }
-
-    case "every": {
-      const seconds = Math.floor(schedule.everyMs / 1000);
-      if (seconds < 60) return `every ${seconds}s`;
-      const minutes = Math.floor(seconds / 60);
-      if (minutes < 60) return `every ${minutes}m`;
-      const hours = Math.floor(minutes / 60);
-      if (hours < 24) return `every ${hours}h`;
-      const days = Math.floor(hours / 24);
-      return `every ${days}d`;
-    }
-
-    case "cron": {
-      const tz = schedule.tz ? ` (${schedule.tz})` : "";
-      return `cron: ${schedule.expr}${tz}`;
-    }
-  }
-}

package/src/trigger/sources/cron/types.ts

@@ -1,333 +0,0 @@
-/**
- * Cron Service Types
- *
- * Types for the cron scheduler that manages time-based triggers.
- *
- * @module trigger/sources/cron/types
- */
-
-import type { AgentId } from "../../../store/types/index.js";
-import type { TriggerWakeMode, TriggerRoutingHint } from "../../types.js";
-
-// =============================================================================
-// Schedule Types
-// =============================================================================
-
-/**
- * One-shot schedule - runs once at a specific time
- */
-export interface AtSchedule {
-  kind: "at";
-  /** Unix timestamp in milliseconds */
-  atMs: number;
-}
-
-/**
- * Recurring interval schedule
- */
-export interface EverySchedule {
-  kind: "every";
-  /** Interval in milliseconds */
-  everyMs: number;
-  /** Optional anchor time for alignment */
-  anchorMs?: number;
-}
-
-/**
- * Cron expression schedule
- */
-export interface CronExprSchedule {
-  kind: "cron";
-  /** Cron expression (5 or 6 fields) */
-  expr: string;
-  /** Timezone (IANA format, e.g., "America/New_York") */
-  tz?: string;
-}
-
-/**
- * Union of all schedule types
- */
-export type CronSchedule = AtSchedule | EverySchedule | CronExprSchedule;
-
-// =============================================================================
-// Job Payload Types
-// =============================================================================
-
-/**
- * System event payload - injects text into agent's context
- */
-export interface SystemEventPayload {
-  kind: "systemEvent";
-  /** Text to inject as system event */
-  text: string;
-}
-
-/**
- * Agent prompt payload - sends a full prompt to agent
- */
-export interface AgentPromptPayload {
-  kind: "agentPrompt";
-  /** Message to send to agent */
-  message: string;
-  /** Optional timeout in seconds */
-  timeoutSeconds?: number;
-  /** Optional model override */
-  model?: string;
-}
-
-/**
- * Union of job payload types
- */
-export type CronJobPayload = SystemEventPayload | AgentPromptPayload;
-
-// =============================================================================
-// Job State Types
-// =============================================================================
-
-/**
- * Job execution state
- */
-export interface CronJobState {
-  /** Next scheduled run time */
-  nextRunAtMs?: number;
-  /** Currently running since (undefined if not running) */
-  runningAtMs?: number;
-  /** Last run time */
-  lastRunAtMs?: number;
-  /** Last run status */
-  lastStatus?: "ok" | "error" | "skipped";
-  /** Last error message if failed */
-  lastError?: string;
-  /** Last run duration in ms */
-  lastDurationMs?: number;
-  /** Run count */
-  runCount?: number;
-}
-
-// =============================================================================
-// Cron Job Definition
-// =============================================================================
-
-/**
- * Session target for job execution
- */
-export type CronSessionTarget = "main" | "isolated";
-
-/**
- * Full cron job definition
- */
-export interface CronJob {
-  /** Unique job ID */
-  id: string;
-  /** Human-readable name */
-  name: string;
-  /** Optional description */
-  description?: string;
-  /** Whether job is enabled */
-  enabled: boolean;
-  /** Delete job after successful run (for one-shot jobs) */
-  deleteAfterRun?: boolean;
-  /** Creation timestamp */
-  createdAtMs: number;
-  /** Last update timestamp */
-  updatedAtMs: number;
-  /** Schedule specification */
-  schedule: CronSchedule;
-  /** Session target */
-  sessionTarget: CronSessionTarget;
-  /** Wake mode for trigger delivery */
-  wakeMode: TriggerWakeMode;
-  /** Job payload */
-  payload: CronJobPayload;
-  /** Optional routing hints */
-  routing?: TriggerRoutingHint;
-  /** Optional target agent ID (overrides routing) */
-  targetAgentId?: AgentId;
-  /** Job state */
-  state: CronJobState;
-  /** Optional metadata */
-  metadata?: Record<string, unknown>;
-}
-
-// =============================================================================
-// Job Operations
-// =============================================================================
-
-/**
- * Input for creating a cron job
- */
-export type CronJobCreate = Omit<
-  CronJob,
-  "id" | "createdAtMs" | "updatedAtMs" | "state"
-> & {
-  /** Optional initial state */
-  state?: Partial<CronJobState>;
-};
-
-/**
- * Input for updating a cron job
- */
-export type CronJobPatch = Partial<
-  Omit<CronJob, "id" | "createdAtMs" | "state">
-> & {
-  /** Partial state update */
-  state?: Partial<CronJobState>;
-};
-
-/**
- * Filter options for listing jobs
- */
-export interface CronJobFilter {
-  /** Include disabled jobs */
-  includeDisabled?: boolean;
-  /** Filter by name pattern */
-  namePattern?: string;
-  /** Filter by session target */
-  sessionTarget?: CronSessionTarget;
-}
-
-// =============================================================================
-// Cron Events
-// =============================================================================
-
-/**
- * Event emitted when a job starts
- */
-export interface CronJobStartedEvent {
-  action: "started";
-  jobId: string;
-  runAtMs: number;
-}
-
-/**
- * Event emitted when a job finishes
- */
-export interface CronJobFinishedEvent {
-  action: "finished";
-  jobId: string;
-  status: "ok" | "error" | "skipped";
-  error?: string;
-  durationMs: number;
-  nextRunAtMs?: number;
-}
-
-/**
- * Event emitted when a job is scheduled
- */
-export interface CronJobScheduledEvent {
-  action: "scheduled";
-  jobId: string;
-  nextRunAtMs: number;
-}
-
-/**
- * Event emitted when a job is disabled
- */
-export interface CronJobDisabledEvent {
-  action: "disabled";
-  jobId: string;
-}
-
-/**
- * Event emitted when a job is removed
- */
-export interface CronJobRemovedEvent {
-  action: "removed";
-  jobId: string;
-}
-
-/**
- * Union of all cron events
- */
-export type CronEvent =
-  | CronJobStartedEvent
-  | CronJobFinishedEvent
-  | CronJobScheduledEvent
-  | CronJobDisabledEvent
-  | CronJobRemovedEvent;
-
-// =============================================================================
-// Cron Service Interface
-// =============================================================================
-
-/**
- * Cron service configuration
- */
-export interface CronServiceConfig {
-  /** Enable cron service */
-  enabled?: boolean;
-  /** Storage path for jobs (":memory:" or file path) */
-  storePath?: string;
-  /** Event callback */
-  onEvent?: (event: CronEvent) => void;
-}
-
-/**
- * Cron service interface
- */
-export interface CronService {
-  /**
-   * Start the cron service
-   */
-  start(): Promise<void>;
-
-  /**
-   * Stop the cron service
-   */
-  stop(): Promise<void>;
-
-  /**
-   * Check if service is running
-   */
-  isRunning(): boolean;
-
-  /**
-   * List all jobs
-   */
-  list(filter?: CronJobFilter): Promise<CronJob[]>;
-
-  /**
-   * Get a job by ID
-   */
-  get(id: string): Promise<CronJob | null>;
-
-  /**
-   * Add a new job
-   */
-  add(input: CronJobCreate): Promise<CronJob>;
-
-  /**
-   * Update an existing job
-   */
-  update(id: string, patch: CronJobPatch): Promise<CronJob>;
-
-  /**
-   * Remove a job
-   */
-  remove(id: string): Promise<void>;
-
-  /**
-   * Enable a job
-   */
-  enable(id: string): Promise<CronJob>;
-
-  /**
-   * Disable a job
-   */
-  disable(id: string): Promise<CronJob>;
-
-  /**
-   * Manually run a job
-   */
-  run(id: string, opts?: { force?: boolean }): Promise<void>;
-
-  /**
-   * Trigger a job immediately (alias for run with force: true)
-   */
-  triggerNow(id: string): Promise<void>;
-
-  /**
-   * Get next scheduled run time across all jobs
-   */
-  getNextRunTime(): number | null;
-}

package/src/trigger/sources/index.ts

@@ -1,10 +0,0 @@
-/**
- * Trigger Sources
- *
- * Components that generate trigger events.
- *
- * @module trigger/sources
- */
-
-export * from "./cron/index.js";
-export * from "./webhook/index.js";

package/src/trigger/sources/webhook/index.ts

@@ -1,25 +0,0 @@
-/**
- * Webhook Handler
- *
- * HTTP webhook trigger source for external integrations.
- *
- * @module trigger/sources/webhook
- */
-
-export {
-  createWebhookHandler,
-  type WebhookHandlerDeps,
-} from "./webhook-handler.js";
-
-export type {
-  WebhookHandler,
-  WebhookHandlerConfig,
-  WebhookEndpoint,
-  WebhookEndpointCreate,
-  WebhookEndpointPatch,
-  WebhookRequest,
-  WebhookHandleResult,
-  WebhookValidationResult,
-  WebhookMethod,
-  WebhookEvent,
-} from "./types.js";