@arela/uploader 1.1.4 → 1.2.0

package/.claude/worktrees/agent-multi-profile/src/commands/PollWorkerCommand.js

@@ -0,0 +1,169 @@
+import logger from '../services/LoggingService.js';
+import { PipelineApiService } from '../services/PipelineApiService.js';
+import { PipelineJobRunner } from '../services/PipelineJobRunner.js';
+
+import appConfig from '../config/config.js';
+import ErrorHandler from '../errors/ErrorHandler.js';
+
+/**
+ * Poll Worker Command Handler
+ * Runs arela-uploader as an HTTP-polling worker, fetching jobs from the API.
+ * Alternative to BullMQ/Redis-based worker for environments without Redis access.
+ * Job execution lives in PipelineJobRunner (shared with `arela agent`).
+ *
+ * Usage:
+ *   arela worker --poll
+ *   arela worker --poll --interval 10000
+ *
+ * Environment variables:
+ *   WORKER_POLL_INTERVAL - Polling interval in ms (default: 5000)
+ *   WORKER_POLL_API_TARGET - API target for polling (default: 'agencia')
+ *   ARELA_SERVER_ID - Server identifier for job assignment
+ */
+export class PollWorkerCommand {
+  constructor() {
+    this.errorHandler = new ErrorHandler(logger);
+    this.isShuttingDown = false;
+    this.currentJob = null;
+    this.pipelineApi = null;
+    this.jobRunner = null;
+    this.pollTimer = null;
+  }
+
+  /**
+   * Execute the poll worker command
+   * @param {Object} options - Command options
+   * @param {number} options.interval - Polling interval in milliseconds
+   * @param {string} options.api - API target for polling
+   */
+  async execute(options = {}) {
+    try {
+      const workerConfig = appConfig.getWorkerConfig();
+      const pollConfig = workerConfig.poll;
+
+      // Get configuration
+      const interval = parseInt(options.interval) || pollConfig.interval;
+      const apiTarget = options.api || pollConfig.apiTarget;
+      const serverId = appConfig.getServerId();
+
+      if (!serverId) {
+        throw new Error(
+          'ARELA_SERVER_ID is required for poll mode. Set it in your .env file.',
+        );
+      }
+
+      this.serverId = serverId;
+
+      // Initialize Pipeline API service and the shared job runner
+      this.pipelineApi = new PipelineApiService(apiTarget);
+      this.jobRunner = new PipelineJobRunner(this.pipelineApi, serverId);
+
+      console.log('\n🔧 Starting Arela Poll Worker');
+      console.log(`📡 API Target: ${apiTarget}`);
+      console.log(`🖥️  Server ID: ${serverId}`);
+      console.log(`⏱️  Poll Interval: ${interval}ms`);
+
+      logger.info('🔧 Starting Arela Poll Worker');
+      logger.info(`📡 API Target: ${apiTarget}`);
+      logger.info(`🖥️  Server ID: ${serverId}`);
+      logger.info(`⏱️  Poll Interval: ${interval}ms`);
+
+      // Setup graceful shutdown handlers
+      this.#setupShutdownHandlers();
+
+      // Start polling loop
+      await this.#startPolling(serverId, interval);
+    } catch (error) {
+      logger.error('❌ Poll Worker failed to start:', error.message);
+      throw error;
+    }
+  }
+
+  /**
+   * Start the polling loop
+   * @private
+   */
+  async #startPolling(serverId, interval) {
+    console.log('\n✅ Poll Worker is running. Press Ctrl+C to stop.\n');
+    logger.success('Poll Worker is running');
+
+    while (!this.isShuttingDown) {
+      try {
+        // Check for next job
+        const job = await this.pipelineApi.getNextJob(serverId);
+
+        if (job && job.id) {
+          console.log(`📥 Got job: ${job.type} for RFC ${job.rfc}`);
+          logger.info(`📥 Got job: ${job.id} - ${job.type} for RFC ${job.rfc}`);
+          this.currentJob = job;
+          try {
+            await this.jobRunner.processJob(job);
+          } finally {
+            this.currentJob = null;
+          }
+        } else {
+          // Only log to file, not console (too noisy)
+          logger.debug('📭 No jobs available, waiting...');
+        }
+      } catch (error) {
+        console.error(`❌ Polling error: ${error.message}`);
+        logger.error(`❌ Polling error: ${error.message}`);
+      }
+
+      // Wait for next poll (unless shutting down)
+      if (!this.isShuttingDown) {
+        await this.#sleep(interval);
+      }
+    }
+  }
+
+  /**
+   * Sleep for specified milliseconds
+   * @private
+   */
+  #sleep(ms) {
+    return new Promise((resolve) => {
+      this.pollTimer = setTimeout(resolve, ms);
+    });
+  }
+
+  /**
+   * Setup graceful shutdown handlers
+   * @private
+   */
+  #setupShutdownHandlers() {
+    const shutdown = async (signal) => {
+      if (this.isShuttingDown) return;
+      this.isShuttingDown = true;
+
+      logger.info(`\n👋 Received ${signal}. Shutting down poll worker...`);
+
+      // Clear poll timer
+      if (this.pollTimer) {
+        clearTimeout(this.pollTimer);
+      }
+
+      // Wait for current job to finish if any
+      if (this.currentJob) {
+        logger.info(
+          `  ⏳ Waiting for current job to finish: ${this.currentJob.id}`,
+        );
+        // Give it a moment to complete
+        await this.#sleep(2000);
+      }
+
+      // Cleanup
+      if (this.pipelineApi) {
+        this.pipelineApi.destroy();
+      }
+
+      logger.info('✅ Poll worker stopped gracefully');
+      process.exit(0);
+    };
+
+    process.on('SIGINT', () => shutdown('SIGINT'));
+    process.on('SIGTERM', () => shutdown('SIGTERM'));
+  }
+}
+
+export default new PollWorkerCommand();