reqon-dsl 0.2.0 → 0.3.0

package/dist/config/constants.js

@@ -0,0 +1,128 @@
+/**
+ * Centralized Configuration Constants
+ *
+ * This module contains all default values and configuration constants used
+ * throughout the Reqon framework. Centralizing these values makes it easier
+ * to understand, tune, and override defaults.
+ */
+// ============================================
+// HTTP Client Configuration
+// ============================================
+/**
+ * Default retry configuration for HTTP requests
+ */
+export const HTTP_RETRY_DEFAULTS = {
+    /** Maximum number of retry attempts */
+    MAX_ATTEMPTS: 3,
+    /** Initial delay between retries in milliseconds */
+    INITIAL_DELAY_MS: 1000,
+    /** Maximum delay between retries in milliseconds */
+    MAX_DELAY_MS: 30000,
+    /** Backoff strategy: 'exponential', 'linear', or 'constant' */
+    BACKOFF: 'exponential',
+};
+/**
+ * Default HTTP headers
+ */
+export const HTTP_DEFAULT_HEADERS = {
+    CONTENT_TYPE: 'application/json',
+    ACCEPT: 'application/json',
+};
+// ============================================
+// Rate Limiter Configuration
+// ============================================
+/**
+ * Default rate limiter configuration
+ */
+export const RATE_LIMIT_DEFAULTS = {
+    /** Default strategy when rate limited: 'pause', 'throttle', or 'fail' */
+    STRATEGY: 'pause',
+    /** Maximum wait time in seconds before timing out */
+    MAX_WAIT_SECONDS: 300,
+    /** Seconds before starting to notify about ongoing waits */
+    NOTIFY_AT_SECONDS: 10,
+    /** Fallback requests per minute when no rate limit info available */
+    FALLBACK_RPM: 60,
+    /** Maximum age for stale rate limit entries (1 hour in ms) */
+    MAX_STALE_AGE_MS: 60 * 60 * 1000,
+    /** Cleanup interval for stale entries (5 minutes in ms) */
+    CLEANUP_INTERVAL_MS: 5 * 60 * 1000,
+    /** Number of responses between cleanup checks */
+    CLEANUP_CHECK_INTERVAL: 100,
+    /** Maximum entries before forced cleanup */
+    MAX_ENTRIES_BEFORE_CLEANUP: 1000,
+};
+// ============================================
+// Circuit Breaker Configuration
+// ============================================
+/**
+ * Default circuit breaker configuration
+ */
+export const CIRCUIT_BREAKER_DEFAULTS = {
+    /** Number of failures before opening circuit */
+    FAILURE_THRESHOLD: 5,
+    /** Time in milliseconds before attempting recovery */
+    RESET_TIMEOUT_MS: 30000,
+    /** Number of successful requests in half-open to close circuit */
+    SUCCESS_THRESHOLD: 2,
+    /** Time window in milliseconds for counting failures */
+    FAILURE_WINDOW_MS: 60000,
+    /** HTTP status codes to count as failures */
+    FAILURE_STATUS_CODES: [500, 501, 502, 503, 504],
+    /** Whether to count network errors as failures */
+    COUNT_NETWORK_ERRORS: true,
+};
+// ============================================
+// Webhook Server Configuration
+// ============================================
+/**
+ * Default webhook server configuration
+ */
+export const WEBHOOK_DEFAULTS = {
+    /** Default port for webhook server */
+    PORT: 3000,
+    /** Default host binding */
+    HOST: '0.0.0.0',
+    /** Default timeout for wait steps (5 minutes in ms) */
+    DEFAULT_TIMEOUT_MS: 300000,
+    /** Cleanup interval for expired registrations (1 minute in ms) */
+    CLEANUP_INTERVAL_MS: 60000,
+};
+// ============================================
+// Store Configuration
+// ============================================
+/**
+ * Default store configuration
+ */
+export const STORE_DEFAULTS = {
+    /** Default base directory for file stores */
+    DATA_DIR: '.reqon-data',
+    /** Default subdirectory for executions */
+    EXECUTIONS_DIR: 'executions',
+    /** Default subdirectory for sync state */
+    SYNC_DIR: 'sync',
+};
+// ============================================
+// Scheduler Configuration
+// ============================================
+/**
+ * Default scheduler configuration
+ */
+export const SCHEDULER_DEFAULTS = {
+    /** Default retry configuration for failed scheduled missions */
+    MAX_RETRIES: 3,
+    /** Default delay between retries in seconds */
+    RETRY_DELAY_SECONDS: 60,
+};
+// ============================================
+// Execution Configuration
+// ============================================
+/**
+ * Default execution configuration
+ */
+export const EXECUTION_DEFAULTS = {
+    /** Whether development mode is enabled by default (uses file stores) */
+    DEVELOPMENT_MODE: true,
+    /** Whether to persist execution state by default */
+    PERSIST_STATE: false,
+};

package/dist/config/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Configuration module exports
+ */
+export * from './constants.js';

package/dist/config/index.js

@@ -0,0 +1,4 @@
+/**
+ * Configuration module exports
+ */
+export * from './constants.js';

package/dist/control/index.d.ts

@@ -0,0 +1,2 @@
+export { ControlServer } from './server.js';
+export type { ControlServerConfig, ControlServerCallbacks, StatusResponse, ControlResponse, } from './types.js';

package/dist/control/index.js

@@ -0,0 +1 @@
+export { ControlServer } from './server.js';

package/dist/control/server.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Control Server
+ *
+ * HTTP server for runtime control of mission execution.
+ * Provides pause/resume commands and live status queries.
+ */
+import type { ExecutionState, LiveProgress } from '../execution/index.js';
+import type { ControlServerConfig, ControlServerCallbacks } from './types.js';
+/**
+ * Control Server
+ *
+ * Provides HTTP endpoints for controlling mission execution:
+ * - POST /pause - Request graceful pause
+ * - POST /resume - Clear pause request
+ * - GET /status - Get current execution state and progress
+ * - GET /health - Health check
+ */
+export declare class ControlServer {
+    private config;
+    private callbacks;
+    private server?;
+    private running;
+    private startTime;
+    private pauseRequested;
+    private executionState?;
+    private liveProgress?;
+    constructor(config?: ControlServerConfig, callbacks?: ControlServerCallbacks);
+    /**
+     * Start the control server
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the control server
+     */
+    stop(): Promise<void>;
+    /**
+     * Check if pause has been requested
+     */
+    isPauseRequested(): boolean;
+    /**
+     * Clear pause request (called after pause is handled)
+     */
+    clearPauseRequest(): void;
+    /**
+     * Update execution state (called by executor)
+     */
+    updateState(state: ExecutionState): void;
+    /**
+     * Update live progress (called by executor)
+     */
+    updateProgress(progress: LiveProgress): void;
+    /**
+     * Check if the server is running
+     */
+    isRunning(): boolean;
+    /**
+     * Get the server port
+     */
+    getPort(): number;
+    /**
+     * Handle incoming HTTP request
+     */
+    private handleRequest;
+    /**
+     * Handle health check
+     */
+    private handleHealth;
+    /**
+     * Handle status query
+     */
+    private handleStatus;
+    /**
+     * Handle pause request
+     */
+    private handlePause;
+    /**
+     * Handle resume request
+     */
+    private handleResume;
+    /**
+     * Send JSON response
+     */
+    private sendJson;
+    /**
+     * Log message if verbose mode enabled
+     */
+    private log;
+}

package/dist/control/server.js

@@ -0,0 +1,238 @@
+/**
+ * Control Server
+ *
+ * HTTP server for runtime control of mission execution.
+ * Provides pause/resume commands and live status queries.
+ */
+import { createServer } from 'node:http';
+import { parse as parseUrl } from 'node:url';
+const DEFAULTS = {
+    PORT: 3001,
+    HOST: 'localhost',
+};
+/**
+ * Control Server
+ *
+ * Provides HTTP endpoints for controlling mission execution:
+ * - POST /pause - Request graceful pause
+ * - POST /resume - Clear pause request
+ * - GET /status - Get current execution state and progress
+ * - GET /health - Health check
+ */
+export class ControlServer {
+    config;
+    callbacks;
+    server;
+    running = false;
+    startTime = Date.now();
+    // State managed by the control server
+    pauseRequested = false;
+    executionState;
+    liveProgress;
+    constructor(config = {}, callbacks = {}) {
+        this.config = {
+            port: config.port ?? DEFAULTS.PORT,
+            host: config.host ?? DEFAULTS.HOST,
+            verbose: config.verbose ?? false,
+        };
+        this.callbacks = callbacks;
+    }
+    /**
+     * Start the control server
+     */
+    async start() {
+        if (this.running)
+            return;
+        return new Promise((resolve, reject) => {
+            this.server = createServer((req, res) => this.handleRequest(req, res));
+            this.server.on('error', (error) => {
+                reject(error);
+            });
+            this.server.listen(this.config.port, this.config.host, () => {
+                this.running = true;
+                this.startTime = Date.now();
+                this.log(`Control server listening on ${this.config.host}:${this.config.port}`);
+                resolve();
+            });
+        });
+    }
+    /**
+     * Stop the control server
+     */
+    async stop() {
+        if (!this.running)
+            return;
+        return new Promise((resolve) => {
+            if (this.server) {
+                this.server.close(() => {
+                    this.running = false;
+                    this.log('Control server stopped');
+                    resolve();
+                });
+            }
+            else {
+                resolve();
+            }
+        });
+    }
+    /**
+     * Check if pause has been requested
+     */
+    isPauseRequested() {
+        return this.pauseRequested;
+    }
+    /**
+     * Clear pause request (called after pause is handled)
+     */
+    clearPauseRequest() {
+        this.pauseRequested = false;
+    }
+    /**
+     * Update execution state (called by executor)
+     */
+    updateState(state) {
+        this.executionState = state;
+    }
+    /**
+     * Update live progress (called by executor)
+     */
+    updateProgress(progress) {
+        this.liveProgress = progress;
+    }
+    /**
+     * Check if the server is running
+     */
+    isRunning() {
+        return this.running;
+    }
+    /**
+     * Get the server port
+     */
+    getPort() {
+        return this.config.port;
+    }
+    /**
+     * Handle incoming HTTP request
+     */
+    async handleRequest(req, res) {
+        const url = parseUrl(req.url ?? '/', true);
+        const path = url.pathname ?? '/';
+        const method = req.method ?? 'GET';
+        // Set CORS headers for flexibility
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+        res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+        // Handle preflight
+        if (method === 'OPTIONS') {
+            res.writeHead(204);
+            res.end();
+            return;
+        }
+        try {
+            // Route requests
+            if (path === '/health' || path === '/_health') {
+                this.handleHealth(res);
+            }
+            else if (path === '/status') {
+                this.handleStatus(res);
+            }
+            else if (path === '/pause' && method === 'POST') {
+                this.handlePause(res);
+            }
+            else if (path === '/resume' && method === 'POST') {
+                this.handleResume(res);
+            }
+            else {
+                this.sendJson(res, 404, { error: 'Not found', path });
+            }
+        }
+        catch (error) {
+            this.sendJson(res, 500, { error: error.message });
+        }
+    }
+    /**
+     * Handle health check
+     */
+    handleHealth(res) {
+        this.sendJson(res, 200, {
+            status: 'ok',
+            timestamp: new Date().toISOString(),
+            uptime: Date.now() - this.startTime,
+        });
+    }
+    /**
+     * Handle status query
+     */
+    handleStatus(res) {
+        this.callbacks.onStatusQueried?.();
+        const response = {
+            execution: this.executionState,
+            progress: this.liveProgress,
+            pauseRequested: this.pauseRequested,
+            uptime: Date.now() - this.startTime,
+            timestamp: new Date().toISOString(),
+        };
+        this.sendJson(res, 200, response);
+    }
+    /**
+     * Handle pause request
+     */
+    handlePause(res) {
+        if (this.pauseRequested) {
+            const response = {
+                success: true,
+                message: 'Pause already requested',
+                pauseRequested: true,
+            };
+            this.sendJson(res, 200, response);
+            return;
+        }
+        this.pauseRequested = true;
+        this.callbacks.onPauseRequested?.();
+        this.log('Pause requested');
+        const response = {
+            success: true,
+            message: 'Pause requested. Execution will pause at next safe point.',
+            pauseRequested: true,
+        };
+        this.sendJson(res, 200, response);
+    }
+    /**
+     * Handle resume request
+     */
+    handleResume(res) {
+        if (!this.pauseRequested) {
+            const response = {
+                success: true,
+                message: 'No pause was requested',
+                pauseRequested: false,
+            };
+            this.sendJson(res, 200, response);
+            return;
+        }
+        this.pauseRequested = false;
+        this.callbacks.onResumeRequested?.();
+        this.log('Pause request cleared');
+        const response = {
+            success: true,
+            message: 'Pause request cleared. Use --resume flag to resume execution.',
+            pauseRequested: false,
+        };
+        this.sendJson(res, 200, response);
+    }
+    /**
+     * Send JSON response
+     */
+    sendJson(res, status, data) {
+        res.writeHead(status, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(data, null, 2));
+    }
+    /**
+     * Log message if verbose mode enabled
+     */
+    log(message) {
+        if (this.config.verbose) {
+            console.log(`[Control] ${message}`);
+        }
+    }
+}

package/dist/control/types.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Control Server Types
+ *
+ * Types for the HTTP control server that enables
+ * pause/resume and live status queries.
+ */
+import type { ExecutionState, LiveProgress } from '../execution/index.js';
+/**
+ * Configuration for the control server
+ */
+export interface ControlServerConfig {
+    /** Port to listen on (default: 3001) */
+    port?: number;
+    /** Host to bind to (default: localhost) */
+    host?: string;
+    /** Enable verbose logging */
+    verbose?: boolean;
+}
+/**
+ * Callbacks for control server events
+ */
+export interface ControlServerCallbacks {
+    /** Called when pause is requested */
+    onPauseRequested?: () => void;
+    /** Called when resume is requested */
+    onResumeRequested?: () => void;
+    /** Called when status is queried */
+    onStatusQueried?: () => void;
+}
+/**
+ * Response for status endpoint
+ */
+export interface StatusResponse {
+    /** Execution state (if available) */
+    execution?: ExecutionState;
+    /** Live progress (if available) */
+    progress?: LiveProgress;
+    /** Whether pause has been requested */
+    pauseRequested: boolean;
+    /** Server uptime in milliseconds */
+    uptime: number;
+    /** Timestamp of this response */
+    timestamp: string;
+}
+/**
+ * Response for pause/resume endpoints
+ */
+export interface ControlResponse {
+    /** Whether the operation succeeded */
+    success: boolean;
+    /** Optional message */
+    message?: string;
+    /** Whether pause is currently requested */
+    pauseRequested: boolean;
+}

package/dist/control/types.js

@@ -0,0 +1,7 @@
+/**
+ * Control Server Types
+ *
+ * Types for the HTTP control server that enables
+ * pause/resume and live status queries.
+ */
+export {};

package/dist/debug/cli-debugger.d.ts

@@ -0,0 +1,17 @@
+/**
+ * CLI Debugger - Interactive readline-based debugger for terminal use
+ */
+import type { DebugCommand, DebugSnapshot } from './controller.js';
+import { BaseDebugController } from './controller.js';
+export declare class CLIDebugger extends BaseDebugController {
+    private rl;
+    private closed;
+    constructor();
+    pause(snapshot: DebugSnapshot): Promise<DebugCommand>;
+    private printSnapshot;
+    private formatValue;
+    private promptCommand;
+    private parseCommand;
+    private printHelp;
+    close(): void;
+}