@arela/uploader 1.0.21 → 1.0.22

package/package.json

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

package/src/commands/DatastageCommand.js

@@ -0,0 +1,164 @@
+import fs from 'fs';
+import path from 'path';
+
+import { DatastageApiService } from '../services/DatastageApiService.js';
+import logger from '../services/LoggingService.js';
+
+import appConfig from '../config/config.js';
+import ErrorHandler from '../errors/ErrorHandler.js';
+
+/**
+ * Datastage Command Handler
+ * Uploads monthly Datastage *.zip files from a directory to the API.
+ * Sequential, idempotent via the cli `datastage_uploads` tracking table.
+ */
+export class DatastageCommand {
+  constructor() {
+    this.errorHandler = new ErrorHandler(logger);
+  }
+
+  /**
+   * @param {Object} options
+   * @param {string} options.dir - directory containing *.zip files (required)
+   * @param {string} [options.api] - 'default'|'agencia'|'cliente'
+   * @param {boolean} [options.retryFailed] - re-attempt files in 'failed' status
+   * @param {boolean} [options.showStats] - print final stats from API
+   */
+  async execute(options = {}) {
+    const startTime = Date.now();
+
+    if (!options.dir) {
+      throw new Error('--dir <path> is required');
+    }
+    const sourceDirectory = path.resolve(options.dir);
+    if (!fs.existsSync(sourceDirectory)) {
+      throw new Error(`Directory not found: ${sourceDirectory}`);
+    }
+    const dirStat = fs.statSync(sourceDirectory);
+    if (!dirStat.isDirectory()) {
+      throw new Error(`Not a directory: ${sourceDirectory}`);
+    }
+
+    const apiTarget = options.api || 'default';
+    const api = new DatastageApiService(apiTarget);
+
+    logger.info('📦 Starting arela datastage command');
+    logger.info(`🎯 API Target: ${apiTarget}`);
+    logger.info(`📂 Source: ${sourceDirectory}`);
+
+    // 1. Enumerate *.zip in root directory (non-recursive)
+    const entries = fs.readdirSync(sourceDirectory, { withFileTypes: true });
+    const zipFiles = entries
+      .filter((e) => e.isFile() && /\.zip$/i.test(e.name))
+      .map((e) => path.join(sourceDirectory, e.name));
+
+    if (zipFiles.length === 0) {
+      logger.warn('No *.zip files found in directory. Nothing to do.');
+      return { uploaded: 0, failed: 0, skipped: 0 };
+    }
+    logger.info(`🗂  Found ${zipFiles.length} zip file(s)`);
+
+    // 2. Register each file (idempotent upsert)
+    logger.info('📝 Registering files...');
+    for (const zipPath of zipFiles) {
+      const stats = fs.statSync(zipPath);
+      try {
+        await api.registerUpload({
+          absolutePath: zipPath,
+          fileName: path.basename(zipPath),
+          sizeBytes: stats.size,
+          fileModifiedAt: stats.mtime.toISOString(),
+          sourceDirectory,
+        });
+      } catch (err) {
+        logger.error(
+          `  ✗ register failed for ${path.basename(zipPath)}: ${err.message}`,
+        );
+        throw err;
+      }
+    }
+
+    // 3. Fetch pending list scoped to this directory
+    const pending = await api.getPending(sourceDirectory);
+    const pendingPaths = new Set(pending.map((p) => p.absolutePath));
+
+    const alreadyUploaded = zipFiles.length - pendingPaths.size;
+    if (alreadyUploaded > 0) {
+      logger.info(`⏭  Skipping ${alreadyUploaded} already uploaded file(s)`);
+    }
+
+    if (pending.length === 0) {
+      logger.success('✅ All files already uploaded. Nothing to do.');
+      if (options.showStats) {
+        const s = await api.getStats(sourceDirectory);
+        logger.info(`📊 Stats: ${JSON.stringify(s)}`);
+      }
+      return { uploaded: 0, failed: 0, skipped: alreadyUploaded };
+    }
+
+    // 4. Sequential upload loop
+    logger.info(`🚀 Uploading ${pending.length} file(s) sequentially...`);
+    let uploaded = 0;
+    let failed = 0;
+
+    for (let i = 0; i < pending.length; i++) {
+      const row = pending[i];
+      const localPath = row.absolutePath;
+      const label = `[${i + 1}/${pending.length}] ${row.fileName}`;
+
+      if (!fs.existsSync(localPath)) {
+        const err = `File missing on disk: ${localPath}`;
+        logger.error(`✗ ${label}: ${err}`);
+        try {
+          await api.markFailed(row.id, err);
+        } catch (e) {
+          logger.error(`  mark-failed error: ${e.message}`);
+        }
+        failed++;
+        continue;
+      }
+
+      try {
+        logger.info(`⬆  ${label}: uploading...`);
+        const result = await api.uploadZip(localPath);
+        const datastageId = result?.id || result?.data?.id;
+        const folio = result?.folio || result?.data?.folio;
+        if (!datastageId) {
+          throw new Error(
+            'API returned no datastage id in response: ' +
+              JSON.stringify(result).slice(0, 300),
+          );
+        }
+        await api.markUploaded(row.id, { datastageId, folio });
+        logger.success(
+          `✓ ${label}: folio=${folio || 'n/a'} datastageId=${datastageId}`,
+        );
+        uploaded++;
+      } catch (err) {
+        logger.error(`✗ ${label}: ${err.message}`);
+        try {
+          await api.markFailed(row.id, err.message);
+        } catch (e) {
+          logger.error(`  mark-failed error: ${e.message}`);
+        }
+        failed++;
+      }
+    }
+
+    const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+    logger.info('—'.repeat(60));
+    logger.info(
+      `Done in ${elapsed}s — uploaded=${uploaded} failed=${failed} skipped=${alreadyUploaded}`,
+    );
+
+    if (options.showStats) {
+      const s = await api.getStats(sourceDirectory);
+      logger.info(`📊 Final stats: ${JSON.stringify(s)}`);
+    }
+
+    return { uploaded, failed, skipped: alreadyUploaded };
+  }
+}
+
+const datastageCommand = new DatastageCommand();
+export default datastageCommand;

package/src/commands/IdentifyCommand.js

@@ -74,29 +74,95 @@ export class IdentifyCommand {
       const scanConfig = appConfig.getScanConfig();
       const batchSize = parseInt(options.batchSize) || 100;
 
+      // Parse optional path prefix mapping: "O:/=/Volumes/nas/"
+      const pathPrefixMap = options.pathPrefix
+        ? this.#parsePathPrefix(options.pathPrefix)
+        : null;
+
       logger.info('🔍 Starting arela identify command');
       logger.info(`🎯 API Target: ${apiTarget}`);
       logger.info(`📦 Batch Size: ${batchSize}`);
+      if (options.table) logger.info(`📌 Target table: ${options.table}`);
+      if (options.resetAttempts)
+        logger.info('♻️  Reset detection attempts: ON');
+      if (pathPrefixMap)
+        logger.info(
+          `🗺  Path prefix map: ${pathPrefixMap.from} → ${pathPrefixMap.to}`,
+        );
 
-      // Fetch all tables for this instance
-      logger.info('\n📊 Fetching instance tables...');
-      const tables = await this.scanApiService.getInstanceTables(
-        scanConfig.companySlug,
-        scanConfig.serverId,
-        scanConfig.basePathFull,
-      );
+      // Resolve the list of tables to process
+      let tables;
+      if (options.fileId && options.table) {
+        // Single-file mode — identify exactly one file record
+        logger.info(
+          `\n🎯 Single-file mode: ${options.table} / ${options.fileId}`,
+        );
+        this.#reportProgress(0, `Fetching file record ${options.fileId}...`);
+        const record = await this.scanApiService.getFileRecord(
+          options.table,
+          options.fileId,
+        );
+        const results = await this.#detectFilesLocally(
+          [record],
+          1,
+          pathPrefixMap,
+        );
+        const updates = results.filter((r) => r !== null);
+        if (updates.length > 0) {
+          await this.scanApiService.batchUpdateDetection(
+            options.table,
+            updates,
+          );
+        }
+        this.#reportProgress(100, `Single-file identification complete`);
+        logger.success(`\n✅ Single-file identification complete`);
+        const firstUpdate = updates[0];
+        return {
+          processed: 1,
+          detected: updates.length,
+          proformas: 0,
+          errors: 1 - updates.length,
+          detectedType: firstUpdate?.detectedType ?? null,
+          detectedPedimento: firstUpdate?.detectedPedimento ?? null,
+          rfc: firstUpdate?.rfc ?? null,
+          arelaPath: firstUpdate?.arelaPath ?? null,
+        };
+      } else if (options.table) {
+        // Single-table mode — no need to match instance tables
+        tables = [{ tableName: options.table }];
+        logger.info(`\n📌 Single-table mode: ${options.table}`);
+      } else {
+        logger.info('\n📊 Fetching instance tables...');
+        tables = await this.scanApiService.getInstanceTables(
+          scanConfig.companySlug,
+          scanConfig.serverId,
+          scanConfig.basePathFull,
+        );
+
+        if (tables.length === 0) {
+          throw new ConfigurationError(
+            'No tables found for this instance. Run "arela scan" first.',
+          );
+        }
 
-      if (tables.length === 0) {
-        throw new ConfigurationError(
-          'No tables found for this instance. Run "arela scan" first.',
+        logger.info(
+          `📋 Found ${tables.length} table${tables.length === 1 ? '' : 's'} to process`,
         );
+        for (const table of tables) {
+          logger.info(`   - ${table.tableName}`);
+        }
       }
 
-      logger.info(
-        `📋 Found ${tables.length} table${tables.length === 1 ? '' : 's'} to process`,
-      );
-      for (const table of tables) {
-        logger.info(`   - ${table.tableName}`);
+      // Optionally reset detection attempts so previously-failed files are retried
+      if (options.resetAttempts) {
+        for (const table of tables) {
+          const { reset } = await this.scanApiService.resetDetectionAttempts(
+            table.tableName,
+          );
+          logger.info(
+            `♻️  Reset ${reset} detection attempt(s) in ${table.tableName}`,
+          );
+        }
       }
 
       // Process each table
@@ -127,6 +193,7 @@ export class IdentifyCommand {
           table.tableName,
           batchSize,
           startTime,
+          pathPrefixMap,
         );
 
         totalStats.processed += stats.processed;
@@ -183,7 +250,7 @@ export class IdentifyCommand {
    * @param {number} startTime - Start time for speed calculation
    * @returns {Promise<Object>} Processing statistics
    */
-  async #processTable(tableName, batchSize, startTime) {
+  async #processTable(tableName, batchSize, startTime, pathPrefixMap = null) {
     // Get detection statistics first (allTypes=true to count all supported file types)
     const initialStats = await this.scanApiService.getDetectionStats(
       tableName,
@@ -255,7 +322,11 @@ export class IdentifyCommand {
       const files = response.data;
 
       // Detect files locally with concurrent processing
-      const detectionResults = await this.#detectFilesLocally(files, 10);
+      const detectionResults = await this.#detectFilesLocally(
+        files,
+        10,
+        pathPrefixMap,
+      );
 
       // Batch update to API
       const updateResult = await this.scanApiService.batchUpdateDetection(
@@ -301,7 +372,7 @@ export class IdentifyCommand {
    * @param {number} concurrency - Maximum concurrent detections
    * @returns {Promise<Array>} Detection results
    */
-  async #detectFilesLocally(files, concurrency = 10) {
+  async #detectFilesLocally(files, concurrency = 10, pathPrefixMap = null) {
     const limit = pLimit(concurrency);
     const basePath = appConfig.getBasePath();
 
@@ -309,7 +380,17 @@ export class IdentifyCommand {
       limit(async () => {
         try {
           // Check if file exists on filesystem
-          const absolutePath = file.absolute_path;
+          let absolutePath = file.absolute_path;
+
+          // Apply cross-platform path prefix mapping if configured
+          if (
+            pathPrefixMap &&
+            absolutePath &&
+            absolutePath.startsWith(pathPrefixMap.from)
+          ) {
+            absolutePath =
+              pathPrefixMap.to + absolutePath.slice(pathPrefixMap.from.length);
+          }
 
           if (!fs.existsSync(absolutePath)) {
             return {
@@ -543,6 +624,44 @@ export class IdentifyCommand {
       }
     }
   }
+
+  /**
+   * Parse a path prefix mapping string such as "O:/=/Volumes/nas/" into { from, to }.
+   * Supports both "FROM=TO" and "FROM:TO" separators.
+   * @private
+   * @param {string} mapping
+   * @returns {{ from: string, to: string }}
+   */
+  #parsePathPrefix(mapping) {
+    // Support either "FROM=TO" or "FROM:TO" as separator
+    const eqIdx = mapping.indexOf('=');
+    const colonIdx = mapping.indexOf(':');
+
+    let sep = -1;
+    // "O:/=/Volumes" — the colon inside "O:/" is part of a Windows drive letter; prefer '=' separator
+    if (eqIdx !== -1) {
+      sep = eqIdx;
+    } else if (colonIdx !== -1) {
+      sep = colonIdx;
+    }
+
+    if (sep === -1) {
+      throw new Error(
+        `Invalid --path-prefix format: "${mapping}". Expected "FROM=TO" e.g. "O:/=/Volumes/nas/"`,
+      );
+    }
+
+    const from = mapping.slice(0, sep);
+    const to = mapping.slice(sep + 1);
+
+    if (!from || !to) {
+      throw new Error(
+        `Invalid --path-prefix format: "${mapping}". Both FROM and TO parts must be non-empty.`,
+      );
+    }
+
+    return { from, to };
+  }
 }
 
 // Export singleton instance

package/src/commands/PollWorkerCommand.js

@@ -342,6 +342,8 @@ export class PollWorkerCommand {
       batchSize: 100,
       showStats: false,
       onProgress,
+      ...(job.fileId && { fileId: job.fileId }),
+      ...(job.table && { table: job.table }),
     };
 
     return identifyCommand.execute(options);

package/src/config/config.js

@@ -37,10 +37,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.21';
+      return packageJson.version || '1.0.22';
     } catch (error) {
       console.warn('⚠️ Could not read package.json version, using fallback');
-      return '1.0.21';
+      return '1.0.22';
     }
   }
 

package/src/document-types/_pedimento-shared-extractors.js

@@ -25,49 +25,118 @@ export const tipoOperacionExtractor = {
   },
 };
 
-// 3) Clave de Pedimento: 2 chars after tipoOperacion
+// 3) Clave de Pedimento: 2 chars after tipoOperacion (multiple layout patterns)
 export const clavePedimentoExtractor = {
   field: 'clavePedimento',
   extract: (source) => {
-    const match = source.match(
-      /\d{2}\s+\d{2}\s+\d{4}\s+\d{7}\s+[A-Z]{3}\s+([A-Z0-9]{2})/,
-    );
-    return new FieldResult('clavePedimento', !!match, match ? match[1] : null);
+    const patterns = [
+      // Standard spaced layout: "22 07 3429 2002089 EXP RT"
+      /\d{2}\s+\d{2}\s+\d{4}\s+\d{7}\s+[A-Z]{3}\s+([A-Z0-9]{2})\b/,
+      // Concatenated 15-digit layout: "260734296013645 EXP RT"
+      /\d{15}\s+[A-Z]{3}\s+([A-Z0-9]{2})\b/,
+      // Fallback: T.OPER keyword followed by 2-char clave
+      /\b(?:EXP|IMP|TRA|TRN)\s+([A-Z][A-Z0-9])\b/,
+      // Explicit label
+      /CVE\.?\s*PED(?:IMENTO)?[^A-Z0-9]{0,60}?\b([A-Z][A-Z0-9])\b/i,
+    ];
+    for (const re of patterns) {
+      const m = source.match(re);
+      if (m) return new FieldResult('clavePedimento', true, m[1]);
+    }
+    return new FieldResult('clavePedimento', false, null);
   },
 };
 
 // 4) Aduana E/S: 3-digit code on the peso-bruto line
+//    Fallback A: allow 2-digit code (some SIMP layouts omit the leading zero).
+//    Fallback B: derive the 2-digit customs-office code from positions 2-3 of
+//    numPedimento (e.g. "260734296013645" → "07"), which is what the
+//    arela_path formula uses after padStart(2,'0').
 export const aduanaEntradaSalidaExtractor = {
   field: 'aduanaEntradaSalida',
   extract: (source) => {
-    const match = source.match(/^\s*\d+\s+[\d,.]+\s+(\d{3})\s*$/m);
-    return new FieldResult(
-      'aduanaEntradaSalida',
-      !!match,
-      match ? match[1] : null,
-    );
+    // Primary: 3-digit aduana code at end of peso-bruto line
+    const m3 = source.match(/^\s*\d+\s+[\d,.]+\s+(\d{3})\s*$/m);
+    if (m3) return new FieldResult('aduanaEntradaSalida', true, m3[1]);
+
+    // Fallback A: 2-digit aduana code at end of peso-bruto line
+    const m2 = source.match(/^\s*\d+\s+[\d,.]+\s+(\d{2})\s*$/m);
+    if (m2) return new FieldResult('aduanaEntradaSalida', true, m2[1]);
+
+    // Fallback B: derive 2-digit customs-office code from numPedimento
+    //   Format: AA BB CCCC DDDDDDD  →  BB (positions 2-3) = aduana
+    const pedMatch = source.match(/\d{2}\s?\d{2}\s?\d{4}\s?\d{7}/);
+    if (pedMatch) {
+      const num = pedMatch[0].replace(/\s/g, '');
+      if (num.length === 15) {
+        return new FieldResult(
+          'aduanaEntradaSalida',
+          true,
+          num.substring(2, 4),
+        );
+      }
+    }
+
+    return new FieldResult('aduanaEntradaSalida', false, null);
   },
 };
 
-// 5) RFC: 12–13 alphanumeric chars on its own line
+// 5) RFC: importer/exporter RFC on its own line.
+//    Strategy A: strict whole-line pattern (3-4 letters + 6 consecutive digits +
+//    3 alphanum). COVE codes like COVE2681B1RX8 naturally fail this because
+//    their digit section is non-consecutive (2681B1 has a letter at pos 5).
+//    Strategy B: RFC as a word within a longer line (handles "RFC: IMS030409FZ0").
+//    Strategy C: loose 12-13 alphanum isolated on its own line — iterate ALL
+//    matches via matchAll() so that a leading COVE code is skipped and the
+//    actual RFC (which appears later in the document) is still found.
 export const rfcExtractor = {
   field: 'rfc',
   extract: (source) => {
-    const match = source.match(/\n\s*([A-Z0-9]{12,13})\s*\n/);
-    return new FieldResult('rfc', !!match, match ? match[1] : null);
+    const RFC_STRICT = /^[A-Z]{3,4}\d{6}[A-Z0-9]{3}$/i;
+    const lines = source
+      .split(/\r?\n/)
+      .map((l) => l.trim())
+      .filter((l) => l);
+
+    // Primary: RFC occupies an entire trimmed line
+    const strictLine = lines.find((line) => RFC_STRICT.test(line));
+    if (strictLine) return new FieldResult('rfc', true, strictLine);
+
+    // Fallback A: RFC embedded in a longer line (word-boundary search)
+    for (const line of lines) {
+      const m = line.match(/\b([A-Z]{3,4}\d{6}[A-Z0-9]{3})\b/i);
+      if (m) return new FieldResult('rfc', true, m[1]);
+    }
+
+    // Fallback B: loose 12-13 alphanum isolated on its own line.
+    // Use matchAll() to iterate ALL occurrences — a leading COVE code must not
+    // short-circuit the search; the RFC typically follows it in the document.
+    for (const m of source.matchAll(/\n\s*([A-Z0-9]{12,13})\s*\n/g)) {
+      if (!/^COVE/i.test(m[1])) return new FieldResult('rfc', true, m[1]);
+    }
+
+    return new FieldResult('rfc', false, null);
   },
 };
 
-// 6) Código de Aceptación: 8 alphanumeric chars on the line right after the RFC
+// 6) Código de Aceptación: 8 alphanumeric chars on the line right after the RFC.
+//    Uses the same RFC-line detection logic as rfcExtractor.
 export const codigoAceptacionExtractor = {
   field: 'codigoAceptacion',
   extract: (source) => {
+    const RFC_STRICT = /^[A-Z]{3,4}\d{6}[A-Z0-9]{3}$/i;
+    const RFC_LOOSE = /^[A-Z0-9]{12,13}$/;
     const lines = source
       .split(/\r?\n/)
       .map((l) => l.trim())
       .filter((l) => l.length > 0);
 
-    const rfcIndex = lines.findIndex((l) => /^[A-Z0-9]{12,13}$/.test(l));
+    // Find RFC line using strict pattern first, then loose (excluding COVE)
+    let rfcIndex = lines.findIndex((l) => RFC_STRICT.test(l));
+    if (rfcIndex < 0) {
+      rfcIndex = lines.findIndex((l) => RFC_LOOSE.test(l) && !/^COVE/i.test(l));
+    }
+
     let code = null;
     if (rfcIndex >= 0 && /^[A-Z0-9]{8}$/.test(lines[rfcIndex + 1] || '')) {
       code = lines[rfcIndex + 1];
@@ -77,24 +146,31 @@ export const codigoAceptacionExtractor = {
 };
 
 // 7) Num. E-Document: collects all 13-char alphanumeric codes following
-//    `NUM. E-DOCUMENT` labels. CoveFact / Pedimento Completo emit one row
-//    per ED clave inside the CLAVE/COMPL. IDENTIFICADOR table.
+//    `NUM. E-DOCUMENT` / `NUMERO DE E-DOCUMENT` labels.
 export const numEDocumentoExtractor = {
   field: 'numEDocumento',
   extract: (source) => {
     const lines = source.split(/\r?\n/);
-    const edocLines = lines.filter((line) => /NUM\.?\s*E-DOCUMENT/i.test(line));
+    const extractedCodes = [];
+    const titlePatterns = [/NUMERO\s+DE\s+E-DOCUMENT/i, /NUM\.?\s*E-DOCUMENT/i];
 
-    if (edocLines.length === 0) {
-      return new FieldResult('numEDocumento', false, null);
-    }
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const hasTitle = titlePatterns.some((p) => p.test(line));
+      if (!hasTitle) continue;
 
-    const extractedCodes = [];
-    edocLines.forEach((line) => {
-      const afterEdoc = line.replace(/.*NUM\.?\s*E-DOCUMENT\s*/i, '');
-      const codes = afterEdoc.match(/[A-Z0-9]{13}/g) || [];
-      extractedCodes.push(...codes);
-    });
+      // Codes on the title line itself
+      const codesInLine = line.match(/[A-Z0-9]{13}/g) || [];
+      extractedCodes.push(...codesInLine);
+
+      // Codes on the next few lines (e.g. CLAVE/COMPL. table rows)
+      for (let j = 1; j <= 10 && i + j < lines.length; j++) {
+        const nextLine = lines[i + j];
+        if (/NUMERO|OBSERVACIONES/i.test(nextLine)) break;
+        const codesInNextLine = nextLine.match(/[A-Z0-9]{13}/g) || [];
+        extractedCodes.push(...codesInNextLine);
+      }
+    }
 
     if (extractedCodes.length === 0) {
       return new FieldResult('numEDocumento', false, null);
@@ -109,14 +185,18 @@ export const numEDocumentoExtractor = {
 export const paymentDateExtractor = {
   field: 'paymentDate',
   extract: (source) => {
-    let match = source.match(/2\s+PAGO:\s*(\d{2}\/\d{2}\/\d{4})/);
-    if (!match) {
-      match = source.match(/FECHA DE PAGO:\s*(\d{4}\/\d{2}\/\d{2})/);
-    }
-    if (!match) {
-      match = source.match(/PRESENTACION:\s*(\d{2}\/\d{2}\/\d{4})/);
+    const patterns = [
+      /FECHA\s+DE\s+PAGO:?\s*(\d{2}\/\d{2}\/\d{4})/i,
+      /FECHA\s+DE\s+PAGO:?\s*(\d{4}\/\d{2}\/\d{2})/i,
+      /2\s+PAGO:\s*(\d{2}\/\d{2}\/\d{4})/,
+      /(?:^|\n)\s*PAGO\s+(\d{2}\/\d{2}\/\d{4})/i,
+      /PRESENTACION:\s*(\d{2}\/\d{2}\/\d{4})/i,
+    ];
+    for (const re of patterns) {
+      const m = source.match(re);
+      if (m) return new FieldResult('paymentDate', true, m[1]);
     }
-    return new FieldResult('paymentDate', !!match, match ? match[1] : null);
+    return new FieldResult('paymentDate', false, null);
   },
 };
 
@@ -152,14 +232,16 @@ export const coveExtractor = {
 };
 
 // 10) Patente: from the PATENTE/PEDIMENTO/ADUANA header table
+//    Fallback A: pago electrónico line "3429 4024126 07" (pedimento_completo).
+//    Fallback B: positions 4-7 of numPedimento (always available when found).
 export const patenteExtractor = {
   field: 'patente',
   extract: (source) => {
+    // Primary: PATENTE:/PEDIMENTO:/ADUANA: header followed by data line
     const lines = source.split(/\r?\n/);
     const patenteHeaderIndex = lines.findIndex((line) =>
       /PATENTE:.*PEDIMENTO:.*ADUANA:/i.test(line),
     );
-
     if (patenteHeaderIndex >= 0) {
       for (let i = patenteHeaderIndex + 1; i < lines.length; i++) {
         const line = lines[i].trim();
@@ -169,6 +251,20 @@ export const patenteExtractor = {
         }
       }
     }
+
+    // Fallback A: pago electrónico line "3429 4024126 07"
+    const pagoMatch = source.match(/(\d{4})\s+\d{7}\s+\d{2}/);
+    if (pagoMatch) return new FieldResult('patente', true, pagoMatch[1]);
+
+    // Fallback B: positions 4-7 of numPedimento
+    const pedMatch = source.match(/\d{2}\s?\d{2}\s?\d{4}\s?\d{7}/);
+    if (pedMatch) {
+      const num = pedMatch[0].replace(/\s/g, '');
+      if (num.length === 15) {
+        return new FieldResult('patente', true, num.substring(4, 8));
+      }
+    }
+
     return new FieldResult('patente', false, null);
   },
 };

package/src/document-types/pedimento-completo.js

@@ -17,22 +17,53 @@ export const pedimentoCompletoDefinition = {
   type: 'pedimento_completo',
   extensions: ['pdf'],
   match: (source) => {
+    // Hard exclude: "FORMA SIMPLIFICADA" is handled by pedimento_simplificado.
     if (/FORMA SIMPLIFICADA DE PEDIMENTO/i.test(source)) return false;
 
+    // Hard exclude: "AVISO CONSOLIDADO" shares the header trio but is a
+    // different document type handled by aviso_consolidado.
+    if (/AVISO\s+CONSOLIDADO/i.test(source)) return false;
+
     const hasHeaderFields =
       /NUM\.?\s*PEDIMENTO:/i.test(source) &&
       /CVE\.?\s*PEDIMENTO:/i.test(source) &&
       /T\.?\s*OPER:/i.test(source);
-    if (!hasHeaderFields) return false;
+    if (hasHeaderFields) {
+      const hasCopyMarker =
+        /ORIGINAL:\s*ADMINISTRACION GENERAL DE ADUANAS/i.test(source) ||
+        /SEGUNDA\s+COPIA/i.test(source) ||
+        /TERCERA\s+COPIA/i.test(source) ||
+        /COPIA\s+(SIMPLIFICAD[AO])?\s*TRANSPORTISTA/i.test(source) ||
+        /DEFINITIVO/i.test(source) ||
+        /ANEXO\s+DEL\s+PEDIMENTO/i.test(source) ||
+        /\*+FIN\s+DE\s+PEDIMENTO\s*\*+/i.test(source);
+      if (hasCopyMarker) return true;
+    }
 
-    const hasCopyMarker =
-      /ORIGINAL:\s*ADMINISTRACION GENERAL DE ADUANAS/i.test(source) ||
-      /SEGUNDA COPIA/i.test(source) ||
-      /TERCERA COPIA/i.test(source) ||
-      /COPIA\s+(SIMPLIFICAD[AO])?\s*TRANSPORTISTA/i.test(source) ||
-      /DEFINITIVO/i.test(source);
+    // Fallback clue-counting heuristic for exotic layouts.
+    const clues = [
+      /\bPEDIMENTO\s*\n.*NUM\.\s*PEDIMENTO:/i,
+      /NUM\.\s*PEDIMENTO:\s*T\.OPER:\s*CVE\.PEDIMENTO:\s*REGIMEN:/i,
+      /\d{2}\s+\d{2}\s+\d{4}\s+\d{7}\s+[A-Z]{3}\s+[A-Z]{3}/i,
+      /CERTIFICACIONES/i,
+      /DESTINO\/ORIGEN\s+TIPO\s+CAMBIO\s+PESO\s+BRUTO\s+ADUANA\s+E\/S/i,
+      /MEDIOS\s+DE\s+TRANSPORTE/i,
+      /DATOS\s+DEL\s+IMPORTADOR\/EXPORTADOR/i,
+      /RFC:\s+NOMBRE,\s+DENOMINACION\s+O\s+RAZON\s+SOCIAL:/i,
+      /CUADRO\s+DE\s+LIQUIDACION/i,
+      /\*\*\*\s+PAGO\s+ELECTRONICO\s+\*\*\*/i,
+      /PATENTE:\s+PEDIMENTO:\s+ADUANA:/i,
+      /LINEA\s+DE\s+CAPTURA:/i,
+      /DATOS\s+DEL\s+PROVEEDOR\s+O\s+COMPRADOR/i,
+      /CLAVE\/COMPL\.\s+IDENTIFICADOR/i,
+      /ANEXO\s+DEL\s+PEDIMENTO/i,
+      /\*+FIN\s+DE\s+PEDIMENTO\s+\*+NUM\.\s+TOTAL\s+DE\s+PARTIDAS:/i,
+      /DECLARO\s+BAJO\s+PROTESTA\s+DE\s+DECIR\s+VERDAD/i,
+      /PEDIMENTO\s+ELABORADO\s+DE\s+CONFORMIDAD/i,
+    ];
 
-    return hasCopyMarker;
+    const found = clues.filter((clue) => clue.test(source));
+    return found.length > clues.length * 0.25;
   },
 
   /**

package/src/document-types/pedimento-simplificado.js

@@ -7,7 +7,36 @@ export const pedimentoSimplificadoDefinition = {
   type: 'pedimento_simplificado',
   extensions: ['pdf'],
   match: (source) => {
-    return /FORMA SIMPLIFICADA DE PEDIMENTO/i.test(source);
+    // Hard exclude: "AVISO CONSOLIDADO" shares the header trio but is a
+    // different document type handled by aviso_consolidado.
+    if (/AVISO\s+CONSOLIDADO/i.test(source)) return false;
+
+    // Fast path: the literal title appears on standard SIMP layouts.
+    if (/FORMA SIMPLIFICADA DE PEDIMENTO/i.test(source)) return true;
+
+    // Some PDFs (single-page anchors) lack that title but still carry the
+    // three pedimento header fields. Treat them as simplificado UNLESS they
+    // have the multi-page copy markers that uniquely identify a completo.
+    const hasHeaderFields =
+      /NUM\.?\s*PEDIMENTO:/i.test(source) &&
+      /CVE\.?\s*PEDIMENTO:/i.test(source) &&
+      /T\.?\s*OPER:/i.test(source);
+    if (!hasHeaderFields) return false;
+
+    const hasCompletoCopyMarker =
+      /ORIGINAL:\s*ADMINISTRACION GENERAL DE ADUANAS/i.test(source) ||
+      /SEGUNDA\s+COPIA/i.test(source) ||
+      /TERCERA\s+COPIA/i.test(source) ||
+      /COPIA\s+(SIMPLIFICAD[AO])?\s*TRANSPORTISTA/i.test(source) ||
+      /ANEXO\s+DEL\s+PEDIMENTO/i.test(source) ||
+      /\*+FIN\s+DE\s+PEDIMENTO\s*\*+/i.test(source);
+    if (hasCompletoCopyMarker) return false;
+
+    // Exclude COVE/eDocument forms that may reference a pedimento in their body.
+    if (/COMPROBANTE\s+DE\s+VALOR\s+ELECTR[ÓO]NICO/i.test(source)) return false;
+    if (/\bCOVE\b\s*:/i.test(source) && !/PAGO/i.test(source)) return false;
+
+    return true;
   },
 
   /**

package/src/index.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
 
+import datastageCommand from './commands/DatastageCommand.js';
 import gdriveSyncCommand from './commands/GDriveSyncCommand.js';
 import identifyCommand from './commands/IdentifyCommand.js';
 import pollWorkerCommand from './commands/PollWorkerCommand.js';
@@ -26,6 +27,7 @@ class ArelaUploaderCLI {
     this.scanCommand = scanCommand;
     this.uploadCommand = new UploadCommand();
     this.watchCommand = watchCommand;
+    this.datastageCommand = datastageCommand;
 
     this.#setupProgram();
     this.#setupCommands();
@@ -204,6 +206,34 @@ class ArelaUploaderCLI {
         }
       });
 
+    // 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')
@@ -335,6 +365,18 @@ class ArelaUploaderCLI {
         '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 {

package/src/services/DatastageApiService.js

@@ -0,0 +1,240 @@
+import FormData from 'form-data';
+import fs from 'fs';
+import { Agent } from 'http';
+import { Agent as HttpsAgent } from 'https';
+import fetch from 'node-fetch';
+import path from 'path';
+
+import appConfig from '../config/config.js';
+import logger from './LoggingService.js';
+
+/**
+ * Datastage API Service
+ * Handles API communication for the arela datastage command:
+ *  - tracking endpoints under /api/uploader/datastage/*
+ *  - zip upload endpoint POST /api/datastage (multipart, field: zipFile)
+ */
+export class DatastageApiService {
+  /**
+   * @param {string|null} apiTarget - 'default'|'agencia'|'cliente'
+   */
+  constructor(apiTarget = null) {
+    this.apiTarget = apiTarget;
+    const apiConfig = appConfig.getApiConfig(apiTarget);
+    this.baseUrl = apiConfig.baseUrl;
+    this.token = apiConfig.token;
+
+    const maxApiConnections = parseInt(process.env.MAX_API_CONNECTIONS) || 10;
+    const connectionTimeout =
+      parseInt(process.env.API_CONNECTION_TIMEOUT) || 300000;
+
+    this.maxRetries = parseInt(process.env.API_MAX_RETRIES) || 3;
+    this.useExponentialBackoff =
+      process.env.API_RETRY_EXPONENTIAL_BACKOFF !== 'false';
+    this.fixedRetryDelay = parseInt(process.env.API_RETRY_DELAY) || 1000;
+
+    const agentOpts = {
+      keepAlive: true,
+      keepAliveMsecs: 30000,
+      maxSockets: maxApiConnections,
+      maxFreeSockets: Math.ceil(maxApiConnections / 2),
+      maxTotalSockets: maxApiConnections + 5,
+      timeout: connectionTimeout,
+      scheduling: 'fifo',
+    };
+    this.httpAgent = new Agent(agentOpts);
+    this.httpsAgent = new HttpsAgent(agentOpts);
+
+    logger.debug(
+      `🔗 Datastage API Service configured (target=${apiTarget || 'default'})`,
+    );
+  }
+
+  #getAgent(url) {
+    return url.startsWith('https://') ? this.httpsAgent : this.httpAgent;
+  }
+
+  #isRetryableError(error, response = null) {
+    if (
+      error?.code === 'ECONNRESET' ||
+      error?.code === 'ETIMEDOUT' ||
+      error?.code === 'ECONNREFUSED' ||
+      error?.code === 'ENOTFOUND' ||
+      error?.code === 'EAI_AGAIN'
+    ) {
+      return true;
+    }
+    if (response) {
+      const s = response.status;
+      if (s === 429 || (s >= 500 && s < 600)) return true;
+    }
+    if (error?.message && error.message.includes('timeout')) return true;
+    return false;
+  }
+
+  #calculateBackoff(attempt) {
+    if (!this.useExponentialBackoff) {
+      const jitter = this.fixedRetryDelay * 0.2 * (Math.random() * 2 - 1);
+      return Math.floor(this.fixedRetryDelay + jitter);
+    }
+    const baseDelay = 1000;
+    const maxDelay = 16000;
+    const delay = Math.min(baseDelay * Math.pow(2, attempt - 1), maxDelay);
+    const jitter = delay * 0.2 * (Math.random() * 2 - 1);
+    return Math.floor(delay + jitter);
+  }
+
+  #sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+  }
+
+  async #requestJson(endpoint, method = 'GET', body = null, headers = {}) {
+    const url = `${this.baseUrl}${endpoint}`;
+    const options = {
+      method,
+      headers: {
+        'x-api-key': this.token,
+        'Content-Type': 'application/json',
+        ...headers,
+      },
+      agent: this.#getAgent(url),
+    };
+    if (body) options.body = JSON.stringify(body);
+
+    let lastError;
+    let lastResponse = null;
+    const retries = this.maxRetries;
+
+    for (let attempt = 1; attempt <= retries + 1; attempt++) {
+      try {
+        const response = await fetch(url, options);
+        lastResponse = response;
+        if (!response.ok) {
+          const errorText = await response.text();
+          let errorMessage = `API ${method} ${endpoint} failed: ${response.status} ${response.statusText}`;
+          try {
+            const j = JSON.parse(errorText);
+            errorMessage = j.message || errorMessage;
+          } catch {
+            errorMessage = errorText || errorMessage;
+          }
+          const err = new Error(errorMessage);
+          err.status = response.status;
+          if (this.#isRetryableError(err, response) && attempt <= retries) {
+            const d = this.#calculateBackoff(attempt);
+            logger.warn(
+              `Retrying ${method} ${endpoint} (attempt ${attempt}/${retries + 1}) in ${d}ms: ${errorMessage}`,
+            );
+            await this.#sleep(d);
+            continue;
+          }
+          throw err;
+        }
+        return await response.json();
+      } catch (error) {
+        lastError = error;
+        if (this.#isRetryableError(error, lastResponse) && attempt <= retries) {
+          const d = this.#calculateBackoff(attempt);
+          logger.warn(
+            `Retrying ${method} ${endpoint} (attempt ${attempt}/${retries + 1}) in ${d}ms: ${error.message}`,
+          );
+          await this.#sleep(d);
+          continue;
+        }
+        throw error;
+      }
+    }
+    throw lastError;
+  }
+
+  // --- Tracking endpoints ---
+
+  async registerUpload({
+    absolutePath,
+    fileName,
+    sizeBytes,
+    fileModifiedAt,
+    sourceDirectory,
+  }) {
+    return this.#requestJson('/api/uploader/datastage/register', 'POST', {
+      absolutePath,
+      fileName,
+      sizeBytes,
+      fileModifiedAt,
+      sourceDirectory,
+    });
+  }
+
+  async getPending(sourceDirectory = null) {
+    const qs = sourceDirectory
+      ? `?sourceDirectory=${encodeURIComponent(sourceDirectory)}`
+      : '';
+    return this.#requestJson(`/api/uploader/datastage/pending${qs}`, 'GET');
+  }
+
+  async getStats(sourceDirectory = null) {
+    const qs = sourceDirectory
+      ? `?sourceDirectory=${encodeURIComponent(sourceDirectory)}`
+      : '';
+    return this.#requestJson(`/api/uploader/datastage/stats${qs}`, 'GET');
+  }
+
+  async markUploaded(id, { datastageId, folio }) {
+    return this.#requestJson(
+      `/api/uploader/datastage/${id}/mark-uploaded`,
+      'PATCH',
+      { datastageId, folio },
+    );
+  }
+
+  async markFailed(id, error) {
+    return this.#requestJson(
+      `/api/uploader/datastage/${id}/mark-failed`,
+      'PATCH',
+      { error: String(error || 'unknown') },
+    );
+  }
+
+  // --- Zip upload ---
+
+  /**
+   * Upload a single zip file to POST /api/datastage (multipart, field name 'zipFile').
+   * Returns the created Datastage row { id, folio, ... }.
+   */
+  async uploadZip(localPath) {
+    const url = `${this.baseUrl}/api/datastage`;
+    const form = new FormData();
+    const fileName = path.basename(localPath);
+    form.append('zipFile', fs.createReadStream(localPath), {
+      filename: fileName,
+      contentType: 'application/zip',
+    });
+
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'x-api-key': this.token,
+        ...form.getHeaders(),
+      },
+      body: form,
+      agent: this.#getAgent(url),
+    });
+
+    if (!response.ok) {
+      const text = await response.text();
+      let msg = `Datastage upload failed: ${response.status} ${response.statusText}`;
+      try {
+        const j = JSON.parse(text);
+        msg = j.message || msg;
+      } catch {
+        msg = text || msg;
+      }
+      const err = new Error(msg);
+      err.status = response.status;
+      throw err;
+    }
+    return await response.json();
+  }
+}
+
+export default DatastageApiService;

package/src/services/ScanApiService.js

@@ -375,6 +375,20 @@ export class ScanApiService {
    * @param {boolean} allTypes - When true, fetch all supported file types instead of just likely-simplificado PDFs
    * @returns {Promise<Object>} { data: Array, hasMore: boolean }
    */
+  /**
+   * Get a single file record by ID (for single-file identify mode).
+   * @param {string} tableName - Scan table name (with or without cli. prefix)
+   * @param {string} fileId - UUID of the file record
+   * @returns {Promise<{ id: string, file_name: string, file_extension: string, absolute_path: string }>}
+   */
+  async getFileRecord(tableName, fileId) {
+    const cleanTable = tableName.replace(/^cli\./, '');
+    const url = `/api/uploader/scan/file-record?tableName=${encodeURIComponent(cleanTable)}&fileId=${encodeURIComponent(fileId)}`;
+    const result = await this.#request(url, 'GET');
+    logger.debug(`Fetched file record ${fileId} from ${cleanTable}`);
+    return result;
+  }
+
   async fetchPdfsForDetection(
     tableName,
     offset = 0,
@@ -398,6 +412,22 @@ export class ScanApiService {
     return result;
   }
 
+  /**
+   * Reset detection_attempts to 0 for undetected files so they can be re-processed.
+   * @param {string} tableName - Target scan table name
+   * @param {string|null} absolutePath - If provided, reset only this specific file
+   * @returns {Promise<{ reset: number }>}
+   */
+  async resetDetectionAttempts(tableName, absolutePath = null) {
+    let url = `/api/uploader/scan/reset-detection-attempts?tableName=${encodeURIComponent(tableName)}`;
+    if (absolutePath) {
+      url += `&absolutePath=${encodeURIComponent(absolutePath)}`;
+    }
+    const result = await this.#request(url, 'PATCH');
+    logger.debug(`Reset ${result.reset} detection attempt(s) in ${tableName}`);
+    return result;
+  }
+
   /**
    * Batch update detection results
    * @param {string} tableName - Target table name