moflo 4.8.31 → 4.8.32

package/src/@claude-flow/shared/dist/resilience/circuit-breaker.d.ts

@@ -1,132 +0,0 @@
-/**
- * Circuit Breaker Pattern
- *
- * Prevents cascading failures by breaking the circuit after failures.
- *
- * @module v3/shared/resilience/circuit-breaker
- */
-import { EventEmitter } from 'events';
-/**
- * Circuit breaker states
- */
-export declare enum CircuitBreakerState {
-    /** Circuit is closed, requests flow normally */
-    CLOSED = "CLOSED",
-    /** Circuit is open, requests are rejected immediately */
-    OPEN = "OPEN",
-    /** Circuit is testing if service recovered */
-    HALF_OPEN = "HALF_OPEN"
-}
-/**
- * Circuit breaker options
- */
-export interface CircuitBreakerOptions {
-    /** Name for identification */
-    name: string;
-    /** Failure threshold before opening circuit (default: 5) */
-    failureThreshold: number;
-    /** Success threshold in half-open state to close circuit (default: 3) */
-    successThreshold: number;
-    /** Time to wait before testing again in ms (default: 30000) */
-    timeout: number;
-    /** Time window to track failures in ms (default: 60000) */
-    rollingWindow: number;
-    /** Volume threshold - minimum requests before tripping (default: 10) */
-    volumeThreshold: number;
-    /** Custom failure detection */
-    isFailure?: (error: Error) => boolean;
-    /** Fallback function when circuit is open */
-    fallback?: <T>(error: Error) => T | Promise<T>;
-    /** Callback when state changes */
-    onStateChange?: (from: CircuitBreakerState, to: CircuitBreakerState) => void;
-}
-/**
- * Circuit breaker statistics
- */
-export interface CircuitBreakerStats {
-    state: CircuitBreakerState;
-    failures: number;
-    successes: number;
-    totalRequests: number;
-    rejectedRequests: number;
-    lastFailure: Date | null;
-    lastSuccess: Date | null;
-    openSince: Date | null;
-}
-/**
- * Circuit Breaker
- *
- * Implements the circuit breaker pattern to prevent cascading failures.
- *
- * @example
- * const breaker = new CircuitBreaker({
- *   name: 'external-api',
- *   failureThreshold: 5,
- *   timeout: 30000,
- * });
- *
- * try {
- *   const result = await breaker.execute(() => fetchExternalAPI());
- * } catch (error) {
- *   if (error.message === 'Circuit is open') {
- *     // Handle circuit open case
- *   }
- * }
- */
-export declare class CircuitBreaker extends EventEmitter {
-    private readonly options;
-    private state;
-    private requests;
-    private halfOpenSuccesses;
-    private openedAt;
-    private lastFailure;
-    private lastSuccess;
-    private rejectedCount;
-    private timeoutId?;
-    constructor(options: CircuitBreakerOptions);
-    /**
-     * Execute a function through the circuit breaker
-     */
-    execute<T>(fn: () => Promise<T>): Promise<T>;
-    /**
-     * Get current state
-     */
-    getState(): CircuitBreakerState;
-    /**
-     * Get statistics
-     */
-    getStats(): CircuitBreakerStats;
-    /**
-     * Force reset the circuit breaker
-     */
-    reset(): void;
-    /**
-     * Handle successful request
-     */
-    private onSuccess;
-    /**
-     * Handle failed request
-     */
-    private onFailure;
-    /**
-     * Check if state should change based on timeout
-     */
-    private checkState;
-    /**
-     * Transition to new state
-     */
-    private transitionTo;
-    /**
-     * Schedule transition to half-open
-     */
-    private scheduleHalfOpen;
-    /**
-     * Notify state change
-     */
-    private notifyStateChange;
-    /**
-     * Clean old requests outside rolling window
-     */
-    private cleanOldRequests;
-}
-//# sourceMappingURL=circuit-breaker.d.ts.map

package/src/@claude-flow/shared/dist/resilience/index.d.ts

@@ -1,19 +0,0 @@
-/**
- * Resilience Patterns
- *
- * Production-ready resilience utilities:
- * - Retry with exponential backoff
- * - Circuit breaker pattern
- * - Rate limiting
- *
- * @module v3/shared/resilience
- */
-export { retry, RetryError } from './retry.js';
-export type { RetryOptions, RetryResult } from './retry.js';
-export { CircuitBreaker } from './circuit-breaker.js';
-export type { CircuitBreakerOptions, CircuitBreakerStats } from './circuit-breaker.js';
-export { SlidingWindowRateLimiter, TokenBucketRateLimiter } from './rate-limiter.js';
-export type { RateLimiter, RateLimiterOptions, RateLimitResult } from './rate-limiter.js';
-export { Bulkhead } from './bulkhead.js';
-export type { BulkheadOptions, BulkheadStats } from './bulkhead.js';
-//# sourceMappingURL=index.d.ts.map

package/src/@claude-flow/shared/dist/resilience/rate-limiter.d.ts

@@ -1,168 +0,0 @@
-/**
- * Rate Limiter
- *
- * Production-ready rate limiting implementations.
- *
- * @module v3/shared/resilience/rate-limiter
- */
-/**
- * Rate limiter options
- */
-export interface RateLimiterOptions {
-    /** Maximum requests allowed in the window */
-    maxRequests: number;
-    /** Time window in milliseconds */
-    windowMs: number;
-    /** Enable sliding window (vs fixed window) */
-    slidingWindow?: boolean;
-    /** Key generator for per-key limiting */
-    keyGenerator?: (context: unknown) => string;
-    /** Skip limiter for certain requests */
-    skip?: (context: unknown) => boolean;
-    /** Handler when rate limit is exceeded */
-    onRateLimited?: (key: string, remaining: number, resetAt: Date) => void;
-}
-/**
- * Rate limit result
- */
-export interface RateLimitResult {
-    allowed: boolean;
-    remaining: number;
-    resetAt: Date;
-    retryAfter: number;
-    total: number;
-    used: number;
-}
-/**
- * Base Rate Limiter interface
- */
-export interface RateLimiter {
-    /** Check if request is allowed */
-    check(key?: string): RateLimitResult;
-    /** Consume a request token */
-    consume(key?: string): RateLimitResult;
-    /** Reset a specific key or all keys */
-    reset(key?: string): void;
-    /** Get current status */
-    status(key?: string): RateLimitResult;
-}
-/**
- * Sliding Window Rate Limiter
- *
- * Uses sliding window algorithm for smooth rate limiting.
- *
- * @example
- * const limiter = new SlidingWindowRateLimiter({
- *   maxRequests: 100,
- *   windowMs: 60000, // 100 requests per minute
- * });
- *
- * const result = limiter.consume('user-123');
- * if (!result.allowed) {
- *   throw new Error(`Rate limited. Retry in ${result.retryAfter}ms`);
- * }
- */
-export declare class SlidingWindowRateLimiter implements RateLimiter {
-    private readonly options;
-    private readonly requests;
-    private cleanupInterval?;
-    constructor(options: RateLimiterOptions);
-    /**
-     * Check if a request would be allowed without consuming
-     */
-    check(key?: string): RateLimitResult;
-    /**
-     * Consume a request token
-     */
-    consume(key?: string): RateLimitResult;
-    /**
-     * Reset rate limit for a key
-     */
-    reset(key?: string): void;
-    /**
-     * Get current status
-     */
-    status(key?: string): RateLimitResult;
-    /**
-     * Cleanup resources
-     */
-    destroy(): void;
-    /**
-     * Clean old entries for a specific key
-     */
-    private cleanupKey;
-    /**
-     * Clean all old entries
-     */
-    private cleanup;
-    /**
-     * Get reset time based on oldest entry
-     */
-    private getResetTime;
-    /**
-     * Get retry after time in ms
-     */
-    private getRetryAfter;
-}
-/**
- * Token Bucket Rate Limiter
- *
- * Uses token bucket algorithm for burst-friendly rate limiting.
- *
- * @example
- * const limiter = new TokenBucketRateLimiter({
- *   maxRequests: 10, // bucket size
- *   windowMs: 1000,  // refill interval
- * });
- */
-export declare class TokenBucketRateLimiter implements RateLimiter {
-    private readonly options;
-    private readonly buckets;
-    private cleanupInterval?;
-    constructor(options: RateLimiterOptions);
-    /**
-     * Check if a request would be allowed
-     */
-    check(key?: string): RateLimitResult;
-    /**
-     * Consume a token
-     */
-    consume(key?: string): RateLimitResult;
-    /**
-     * Reset bucket for a key
-     */
-    reset(key?: string): void;
-    /**
-     * Get current status
-     */
-    status(key?: string): RateLimitResult;
-    /**
-     * Cleanup resources
-     */
-    destroy(): void;
-    /**
-     * Get or create bucket for key
-     */
-    private getBucket;
-    /**
-     * Refill tokens based on elapsed time
-     */
-    private refill;
-    /**
-     * Clean inactive buckets
-     */
-    private cleanup;
-}
-/**
- * Rate limiter middleware for Express-like frameworks
- */
-export declare function createRateLimiterMiddleware(limiter: RateLimiter): (req: {
-    ip?: string;
-    headers?: Record<string, string>;
-}, res: {
-    status: (code: number) => {
-        json: (body: unknown) => void;
-    };
-    setHeader: (name: string, value: string) => void;
-}, next: () => void) => void;
-//# sourceMappingURL=rate-limiter.d.ts.map

package/src/@claude-flow/shared/dist/resilience/retry.d.ts

@@ -1,91 +0,0 @@
-/**
- * Retry with Exponential Backoff
- *
- * Production-ready retry logic with jitter, max retries, and error filtering.
- *
- * @module v3/shared/resilience/retry
- */
-/**
- * Retry options
- */
-export interface RetryOptions {
-    /** Maximum number of retry attempts (default: 3) */
-    maxAttempts: number;
-    /** Initial delay in milliseconds (default: 100) */
-    initialDelay: number;
-    /** Maximum delay in milliseconds (default: 10000) */
-    maxDelay: number;
-    /** Backoff multiplier (default: 2) */
-    backoffMultiplier: number;
-    /** Jitter factor 0-1 to randomize delays (default: 0.1) */
-    jitter: number;
-    /** Timeout for each attempt in milliseconds (default: 30000) */
-    timeout: number;
-    /** Errors that should trigger a retry (default: all errors) */
-    retryableErrors?: (error: Error) => boolean;
-    /** Callback for each retry attempt */
-    onRetry?: (error: Error, attempt: number, delay: number) => void;
-}
-/**
- * Retry result
- */
-export interface RetryResult<T> {
-    success: boolean;
-    result?: T;
-    attempts: number;
-    totalTime: number;
-    errors: Error[];
-}
-/**
- * Retry error with attempt history
- */
-export declare class RetryError extends Error {
-    readonly attempts: number;
-    readonly errors: Error[];
-    readonly totalTime: number;
-    constructor(message: string, attempts: number, errors: Error[], totalTime: number);
-}
-/**
- * Retry a function with exponential backoff
- *
- * @param fn Function to retry
- * @param options Retry configuration
- * @returns Result with success/failure and metadata
- *
- * @example
- * const result = await retry(
- *   () => fetchData(),
- *   { maxAttempts: 5, initialDelay: 200 }
- * );
- *
- * if (result.success) {
- *   console.log('Data:', result.result);
- * } else {
- *   console.log('Failed after', result.attempts, 'attempts');
- * }
- */
-export declare function retry<T>(fn: () => Promise<T>, options?: Partial<RetryOptions>): Promise<RetryResult<T>>;
-/**
- * Wrap a function with retry behavior
- *
- * @param fn Function to wrap
- * @param options Retry configuration
- * @returns Wrapped function that retries on failure
- */
-export declare function withRetry<T extends (...args: unknown[]) => Promise<unknown>>(fn: T, options?: Partial<RetryOptions>): (...args: Parameters<T>) => Promise<RetryResult<Awaited<ReturnType<T>>>>;
-/**
- * Common retryable error predicates
- */
-export declare const RetryableErrors: {
-    /** Network errors (ECONNRESET, ETIMEDOUT, etc.) */
-    network: (error: Error) => boolean;
-    /** Rate limit errors (429) */
-    rateLimit: (error: Error) => boolean;
-    /** Server errors (5xx) */
-    serverError: (error: Error) => boolean;
-    /** Transient errors (network + rate limit + 5xx) */
-    transient: (error: Error) => boolean;
-    /** All errors are retryable */
-    all: () => boolean;
-};
-//# sourceMappingURL=retry.d.ts.map

package/src/@claude-flow/shared/dist/security/index.d.ts

@@ -1,10 +0,0 @@
-/**
- * Security Module
- *
- * Shared security utilities for V3 Claude Flow.
- *
- * @module v3/shared/security
- */
-export { generateSecureId, generateUUID, generateSecureToken, generateShortId, generateSessionId, generateAgentId, generateTaskId, generateMemoryId, generateEventId, generateSwarmId, generatePatternId, generateTrajectoryId, secureRandomInt, secureRandomChoice, secureShuffleArray, } from './secure-random.js';
-export { validateInput, sanitizeString, validatePath, validateCommand, validateTags, isValidIdentifier, escapeForSql, type ValidationResult, type ValidationOptions, } from './input-validation.js';
-//# sourceMappingURL=index.d.ts.map

package/src/@claude-flow/shared/dist/security/input-validation.d.ts

@@ -1,73 +0,0 @@
-/**
- * Input Validation Utilities
- *
- * Secure input validation and sanitization.
- *
- * @module v3/shared/security/input-validation
- */
-/**
- * Validation result
- */
-export interface ValidationResult {
-    valid: boolean;
-    error?: string;
-    sanitized?: unknown;
-}
-/**
- * Validation options
- */
-export interface ValidationOptions {
-    maxLength?: number;
-    minLength?: number;
-    pattern?: RegExp;
-    allowedChars?: RegExp;
-    required?: boolean;
-    trim?: boolean;
-}
-/**
- * Validate and sanitize string input
- * @param input Input string
- * @param options Validation options
- * @returns Validation result
- */
-export declare function validateInput(input: unknown, options?: ValidationOptions): ValidationResult;
-/**
- * Sanitize string by removing dangerous characters
- * @param input Input string
- * @returns Sanitized string
- */
-export declare function sanitizeString(input: string): string;
-/**
- * Validate file path (prevent path traversal)
- * @param path File path
- * @param allowedBase Allowed base directory
- * @returns Validation result
- */
-export declare function validatePath(path: string, allowedBase?: string): ValidationResult;
-/**
- * Validate command (prevent command injection)
- * @param command Command string
- * @param allowedCommands Optional whitelist of allowed commands
- * @returns Validation result
- */
-export declare function validateCommand(command: string, allowedCommands?: string[]): ValidationResult;
-/**
- * Validate tags for safe SQL usage
- * @param tags Array of tag strings
- * @returns Validation result with sanitized tags
- */
-export declare function validateTags(tags: unknown): ValidationResult;
-/**
- * Check if string is a valid identifier
- * @param id Identifier string
- * @returns True if valid
- */
-export declare function isValidIdentifier(id: string): boolean;
-/**
- * Escape string for safe SQL usage (use parameterized queries instead when possible)
- * This is a LAST RESORT - always prefer parameterized queries
- * @param value String to escape
- * @returns Escaped string
- */
-export declare function escapeForSql(value: string): string;
-//# sourceMappingURL=input-validation.d.ts.map

package/src/@claude-flow/shared/dist/security/secure-random.d.ts

@@ -1,92 +0,0 @@
-/**
- * Secure Random Utilities
- *
- * Cryptographically secure random ID and token generation.
- * Replaces Math.random() for security-sensitive operations.
- *
- * @module v3/shared/security/secure-random
- */
-/**
- * Generate a cryptographically secure random ID
- * @param prefix Optional prefix for the ID
- * @param length Number of random bytes (default 12)
- * @returns Secure random ID string
- */
-export declare function generateSecureId(prefix?: string, length?: number): string;
-/**
- * Generate a UUID v4 (cryptographically secure)
- * @returns UUID string
- */
-export declare function generateUUID(): string;
-/**
- * Generate a secure token for authentication
- * @param length Number of bytes (default 32)
- * @returns Hex-encoded token string
- */
-export declare function generateSecureToken(length?: number): string;
-/**
- * Generate a short secure ID (for display purposes)
- * @param prefix Optional prefix
- * @returns Short secure ID
- */
-export declare function generateShortId(prefix?: string): string;
-/**
- * Generate a secure session ID
- * @returns Session ID string
- */
-export declare function generateSessionId(): string;
-/**
- * Generate a secure agent ID
- * @returns Agent ID string
- */
-export declare function generateAgentId(): string;
-/**
- * Generate a secure task ID
- * @returns Task ID string
- */
-export declare function generateTaskId(): string;
-/**
- * Generate a secure memory ID
- * @returns Memory ID string
- */
-export declare function generateMemoryId(): string;
-/**
- * Generate a secure event ID
- * @returns Event ID string
- */
-export declare function generateEventId(): string;
-/**
- * Generate a secure swarm ID
- * @returns Swarm ID string
- */
-export declare function generateSwarmId(): string;
-/**
- * Generate a secure pattern ID
- * @returns Pattern ID string
- */
-export declare function generatePatternId(): string;
-/**
- * Generate a secure trajectory ID
- * @returns Trajectory ID string
- */
-export declare function generateTrajectoryId(): string;
-/**
- * Generate a random integer in range [min, max] using crypto
- * @param min Minimum value (inclusive)
- * @param max Maximum value (inclusive)
- * @returns Cryptographically random integer
- */
-export declare function secureRandomInt(min: number, max: number): number;
-/**
- * Secure random selection from array
- * @param array Array to select from
- * @returns Random element
- */
-export declare function secureRandomChoice<T>(array: T[]): T;
-/**
- * Secure shuffle array (Fisher-Yates with crypto)
- * @param array Array to shuffle
- * @returns New shuffled array
- */
-export declare function secureShuffleArray<T>(array: T[]): T[];
-//# sourceMappingURL=secure-random.d.ts.map

package/src/@claude-flow/shared/dist/services/index.d.ts

@@ -1,7 +0,0 @@
-/**
- * Shared Services
- *
- * @module @claude-flow/shared/services
- */
-export { V3ProgressService, createV3ProgressService, getV3Progress, syncV3Progress, getDefaultProgressService, type V3ProgressMetrics, type V3ProgressOptions, type ProgressChangeEvent, } from './v3-progress.service.js';
-//# sourceMappingURL=index.d.ts.map