@cloudpftc/opencode-orchestrator 3.5.15

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

@@ -0,0 +1,159 @@
+/**
+ * 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

@@ -0,0 +1,10 @@
+/**
+ * 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

@@ -0,0 +1,12 @@
+/**
+ * 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

@@ -0,0 +1,73 @@
+/**
+ * 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

@@ -0,0 +1,201 @@
+/**
+ * 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

@@ -0,0 +1,92 @@
+/**
+ * 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

@@ -0,0 +1,142 @@
+/**
+ * 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

@@ -0,0 +1,7 @@
+/**
+ * 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