@arela/uploader 1.1.3 → 1.2.0

package/.claude/worktrees/agent-multi-profile/src/index.js

@@ -0,0 +1,890 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+
+import agentCommand from './commands/AgentCommand.js';
+import agentInitCommand from './commands/AgentInitCommand.js';
+import datastageCommand from './commands/DatastageCommand.js';
+import gdriveSyncCommand from './commands/GDriveSyncCommand.js';
+import identifyCommand from './commands/IdentifyCommand.js';
+import pollWorkerCommand from './commands/PollWorkerCommand.js';
+import PropagateCommand from './commands/PropagateCommand.js';
+import PushCommand from './commands/PushCommand.js';
+import scanCommand from './commands/ScanCommand.js';
+import UploadCommand from './commands/UploadCommand.js';
+import watchCommand from './commands/WatchCommand.js';
+import workerCommand from './commands/WorkerCommand.js';
+import appConfig from './config/config.js';
+import ErrorHandler from './errors/ErrorHandler.js';
+import { getCurrentPdfFile } from './file-detection.js';
+import logger from './services/LoggingService.js';
+
+// Exception names thrown by pdf.js (used via pdf-parse) when a PDF is
+// malformed, encrypted, or truncated. Matched by error.name because the
+// classes live inside pdfjs-dist and are not exported by pdf-parse.
+const PDFJS_PARSE_ERRORS = new Set([
+  'XRefEntryException',
+  'XRefParseException',
+  'InvalidPDFException',
+  'MissingPDFException',
+  'PasswordException',
+  'FormatError',
+]);
+
+/**
+ * Arela Uploader CLI
+ * Professional file uploader with document detection and organization
+ */
+class ArelaUploaderCLI {
+  constructor() {
+    this.program = new Command();
+    this.errorHandler = new ErrorHandler(logger);
+    this.identifyCommand = identifyCommand;
+    this.scanCommand = scanCommand;
+    this.uploadCommand = new UploadCommand();
+    this.watchCommand = watchCommand;
+    this.datastageCommand = datastageCommand;
+
+    this.#setupProgram();
+    this.#setupCommands();
+    this.#setupErrorHandling();
+  }
+
+  /**
+   * Setup the main program configuration
+   * @private
+   */
+  #setupProgram() {
+    this.program
+      .name('arela')
+      .description(
+        'CLI to upload files/directories to Arela with automatic processing',
+      )
+      .version(appConfig.packageVersion)
+      .option('-v, --verbose', 'Enable verbose logging')
+      .option('--clear-log', 'Clear the log file before starting');
+  }
+
+  /**
+   * Setup CLI commands
+   * @private
+   */
+  #setupCommands() {
+    // Main upload command
+    this.program
+      .command('upload')
+      .description('Upload files to Arela with automatic processing')
+      .option(
+        '--api <target>',
+        'API target: default|agencia|cliente',
+        'default',
+      )
+      .option(
+        '--source-api <target>',
+        'Source API for reading data (cross-tenant mode): agencia|cliente',
+      )
+      .option(
+        '--target-api <target>',
+        'Target API for uploading files (cross-tenant mode): agencia|cliente',
+      )
+      .option(
+        '-b, --batch-size <size>',
+        'Number of files to process in each batch',
+        '10',
+      )
+      .option('-p, --prefix <prefix>', 'Prefix for uploaded files')
+      .option(
+        '--folder-structure <structure>',
+        'Custom folder structure for organization',
+      )
+      .option('--client-path <path>', 'Override client path for metadata')
+      .option(
+        '--auto-detect-structure',
+        'Automatically detect folder structure from file paths',
+      )
+      .option('--auto-detect', 'Enable automatic document type detection')
+      .option('--auto-organize', 'Enable automatic file organization')
+      .option('--force-supabase', 'Force direct Supabase upload mode')
+      .option('--skip-processed', 'Skip files that have already been processed')
+      .option('--show-stats', 'Show performance statistics')
+      .option(
+        '--upload-by-rfc',
+        'Upload files based on specific RFC values from UPLOAD_RFCS',
+      )
+      .option(
+        '--run-all-phases',
+        'Run all processing phases (stats, detection, organization)',
+      )
+      .action(async (options) => {
+        try {
+          // Handle cross-tenant mode (source and target APIs)
+          if (options.sourceApi && options.targetApi) {
+            appConfig.setCrossTenantTargets(
+              options.sourceApi,
+              options.targetApi,
+            );
+          } else if (options.api && options.api !== 'default') {
+            // Set single API target if specified
+            appConfig.setApiTarget(options.api);
+          }
+
+          // Handle --upload-by-rfc as a specific operation
+          if (options.uploadByRfc) {
+            const databaseService = await import(
+              './services/DatabaseService.js'
+            );
+            console.log('🎯 Running RFC-based upload...');
+            const result = await databaseService.default.uploadFilesByRfc({
+              batchSize: parseInt(options.batchSize) || 10,
+              showProgress: true,
+              folderStructure: options.folderStructure,
+              apiTarget: options.api,
+              sourceApi: options.sourceApi,
+              targetApi: options.targetApi,
+            });
+            console.log(
+              `✅ RFC upload completed: ${result.processedCount} processed, ${result.uploadedCount} uploaded, ${result.errorCount} errors`,
+            );
+            return;
+          }
+
+          await this.uploadCommand.execute(options);
+        } catch (error) {
+          this.errorHandler.handleFatalError(error, { command: 'upload' });
+        }
+      });
+
+    // Stats-only command
+    this.program
+      .command('stats')
+      .description('Collect file statistics without uploading')
+      .option(
+        '--api <target>',
+        'API target: agencia|cliente|default',
+        'default',
+      )
+      .option(
+        '-b, --batch-size <size>',
+        'Number of files to process in each batch',
+        '10',
+      )
+      .option('--client-path <path>', 'Override client path for metadata')
+      .option(
+        '--stats-only',
+        'Collect file statistics without uploading (backward compatibility)',
+      )
+      .option(
+        '--run-all-phases',
+        'Run all processing phases (stats, detection, organization)',
+      )
+      .option('--show-stats', 'Show performance statistics')
+      .action(async (options) => {
+        try {
+          // Set API target if specified
+          if (options.api && options.api !== 'default') {
+            appConfig.setApiTarget(options.api);
+          }
+          const statsOptions = { ...options, statsOnly: true };
+          await this.uploadCommand.execute(statsOptions);
+        } catch (error) {
+          this.errorHandler.handleFatalError(error, { command: 'stats' });
+        }
+      });
+
+    // Scan command (optimized stats collection with streaming)
+    this.program
+      .command('scan')
+      .description(
+        'Scan filesystem and collect file statistics (optimized with streaming)',
+      )
+      .option(
+        '--api <target>',
+        'API target: agencia|cliente|default',
+        'default',
+      )
+      .option(
+        '--count-first',
+        'Count files first for percentage-based progress (slower start)',
+      )
+      .option(
+        '--no-stream',
+        'Use synchronous file discovery instead of streaming (original approach)',
+      )
+      .action(async (options) => {
+        try {
+          // Set API target if specified
+          if (options.api && options.api !== 'default') {
+            appConfig.setApiTarget(options.api);
+          }
+          await this.scanCommand.execute(options);
+        } catch (error) {
+          this.errorHandler.handleFatalError(error, { command: 'scan' });
+        }
+      });
+
+    // Datastage command — upload monthly datastage *.zip files from a directory
+    this.program
+      .command('datastage')
+      .description(
+        '📦 Upload monthly datastage *.zip files from a directory to Arela',
+      )
+      .requiredOption(
+        '--dir <path>',
+        'Directory containing *.zip files (non-recursive)',
+      )
+      .option(
+        '--api <target>',
+        'API target: default|agencia|cliente',
+        'default',
+      )
+      .option('--retry-failed', 'Re-attempt files in failed status')
+      .option('--show-stats', 'Print final stats summary')
+      .action(async (options) => {
+        try {
+          if (options.api && options.api !== 'default') {
+            appConfig.setApiTarget(options.api);
+          }
+          await this.datastageCommand.execute(options);
+        } catch (error) {
+          this.errorHandler.handleFatalError(error, { command: 'datastage' });
+        }
+      });
+
+    // Detection command
+    this.program
+      .command('detect')
+      .description('Run document detection on existing file records')
+      .option(
+        '--api <target>',
+        'API target: agencia|cliente|default',
+        'default',
+      )
+      .option(
+        '-b, --batch-size <size>',
+        'Number of files to process in each batch',
+        '10',
+      )
+      .option(
+        '--detect-pdfs',
+        'Run PDF detection on existing database records (backward compatibility)',
+      )
+      .option(
+        '--propagate-arela-path',
+        'Propagate arela_path from pedimento records to related files',
+      )
+      .action(async (options) => {
+        try {
+          // Set API target if specified
+          if (options.api && options.api !== 'default') {
+            appConfig.setApiTarget(options.api);
+          }
+
+          const databaseService = await import('./services/DatabaseService.js');
+
+          // Handle --propagate-arela-path as a specific operation
+          if (options.propagateArelaPath) {
+            console.log('🔄 Running arela_path propagation...');
+            const result = await databaseService.default.propagateArelaPath({
+              showProgress: true,
+            });
+            console.log(
+              `✅ Propagation completed: ${result.processedCount} processed, ${result.updatedCount} updated, ${result.errorCount} errors`,
+            );
+            return;
+          }
+
+          // Default behavior: run PDF detection
+          console.log(
+            '🔍 Running PDF detection on existing database records...',
+          );
+          const result =
+            await databaseService.default.detectPedimentosInDatabase({
+              batchSize: parseInt(options.batchSize) || 10,
+            });
+          console.log(
+            `✅ Detection completed: ${result.detectedCount} detected, ${result.processedCount} processed, ${result.errorCount} errors`,
+          );
+        } catch (error) {
+          this.errorHandler.handleFatalError(error, { command: 'detect' });
+        }
+      });
+
+    // Configuration command
+    this.program
+      .command('config')
+      .description('Show current configuration')
+      .action(() => {
+        try {
+          this.#showConfiguration();
+        } catch (error) {
+          this.errorHandler.handleFatalError(error, { command: 'config' });
+        }
+      });
+
+    // Query command for inspection
+    this.program
+      .command('query')
+      .description('Query database for file status and information')
+      .option(
+        '--ready-files',
+        'Show files that are ready for upload (detected but not uploaded)',
+      )
+      .action(async (options) => {
+        try {
+          const databaseService = await import('./services/DatabaseService.js');
+
+          if (options.readyFiles) {
+            console.log('🔍 Querying files ready for upload...');
+
+            const readyFiles =
+              await databaseService.default.getFilesReadyForUpload();
+
+            if (readyFiles.length === 0) {
+              console.log('ℹ️  No files are currently ready for upload');
+              console.log(
+                '   Tip: Run "arela detect" and "arela detect --propagate-arela-path" first to prepare files for upload',
+              );
+            } else {
+              console.log(
+                `\n📋 ${readyFiles.length} files are ready for upload!`,
+              );
+              console.log(
+                '   Use "arela upload --upload-by-rfc" to upload them to Arela API',
+              );
+            }
+            return;
+          }
+
+          // Default behavior: show help for query command
+          console.log('Available query options:');
+          console.log('  --ready-files    Show files ready for upload');
+        } catch (error) {
+          this.errorHandler.handleFatalError(error, { command: 'query' });
+        }
+      });
+
+    // ============================================================================
+    // NEW SIMPLIFIED COMMANDS (Optimized versions with better naming)
+    // ============================================================================
+
+    // Identify command - simplified version of "detect --detect-pdfs"
+    this.program
+      .command('identify')
+      .description('🔍 Identify document types using matchers (optimized)')
+      .option(
+        '--api <target>',
+        'API target: agencia|cliente|default',
+        'default',
+      )
+      .option(
+        '-b, --batch-size <size>',
+        'Number of files to process in each batch',
+        '100',
+      )
+      .option(
+        '--table <tableName>',
+        'Process only this scan table (instead of all instance tables)',
+      )
+      .option(
+        '--reset-attempts',
+        'Reset detection_attempts to 0 before processing so previously-failed files are retried',
+      )
+      .option(
+        '--path-prefix <mapping>',
+        'Remap file path prefix for cross-platform access. Format: FROM:TO  e.g. "O:/=/Volumes/nas/"',
+      )
+      .option('--show-stats', 'Show performance statistics')
+      .action(async (options) => {
+        try {
+          await this.identifyCommand.execute(options);
+        } catch (error) {
+          this.errorHandler.handleFatalError(error, { command: 'identify' });
+        }
+      });
+
+    // Propagate command - simplified version of "detect --propagate-arela-path"
+    this.program
+      .command('propagate')
+      .description(
+        '🔄 Propagate arela_path from pedimentos to related files (optimized)',
+      )
+      .option(
+        '--api <target>',
+        'API target: agencia|cliente|default',
+        'default',
+      )
+      .option(
+        '-b, --batch-size <size>',
+        'Number of pedimentos to process per batch',
+        '50',
+      )
+      .option('--show-stats', 'Show performance statistics')
+      .action(async (options) => {
+        try {
+          const propagateCommand = new PropagateCommand(options);
+          await propagateCommand.execute();
+        } catch (error) {
+          this.errorHandler.handleFatalError(error, { command: 'propagate' });
+        }
+      });
+
+    // Push command - simplified version of "upload --upload-by-rfc"
+    this.program
+      .command('push')
+      .description('📤 Upload files by RFC to Arela API (optimized)')
+      .option(
+        '--api <target>',
+        'API target for scan operations: default|agencia|cliente',
+        'default',
+      )
+      .option(
+        '--scan-api <target>',
+        'API for reading scan table: default|agencia|cliente',
+        'default',
+      )
+      .option(
+        '--push-api <target>',
+        'API for uploading files: default|agencia|cliente',
+      )
+      .option(
+        '--source-api <target>',
+        'Source API for reading data (cross-tenant mode): agencia|cliente',
+      )
+      .option(
+        '--target-api <target>',
+        'Target API for uploading files (cross-tenant mode): agencia|cliente',
+      )
+      .option(
+        '-b, --batch-size <size>',
+        'Number of files to fetch per batch',
+        '100',
+      )
+      .option(
+        '--upload-batch-size <size>',
+        'Number of files to upload concurrently',
+        '10',
+      )
+      .option(
+        '--rfcs <rfcs>',
+        'Comma-separated RFCs to filter (overrides PUSH_RFCS env var)',
+      )
+      .option(
+        '--years <years>',
+        'Comma-separated years to filter (overrides PUSH_YEARS env var)',
+      )
+      .option(
+        '--folder-structure <path>',
+        'Storage path prefix (overrides PUSH_FOLDER_STRUCTURE env var)',
+      )
+      .option('--no-auto-organize', 'Disable automatic file organization')
+      .option('--show-stats', 'Show performance statistics')
+      .action(async (options) => {
+        try {
+          // Handle cross-tenant mode (source and target APIs)
+          // Map source-api/target-api to scan-api/push-api for consistency
+          if (options.sourceApi && options.targetApi) {
+            appConfig.setCrossTenantTargets(
+              options.sourceApi,
+              options.targetApi,
+            );
+            // Also set scan-api and push-api for PushCommand compatibility
+            options.scanApi = options.sourceApi;
+            options.pushApi = options.targetApi;
+          }
+
+          // Parse comma-separated values
+          if (options.rfcs) {
+            options.rfcs = options.rfcs
+              .split(',')
+              .map((r) => r.trim().toUpperCase())
+              .filter(Boolean);
+          }
+          if (options.years) {
+            options.years = options.years
+              .split(',')
+              .map((y) => parseInt(y.trim(), 10))
+              .filter((y) => !isNaN(y));
+          }
+
+          const pushCommand = new PushCommand();
+          await pushCommand.execute(options);
+        } catch (error) {
+          this.errorHandler.handleFatalError(error, { command: 'push' });
+        }
+      });
+
+    // ============================================================================
+    // END OF NEW SIMPLIFIED COMMANDS
+    // ============================================================================
+
+    // GDrive sync command - mirror a Google Drive folder to local before scan
+    this.program
+      .command('gdrive-sync')
+      .description(
+        '☁️  Mirror a Google Drive folder to local filesystem (pre-scan source)',
+      )
+      .option(
+        '--root-folder <id>',
+        'Drive folder ID to sync (overrides GDRIVE_ROOT_FOLDER_ID)',
+      )
+      .option(
+        '--dest <path>',
+        'Local mirror destination (overrides GDRIVE_LOCAL_MIRROR_PATH)',
+      )
+      .option('--full', 'Ignore state file and re-verify all files')
+      .option('--dry-run', 'List/plan only, no downloads or writes')
+      .action(async (options) => {
+        try {
+          await gdriveSyncCommand.execute(options);
+        } catch (error) {
+          this.errorHandler.handleFatalError(error, {
+            command: 'gdrive-sync',
+          });
+        }
+      });
+
+    // Watch command
+    this.program
+      .command('watch')
+      .description(
+        'Monitor directories for file changes and upload automatically',
+      )
+      .option(
+        '--api <target>',
+        'API target: default|agencia|cliente',
+        'default',
+      )
+      .option(
+        '--source-api <target>',
+        'Source API for reading data (cross-tenant mode): agencia|cliente',
+      )
+      .option(
+        '--target-api <target>',
+        'Target API for uploading files (cross-tenant mode): agencia|cliente',
+      )
+      .option(
+        '-d, --directories <paths>',
+        'Comma-separated directories to watch',
+      )
+      .option(
+        '-s, --strategy <strategy>',
+        'Upload strategy: individual|batch|full-structure',
+        'batch',
+      )
+      .option('--debounce <ms>', 'Debounce delay in milliseconds', '1000')
+      .option(
+        '-b, --batch-size <size>',
+        'Number of files to process in each batch',
+        '10',
+      )
+      .option(
+        '--poll <ms>',
+        'Use polling instead of native file system events (interval in ms)',
+      )
+      .option('--ignore <patterns>', 'Comma-separated patterns to ignore')
+      .option('--auto-detect', 'Enable automatic document type detection')
+      .option('--auto-organize', 'Enable automatic file organization')
+      .option(
+        '--auto-processing',
+        'Enable automatic 4-step pipeline (stats, detect, propagate, upload)',
+      )
+      .option('--dry-run', 'Simulate changes without uploading')
+      .option('--verbose', 'Enable verbose logging')
+      .action(async (options) => {
+        try {
+          // Handle cross-tenant mode (source and target APIs)
+          if (options.sourceApi && options.targetApi) {
+            appConfig.setCrossTenantTargets(
+              options.sourceApi,
+              options.targetApi,
+            );
+          } else if (options.api && options.api !== 'default') {
+            // Set single API target if specified
+            appConfig.setApiTarget(options.api);
+          }
+
+          await this.watchCommand.execute(options);
+        } catch (error) {
+          this.errorHandler.handleFatalError(error, { command: 'watch' });
+        }
+      });
+
+    // ============================================================================
+    // WORKER MODE - BullMQ job processor
+    // ============================================================================
+
+    // Worker command - process jobs from BullMQ queues
+    this.program
+      .command('worker')
+      .description('🔧 Run as BullMQ worker to process pipeline jobs from UI')
+      .option(
+        '--queues <queues>',
+        'Comma-separated queues to listen to (default: all pipeline queues)',
+      )
+      .option(
+        '-c, --concurrency <number>',
+        'Number of concurrent jobs per queue',
+        '1',
+      )
+      .option(
+        '--poll',
+        'Use HTTP polling mode instead of BullMQ (for environments without Redis)',
+      )
+      .option(
+        '--api <target>',
+        'API target for polling (e.g., agencia, cliente, ktj)',
+        'agencia',
+      )
+      .action(async (options) => {
+        try {
+          if (options.poll) {
+            // HTTP polling mode - for Windows Server or environments without Redis
+            await pollWorkerCommand.execute(options);
+          } else {
+            // BullMQ mode - default for environments with Redis
+            await workerCommand.execute(options);
+          }
+        } catch (error) {
+          this.errorHandler.handleFatalError(error, { command: 'worker' });
+        }
+      });
+
+    // ============================================================================
+    // AGENT MODE - one process polling N tenant APIs (replaces N worker terminals)
+    // ============================================================================
+
+    const agent = this.program
+      .command('agent')
+      .description(
+        '🤖 Multi-profile polling agent: one process for all tenant APIs (profiles.json)',
+      );
+
+    agent
+      .command('run', { isDefault: true })
+      .description('Run the agent (default: `arela agent` runs this)')
+      .option(
+        '--config <path>',
+        'Path to profiles.json (default: ~/.arela/profiles.json)',
+      )
+      .option('--interval <ms>', 'Base poll interval per idle round')
+      .option(
+        '--profile <names>',
+        'Comma-separated subset of profiles to run (debugging)',
+      )
+      .action(async (options) => {
+        try {
+          await agentCommand.execute(options);
+        } catch (error) {
+          this.errorHandler.handleFatalError(error, { command: 'agent' });
+        }
+      });
+
+    agent
+      .command('init')
+      .description(
+        'Generate profiles.json + pipeline_config seeds from legacy per-folder .env files',
+      )
+      .requiredOption(
+        '--from <dirs...>',
+        'Folders containing the legacy .env files (one per RFC×source)',
+      )
+      .option(
+        '--server-id <id>',
+        'Machine server id (default: ARELA_SERVER_ID from first .env, else hostname)',
+      )
+      .option('--out <dir>', 'Output directory', '~/.arela')
+      .option('--force', 'Overwrite an existing profiles.json')
+      .action(async (options) => {
+        try {
+          await agentInitCommand.execute(options.from, options);
+        } catch (error) {
+          this.errorHandler.handleFatalError(error, { command: 'agent init' });
+        }
+      });
+
+    // Version command (already handled by program.version())
+
+    // Help command
+    this.program
+      .command('help')
+      .description('Show help information')
+      .action(() => {
+        this.program.help();
+      });
+  }
+
+  /**
+   * Setup global error handling
+   * @private
+   */
+  #setupErrorHandling() {
+    // Handle uncaught exceptions
+    process.on('uncaughtException', (error) => {
+      this.errorHandler.handleFatalError(error, {
+        context: 'uncaughtException',
+      });
+    });
+
+    // Handle unhandled promise rejections
+    process.on('unhandledRejection', (reason, promise) => {
+      const error =
+        reason instanceof Error ? reason : new Error(String(reason));
+
+      // pdf.js rejects internal worker promises when a PDF is corrupt; those
+      // rejections cannot be caught around the parser call, and one bad file
+      // must not abort the rest of the batch.
+      if (PDFJS_PARSE_ERRORS.has(error.name)) {
+        const file = getCurrentPdfFile();
+        console.warn(
+          `⚠️ Corrupt or unreadable PDF${file ? ` (${file})` : ''}: ${error.message} — skipping`,
+        );
+        this.errorHandler.handleError(error, {
+          context: 'unhandledRejection',
+          file,
+        });
+        return;
+      }
+
+      this.errorHandler.handleFatalError(error, {
+        context: 'unhandledRejection',
+        promise: promise.toString(),
+      });
+    });
+
+    // Handle SIGINT (Ctrl+C)
+    process.on('SIGINT', () => {
+      console.log('\n👋 Received SIGINT. Gracefully shutting down...');
+      logger.info('Application interrupted by user (SIGINT)');
+      logger.flush();
+      process.exit(0);
+    });
+
+    // Handle SIGTERM
+    process.on('SIGTERM', () => {
+      console.log('\n👋 Received SIGTERM. Gracefully shutting down...');
+      logger.info('Application terminated by system (SIGTERM)');
+      logger.flush();
+      process.exit(0);
+    });
+  }
+
+  /**
+   * Show current configuration
+   * @private
+   */
+  #showConfiguration() {
+    console.log('🔧 Current Configuration:');
+    console.log(`   Version: ${appConfig.packageVersion}`);
+    console.log('\n📡 API Configuration (Multi-Tenant):');
+    console.log(`   Active Target: ${appConfig.api.activeTarget || 'default'}`);
+    console.log('\n   🌐 Default API:');
+    console.log(`      URL: ${appConfig.api.baseUrl || 'Not configured'}`);
+    console.log(
+      `      Token: ${appConfig.api.token ? '✅ Set' : '❌ Not set'}`,
+    );
+    console.log('\n   🏢 Agencia API:');
+    console.log(
+      `      URL: ${appConfig.api.targets.agencia?.baseUrl || 'Not configured'}`,
+    );
+    console.log(
+      `      Token: ${appConfig.api.targets.agencia?.token ? '✅ Set' : '❌ Not set'}`,
+    );
+    console.log('\n   👤 Cliente API:');
+    console.log(
+      `      URL: ${appConfig.api.targets.cliente?.baseUrl || 'Not configured'}`,
+    );
+    console.log(
+      `      Token: ${appConfig.api.targets.cliente?.token ? '✅ Set' : '❌ Not set'}`,
+    );
+    console.log('\n🗄️  Supabase Configuration:');
+    console.log(`   URL: ${appConfig.supabase.url || 'Not configured'}`);
+    console.log(`   Key: ${appConfig.supabase.key ? '✅ Set' : '❌ Not set'}`);
+    console.log(`   Bucket: ${appConfig.supabase.bucket || 'Not configured'}`);
+    console.log('\n📁 Upload Configuration:');
+    console.log(
+      `   Base Path: ${appConfig.upload.basePath || 'Not configured'}`,
+    );
+    console.log(
+      `   Sources: ${appConfig.upload.sources?.join(', ') || 'Not configured'}`,
+    );
+    console.log(
+      `   RFCs: ${appConfig.upload.rfcs?.join(', ') || 'Not configured'}`,
+    );
+    console.log('\n⚡ Performance Configuration:');
+    console.log(`   Batch Delay: ${appConfig.performance.batchDelay}ms`);
+    console.log(
+      `   Progress Update Interval: ${appConfig.performance.progressUpdateInterval}`,
+    );
+    console.log(`   Log Buffer Size: ${appConfig.performance.logBufferSize}`);
+    console.log('\n📝 Logging Configuration:');
+    console.log(
+      `   Verbose: ${appConfig.logging.verbose ? '✅ Enabled' : '❌ Disabled'}`,
+    );
+    console.log(`   Log File: ${appConfig.logging.logFilePath}`);
+    console.log('\n🎯 Service Availability:');
+    console.log(
+      `   API Mode (default): ${appConfig.isApiModeAvailable() ? '✅ Available' : '❌ Not available'}`,
+    );
+    console.log(
+      `   API Mode (agencia): ${appConfig.isApiModeAvailable('agencia') ? '✅ Available' : '❌ Not available'}`,
+    );
+    console.log(
+      `   API Mode (cliente): ${appConfig.isApiModeAvailable('cliente') ? '✅ Available' : '❌ Not available'}`,
+    );
+    console.log(
+      `   Supabase Mode: ${appConfig.isSupabaseModeAvailable() ? '✅ Available' : '❌ Not available'}`,
+    );
+    console.log('\n📋 Uso Multi-Tenant:');
+    console.log(
+      '   arela stats --api agencia         # Registrar archivos en BD agencia',
+    );
+    console.log(
+      '   arela detect --api agencia        # Detectar pedimentos en BD agencia',
+    );
+    console.log(
+      '   arela upload --api cliente        # Subir archivos al cliente configurado',
+    );
+    console.log('\n👁️ Modo Watch Multi-Tenant:');
+    console.log(
+      '   arela watch --api cliente                              # Watch con API cliente',
+    );
+    console.log(
+      '   arela watch --source-api agencia --target-api cliente  # Cross-tenant watch',
+    );
+    console.log(
+      '\n💡 Tip: Configura ARELA_API_CLIENTE_URL y ARELA_API_CLIENTE_TOKEN',
+    );
+    console.log('   en .env para apuntar al cliente específico que necesites.');
+  }
+
+  /**
+   * Parse command line arguments and execute
+   */
+  async run() {
+    try {
+      // Set verbose mode if requested globally
+      const args = process.argv;
+      if (args.includes('-v') || args.includes('--verbose')) {
+        logger.setVerbose(true);
+      }
+
+      // Clear log if requested globally
+      if (args.includes('--clear-log')) {
+        logger.clearLogFile();
+        logger.info('Log file cleared');
+      }
+
+      // Log application start
+      logger.info(`Arela Uploader v${appConfig.packageVersion} started`);
+      logger.info(`Command: ${args.slice(2).join(' ')}`);
+
+      // Parse and execute commands
+      await this.program.parseAsync();
+    } catch (error) {
+      this.errorHandler.handleFatalError(error, { context: 'cli-execution' });
+    }
+  }
+}
+
+// Create and run the CLI application
+const cli = new ArelaUploaderCLI();
+await cli.run();