claude-flow-novice 2.15.3 → 2.15.5

package/dist/lib/queue-recovery.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/queue-recovery.ts"],"sourcesContent":["/**\r\n * Queue Recovery System\r\n *\r\n * Provides failure detection, dead letter queue management, and automatic recovery\r\n * for Redis queue operations. Handles coordinator crashes and message reprocessing.\r\n * Part of Task 3.4: Redis Queue Consistency & Recovery (Integration Standardization Sprint 3)\r\n *\r\n * Features:\r\n * - Dead letter queue for failed messages\r\n * - Automatic retry with exponential backoff\r\n * - Failure detection (tasks not processed within timeout)\r\n * - Coordinator crash recovery procedure\r\n * - Message reprocessing safeguards\r\n *\r\n * Usage:\r\n *   const recovery = new QueueRecovery(queueManager);\r\n *\r\n *   // Start monitoring for stuck messages\r\n *   recovery.startMonitoring();\r\n *\r\n *   // Recover from coordinator crash\r\n *   await recovery.recoverFromCrash();\r\n *\r\n *   // Process dead letter queue\r\n *   const reprocessed = await recovery.reprocessDeadLetters();\r\n */\r\n\r\nimport { RedisClientType } from 'redis';\r\nimport { createLogger } from './logging.js';\r\nimport { createError, ErrorCode, isRetryableError } from './errors.js';\r\nimport { withRetry, sleep } from './retry.js';\r\nimport { RedisQueueManager, QueueMessage } from './redis-queue-manager.js';\r\n\r\nconst logger = createLogger('queue-recovery');\r\n\r\n/**\r\n * Recovery options\r\n */\r\nexport interface RecoveryOptions {\r\n  /** Maximum number of retry attempts (default: 3) */\r\n  maxRetries?: number;\r\n  /** Base retry delay in milliseconds (default: 1000) */\r\n  baseRetryDelayMs?: number;\r\n  /** Maximum retry delay in milliseconds (default: 60000) */\r\n  maxRetryDelayMs?: number;\r\n  /** Message processing timeout in milliseconds (default: 300000 - 5 minutes) */\r\n  processingTimeoutMs?: number;\r\n  /** Monitoring interval in milliseconds (default: 60000 - 1 minute) */\r\n  monitoringIntervalMs?: number;\r\n  /** Dead letter queue name (default: 'dlq') */\r\n  deadLetterQueue?: string;\r\n  /** Enable automatic reprocessing of dead letters (default: false) */\r\n  autoReprocess?: boolean;\r\n}\r\n\r\n/**\r\n * Recovery statistics\r\n */\r\nexport interface RecoveryStats {\r\n  /** Total messages recovered */\r\n  totalRecovered: number;\r\n  /** Total messages sent to DLQ */\r\n  totalDeadLettered: number;\r\n  /** Total messages reprocessed from DLQ */\r\n  totalReprocessed: number;\r\n  /** Total stuck messages detected */\r\n  totalStuckDetected: number;\r\n  /** Last recovery timestamp */\r\n  lastRecoveryAt?: Date;\r\n}\r\n\r\n/**\r\n * Dead letter metadata\r\n */\r\nexport interface DeadLetterMetadata {\r\n  /** Original queue */\r\n  originalQueue: string;\r\n  /** Failure reason */\r\n  failureReason: string;\r\n  /** Number of retry attempts made */\r\n  retryAttempts: number;\r\n  /** Dead lettered timestamp */\r\n  deadLetteredAt: Date;\r\n  /** Original message metadata */\r\n  originalMetadata?: Record<string, any>;\r\n}\r\n\r\n/**\r\n * Default recovery options\r\n */\r\nconst DEFAULT_RECOVERY_OPTIONS: Required<RecoveryOptions> = {\r\n  maxRetries: 3,\r\n  baseRetryDelayMs: 1000,\r\n  maxRetryDelayMs: 60000,\r\n  processingTimeoutMs: 300000, // 5 minutes\r\n  monitoringIntervalMs: 60000, // 1 minute\r\n  deadLetterQueue: 'dlq',\r\n  autoReprocess: false,\r\n};\r\n\r\n/**\r\n * Queue Recovery System\r\n *\r\n * Handles failure detection, retry, and recovery for queue operations.\r\n */\r\nexport class QueueRecovery {\r\n  private queueManager: RedisQueueManager;\r\n  private redis: RedisClientType;\r\n  private options: Required<RecoveryOptions>;\r\n  private monitoringTimer: NodeJS.Timeout | null = null;\r\n  private stats: RecoveryStats = {\r\n    totalRecovered: 0,\r\n    totalDeadLettered: 0,\r\n    totalReprocessed: 0,\r\n    totalStuckDetected: 0,\r\n  };\r\n\r\n  /**\r\n   * Create a new QueueRecovery instance\r\n   *\r\n   * @param queueManager - Queue manager instance\r\n   * @param redis - Redis client instance\r\n   * @param options - Recovery options\r\n   */\r\n  constructor(\r\n    queueManager: RedisQueueManager,\r\n    redis: RedisClientType,\r\n    options: RecoveryOptions = {}\r\n  ) {\r\n    this.queueManager = queueManager;\r\n    this.redis = redis;\r\n    this.options = { ...DEFAULT_RECOVERY_OPTIONS, ...options };\r\n\r\n    logger.info('QueueRecovery initialized', {\r\n      maxRetries: this.options.maxRetries,\r\n      processingTimeoutMs: this.options.processingTimeoutMs,\r\n      deadLetterQueue: this.options.deadLetterQueue,\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Retry message processing with exponential backoff\r\n   *\r\n   * @param message - Message to retry\r\n   * @param processFn - Function to process message\r\n   * @returns Processing result\r\n   */\r\n  public async retryWithBackoff<T = any, R = any>(\r\n    message: QueueMessage<T>,\r\n    processFn: (payload: T) => Promise<R>\r\n  ): Promise<R> {\r\n    const maxAttempts = this.options.maxRetries;\r\n    let attempt = message.deliveryAttempts;\r\n\r\n    while (attempt <= maxAttempts) {\r\n      try {\r\n        logger.debug('Processing message with retry', {\r\n          messageId: message.id,\r\n          attempt,\r\n          maxAttempts,\r\n        });\r\n\r\n        const result = await processFn(message.payload);\r\n\r\n        if (attempt > 1) {\r\n          this.stats.totalRecovered++;\r\n          logger.info('Message processed successfully after retry', {\r\n            messageId: message.id,\r\n            attempt,\r\n          });\r\n        }\r\n\r\n        return result;\r\n      } catch (error) {\r\n        const err = error instanceof Error ? error : new Error(String(error));\r\n\r\n        logger.warn('Message processing failed', {\r\n          messageId: message.id,\r\n          attempt,\r\n          error: err.message,\r\n        });\r\n\r\n        // Check if we should retry\r\n        if (!isRetryableError(err) || attempt >= maxAttempts) {\r\n          logger.error('Message processing failed permanently', err, {\r\n            messageId: message.id,\r\n            attempt,\r\n            retryable: isRetryableError(err),\r\n          });\r\n\r\n          // Send to dead letter queue\r\n          await this.sendToDeadLetter(message, err.message);\r\n\r\n          throw err;\r\n        }\r\n\r\n        // Calculate backoff delay\r\n        const delay = this.calculateBackoffDelay(attempt);\r\n\r\n        logger.debug('Retrying message after delay', {\r\n          messageId: message.id,\r\n          attempt,\r\n          delayMs: delay,\r\n        });\r\n\r\n        // Wait before retry\r\n        await sleep(delay);\r\n\r\n        attempt++;\r\n      }\r\n    }\r\n\r\n    // Should never reach here, but TypeScript needs it\r\n    throw createError(\r\n      ErrorCode.RETRY_EXHAUSTED,\r\n      'Message processing retry exhausted',\r\n      { messageId: message.id, attempts: attempt }\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Send message to dead letter queue\r\n   *\r\n   * @param message - Message to dead letter\r\n   * @param reason - Failure reason\r\n   */\r\n  public async sendToDeadLetter<T = any>(\r\n    message: QueueMessage<T>,\r\n    reason: string\r\n  ): Promise<void> {\r\n    try {\r\n      const metadata: DeadLetterMetadata = {\r\n        originalQueue: message.queue,\r\n        failureReason: reason,\r\n        retryAttempts: message.deliveryAttempts,\r\n        deadLetteredAt: new Date(),\r\n        originalMetadata: message.metadata,\r\n      };\r\n\r\n      // Enqueue to dead letter queue\r\n      await this.queueManager.enqueue(\r\n        this.options.deadLetterQueue,\r\n        message.payload,\r\n        {\r\n          deduplicate: false, // Allow duplicate dead letters\r\n          metadata,\r\n        }\r\n      );\r\n\r\n      this.stats.totalDeadLettered++;\r\n\r\n      logger.info('Message sent to dead letter queue', {\r\n        messageId: message.id,\r\n        originalQueue: message.queue,\r\n        reason,\r\n        retryAttempts: message.deliveryAttempts,\r\n      });\r\n    } catch (error) {\r\n      logger.error('Failed to send message to DLQ', error instanceof Error ? error : new Error(String(error)), {\r\n        messageId: message.id,\r\n      });\r\n\r\n      throw createError(\r\n        ErrorCode.DB_QUERY_FAILED,\r\n        'Failed to send message to dead letter queue',\r\n        { messageId: message.id },\r\n        error instanceof Error ? error : undefined\r\n      );\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Reprocess messages from dead letter queue\r\n   *\r\n   * @param processFn - Function to process dead letter messages\r\n   * @param maxMessages - Maximum number of messages to reprocess (default: 100)\r\n   * @returns Number of messages reprocessed\r\n   */\r\n  public async reprocessDeadLetters<T = any>(\r\n    processFn: (payload: T, metadata: DeadLetterMetadata) => Promise<void>,\r\n    maxMessages: number = 100\r\n  ): Promise<number> {\r\n    let reprocessedCount = 0;\r\n\r\n    try {\r\n      logger.info('Starting dead letter reprocessing', {\r\n        maxMessages,\r\n      });\r\n\r\n      for (let i = 0; i < maxMessages; i++) {\r\n        // Dequeue from dead letter queue\r\n        const message = await this.queueManager.dequeue<T>(\r\n          this.options.deadLetterQueue,\r\n          { timeout: 0 }\r\n        );\r\n\r\n        if (!message) {\r\n          // No more messages\r\n          break;\r\n        }\r\n\r\n        try {\r\n          const metadata = message.metadata as DeadLetterMetadata;\r\n\r\n          // Process message\r\n          await processFn(message.payload, metadata);\r\n\r\n          // Acknowledge successful processing\r\n          await this.queueManager.acknowledge(message.id);\r\n\r\n          reprocessedCount++;\r\n          this.stats.totalReprocessed++;\r\n\r\n          logger.debug('Dead letter message reprocessed', {\r\n            messageId: message.id,\r\n            originalQueue: metadata.originalQueue,\r\n          });\r\n        } catch (error) {\r\n          // Reject message (will stay in DLQ or be retried based on options)\r\n          await this.queueManager.reject(message.id, {\r\n            retry: false,\r\n            error: error instanceof Error ? error.message : String(error),\r\n          });\r\n\r\n          logger.error('Failed to reprocess dead letter', error instanceof Error ? error : new Error(String(error)), {\r\n            messageId: message.id,\r\n          });\r\n        }\r\n      }\r\n\r\n      logger.info('Dead letter reprocessing complete', {\r\n        reprocessedCount,\r\n      });\r\n\r\n      return reprocessedCount;\r\n    } catch (error) {\r\n      logger.error('Dead letter reprocessing failed', error instanceof Error ? error : new Error(String(error)));\r\n\r\n      throw createError(\r\n        ErrorCode.DB_QUERY_FAILED,\r\n        'Failed to reprocess dead letters',\r\n        { reprocessedCount },\r\n        error instanceof Error ? error : undefined\r\n      );\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Detect and recover stuck messages (messages in processing longer than timeout)\r\n   *\r\n   * @param queue - Queue name to check\r\n   * @returns Number of stuck messages recovered\r\n   */\r\n  public async recoverStuckMessages(queue: string): Promise<number> {\r\n    try {\r\n      const processingKey = `queue:${queue}:processing`;\r\n      const queueKey = `queue:${queue}`;\r\n\r\n      // Get all messages in processing\r\n      const processingMessages = await this.redis.lRange(processingKey, 0, -1);\r\n\r\n      let recoveredCount = 0;\r\n      const now = Date.now();\r\n\r\n      for (const messageData of processingMessages) {\r\n        const message = JSON.parse(messageData) as QueueMessage;\r\n\r\n        // Check if message is stuck (processing longer than timeout)\r\n        if (message.dequeuedAt) {\r\n          const processingTime = now - new Date(message.dequeuedAt).getTime();\r\n\r\n          if (processingTime > this.options.processingTimeoutMs) {\r\n            logger.warn('Stuck message detected', {\r\n              messageId: message.id,\r\n              queue,\r\n              processingTimeMs: processingTime,\r\n              timeoutMs: this.options.processingTimeoutMs,\r\n            });\r\n\r\n            this.stats.totalStuckDetected++;\r\n\r\n            // Check if message has exceeded max retries\r\n            if (message.deliveryAttempts >= this.options.maxRetries) {\r\n              // Send to dead letter queue\r\n              await this.sendToDeadLetter(\r\n                message,\r\n                `Message stuck in processing for ${processingTime}ms (exceeded max retries)`\r\n              );\r\n\r\n              // Remove from processing\r\n              await this.redis.lRem(processingKey, 1, messageData);\r\n\r\n              logger.info('Stuck message sent to DLQ', {\r\n                messageId: message.id,\r\n                deliveryAttempts: message.deliveryAttempts,\r\n              });\r\n            } else {\r\n              // Re-enqueue for retry\r\n              message.deliveryAttempts++;\r\n              message.metadata = {\r\n                ...message.metadata,\r\n                recoveredAt: new Date().toISOString(),\r\n                recoveryReason: 'Stuck in processing',\r\n              };\r\n\r\n              // Remove from processing and add back to queue\r\n              await this.redis.lRem(processingKey, 1, messageData);\r\n              await this.redis.rPush(queueKey, JSON.stringify(message));\r\n\r\n              recoveredCount++;\r\n              this.stats.totalRecovered++;\r\n\r\n              logger.info('Stuck message re-enqueued', {\r\n                messageId: message.id,\r\n                deliveryAttempts: message.deliveryAttempts,\r\n              });\r\n            }\r\n          }\r\n        }\r\n      }\r\n\r\n      if (recoveredCount > 0) {\r\n        this.stats.lastRecoveryAt = new Date();\r\n      }\r\n\r\n      logger.debug('Stuck message recovery complete', {\r\n        queue,\r\n        recoveredCount,\r\n        totalStuckDetected: this.stats.totalStuckDetected,\r\n      });\r\n\r\n      return recoveredCount;\r\n    } catch (error) {\r\n      logger.error('Failed to recover stuck messages', error instanceof Error ? error : new Error(String(error)), {\r\n        queue,\r\n      });\r\n\r\n      throw createError(\r\n        ErrorCode.DB_QUERY_FAILED,\r\n        'Failed to recover stuck messages',\r\n        { queue },\r\n        error instanceof Error ? error : undefined\r\n      );\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Recover from coordinator crash\r\n   *\r\n   * Scans all queues for stuck messages and recovers them.\r\n   *\r\n   * @returns Object with recovery results per queue\r\n   */\r\n  public async recoverFromCrash(): Promise<Record<string, number>> {\r\n    try {\r\n      logger.info('Starting coordinator crash recovery');\r\n\r\n      // Get all queues\r\n      const queues = await this.queueManager.getQueues();\r\n\r\n      const results: Record<string, number> = {};\r\n\r\n      // Recover stuck messages from each queue\r\n      for (const queue of queues) {\r\n        // Skip dead letter queue\r\n        if (queue === this.options.deadLetterQueue) {\r\n          continue;\r\n        }\r\n\r\n        const recovered = await this.recoverStuckMessages(queue);\r\n        results[queue] = recovered;\r\n      }\r\n\r\n      const totalRecovered = Object.values(results).reduce((sum, count) => sum + count, 0);\r\n\r\n      logger.info('Coordinator crash recovery complete', {\r\n        queuesProcessed: queues.length,\r\n        totalRecovered,\r\n        results,\r\n      });\r\n\r\n      return results;\r\n    } catch (error) {\r\n      logger.error('Coordinator crash recovery failed', error instanceof Error ? error : new Error(String(error)));\r\n\r\n      throw createError(\r\n        ErrorCode.DB_QUERY_FAILED,\r\n        'Failed to recover from coordinator crash',\r\n        {},\r\n        error instanceof Error ? error : undefined\r\n      );\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Start automatic monitoring for stuck messages\r\n   */\r\n  public startMonitoring(): void {\r\n    if (this.monitoringTimer) {\r\n      logger.warn('Monitoring already started');\r\n      return;\r\n    }\r\n\r\n    this.monitoringTimer = setInterval(\r\n      async () => {\r\n        try {\r\n          await this.recoverFromCrash();\r\n\r\n          // Auto-reprocess dead letters if enabled\r\n          if (this.options.autoReprocess) {\r\n            await this.reprocessDeadLetters(async (payload, metadata) => {\r\n              logger.debug('Auto-reprocessing dead letter', {\r\n                originalQueue: metadata.originalQueue,\r\n              });\r\n\r\n              // Re-enqueue to original queue\r\n              await this.queueManager.enqueue(metadata.originalQueue, payload, {\r\n                deduplicate: false,\r\n                metadata: {\r\n                  ...metadata,\r\n                  reprocessedAt: new Date().toISOString(),\r\n                },\r\n              });\r\n            });\r\n          }\r\n        } catch (error) {\r\n          logger.error('Monitoring cycle failed', error instanceof Error ? error : new Error(String(error)));\r\n        }\r\n      },\r\n      this.options.monitoringIntervalMs\r\n    );\r\n\r\n    logger.info('Monitoring started', {\r\n      intervalMs: this.options.monitoringIntervalMs,\r\n      autoReprocess: this.options.autoReprocess,\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Stop automatic monitoring\r\n   */\r\n  public stopMonitoring(): void {\r\n    if (this.monitoringTimer) {\r\n      clearInterval(this.monitoringTimer);\r\n      this.monitoringTimer = null;\r\n      logger.info('Monitoring stopped');\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Get recovery statistics\r\n   *\r\n   * @returns Current statistics\r\n   */\r\n  public getStats(): RecoveryStats {\r\n    return { ...this.stats };\r\n  }\r\n\r\n  /**\r\n   * Reset statistics\r\n   */\r\n  public resetStats(): void {\r\n    this.stats = {\r\n      totalRecovered: 0,\r\n      totalDeadLettered: 0,\r\n      totalReprocessed: 0,\r\n      totalStuckDetected: 0,\r\n    };\r\n\r\n    logger.debug('Statistics reset');\r\n  }\r\n\r\n  /**\r\n   * Shutdown recovery system (stop monitoring)\r\n   */\r\n  public shutdown(): void {\r\n    this.stopMonitoring();\r\n    logger.info('QueueRecovery shutdown');\r\n  }\r\n\r\n  /**\r\n   * Calculate exponential backoff delay\r\n   *\r\n   * @param attempt - Current attempt number (1-based)\r\n   * @returns Delay in milliseconds\r\n   */\r\n  private calculateBackoffDelay(attempt: number): number {\r\n    // Exponential backoff: baseDelay * 2^(attempt - 1)\r\n    const delay = this.options.baseRetryDelayMs * Math.pow(2, attempt - 1);\r\n\r\n    // Cap at max delay\r\n    const cappedDelay = Math.min(delay, this.options.maxRetryDelayMs);\r\n\r\n    // Add jitter (+/- 10%) to prevent thundering herd\r\n    const jitterFactor = 0.1;\r\n    const jitterRange = cappedDelay * jitterFactor;\r\n    const jitter = (Math.random() * 2 - 1) * jitterRange;\r\n\r\n    return Math.max(0, Math.floor(cappedDelay + jitter));\r\n  }\r\n}\r\n\r\n/**\r\n * Message reprocessing safeguards\r\n */\r\nexport class ReprocessingSafeguards {\r\n  private processedMessages: Set<string> = new Set();\r\n  private maxProcessedTracking: number;\r\n\r\n  /**\r\n   * Create a new ReprocessingSafeguards instance\r\n   *\r\n   * @param maxProcessedTracking - Maximum number of processed message IDs to track (default: 10000)\r\n   */\r\n  constructor(maxProcessedTracking: number = 10000) {\r\n    this.maxProcessedTracking = maxProcessedTracking;\r\n\r\n    logger.debug('ReprocessingSafeguards initialized', {\r\n      maxProcessedTracking,\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Check if message has already been processed\r\n   *\r\n   * @param messageId - Message ID to check\r\n   * @returns True if already processed\r\n   */\r\n  public hasBeenProcessed(messageId: string): boolean {\r\n    return this.processedMessages.has(messageId);\r\n  }\r\n\r\n  /**\r\n   * Mark message as processed\r\n   *\r\n   * @param messageId - Message ID to mark\r\n   */\r\n  public markProcessed(messageId: string): void {\r\n    // Implement simple LRU-like behavior\r\n    if (this.processedMessages.size >= this.maxProcessedTracking) {\r\n      // Remove oldest entry (first in Set)\r\n      const firstId = this.processedMessages.values().next().value;\r\n      this.processedMessages.delete(firstId);\r\n    }\r\n\r\n    this.processedMessages.add(messageId);\r\n  }\r\n\r\n  /**\r\n   * Clear all processed message tracking\r\n   */\r\n  public clear(): void {\r\n    this.processedMessages.clear();\r\n    logger.debug('Processed messages cleared');\r\n  }\r\n\r\n  /**\r\n   * Get number of tracked processed messages\r\n   */\r\n  public getTrackedCount(): number {\r\n    return this.processedMessages.size;\r\n  }\r\n}\r\n"],"names":["createLogger","createError","ErrorCode","isRetryableError","sleep","logger","DEFAULT_RECOVERY_OPTIONS","maxRetries","baseRetryDelayMs","maxRetryDelayMs","processingTimeoutMs","monitoringIntervalMs","deadLetterQueue","autoReprocess","QueueRecovery","queueManager","redis","options","monitoringTimer","stats","totalRecovered","totalDeadLettered","totalReprocessed","totalStuckDetected","info","retryWithBackoff","message","processFn","maxAttempts","attempt","deliveryAttempts","debug","messageId","id","result","payload","error","err","Error","String","warn","retryable","sendToDeadLetter","delay","calculateBackoffDelay","delayMs","RETRY_EXHAUSTED","attempts","reason","metadata","originalQueue","queue","failureReason","retryAttempts","deadLetteredAt","Date","originalMetadata","enqueue","deduplicate","DB_QUERY_FAILED","undefined","reprocessDeadLetters","maxMessages","reprocessedCount","i","dequeue","timeout","acknowledge","reject","retry","recoverStuckMessages","processingKey","queueKey","processingMessages","lRange","recoveredCount","now","messageData","JSON","parse","dequeuedAt","processingTime","getTime","processingTimeMs","timeoutMs","lRem","recoveredAt","toISOString","recoveryReason","rPush","stringify","lastRecoveryAt","recoverFromCrash","queues","getQueues","results","recovered","Object","values","reduce","sum","count","queuesProcessed","length","startMonitoring","setInterval","reprocessedAt","intervalMs","stopMonitoring","clearInterval","getStats","resetStats","shutdown","Math","pow","cappedDelay","min","jitterFactor","jitterRange","jitter","random","max","floor","ReprocessingSafeguards","processedMessages","Set","maxProcessedTracking","hasBeenProcessed","has","markProcessed","size","firstId","next","value","delete","add","clear","getTrackedCount"],"mappings":"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"}

package/dist/lib/redis-queue-manager.js

@@ -0,0 +1,512 @@
+/**
+ * Redis Queue Manager
+ *
+ * Provides reliable queue operations with idempotency, acknowledgment protocol,
+ * and message visibility timeout for Docker agent ↔ Redis communication.
+ * Part of Task 3.4: Redis Queue Consistency & Recovery (Integration Standardization Sprint 3)
+ *
+ * Features:
+ * - Enqueue with idempotency (prevents duplicate messages)
+ * - Dequeue with acknowledgment protocol
+ * - Message visibility timeout
+ * - Queue monitoring (depth, age, throughput)
+ * - Multiple queue support (task, result, coordination)
+ * - Performance: <100ms per operation
+ *
+ * Usage:
+ *   const queueManager = new RedisQueueManager(redisClient);
+ *
+ *   // Producer
+ *   await queueManager.enqueue('task-queue', {
+ *     taskId: 'task-001',
+ *     agentType: 'backend-developer',
+ *     payload: { ... }
+ *   });
+ *
+ *   // Consumer
+ *   const message = await queueManager.dequeue('task-queue', { timeout: 30000 });
+ *   try {
+ *     await processTask(message.payload);
+ *     await queueManager.acknowledge(message.id);
+ *   } catch (error) {
+ *     await queueManager.reject(message.id, { retry: true });
+ *   }
+ */ import { v4 as uuidv4 } from 'uuid';
+import { createLogger } from './logging.js';
+import { createError, ErrorCode, isRetryableError } from './errors.js';
+import { withRetry } from './retry.js';
+import { MessageDeduplicator } from './message-deduplicator.js';
+const logger = createLogger('redis-queue-manager');
+/**
+ * Default queue options
+ */ const DEFAULT_ENQUEUE_OPTIONS = {
+    deduplicate: true,
+    metadata: {},
+    visibilityTimeout: 30000
+};
+const DEFAULT_DEQUEUE_OPTIONS = {
+    timeout: 0,
+    visibilityTimeout: 30000,
+    count: 1
+};
+/**
+ * Redis Queue Manager
+ *
+ * Provides reliable queue operations with at-least-once delivery guarantees.
+ */ export class RedisQueueManager {
+    redis;
+    deduplicator;
+    stats = new Map();
+    /**
+   * Create a new RedisQueueManager instance
+   *
+   * @param redis - Redis client instance
+   * @param deduplicator - Optional custom deduplicator instance
+   */ constructor(redis, deduplicator){
+        this.redis = redis;
+        this.deduplicator = deduplicator || new MessageDeduplicator(redis);
+        logger.info('RedisQueueManager initialized');
+    }
+    /**
+   * Enqueue a message to a queue
+   *
+   * @param queue - Queue name
+   * @param payload - Message payload
+   * @param options - Enqueue options
+   * @returns Message ID
+   */ async enqueue(queue, payload, options = {}) {
+        const opts = {
+            ...DEFAULT_ENQUEUE_OPTIONS,
+            ...options
+        };
+        const startTime = Date.now();
+        try {
+            // Check for duplicates if enabled
+            if (opts.deduplicate) {
+                const isDuplicate = await this.deduplicator.isDuplicate(payload);
+                if (isDuplicate) {
+                    logger.warn('Duplicate message detected, skipping enqueue', {
+                        queue,
+                        payloadHash: this.deduplicator.createFingerprint(payload).substring(0, 16) + '...'
+                    });
+                    throw createError(ErrorCode.DB_DUPLICATE_KEY, 'Duplicate message detected', {
+                        queue
+                    });
+                }
+            }
+            // Create message
+            const message = {
+                id: uuidv4(),
+                queue,
+                payload,
+                createdAt: new Date(),
+                enqueuedAt: new Date(),
+                deliveryAttempts: 0,
+                visibilityTimeout: opts.visibilityTimeout,
+                metadata: opts.metadata
+            };
+            // Push to queue (RPUSH for FIFO)
+            await withRetry(async ()=>{
+                const queueKey = this.getQueueKey(queue);
+                await this.redis.rPush(queueKey, JSON.stringify(message));
+            }, {
+                maxAttempts: 3,
+                shouldRetry: isRetryableError
+            });
+            // Mark as processed in deduplicator if enabled
+            if (opts.deduplicate) {
+                await this.deduplicator.markProcessed(payload, {
+                    messageId: message.id,
+                    queue
+                });
+            }
+            // Update stats
+            this.updateStats(queue, 'enqueued');
+            const duration = Date.now() - startTime;
+            logger.debug('Message enqueued', {
+                queue,
+                messageId: message.id,
+                durationMs: duration
+            });
+            // Validate performance requirement (<100ms)
+            if (duration > 100) {
+                logger.warn('Enqueue operation exceeded 100ms target', {
+                    queue,
+                    durationMs: duration
+                });
+            }
+            return message.id;
+        } catch (error) {
+            logger.error('Failed to enqueue message', error instanceof Error ? error : new Error(String(error)), {
+                queue
+            });
+            throw createError(ErrorCode.DB_QUERY_FAILED, 'Failed to enqueue message', {
+                queue
+            }, error instanceof Error ? error : undefined);
+        }
+    }
+    /**
+   * Dequeue a message from a queue
+   *
+   * @param queue - Queue name
+   * @param options - Dequeue options
+   * @returns Message or null if queue is empty
+   */ async dequeue(queue, options = {}) {
+        const opts = {
+            ...DEFAULT_DEQUEUE_OPTIONS,
+            ...options
+        };
+        const startTime = Date.now();
+        try {
+            const queueKey = this.getQueueKey(queue);
+            const processingKey = this.getProcessingKey(queue);
+            let messageData = null;
+            // Use blocking pop if timeout specified
+            if (opts.timeout > 0) {
+                const result = await withRetry(async ()=>{
+                    // BLMOVE atomically moves from queue to processing set with timeout
+                    return await this.redis.blMove(queueKey, processingKey, 'LEFT', 'RIGHT', opts.timeout / 1000 // Convert to seconds
+                    );
+                }, {
+                    maxAttempts: 1
+                } // Don't retry blocking operations
+                );
+                messageData = result;
+            } else {
+                // Non-blocking pop
+                messageData = await withRetry(async ()=>{
+                    return await this.redis.lMove(queueKey, processingKey, 'LEFT', 'RIGHT');
+                }, {
+                    maxAttempts: 3,
+                    shouldRetry: isRetryableError
+                });
+            }
+            if (!messageData) {
+                return null;
+            }
+            // Parse message
+            const message = JSON.parse(messageData);
+            // Convert date strings back to Date objects
+            message.createdAt = new Date(message.createdAt);
+            message.enqueuedAt = new Date(message.enqueuedAt);
+            message.dequeuedAt = new Date();
+            message.deliveryAttempts++;
+            // Store message with visibility timeout
+            await this.storeInFlight(message, opts.visibilityTimeout);
+            // Update stats
+            this.updateStats(queue, 'dequeued');
+            const duration = Date.now() - startTime;
+            logger.debug('Message dequeued', {
+                queue,
+                messageId: message.id,
+                deliveryAttempts: message.deliveryAttempts,
+                durationMs: duration
+            });
+            // Validate performance requirement (<100ms)
+            if (duration > 100) {
+                logger.warn('Dequeue operation exceeded 100ms target', {
+                    queue,
+                    durationMs: duration
+                });
+            }
+            return message;
+        } catch (error) {
+            logger.error('Failed to dequeue message', error instanceof Error ? error : new Error(String(error)), {
+                queue
+            });
+            throw createError(ErrorCode.DB_QUERY_FAILED, 'Failed to dequeue message', {
+                queue
+            }, error instanceof Error ? error : undefined);
+        }
+    }
+    /**
+   * Acknowledge successful message processing
+   *
+   * @param messageId - Message ID to acknowledge
+   */ async acknowledge(messageId) {
+        const startTime = Date.now();
+        try {
+            // Remove from in-flight storage
+            const message = await this.getInFlight(messageId);
+            if (!message) {
+                logger.warn('Message not found for acknowledgment', {
+                    messageId
+                });
+                return;
+            }
+            // Remove from processing set
+            const processingKey = this.getProcessingKey(message.queue);
+            await withRetry(async ()=>{
+                await this.redis.lRem(processingKey, 1, JSON.stringify(message));
+            }, {
+                maxAttempts: 3,
+                shouldRetry: isRetryableError
+            });
+            // Remove from in-flight storage
+            await this.removeInFlight(messageId);
+            // Update stats
+            this.updateStats(message.queue, 'acknowledged');
+            const duration = Date.now() - startTime;
+            logger.debug('Message acknowledged', {
+                queue: message.queue,
+                messageId,
+                durationMs: duration
+            });
+        } catch (error) {
+            logger.error('Failed to acknowledge message', error instanceof Error ? error : new Error(String(error)), {
+                messageId
+            });
+            throw createError(ErrorCode.DB_QUERY_FAILED, 'Failed to acknowledge message', {
+                messageId
+            }, error instanceof Error ? error : undefined);
+        }
+    }
+    /**
+   * Reject message processing (with optional retry)
+   *
+   * @param messageId - Message ID to reject
+   * @param options - Reject options
+   */ async reject(messageId, options = {}) {
+        const startTime = Date.now();
+        try {
+            // Get message from in-flight storage
+            const message = await this.getInFlight(messageId);
+            if (!message) {
+                logger.warn('Message not found for rejection', {
+                    messageId
+                });
+                return;
+            }
+            // Remove from processing set
+            const processingKey = this.getProcessingKey(message.queue);
+            await withRetry(async ()=>{
+                await this.redis.lRem(processingKey, 1, JSON.stringify(message));
+            }, {
+                maxAttempts: 3,
+                shouldRetry: isRetryableError
+            });
+            // Remove from in-flight storage
+            await this.removeInFlight(messageId);
+            if (options.retry) {
+                // Re-enqueue message
+                message.metadata = {
+                    ...message.metadata,
+                    ...options.metadata,
+                    rejectedAt: new Date().toISOString(),
+                    rejectionReason: options.error
+                };
+                const queueKey = this.getQueueKey(message.queue);
+                await withRetry(async ()=>{
+                    await this.redis.rPush(queueKey, JSON.stringify(message));
+                }, {
+                    maxAttempts: 3,
+                    shouldRetry: isRetryableError
+                });
+                logger.debug('Message rejected and re-enqueued', {
+                    queue: message.queue,
+                    messageId,
+                    deliveryAttempts: message.deliveryAttempts
+                });
+            } else {
+                logger.debug('Message rejected without retry', {
+                    queue: message.queue,
+                    messageId
+                });
+            }
+            // Update stats
+            this.updateStats(message.queue, 'rejected');
+            const duration = Date.now() - startTime;
+            logger.debug('Message rejected', {
+                queue: message.queue,
+                messageId,
+                retry: options.retry,
+                durationMs: duration
+            });
+        } catch (error) {
+            logger.error('Failed to reject message', error instanceof Error ? error : new Error(String(error)), {
+                messageId
+            });
+            throw createError(ErrorCode.DB_QUERY_FAILED, 'Failed to reject message', {
+                messageId
+            }, error instanceof Error ? error : undefined);
+        }
+    }
+    /**
+   * Get queue statistics
+   *
+   * @param queue - Queue name
+   * @returns Queue statistics
+   */ async getStats(queue) {
+        try {
+            const queueKey = this.getQueueKey(queue);
+            const processingKey = this.getProcessingKey(queue);
+            // Get queue depth
+            const depth = await this.redis.lLen(queueKey);
+            // Get in-flight count
+            const inFlight = await this.redis.lLen(processingKey);
+            // Get oldest message age
+            let oldestMessageAge = 0;
+            const oldestMessage = await this.redis.lIndex(queueKey, 0);
+            if (oldestMessage) {
+                const message = JSON.parse(oldestMessage);
+                const age = Date.now() - new Date(message.enqueuedAt).getTime();
+                oldestMessageAge = Math.floor(age / 1000); // Convert to seconds
+            }
+            // Get stats from tracking
+            const stats = this.stats.get(queue) || {
+                enqueued: 0,
+                dequeued: 0,
+                acknowledged: 0,
+                rejected: 0,
+                startTime: new Date()
+            };
+            // Calculate throughput (messages per second)
+            const elapsed = (Date.now() - stats.startTime.getTime()) / 1000;
+            const throughput = elapsed > 0 ? stats.dequeued / elapsed : 0;
+            return {
+                queue,
+                depth,
+                inFlight,
+                oldestMessageAge,
+                totalEnqueued: stats.enqueued,
+                totalDequeued: stats.dequeued,
+                totalAcknowledged: stats.acknowledged,
+                totalRejected: stats.rejected,
+                throughput
+            };
+        } catch (error) {
+            logger.error('Failed to get queue stats', error instanceof Error ? error : new Error(String(error)), {
+                queue
+            });
+            throw createError(ErrorCode.DB_QUERY_FAILED, 'Failed to get queue stats', {
+                queue
+            }, error instanceof Error ? error : undefined);
+        }
+    }
+    /**
+   * Purge all messages from a queue
+   *
+   * @param queue - Queue name
+   * @returns Number of messages purged
+   */ async purge(queue) {
+        try {
+            const queueKey = this.getQueueKey(queue);
+            const count = await withRetry(async ()=>{
+                const len = await this.redis.lLen(queueKey);
+                await this.redis.del(queueKey);
+                return len;
+            }, {
+                maxAttempts: 3,
+                shouldRetry: isRetryableError
+            });
+            logger.info('Queue purged', {
+                queue,
+                messagesPurged: count
+            });
+            return count;
+        } catch (error) {
+            logger.error('Failed to purge queue', error instanceof Error ? error : new Error(String(error)), {
+                queue
+            });
+            throw createError(ErrorCode.DB_QUERY_FAILED, 'Failed to purge queue', {
+                queue
+            }, error instanceof Error ? error : undefined);
+        }
+    }
+    /**
+   * Get all queue names
+   *
+   * @returns Array of queue names
+   */ async getQueues() {
+        try {
+            const pattern = 'queue:*';
+            const keys = await this.redis.keys(pattern);
+            const queues = keys.filter((key)=>!key.includes(':processing')).map((key)=>key.replace('queue:', ''));
+            return queues;
+        } catch (error) {
+            logger.error('Failed to get queues', error instanceof Error ? error : new Error(String(error)));
+            throw createError(ErrorCode.DB_QUERY_FAILED, 'Failed to get queues', {}, error instanceof Error ? error : undefined);
+        }
+    }
+    /**
+   * Shutdown queue manager (cleanup resources)
+   */ shutdown() {
+        this.deduplicator.shutdown();
+        logger.info('RedisQueueManager shutdown');
+    }
+    /**
+   * Get Redis key for queue
+   */ getQueueKey(queue) {
+        return `queue:${queue}`;
+    }
+    /**
+   * Get Redis key for processing set
+   */ getProcessingKey(queue) {
+        return `queue:${queue}:processing`;
+    }
+    /**
+   * Get Redis key for in-flight message storage
+   */ getInFlightKey(messageId) {
+        return `inflight:${messageId}`;
+    }
+    /**
+   * Store message in in-flight storage with TTL
+   */ async storeInFlight(message, visibilityTimeout) {
+        const key = this.getInFlightKey(message.id);
+        await withRetry(async ()=>{
+            await this.redis.set(key, JSON.stringify(message), {
+                PX: visibilityTimeout
+            });
+        }, {
+            maxAttempts: 3,
+            shouldRetry: isRetryableError
+        });
+    }
+    /**
+   * Get message from in-flight storage
+   */ async getInFlight(messageId) {
+        const key = this.getInFlightKey(messageId);
+        const data = await withRetry(async ()=>await this.redis.get(key), {
+            maxAttempts: 3,
+            shouldRetry: isRetryableError
+        });
+        if (!data) {
+            return null;
+        }
+        const message = JSON.parse(data);
+        // Convert date strings back to Date objects
+        message.createdAt = new Date(message.createdAt);
+        message.enqueuedAt = new Date(message.enqueuedAt);
+        if (message.dequeuedAt) {
+            message.dequeuedAt = new Date(message.dequeuedAt);
+        }
+        return message;
+    }
+    /**
+   * Remove message from in-flight storage
+   */ async removeInFlight(messageId) {
+        const key = this.getInFlightKey(messageId);
+        await withRetry(async ()=>await this.redis.del(key), {
+            maxAttempts: 3,
+            shouldRetry: isRetryableError
+        });
+    }
+    /**
+   * Update queue statistics
+   */ updateStats(queue, operation) {
+        let stats = this.stats.get(queue);
+        if (!stats) {
+            stats = {
+                enqueued: 0,
+                dequeued: 0,
+                acknowledged: 0,
+                rejected: 0,
+                startTime: new Date()
+            };
+            this.stats.set(queue, stats);
+        }
+        stats[operation]++;
+    }
+}
+
+//# sourceMappingURL=redis-queue-manager.js.map