@arela/uploader 1.0.7 → 1.0.9

package/.env.template

@@ -9,6 +9,15 @@
 ARELA_API_URL=https://your-arela-api-url.com
 ARELA_API_TOKEN=your-api-token-here
 
+# API Agencia - Configura aquí la URL y Token de la agencia activa
+ARELA_API_AGENCIA_URL=https://agencia-api-example.com
+ARELA_API_AGENCIA_TOKEN=your-agencia-api-token-here
+
+# API Cliente - Configura aquí la URL y Token del cliente activo
+ARELA_API_CLIENTE_URL=https://cliente-api-example.com
+ARELA_API_CLIENTE_TOKEN=your-cliente-api-token-here
+
+
 # Supabase Configuration (fallback)
 SUPABASE_URL=https://your-supabase-url.supabase.co
 SUPABASE_KEY=your-supabase-key-here

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arela/uploader",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "description": "CLI to upload files/directories to Arela",
   "bin": {
     "arela": "./src/index.js"

package/src/commands/IdentifyCommand.js

@@ -42,23 +42,20 @@ export class IdentifyCommand {
       // Validate scan configuration (need same config as scan command)
       appConfig.validateScanConfig();
 
-      // Import ScanApiService dynamically
+      // Determine API target
+      const apiTarget = options.api || 'default';
+
+      // Import ScanApiService dynamically and initialize with target
       const { default: ScanApiService } = await import(
         '../services/ScanApiService.js'
       );
-      this.scanApiService = new ScanApiService();
-
-      // Set API target if specified
-      if (options.api) {
-        appConfig.setApiTarget(options.api);
-        this.scanApiService = new ScanApiService();
-      }
+      this.scanApiService = new ScanApiService(apiTarget);
 
       const scanConfig = appConfig.getScanConfig();
       const batchSize = parseInt(options.batchSize) || 100;
 
       logger.info('🔍 Starting arela identify command');
-      logger.info(`🎯 API Target: ${options.api || 'default'}`);
+      logger.info(`🎯 API Target: ${apiTarget}`);
       logger.info(`📦 Batch Size: ${batchSize}`);
 
       // Fetch all tables for this instance
@@ -273,7 +270,7 @@ export class IdentifyCommand {
               arelaPath: null,
               detectionError:
                 'FILE_NOT_FOUND: File does not exist on filesystem. May have been moved or deleted after scan.',
-              isPedimento: null,  // Unknown - can't determine
+              isPedimento: null, // Unknown - can't determine
             };
           }
 
@@ -289,7 +286,7 @@ export class IdentifyCommand {
               rfc: null,
               arelaPath: null,
               detectionError: `FILE_TOO_LARGE: File size ${(stats.size / 1024 / 1024).toFixed(2)}MB exceeds ${maxSizeBytes / 1024 / 1024}MB limit.`,
-              isPedimento: null,  // Unknown - can't determine
+              isPedimento: null, // Unknown - can't determine
             };
           }
 
@@ -306,13 +303,16 @@ export class IdentifyCommand {
               rfc: result.rfc,
               arelaPath: result.arelaPath,
               detectionError: result.error,
-              isPedimento: true,  // Confirmed pedimento
+              isPedimento: true, // Confirmed pedimento
             };
           }
 
           // If no detection, determine if it's definitely not a pedimento
           // This helps avoid re-processing files we know aren't pedimentos
-          const isDefinitelyNotPedimento = this.#isDefinitelyNotPedimento(result, file);
+          const isDefinitelyNotPedimento = this.#isDefinitelyNotPedimento(
+            result,
+            file,
+          );
 
           // Build descriptive error message
           let detectionError = null;
@@ -340,7 +340,7 @@ export class IdentifyCommand {
             rfc: result.rfc,
             arelaPath: result.arelaPath,
             detectionError,
-            isPedimento: isDefinitelyNotPedimento ? false : null,  // false = not pedimento, null = unknown
+            isPedimento: isDefinitelyNotPedimento ? false : null, // false = not pedimento, null = unknown
           };
         } catch (error) {
           logger.warn(
@@ -367,7 +367,7 @@ export class IdentifyCommand {
             rfc: null,
             arelaPath: null,
             detectionError: `${errorCategory}: ${error.message}`,
-            isPedimento: null,  // Unknown - error occurred
+            isPedimento: null, // Unknown - error occurred
           };
         }
       }),

package/src/commands/PropagateCommand.js

@@ -39,8 +39,10 @@ export class PropagateCommand {
       // Step 1: Validate configuration
       await this.#validateConfiguration();
 
-      // Step 2: Initialize API service
-      this.scanApiService = new ScanApiService();
+      // Step 2: Initialize API service with configured target
+      const apiTarget = this.options.api || 'default';
+      this.scanApiService = new ScanApiService(apiTarget);
+      console.log(`🎯 API Target: ${apiTarget}`);
 
       // Step 3: Fetch all tables for this instance
       const scanConfig = appConfig.getScanConfig();

package/src/commands/PushCommand.js

@@ -15,7 +15,8 @@ import appConfig from '../config/config.js';
  */
 export class PushCommand {
   constructor() {
-    this.scanApiService = new ScanApiService();
+    // ScanApiService will be initialized in execute() with proper API target
+    this.scanApiService = null;
   }
 
   /**
@@ -37,7 +38,6 @@ export class PushCommand {
       // Get configuration
       const scanConfig = appConfig.getScanConfig();
       const pushConfig = appConfig.getPushConfig();
-      const tableName = scanConfig.tableName;
 
       // Override folderStructure from command option if provided
       if (options.folderStructure) {
@@ -48,26 +48,40 @@ export class PushCommand {
           .replace(/\/+$/, '');
       }
 
-      // Set API target for scan/push operations
-      const scanApiTarget = options.api || options.scanApi || 'default';
-      const pushApiTarget = options.pushApi || scanApiTarget;
+      // Determine API targets for scan (read) and push (upload) operations
+      // Priority: explicit scan-api/push-api > source-api/target-api > api > default
+      const scanApiTarget =
+        options.scanApi || options.sourceApi || options.api || 'default';
+      const pushApiTarget =
+        options.pushApi || options.targetApi || options.api || scanApiTarget;
 
-      if (scanApiTarget !== 'default') {
-        appConfig.setApiTarget(scanApiTarget);
-        this.scanApiService = new ScanApiService(); // Reinitialize with new target
-      }
+      // Initialize ScanApiService with the scan API target
+      this.scanApiService = new ScanApiService(scanApiTarget);
 
-      // Get upload API configuration
+      // Get upload API configuration for the push target
       const uploadApiConfig = appConfig.getApiConfig(pushApiTarget);
 
-      console.log(`🎯 Scan API Target: ${scanApiTarget}`);
-      console.log(
-        `🎯 Upload API Target: ${pushApiTarget} → ${uploadApiConfig.baseUrl}`,
-      );
+      // Display API configuration
+      const isCrossTenant = scanApiTarget !== pushApiTarget;
+      if (isCrossTenant) {
+        console.log('🔗 Cross-tenant mode enabled:');
+        console.log(
+          `   📖 Scan API (read): ${scanApiTarget} → ${appConfig.getApiConfig(scanApiTarget).baseUrl}`,
+        );
+        console.log(
+          `   📝 Push API (upload): ${pushApiTarget} → ${uploadApiConfig.baseUrl}`,
+        );
+      } else {
+        console.log(
+          `🎯 API Target: ${scanApiTarget} → ${uploadApiConfig.baseUrl}`,
+        );
+      }
       console.log(`📦 Fetch Batch Size: ${options.batchSize}`);
       console.log(`📤 Upload Batch Size: ${options.uploadBatchSize}`);
       if (pushConfig.folderStructure) {
-        console.log(`📁 Folder Structure Prefix: ${pushConfig.folderStructure}`);
+        console.log(
+          `📁 Folder Structure Prefix: ${pushConfig.folderStructure}`,
+        );
       }
 
       // Apply filters
@@ -294,7 +308,6 @@ export class PushCommand {
         );
 
         // Update counters from API response
-        // Note: The CLI endpoint now handles updating the scan table directly
         batchResults.forEach((result) => {
           results.processed++;
           if (result.uploaded) {
@@ -304,6 +317,17 @@ export class PushCommand {
           }
         });
 
+        // Update scan table via scanApi (supports cross-tenant mode)
+        // This is called on scanApi, not pushApi, because scan tables live on scanApi
+        try {
+          await this.scanApiService.batchUpdateUpload(tableName, batchResults);
+        } catch (updateError) {
+          logger.error(
+            `Failed to update scan table for batch: ${updateError.message}`,
+          );
+          // Don't fail the entire process, just log the error
+        }
+
         // Update progress bar
         const elapsed = (Date.now() - results.startTime) / 1000;
         const speed =
@@ -329,7 +353,7 @@ export class PushCommand {
 
   /**
    * Upload a batch of files using the new CLI upload endpoint
-   * The endpoint updates the CLI scan table directly
+   * Note: Scan table is updated separately via scanApi after this batch completes
    * @private
    */
   async #uploadBatchViaCli(tableName, files, uploadApiConfig) {
@@ -368,8 +392,6 @@ export class PushCommand {
       if (!fs.existsSync(file.absolute_path)) {
         result.uploadError =
           'FILE_NOT_FOUND: File does not exist on filesystem';
-        // Update the scan table with the error
-        await this.scanApiService.batchUpdateUpload(tableName, [result]);
         return result;
       }
 
@@ -377,7 +399,6 @@ export class PushCommand {
       const stats = fs.statSync(file.absolute_path);
       if (!stats.isFile()) {
         result.uploadError = 'NOT_A_FILE: Path is not a regular file';
-        await this.scanApiService.batchUpdateUpload(tableName, [result]);
         return result;
       }
 

package/src/commands/ScanCommand.js

@@ -1,5 +1,5 @@
 import cliProgress from 'cli-progress';
-import { globbyStream } from 'globby';
+import { globby, globbyStream } from 'globby';
 import path from 'path';
 import { Transform } from 'stream';
 import { pipeline } from 'stream/promises';
@@ -26,6 +26,8 @@ export class ScanCommand {
    * Execute the scan command
    * @param {Object} options - Command options
    * @param {boolean} options.countFirst - Count files first for percentage-based progress
+   * @param {string} options.api - API target: 'default', 'agencia', or 'cliente'
+   * @param {boolean} options.stream - Use streaming file discovery (default: true, use --no-stream to disable)
    */
   async execute(options = {}) {
     const startTime = Date.now();
@@ -34,21 +36,28 @@ export class ScanCommand {
       // Validate scan configuration
       appConfig.validateScanConfig();
 
-      // Import ScanApiService dynamically
+      // Determine API target
+      const apiTarget = options.api || 'default';
+
+      // Import ScanApiService dynamically and initialize with target
       const { default: ScanApiService } = await import(
         '../services/ScanApiService.js'
       );
-      this.scanApiService = new ScanApiService();
+      this.scanApiService = new ScanApiService(apiTarget);
 
       const scanConfig = appConfig.getScanConfig();
       // Ensure basePath is absolute for scan operations
       const basePath = PathNormalizer.toAbsolutePath(appConfig.getBasePath());
 
       logger.info('🔍 Starting arela scan command');
+      logger.info(`🎯 API Target: ${apiTarget}`);
       logger.info(`📦 Company: ${scanConfig.companySlug}`);
       logger.info(`🖥️  Server: ${scanConfig.serverId}`);
       logger.info(`📂 Base Path: ${basePath}`);
       logger.info(`📊 Directory Level: ${scanConfig.directoryLevel}`);
+      logger.info(
+        `🔄 File Discovery: ${options.stream !== false ? 'Streaming (globbyStream)' : 'Synchronous (globby)'}`,
+      );
 
       // Step 1: Discover directories at specified level
       logger.info('\n🔍 Discovering directories...');
@@ -89,7 +98,11 @@ export class ScanCommand {
       let totalFiles = null;
       if (options.countFirst) {
         logger.info('\n🔢 Counting files...');
-        totalFiles = await this.#countFiles(basePath, scanConfig);
+        totalFiles = await this.#countFiles(
+          basePath,
+          scanConfig,
+          options.stream !== false,
+        );
         logger.info(`📊 Found ${totalFiles.toLocaleString()} files to scan`);
       }
 
@@ -109,6 +122,7 @@ export class ScanCommand {
           scanConfig,
           reg.tableName,
           null, // Don't use percentage for individual directories
+          options.stream !== false, // Use streaming by default, --no-stream sets stream=false
         );
 
         // Step 4: Complete scan for this directory
@@ -276,22 +290,37 @@ export class ScanCommand {
   /**
    * Count files for percentage-based progress
    * @private
+   * @param {string} basePath - Base path to count from
+   * @param {Object} scanConfig - Scan configuration
+   * @param {boolean} useStream - Use streaming (globbyStream) or sync (globby) approach
    */
-  async #countFiles(basePath, scanConfig) {
+  async #countFiles(basePath, scanConfig, useStream = true) {
     const sources = appConfig.getUploadSources();
     let totalCount = 0;
 
     for (const source of sources) {
       const sourcePath = path.resolve(basePath, source);
-      const files = await globbyStream('**/*', {
-        cwd: sourcePath,
-        onlyFiles: true,
-        absolute: true,
-      });
 
-      for await (const file of files) {
-        if (!this.#shouldExcludeFile(file, scanConfig.excludePatterns)) {
-          totalCount++;
+      if (useStream) {
+        // Streaming approach
+        const files = await globbyStream('**/*', {
+          cwd: sourcePath,
+          onlyFiles: true,
+          absolute: true,
+        });
+
+        for await (const file of files) {
+          if (!this.#shouldExcludeFile(file, scanConfig.excludePatterns)) {
+            totalCount++;
+          }
+        }
+      } else {
+        // Synchronous approach (original method)
+        const files = await globby([`${sourcePath}/**/*`], { onlyFiles: true });
+        for (const file of files) {
+          if (!this.#shouldExcludeFile(file, scanConfig.excludePatterns)) {
+            totalCount++;
+          }
         }
       }
     }
@@ -302,12 +331,18 @@ export class ScanCommand {
   /**
    * Stream files from a single directory and upload stats in batches
    * @private
+   * @param {string} dirPath - Directory path to scan
+   * @param {Object} scanConfig - Scan configuration
+   * @param {string} tableName - Target table name
+   * @param {number|null} totalFiles - Total files count for progress (optional)
+   * @param {boolean} useStream - Use streaming (globbyStream) or sync (globby) approach
    */
   async #streamScanDirectory(
     dirPath,
     scanConfig,
     tableName,
     totalFiles = null,
+    useStream = true,
   ) {
     // For directory-level scanning, we scan the directory directly
     const batchSize = scanConfig.batchSize || 2000;
@@ -323,61 +358,67 @@ export class ScanCommand {
     const progressBar = this.#createProgressBar(totalFiles);
 
     try {
-      // Create stream with stats option
-      const fileStream = globbyStream('**/*', {
-        cwd: dirPath,
-        onlyFiles: true,
-        absolute: true,
-        stats: true, // Get file stats during discovery
-      });
-
-      // Process each file from stream
-      for await (const entry of fileStream) {
-        // globby with stats:true returns {path, stats} objects
-        const filePath = typeof entry === 'string' ? entry : entry.path;
-        const stats = typeof entry === 'object' ? entry.stats : null;
-
-        // Check if file should be excluded
-        if (this.#shouldExcludeFile(filePath, scanConfig.excludePatterns)) {
-          filesSkipped++;
-          continue;
-        }
-
-        // Get file stats (use from globby or fetch manually)
-        const fileStats = stats || FileOperations.getFileStats(filePath);
-        if (!fileStats) {
-          logger.debug(`⚠️ Could not read stats: ${filePath}`);
-          filesSkipped++;
-          continue;
-        }
-
-        // Normalize file record
-        const record = this.#normalizeFileRecord(
-          filePath,
-          fileStats,
-          dirPath,
-          scanTimestamp,
-        );
+      if (useStream) {
+        // Streaming approach: use globbyStream with stats option
+        const fileStream = globbyStream('**/*', {
+          cwd: dirPath,
+          onlyFiles: true,
+          absolute: true,
+          stats: true, // Get file stats during discovery
+        });
 
-        currentBatch.push(record);
-        filesScanned++;
-        totalSize += record.sizeBytes;
+        // Process each file from stream
+        for await (const entry of fileStream) {
+          // globby with stats:true returns {path, stats} objects
+          const filePath = typeof entry === 'string' ? entry : entry.path;
+          const stats = typeof entry === 'object' ? entry.stats : null;
+
+          const result = await this.#processFileEntry(
+            filePath,
+            stats,
+            dirPath,
+            scanConfig,
+            scanTimestamp,
+            tableName,
+            currentBatch,
+            batchSize,
+            progressBar,
+            totalFiles,
+            { filesScanned, filesInserted, filesSkipped, totalSize },
+          );
 
-        // Update progress
-        if (totalFiles) {
-          progressBar.update(filesScanned);
-        } else {
-          // Show throughput instead of percentage
-          const elapsed = (Date.now() - progressBar.startTime) / 1000;
-          const rate = (filesScanned / elapsed).toFixed(1);
-          progressBar.update(filesScanned, { rate });
+          filesScanned = result.filesScanned;
+          filesInserted = result.filesInserted;
+          filesSkipped = result.filesSkipped;
+          totalSize = result.totalSize;
+          currentBatch = result.currentBatch;
         }
+      } else {
+        // Synchronous approach: use globby (original method from UploadCommand)
+        logger.debug('Using synchronous file discovery (globby)...');
+        const files = await globby([`${dirPath}/**/*`], { onlyFiles: true });
+        logger.debug(`Found ${files.length} files to process`);
+
+        for (const filePath of files) {
+          const result = await this.#processFileEntry(
+            filePath,
+            null, // Stats will be fetched manually
+            dirPath,
+            scanConfig,
+            scanTimestamp,
+            tableName,
+            currentBatch,
+            batchSize,
+            progressBar,
+            totalFiles,
+            { filesScanned, filesInserted, filesSkipped, totalSize },
+          );
 
-        // Upload batch when full
-        if (currentBatch.length >= batchSize) {
-          const inserted = await this.#uploadBatch(tableName, currentBatch);
-          filesInserted += inserted;
-          currentBatch = [];
+          filesScanned = result.filesScanned;
+          filesInserted = result.filesInserted;
+          filesSkipped = result.filesSkipped;
+          totalSize = result.totalSize;
+          currentBatch = result.currentBatch;
         }
       }
     } catch (error) {
@@ -400,6 +441,89 @@ export class ScanCommand {
     };
   }
 
+  /**
+   * Process a single file entry (used by both streaming and sync approaches)
+   * @private
+   */
+  async #processFileEntry(
+    filePath,
+    stats,
+    dirPath,
+    scanConfig,
+    scanTimestamp,
+    tableName,
+    currentBatch,
+    batchSize,
+    progressBar,
+    totalFiles,
+    counters,
+  ) {
+    let { filesScanned, filesInserted, filesSkipped, totalSize } = counters;
+
+    // Check if file should be excluded
+    if (this.#shouldExcludeFile(filePath, scanConfig.excludePatterns)) {
+      filesSkipped++;
+      return {
+        filesScanned,
+        filesInserted,
+        filesSkipped,
+        totalSize,
+        currentBatch,
+      };
+    }
+
+    // Get file stats (use from globby or fetch manually)
+    const fileStats = stats || FileOperations.getFileStats(filePath);
+    if (!fileStats) {
+      logger.debug(`⚠️ Could not read stats: ${filePath}`);
+      filesSkipped++;
+      return {
+        filesScanned,
+        filesInserted,
+        filesSkipped,
+        totalSize,
+        currentBatch,
+      };
+    }
+
+    // Normalize file record
+    const record = this.#normalizeFileRecord(
+      filePath,
+      fileStats,
+      dirPath,
+      scanTimestamp,
+    );
+
+    currentBatch.push(record);
+    filesScanned++;
+    totalSize += record.sizeBytes;
+
+    // Update progress
+    if (totalFiles) {
+      progressBar.update(filesScanned);
+    } else {
+      // Show throughput instead of percentage
+      const elapsed = (Date.now() - progressBar.startTime) / 1000;
+      const rate = (filesScanned / elapsed).toFixed(1);
+      progressBar.update(filesScanned, { rate });
+    }
+
+    // Upload batch when full
+    if (currentBatch.length >= batchSize) {
+      const inserted = await this.#uploadBatch(tableName, currentBatch);
+      filesInserted += inserted;
+      currentBatch = [];
+    }
+
+    return {
+      filesScanned,
+      filesInserted,
+      filesSkipped,
+      totalSize,
+      currentBatch,
+    };
+  }
+
   /**
    * Upload a batch of file records
    * @private

package/src/config/config.js

@@ -34,10 +34,10 @@ class Config {
       const __dirname = path.dirname(__filename);
       const packageJsonPath = path.resolve(__dirname, '../../package.json');
       const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
-      return packageJson.version || '1.0.7';
+      return packageJson.version || '1.0.9';
     } catch (error) {
       console.warn('⚠️ Could not read package.json version, using fallback');
-      return '1.0.7';
+      return '1.0.9';
     }
   }
 

package/src/index.js

@@ -185,6 +185,10 @@ class ArelaUploaderCLI {
         '--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
@@ -381,6 +385,14 @@ class ArelaUploaderCLI {
         '--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',
@@ -406,6 +418,18 @@ class ArelaUploaderCLI {
       .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

package/src/services/ScanApiService.js

@@ -10,8 +10,12 @@ import logger from './LoggingService.js';
  * Handles API communication for the arela scan command
  */
 export class ScanApiService {
-  constructor() {
-    const apiConfig = appConfig.getApiConfig();
+  /**
+   * @param {string|null} apiTarget - API target: 'default', 'agencia', 'cliente', or null (uses active target)
+   */
+  constructor(apiTarget = null) {
+    this.apiTarget = apiTarget;
+    const apiConfig = appConfig.getApiConfig(apiTarget);
     this.baseUrl = apiConfig.baseUrl;
     this.token = apiConfig.token;