@herdctl/core 0.0.1

package/dist/fleet-manager/fleet-manager.d.ts

@@ -0,0 +1,699 @@
+/**
+ * FleetManager class for library consumers
+ *
+ * Provides a simple, high-level API to initialize and run a fleet of agents
+ * with minimal configuration. Handles config loading, state directory setup,
+ * and scheduler orchestration internally.
+ *
+ * @example
+ * ```typescript
+ * import { FleetManager } from '@herdctl/core';
+ *
+ * const manager = new FleetManager({
+ *   configPath: './herdctl.yaml',
+ *   stateDir: './.herdctl',
+ * });
+ *
+ * await manager.initialize();
+ * await manager.start();
+ *
+ * // Later...
+ * await manager.stop();
+ * ```
+ */
+import { EventEmitter } from "node:events";
+import { type ResolvedConfig, type ResolvedAgent } from "../config/index.js";
+import type { FleetManagerOptions, FleetManagerState, ConfigReloadedPayload, AgentStartedPayload, AgentStoppedPayload, ScheduleSkippedPayload, JobCreatedPayload, JobOutputPayload, JobCompletedPayload, JobFailedPayload, JobCancelledPayload, JobForkedPayload, FleetStatus, AgentInfo, ScheduleInfo, TriggerOptions, TriggerResult, JobModifications, CancelJobResult, ForkJobResult, FleetManagerStopOptions, LogEntry, LogStreamOptions } from "./types.js";
+/**
+ * FleetManager provides a simple API to manage a fleet of agents
+ *
+ * This class is the primary entry point for library consumers who want to
+ * run herdctl programmatically. It handles:
+ *
+ * - Configuration loading and validation
+ * - State directory initialization
+ * - Scheduler lifecycle management
+ * - Event emission for monitoring
+ *
+ * ## Lifecycle
+ *
+ * 1. **Construction**: Create with options (configPath, stateDir)
+ * 2. **Initialize**: Call `initialize()` to load config and prepare state
+ * 3. **Start**: Call `start()` to begin scheduler and process schedules
+ * 4. **Stop**: Call `stop()` to gracefully shut down
+ *
+ * ## Events
+ *
+ * The FleetManager emits events for monitoring:
+ * - `initialized` - After successful initialization
+ * - `started` - When the scheduler starts running
+ * - `stopped` - When the scheduler stops
+ * - `error` - When an error occurs
+ * - `schedule:trigger` - When a schedule triggers an agent
+ * - `schedule:complete` - When an agent run completes
+ * - `schedule:error` - When an agent run fails
+ *
+ * ## Typed Events (US-2)
+ *
+ * The FleetManager also supports strongly-typed events via TypeScript:
+ * - `config:reloaded` - When configuration is hot-reloaded
+ * - `agent:started` - When an agent is started
+ * - `agent:stopped` - When an agent is stopped
+ * - `schedule:triggered` - When a schedule triggers (with payload)
+ * - `schedule:skipped` - When a schedule is skipped
+ * - `job:created` - When a job is created
+ * - `job:output` - When a job produces output
+ * - `job:completed` - When a job completes successfully
+ * - `job:failed` - When a job fails
+ *
+ * @example
+ * ```typescript
+ * // Subscribe to typed events
+ * manager.on('job:created', (payload) => {
+ *   console.log(`Job ${payload.job.id} created for ${payload.agentName}`);
+ * });
+ *
+ * manager.on('job:output', (payload) => {
+ *   process.stdout.write(payload.output);
+ * });
+ *
+ * manager.on('job:completed', (payload) => {
+ *   console.log(`Job completed in ${payload.durationSeconds}s`);
+ * });
+ * ```
+ */
+export declare class FleetManager extends EventEmitter {
+    private readonly configPath?;
+    private readonly stateDir;
+    private readonly logger;
+    private readonly checkInterval;
+    private status;
+    private config;
+    private stateDirInfo;
+    private scheduler;
+    private initializedAt;
+    private startedAt;
+    private stoppedAt;
+    private lastError;
+    /**
+     * Create a new FleetManager instance
+     *
+     * @param options - Configuration options
+     *
+     * @example
+     * ```typescript
+     * // Minimal configuration
+     * const manager = new FleetManager({
+     *   configPath: './herdctl.yaml',
+     *   stateDir: './.herdctl',
+     * });
+     *
+     * // With custom logger
+     * const manager = new FleetManager({
+     *   configPath: './herdctl.yaml',
+     *   stateDir: './.herdctl',
+     *   logger: myLogger,
+     *   checkInterval: 5000, // 5 seconds
+     * });
+     * ```
+     */
+    constructor(options: FleetManagerOptions);
+    /**
+     * Get the current fleet manager state
+     *
+     * This provides a snapshot of the fleet manager's current status and
+     * configuration for monitoring purposes.
+     */
+    get state(): FleetManagerState;
+    /**
+     * Get the loaded configuration
+     *
+     * @returns The resolved configuration, or null if not initialized
+     */
+    getConfig(): ResolvedConfig | null;
+    /**
+     * Get the loaded agents
+     *
+     * @returns Array of resolved agents, or empty array if not initialized
+     */
+    getAgents(): ResolvedAgent[];
+    /**
+     * Get overall fleet status
+     *
+     * Returns a comprehensive snapshot of the fleet state including:
+     * - Current state and uptime
+     * - Agent counts (total, idle, running, error)
+     * - Job counts
+     * - Scheduler information
+     *
+     * This method works whether the fleet is running or stopped.
+     *
+     * @returns A consistent FleetStatus snapshot
+     *
+     * @example
+     * ```typescript
+     * const status = await manager.getFleetStatus();
+     * console.log(`Fleet: ${status.state}`);
+     * console.log(`Uptime: ${status.uptimeSeconds}s`);
+     * console.log(`Running jobs: ${status.counts.runningJobs}`);
+     * ```
+     */
+    getFleetStatus(): Promise<FleetStatus>;
+    /**
+     * Get information about all configured agents
+     *
+     * Returns detailed information for each agent including:
+     * - Current status and job information
+     * - Schedule details with runtime state
+     * - Configuration details
+     *
+     * This method works whether the fleet is running or stopped.
+     *
+     * @returns Array of AgentInfo objects with current state
+     *
+     * @example
+     * ```typescript
+     * const agents = await manager.getAgentInfo();
+     * for (const agent of agents) {
+     *   console.log(`${agent.name}: ${agent.status}`);
+     *   console.log(`  Schedules: ${agent.scheduleCount}`);
+     * }
+     * ```
+     */
+    getAgentInfo(): Promise<AgentInfo[]>;
+    /**
+     * Get information about a specific agent by name
+     *
+     * Returns detailed information for the specified agent including:
+     * - Current status and job information
+     * - Schedule details with runtime state
+     * - Configuration details
+     *
+     * This method works whether the fleet is running or stopped.
+     *
+     * @param name - The agent name to look up
+     * @returns AgentInfo for the specified agent
+     * @throws {AgentNotFoundError} If no agent with that name exists
+     *
+     * @example
+     * ```typescript
+     * const agent = await manager.getAgentInfoByName('my-agent');
+     * console.log(`Agent: ${agent.name}`);
+     * console.log(`Status: ${agent.status}`);
+     * console.log(`Running: ${agent.runningCount}/${agent.maxConcurrent}`);
+     * ```
+     */
+    getAgentInfoByName(name: string): Promise<AgentInfo>;
+    /**
+     * Read fleet state from disk for status queries
+     *
+     * This provides a consistent snapshot of the fleet state.
+     */
+    private readFleetStateSnapshot;
+    /**
+     * Build AgentInfo from configuration and state
+     */
+    private buildAgentInfo;
+    /**
+     * Build schedule info list from agent configuration and state
+     */
+    private buildScheduleInfoList;
+    /**
+     * Compute fleet counts from agent info list
+     */
+    private computeFleetCounts;
+    /**
+     * Get all schedules across all agents
+     *
+     * Returns a list of all configured schedules with their current state,
+     * including next trigger times.
+     *
+     * @returns Array of ScheduleInfo objects with current state
+     *
+     * @example
+     * ```typescript
+     * const schedules = await manager.getSchedules();
+     * for (const schedule of schedules) {
+     *   console.log(`${schedule.agentName}/${schedule.name}: ${schedule.status}`);
+     *   console.log(`  Next run: ${schedule.nextRunAt}`);
+     * }
+     * ```
+     */
+    getSchedules(): Promise<ScheduleInfo[]>;
+    /**
+     * Get a specific schedule by agent name and schedule name
+     *
+     * @param agentName - The name of the agent
+     * @param scheduleName - The name of the schedule
+     * @returns The schedule info with current state
+     * @throws {AgentNotFoundError} If the agent doesn't exist
+     * @throws {ScheduleNotFoundError} If the schedule doesn't exist
+     *
+     * @example
+     * ```typescript
+     * const schedule = await manager.getSchedule('my-agent', 'hourly');
+     * console.log(`Status: ${schedule.status}`);
+     * console.log(`Last run: ${schedule.lastRunAt}`);
+     * console.log(`Next run: ${schedule.nextRunAt}`);
+     * ```
+     */
+    getSchedule(agentName: string, scheduleName: string): Promise<ScheduleInfo>;
+    /**
+     * Enable a disabled schedule
+     *
+     * Enables a schedule that was previously disabled, allowing it to trigger
+     * again on its configured interval. The enabled state is persisted to the
+     * state directory and survives restarts.
+     *
+     * @param agentName - The name of the agent
+     * @param scheduleName - The name of the schedule
+     * @returns The updated schedule info
+     * @throws {AgentNotFoundError} If the agent doesn't exist
+     * @throws {ScheduleNotFoundError} If the schedule doesn't exist
+     *
+     * @example
+     * ```typescript
+     * // Enable a previously disabled schedule
+     * const schedule = await manager.enableSchedule('my-agent', 'hourly');
+     * console.log(`Schedule status: ${schedule.status}`); // 'idle'
+     * ```
+     */
+    enableSchedule(agentName: string, scheduleName: string): Promise<ScheduleInfo>;
+    /**
+     * Disable a schedule
+     *
+     * Disables a schedule, preventing it from triggering on its configured
+     * interval. The schedule remains in the configuration but won't run until
+     * re-enabled. The disabled state is persisted to the state directory and
+     * survives restarts.
+     *
+     * @param agentName - The name of the agent
+     * @param scheduleName - The name of the schedule
+     * @returns The updated schedule info
+     * @throws {AgentNotFoundError} If the agent doesn't exist
+     * @throws {ScheduleNotFoundError} If the schedule doesn't exist
+     *
+     * @example
+     * ```typescript
+     * // Disable a schedule temporarily
+     * const schedule = await manager.disableSchedule('my-agent', 'hourly');
+     * console.log(`Schedule status: ${schedule.status}`); // 'disabled'
+     *
+     * // Later, re-enable it
+     * await manager.enableSchedule('my-agent', 'hourly');
+     * ```
+     */
+    disableSchedule(agentName: string, scheduleName: string): Promise<ScheduleInfo>;
+    /**
+     * Initialize the fleet manager
+     *
+     * This method:
+     * 1. Loads and validates the configuration file
+     * 2. Initializes the state directory structure
+     * 3. Prepares the scheduler (but does not start it)
+     *
+     * After initialization, the fleet manager is ready to start.
+     *
+     * @throws {FleetManagerStateError} If already initialized or running
+     * @throws {FleetManagerConfigError} If configuration is invalid or not found
+     * @throws {FleetManagerStateDirError} If state directory cannot be created
+     *
+     * @example
+     * ```typescript
+     * const manager = new FleetManager({ ... });
+     * await manager.initialize();
+     * console.log(`Loaded ${manager.state.agentCount} agents`);
+     * ```
+     */
+    initialize(): Promise<void>;
+    /**
+     * Start the fleet manager
+     *
+     * This begins the scheduler, which will:
+     * 1. Check agent schedules at the configured interval
+     * 2. Trigger agents when their schedules are due
+     * 3. Track schedule state in the state directory
+     *
+     * @throws {FleetManagerStateError} If not initialized
+     *
+     * @example
+     * ```typescript
+     * await manager.initialize();
+     * await manager.start();
+     *
+     * // The manager is now running and processing schedules
+     * manager.on('schedule:trigger', (agent, schedule) => {
+     *   console.log(`Triggered ${agent}/${schedule}`);
+     * });
+     * ```
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the fleet manager gracefully
+     *
+     * This will:
+     * 1. Signal the scheduler to stop accepting new triggers
+     * 2. Wait for running jobs to complete (with timeout)
+     * 3. If timeout is reached and cancelOnTimeout is true, cancel remaining jobs
+     * 4. Persist all state before shutdown completes
+     * 5. Emit 'stopped' event when complete
+     *
+     * @param options - Stop options for controlling shutdown behavior
+     * @throws {FleetManagerShutdownError} If shutdown times out and cancelOnTimeout is false
+     *
+     * @example
+     * ```typescript
+     * // Normal shutdown - wait for jobs with default 30s timeout
+     * await manager.stop();
+     *
+     * // Shutdown with custom timeout
+     * await manager.stop({ timeout: 60000 });
+     *
+     * // Shutdown without waiting for jobs (not recommended)
+     * await manager.stop({ waitForJobs: false });
+     *
+     * // Cancel jobs if they don't complete in time
+     * await manager.stop({
+     *   timeout: 30000,
+     *   cancelOnTimeout: true,
+     *   cancelTimeout: 10000,
+     * });
+     * ```
+     */
+    stop(options?: FleetManagerStopOptions): Promise<void>;
+    /**
+     * Reload configuration without restarting the fleet
+     *
+     * This method provides hot configuration reload capability:
+     * 1. Loads and validates the new configuration
+     * 2. If validation fails, keeps the old configuration (fails gracefully)
+     * 3. Running jobs continue with their original configuration
+     * 4. New jobs will use the new configuration
+     * 5. Updates the scheduler with new agent definitions and schedules
+     * 6. Emits a 'config:reloaded' event with a list of changes
+     *
+     * @returns The reload result with change details
+     * @throws {InvalidStateError} If the fleet manager is not initialized
+     * @throws {FleetManagerConfigError} If the new configuration is invalid (re-thrown after logging)
+     *
+     * @example
+     * ```typescript
+     * // Reload configuration
+     * const result = await manager.reload();
+     * console.log(`Reloaded with ${result.changes.length} changes`);
+     *
+     * // Subscribe to reload events
+     * manager.on('config:reloaded', (payload) => {
+     *   console.log(`Config reloaded: ${payload.changes.length} changes`);
+     *   for (const change of payload.changes) {
+     *     console.log(`  ${change.type} ${change.category}: ${change.name}`);
+     *   }
+     * });
+     * ```
+     */
+    reload(): Promise<ConfigReloadedPayload>;
+    /**
+     * Compute the list of changes between old and new configuration
+     */
+    private computeConfigChanges;
+    /**
+     * Check if an agent configuration has been modified
+     * Returns a description of what changed, or null if not modified
+     */
+    private isAgentModified;
+    /**
+     * Check if a schedule configuration has been modified
+     */
+    private isScheduleModified;
+    /**
+     * Get a description of what changed in a schedule
+     */
+    private getScheduleModificationDetails;
+    /**
+     * Cancel all running jobs during shutdown
+     *
+     * @param cancelTimeout - Timeout for each job cancellation
+     */
+    private cancelRunningJobs;
+    /**
+     * Persist shutdown state to ensure all state is saved before completing
+     */
+    private persistShutdownState;
+    /**
+     * Manually trigger an agent outside its normal schedule
+     *
+     * This method allows you to trigger an agent on-demand for testing or
+     * handling urgent situations. You can optionally specify a schedule to use
+     * for configuration (prompt, work source, etc.) or pass runtime options
+     * to override defaults.
+     *
+     * @param agentName - Name of the agent to trigger
+     * @param scheduleName - Optional schedule name to use for configuration
+     * @param options - Optional runtime options to override defaults
+     * @returns The created job information
+     * @throws {InvalidStateError} If the fleet manager is not initialized
+     * @throws {AgentNotFoundError} If the agent doesn't exist
+     * @throws {ScheduleNotFoundError} If the specified schedule doesn't exist
+     * @throws {ConcurrencyLimitError} If the agent is at capacity and bypassConcurrencyLimit is false
+     *
+     * @example
+     * ```typescript
+     * // Trigger with agent defaults
+     * const job = await manager.trigger('my-agent');
+     *
+     * // Trigger a specific schedule
+     * const job = await manager.trigger('my-agent', 'hourly');
+     *
+     * // Trigger with custom prompt
+     * const job = await manager.trigger('my-agent', undefined, {
+     *   prompt: 'Review the latest security updates',
+     * });
+     *
+     * // Force trigger even at capacity
+     * const job = await manager.trigger('my-agent', undefined, {
+     *   bypassConcurrencyLimit: true,
+     * });
+     * ```
+     */
+    trigger(agentName: string, scheduleName?: string, options?: TriggerOptions): Promise<TriggerResult>;
+    /**
+     * Cancel a running job gracefully
+     *
+     * This method cancels a running job by first sending SIGTERM to allow
+     * graceful shutdown. If the job doesn't terminate within the timeout,
+     * it will be forcefully killed with SIGKILL.
+     *
+     * @param jobId - ID of the job to cancel
+     * @param options - Optional cancellation options
+     * @param options.timeout - Time in ms to wait for graceful shutdown (default: 10000)
+     * @returns Result of the cancellation operation
+     * @throws {InvalidStateError} If the fleet manager is not initialized
+     * @throws {JobNotFoundError} If the job doesn't exist
+     *
+     * @example
+     * ```typescript
+     * // Cancel with default timeout
+     * const result = await manager.cancelJob('job-2024-01-15-abc123');
+     * console.log(`Job cancelled: ${result.terminationType}`);
+     *
+     * // Cancel with custom timeout
+     * const result = await manager.cancelJob('job-2024-01-15-abc123', {
+     *   timeout: 30000, // 30 seconds
+     * });
+     * ```
+     */
+    cancelJob(jobId: string, options?: {
+        timeout?: number;
+    }): Promise<CancelJobResult>;
+    /**
+     * Fork a job to create a new job based on an existing one
+     *
+     * This method creates a new job that is based on an existing job's
+     * configuration. The new job will have the same agent and can optionally
+     * have modifications applied (different prompt, schedule, etc.).
+     *
+     * If the original job has a session ID, the new job will fork from that
+     * session, preserving conversation context.
+     *
+     * @param jobId - ID of the job to fork
+     * @param modifications - Optional modifications to apply to the forked job
+     * @returns Result of the fork operation including the new job ID
+     * @throws {InvalidStateError} If the fleet manager is not initialized
+     * @throws {JobNotFoundError} If the original job doesn't exist
+     * @throws {JobForkError} If the job cannot be forked (e.g., no session)
+     *
+     * @example
+     * ```typescript
+     * // Fork with same configuration
+     * const result = await manager.forkJob('job-2024-01-15-abc123');
+     * console.log(`Forked to: ${result.jobId}`);
+     *
+     * // Fork with modified prompt
+     * const result = await manager.forkJob('job-2024-01-15-abc123', {
+     *   prompt: 'Continue the previous task but focus on testing',
+     * });
+     *
+     * // Fork with different schedule
+     * const result = await manager.forkJob('job-2024-01-15-abc123', {
+     *   schedule: 'nightly',
+     * });
+     * ```
+     */
+    forkJob(jobId: string, modifications?: JobModifications): Promise<ForkJobResult>;
+    /**
+     * Stream all fleet logs as an async iterable
+     *
+     * Provides a unified stream of logs from all sources in the fleet including
+     * agents, jobs, and the scheduler. Logs can be filtered by level and optionally
+     * by agent or job.
+     *
+     * For completed jobs, this will replay their history (if includeHistory is true)
+     * before streaming new logs from running jobs.
+     *
+     * @param options - Options for filtering and configuring the stream
+     * @returns An async iterable of LogEntry objects
+     *
+     * @example
+     * ```typescript
+     * // Stream all info+ logs
+     * for await (const log of manager.streamLogs()) {
+     *   console.log(`[${log.level}] ${log.message}`);
+     * }
+     *
+     * // Stream only errors for a specific agent
+     * for await (const log of manager.streamLogs({
+     *   level: 'error',
+     *   agentName: 'my-agent',
+     * })) {
+     *   console.error(log.message);
+     * }
+     * ```
+     */
+    streamLogs(options?: LogStreamOptions): AsyncIterable<LogEntry>;
+    /**
+     * Stream output from a specific job as an async iterable
+     *
+     * Provides a stream of log entries for a specific job. For completed jobs,
+     * this will replay the job's history and then complete. For running jobs,
+     * it will continue streaming until the job completes.
+     *
+     * @param jobId - The ID of the job to stream output from
+     * @returns An async iterable of LogEntry objects
+     * @throws {JobNotFoundError} If the job doesn't exist
+     *
+     * @example
+     * ```typescript
+     * // Stream job output
+     * for await (const log of manager.streamJobOutput('job-2024-01-15-abc123')) {
+     *   console.log(`[${log.level}] ${log.message}`);
+     * }
+     * ```
+     */
+    streamJobOutput(jobId: string): AsyncIterable<LogEntry>;
+    /**
+     * Stream logs for a specific agent as an async iterable
+     *
+     * Provides a stream of log entries for all jobs belonging to a specific agent.
+     * For completed jobs, this will replay their history. For running jobs, it
+     * will continue streaming until the iterator is stopped.
+     *
+     * @param agentName - The name of the agent to stream logs for
+     * @returns An async iterable of LogEntry objects
+     * @throws {AgentNotFoundError} If the agent doesn't exist in the configuration
+     *
+     * @example
+     * ```typescript
+     * // Stream all logs for an agent
+     * for await (const log of manager.streamAgentLogs('my-agent')) {
+     *   console.log(`[${log.jobId}] ${log.message}`);
+     * }
+     * ```
+     */
+    streamAgentLogs(agentName: string): AsyncIterable<LogEntry>;
+    /**
+     * Convert a job output message to a LogEntry
+     */
+    private jobOutputToLogEntry;
+    /**
+     * Determine if a log entry should be yielded based on filters
+     */
+    private shouldYieldLog;
+    /**
+     * Load configuration with proper error handling
+     */
+    private loadConfiguration;
+    /**
+     * Initialize state directory with proper error handling
+     */
+    private initializeStateDir;
+    /**
+     * Start the scheduler asynchronously (don't block on the loop)
+     */
+    private startSchedulerAsync;
+    /**
+     * Handle schedule trigger callback from scheduler
+     */
+    private handleScheduleTrigger;
+    /**
+     * Emit a config:reloaded event
+     *
+     * Called when configuration is hot-reloaded.
+     */
+    emitConfigReloaded(payload: ConfigReloadedPayload): void;
+    /**
+     * Emit an agent:started event
+     *
+     * Called when an agent is started/registered with the fleet.
+     */
+    emitAgentStarted(payload: AgentStartedPayload): void;
+    /**
+     * Emit an agent:stopped event
+     *
+     * Called when an agent is stopped/unregistered from the fleet.
+     */
+    emitAgentStopped(payload: AgentStoppedPayload): void;
+    /**
+     * Emit a schedule:skipped event
+     *
+     * Called when a schedule check is skipped (already running, disabled, etc.).
+     */
+    emitScheduleSkipped(payload: ScheduleSkippedPayload): void;
+    /**
+     * Emit a job:created event
+     *
+     * Called when a new job is created.
+     */
+    emitJobCreated(payload: JobCreatedPayload): void;
+    /**
+     * Emit a job:output event
+     *
+     * Called when a job produces output during execution.
+     * This enables real-time streaming of output to UIs.
+     */
+    emitJobOutput(payload: JobOutputPayload): void;
+    /**
+     * Emit a job:completed event
+     *
+     * Called when a job completes successfully.
+     */
+    emitJobCompleted(payload: JobCompletedPayload): void;
+    /**
+     * Emit a job:failed event
+     *
+     * Called when a job fails.
+     */
+    emitJobFailed(payload: JobFailedPayload): void;
+    /**
+     * Emit a job:cancelled event (US-6)
+     *
+     * Called when a job is cancelled.
+     */
+    emitJobCancelled(payload: JobCancelledPayload): void;
+    /**
+     * Emit a job:forked event (US-6)
+     *
+     * Called when a job is forked to create a new job.
+     */
+    emitJobForked(payload: JobForkedPayload): void;
+}
+//# sourceMappingURL=fleet-manager.d.ts.map

package/dist/fleet-manager/fleet-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fleet-manager.d.ts","sourceRoot":"","sources":["../../src/fleet-manager/fleet-manager.ts"],"names":[],"mappings":"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"}