claude-flow 3.25.6 → 3.26.1

package/v3/@claude-flow/shared/dist/resilience/retry.js

@@ -1,159 +0,0 @@
-/**
- * Retry with Exponential Backoff
- *
- * Production-ready retry logic with jitter, max retries, and error filtering.
- *
- * @module v3/shared/resilience/retry
- */
-/**
- * Retry error with attempt history
- */
-export class RetryError extends Error {
-    attempts;
-    errors;
-    totalTime;
-    constructor(message, attempts, errors, totalTime) {
-        super(message);
-        this.attempts = attempts;
-        this.errors = errors;
-        this.totalTime = totalTime;
-        this.name = 'RetryError';
-    }
-}
-/**
- * Default retry options
- */
-const DEFAULT_OPTIONS = {
-    maxAttempts: 3,
-    initialDelay: 100,
-    maxDelay: 10000,
-    backoffMultiplier: 2,
-    jitter: 0.1,
-    timeout: 30000,
-};
-/**
- * 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 async function retry(fn, options = {}) {
-    const opts = { ...DEFAULT_OPTIONS, ...options };
-    const errors = [];
-    const startTime = Date.now();
-    for (let attempt = 1; attempt <= opts.maxAttempts; attempt++) {
-        try {
-            // Execute with timeout
-            const result = await withTimeout(fn(), opts.timeout, attempt);
-            return {
-                success: true,
-                result,
-                attempts: attempt,
-                totalTime: Date.now() - startTime,
-                errors,
-            };
-        }
-        catch (error) {
-            const err = error instanceof Error ? error : new Error(String(error));
-            errors.push(err);
-            // Check if error is retryable
-            if (opts.retryableErrors && !opts.retryableErrors(err)) {
-                return {
-                    success: false,
-                    attempts: attempt,
-                    totalTime: Date.now() - startTime,
-                    errors,
-                };
-            }
-            // If this was the last attempt, don't delay
-            if (attempt >= opts.maxAttempts) {
-                break;
-            }
-            // Calculate delay with exponential backoff and jitter
-            const baseDelay = opts.initialDelay * Math.pow(opts.backoffMultiplier, attempt - 1);
-            const jitter = baseDelay * opts.jitter * (Math.random() * 2 - 1);
-            const delay = Math.min(baseDelay + jitter, opts.maxDelay);
-            // Callback before retry
-            if (opts.onRetry) {
-                opts.onRetry(err, attempt, delay);
-            }
-            // Wait before next attempt
-            await sleep(delay);
-        }
-    }
-    return {
-        success: false,
-        attempts: opts.maxAttempts,
-        totalTime: Date.now() - startTime,
-        errors,
-    };
-}
-/**
- * Wrap a function with retry behavior
- *
- * @param fn Function to wrap
- * @param options Retry configuration
- * @returns Wrapped function that retries on failure
- */
-export function withRetry(fn, options = {}) {
-    return async (...args) => {
-        return retry(() => fn(...args), options);
-    };
-}
-/**
- * Execute with timeout
- */
-async function withTimeout(promise, timeout, attempt) {
-    const timeoutPromise = new Promise((_, reject) => {
-        setTimeout(() => {
-            reject(new Error(`Attempt ${attempt} timed out after ${timeout}ms`));
-        }, timeout);
-    });
-    return Promise.race([promise, timeoutPromise]);
-}
-/**
- * Sleep for specified milliseconds
- */
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-/**
- * Common retryable error predicates
- */
-export const RetryableErrors = {
-    /** Network errors (ECONNRESET, ETIMEDOUT, etc.) */
-    network: (error) => {
-        const networkCodes = ['ECONNRESET', 'ETIMEDOUT', 'ECONNREFUSED', 'ENOTFOUND', 'EAI_AGAIN'];
-        return networkCodes.some((code) => error.message.includes(code));
-    },
-    /** Rate limit errors (429) */
-    rateLimit: (error) => {
-        return error.message.includes('429') || error.message.toLowerCase().includes('rate limit');
-    },
-    /** Server errors (5xx) */
-    serverError: (error) => {
-        return /5\d\d/.test(error.message) || error.message.includes('Internal Server Error');
-    },
-    /** Transient errors (network + rate limit + 5xx) */
-    transient: (error) => {
-        return (RetryableErrors.network(error) ||
-            RetryableErrors.rateLimit(error) ||
-            RetryableErrors.serverError(error));
-    },
-    /** All errors are retryable */
-    all: () => true,
-};
-//# sourceMappingURL=retry.js.map

package/v3/@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/v3/@claude-flow/shared/dist/security/index.js

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

package/v3/@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/v3/@claude-flow/shared/dist/security/input-validation.js

@@ -1,201 +0,0 @@
-/**
- * Input Validation Utilities
- *
- * Secure input validation and sanitization.
- *
- * @module v3/shared/security/input-validation
- */
-/**
- * Default validation options
- */
-const DEFAULT_OPTIONS = {
-    maxLength: 10000,
-    minLength: 0,
-    required: false,
-    trim: true,
-};
-/**
- * Validate and sanitize string input
- * @param input Input string
- * @param options Validation options
- * @returns Validation result
- */
-export function validateInput(input, options = {}) {
-    const opts = { ...DEFAULT_OPTIONS, ...options };
-    // Check if input exists
-    if (input === null || input === undefined) {
-        if (opts.required) {
-            return { valid: false, error: 'Input is required' };
-        }
-        return { valid: true, sanitized: null };
-    }
-    // Convert to string
-    if (typeof input !== 'string') {
-        return { valid: false, error: 'Input must be a string' };
-    }
-    let sanitized = input;
-    // Trim whitespace
-    if (opts.trim) {
-        sanitized = sanitized.trim();
-    }
-    // Check length
-    if (opts.minLength && sanitized.length < opts.minLength) {
-        return {
-            valid: false,
-            error: `Input must be at least ${opts.minLength} characters`,
-        };
-    }
-    if (opts.maxLength && sanitized.length > opts.maxLength) {
-        return {
-            valid: false,
-            error: `Input must be at most ${opts.maxLength} characters`,
-        };
-    }
-    // Check pattern
-    if (opts.pattern && !opts.pattern.test(sanitized)) {
-        return { valid: false, error: 'Input does not match required pattern' };
-    }
-    // Check allowed characters
-    if (opts.allowedChars && !opts.allowedChars.test(sanitized)) {
-        return { valid: false, error: 'Input contains invalid characters' };
-    }
-    return { valid: true, sanitized };
-}
-/**
- * Sanitize string by removing dangerous characters
- * @param input Input string
- * @returns Sanitized string
- */
-export function sanitizeString(input) {
-    return input
-        .replace(/[<>]/g, '') // Remove HTML tags
-        .replace(/[\x00-\x1f\x7f]/g, '') // Remove control characters
-        .replace(/[\u2028\u2029]/g, '') // Remove line/paragraph separators
-        .trim();
-}
-/**
- * Validate file path (prevent path traversal)
- * @param path File path
- * @param allowedBase Allowed base directory
- * @returns Validation result
- */
-export function validatePath(path, allowedBase) {
-    // Normalize and check for path traversal
-    const normalized = path
-        .replace(/\\/g, '/') // Normalize Windows paths
-        .replace(/\/+/g, '/'); // Remove duplicate slashes
-    // Check for dangerous patterns
-    if (normalized.includes('..') || normalized.includes('~')) {
-        return {
-            valid: false,
-            error: 'Path contains directory traversal characters',
-        };
-    }
-    // Check for absolute paths outside allowed base
-    if (allowedBase && !normalized.startsWith(allowedBase)) {
-        const isAbsolute = normalized.startsWith('/') || /^[a-zA-Z]:/.test(normalized);
-        if (isAbsolute) {
-            return { valid: false, error: 'Path is outside allowed directory' };
-        }
-    }
-    // Check for null bytes
-    if (normalized.includes('\0')) {
-        return { valid: false, error: 'Path contains null bytes' };
-    }
-    // Check length
-    if (normalized.length > 4096) {
-        return { valid: false, error: 'Path is too long' };
-    }
-    return { valid: true, sanitized: normalized };
-}
-/**
- * Validate command (prevent command injection)
- * @param command Command string
- * @param allowedCommands Optional whitelist of allowed commands
- * @returns Validation result
- */
-export function validateCommand(command, allowedCommands) {
-    // Extract base command
-    const parts = command.trim().split(/\s+/);
-    const baseCommand = parts[0]?.toLowerCase();
-    if (!baseCommand) {
-        return { valid: false, error: 'Empty command' };
-    }
-    // Check whitelist if provided
-    if (allowedCommands && !allowedCommands.includes(baseCommand)) {
-        return { valid: false, error: `Command '${baseCommand}' is not allowed` };
-    }
-    // Check for dangerous shell characters
-    const dangerousPatterns = [
-        /[;&|`$]/, // Shell operators
-        /\$\(/, // Command substitution
-        /`.*`/, // Backtick substitution
-        /\|\|/, // OR operator
-        /&&/, // AND operator
-        />\s*>/, // Append redirection
-        /<\s*</, // Here document
-        /\r|\n/, // Newlines (command chaining)
-    ];
-    for (const pattern of dangerousPatterns) {
-        if (pattern.test(command)) {
-            return { valid: false, error: 'Command contains dangerous characters' };
-        }
-    }
-    return { valid: true, sanitized: command };
-}
-/**
- * Validate tags for safe SQL usage
- * @param tags Array of tag strings
- * @returns Validation result with sanitized tags
- */
-export function validateTags(tags) {
-    if (!Array.isArray(tags)) {
-        return { valid: false, error: 'Tags must be an array' };
-    }
-    const sanitized = [];
-    const tagPattern = /^[a-zA-Z0-9_\-.:]+$/;
-    for (const tag of tags) {
-        if (typeof tag !== 'string') {
-            return { valid: false, error: 'Each tag must be a string' };
-        }
-        const trimmed = tag.trim();
-        if (trimmed.length === 0) {
-            continue; // Skip empty tags
-        }
-        if (trimmed.length > 100) {
-            return { valid: false, error: 'Tag is too long (max 100 characters)' };
-        }
-        if (!tagPattern.test(trimmed)) {
-            return {
-                valid: false,
-                error: `Invalid tag: '${trimmed}'. Tags can only contain alphanumeric characters, underscores, hyphens, dots, and colons`,
-            };
-        }
-        sanitized.push(trimmed);
-    }
-    return { valid: true, sanitized };
-}
-/**
- * Check if string is a valid identifier
- * @param id Identifier string
- * @returns True if valid
- */
-export function isValidIdentifier(id) {
-    return /^[a-zA-Z_][a-zA-Z0-9_\-]*$/.test(id) && id.length <= 256;
-}
-/**
- * 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 function escapeForSql(value) {
-    return value
-        .replace(/'/g, "''") // Escape single quotes
-        .replace(/\\/g, '\\\\') // Escape backslashes
-        .replace(/\x00/g, '') // Remove null bytes
-        .replace(/\n/g, '\\n') // Escape newlines
-        .replace(/\r/g, '\\r') // Escape carriage returns
-        .replace(/\x1a/g, '\\Z'); // Escape ctrl+Z (EOF in Windows)
-}
-//# sourceMappingURL=input-validation.js.map

package/v3/@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/v3/@claude-flow/shared/dist/security/secure-random.js

@@ -1,142 +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
- */
-import { randomBytes, randomUUID } from 'crypto';
-/**
- * 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 function generateSecureId(prefix, length = 12) {
-    const timestamp = Date.now().toString(36);
-    const randomPart = randomBytes(length).toString('hex');
-    return prefix ? `${prefix}_${timestamp}_${randomPart}` : `${timestamp}_${randomPart}`;
-}
-/**
- * Generate a UUID v4 (cryptographically secure)
- * @returns UUID string
- */
-export function generateUUID() {
-    return randomUUID();
-}
-/**
- * Generate a secure token for authentication
- * @param length Number of bytes (default 32)
- * @returns Hex-encoded token string
- */
-export function generateSecureToken(length = 32) {
-    return randomBytes(length).toString('hex');
-}
-/**
- * Generate a short secure ID (for display purposes)
- * @param prefix Optional prefix
- * @returns Short secure ID
- */
-export function generateShortId(prefix) {
-    const id = randomBytes(6).toString('base64url');
-    return prefix ? `${prefix}-${id}` : id;
-}
-/**
- * Generate a secure session ID
- * @returns Session ID string
- */
-export function generateSessionId() {
-    return generateSecureId('session', 16);
-}
-/**
- * Generate a secure agent ID
- * @returns Agent ID string
- */
-export function generateAgentId() {
-    return generateSecureId('agent', 12);
-}
-/**
- * Generate a secure task ID
- * @returns Task ID string
- */
-export function generateTaskId() {
-    return generateSecureId('task', 12);
-}
-/**
- * Generate a secure memory ID
- * @returns Memory ID string
- */
-export function generateMemoryId() {
-    return generateSecureId('mem', 12);
-}
-/**
- * Generate a secure event ID
- * @returns Event ID string
- */
-export function generateEventId() {
-    return generateSecureId('evt', 12);
-}
-/**
- * Generate a secure swarm ID
- * @returns Swarm ID string
- */
-export function generateSwarmId() {
-    return generateSecureId('swarm', 12);
-}
-/**
- * Generate a secure pattern ID
- * @returns Pattern ID string
- */
-export function generatePatternId() {
-    return generateSecureId('pat', 12);
-}
-/**
- * Generate a secure trajectory ID
- * @returns Trajectory ID string
- */
-export function generateTrajectoryId() {
-    return generateSecureId('traj', 12);
-}
-/**
- * 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 function secureRandomInt(min, max) {
-    const range = max - min + 1;
-    const bytesNeeded = Math.ceil(Math.log2(range) / 8);
-    const maxValid = Math.pow(256, bytesNeeded) - (Math.pow(256, bytesNeeded) % range);
-    let randomValue;
-    do {
-        const bytes = randomBytes(bytesNeeded);
-        randomValue = bytes.reduce((acc, byte, i) => acc + byte * Math.pow(256, i), 0);
-    } while (randomValue >= maxValid);
-    return min + (randomValue % range);
-}
-/**
- * Secure random selection from array
- * @param array Array to select from
- * @returns Random element
- */
-export function secureRandomChoice(array) {
-    if (array.length === 0) {
-        throw new Error('Cannot select from empty array');
-    }
-    return array[secureRandomInt(0, array.length - 1)];
-}
-/**
- * Secure shuffle array (Fisher-Yates with crypto)
- * @param array Array to shuffle
- * @returns New shuffled array
- */
-export function secureShuffleArray(array) {
-    const result = [...array];
-    for (let i = result.length - 1; i > 0; i--) {
-        const j = secureRandomInt(0, i);
-        [result[i], result[j]] = [result[j], result[i]];
-    }
-    return result;
-}
-//# sourceMappingURL=secure-random.js.map

package/v3/@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