@devlas/dte-sii 2.5.0

package/BoletaService.js

@@ -0,0 +1,109 @@
+// Copyright (c) 2026 Devlas SpA — https://devlas.cl
+// Licencia MIT. Ver archivo LICENSE para mas detalles.
+/**
+ * BoletaService
+ * 
+ * Servicio simplificado para crear boletas electrónicas
+ */
+
+const Certificado = require('./Certificado');
+const CAF = require('./CAF');
+const DTE = require('./DTE');
+const { 
+  sanitizeSiiText,
+  buildDetalle,
+  calcularTotalesDesdeItems,
+  buildReceptorConsumidorFinal,
+  dteError,
+  ERROR_CODES,
+  createScopedLogger,
+  TIPOS_DTE,
+  esBoleta,
+} = require('./utils');
+
+const log = createScopedLogger('BoletaService');
+
+class BoletaService {
+  constructor(config) {
+    this.config = config;
+    this.certificado = null;
+    this.caf = null;
+  }
+  
+  /**
+   * Cargar certificado desde buffer PFX
+   */
+  cargarCertificado(pfxBuffer, password) {
+    this.certificado = new Certificado(pfxBuffer, password);
+    return this;
+  }
+  
+  /**
+   * Cargar CAF desde string XML
+   */
+  cargarCAF(xmlContent) {
+    this.caf = new CAF(xmlContent);
+    return this;
+  }
+  
+  /**
+   * Crear y firmar una boleta
+   * @param {Array} items - Items de la boleta [{NmbItem, QtyItem, PrcItem}]
+   * @param {number} folio - Número de folio
+   * @param {Object} receptor - Datos del receptor (opcional)
+   * @returns {Object} - Resultado con XML firmado
+   */
+  crearBoleta(items, folio, receptor = null) {
+    if (!this.certificado) {
+      throw dteError('Certificado no cargado', ERROR_CODES.CERT_INVALID);
+    }
+    if (!this.caf) {
+      throw dteError('CAF no cargado', ERROR_CODES.CAF_INVALID);
+    }
+    
+    // Usar utilidades centralizadas para construir detalle y calcular totales
+    const detalle = buildDetalle(items);
+    const totales = calcularTotalesDesdeItems(items);
+    
+    const datos = {
+      Encabezado: {
+        IdDoc: {
+          TipoDTE: TIPOS_DTE.BOLETA,
+          Folio: folio,
+          FchEmis: new Date().toISOString().split('T')[0],
+          IndServicio: 3,
+        },
+        Emisor: {
+          RUTEmisor: this.config.rutEmisor,
+          RznSocEmisor: this.config.razonSocial,
+          GiroEmisor: this.config.giro,
+          DirOrigen: this.config.direccion,
+          CmnaOrigen: this.config.comuna,
+        },
+        Receptor: receptor || buildReceptorConsumidorFinal(),
+        Totales: {
+          MntTotal: totales.MntTotal,
+        },
+      },
+      Detalle: detalle,
+    };
+    
+    const dte = new DTE(datos);
+    dte.generarXML();
+    dte.timbrar(this.caf);
+    dte.firmar(this.certificado);
+    
+    log.log(`✅ Boleta creada: Folio ${folio}, Monto $${totales.MntTotal}`);
+    
+    return {
+      ok: true,
+      folio,
+      tipo_dte: TIPOS_DTE.BOLETA,
+      fecha: datos.Encabezado.IdDoc.FchEmis,
+      monto_total: totales.MntTotal,
+      xml: dte.getXML(),
+    };
+  }
+}
+
+module.exports = BoletaService;

package/CAF.js

@@ -0,0 +1,173 @@
+// Copyright (c) 2026 Devlas SpA — https://devlas.cl
+// Licencia MIT. Ver archivo LICENSE para mas detalles.
+/**
+ * CAF (Código de Autorización de Folios)
+ * 
+ * Maneja los archivos CAF del SII para timbraje de documentos
+ */
+
+const forge = require('node-forge');
+const { 
+  cafError, 
+  ERROR_CODES, 
+  createScopedLogger,
+  parseXml,
+  buildXml,
+  IDK_CERTIFICACION,
+  getNombreDte,
+} = require('./utils');
+
+const log = createScopedLogger('CAF');
+
+class CAF {
+  /**
+   * @param {string} xmlContent - Contenido XML del archivo CAF
+   * @throws {DteSiiError} Si el CAF es inválido
+   */
+  constructor(xmlContent) {
+    if (!xmlContent || typeof xmlContent !== 'string') {
+      throw cafError('CAF XML content es requerido', ERROR_CODES.CAF_INVALID, { xmlContent });
+    }
+    
+    // Usar parser centralizado
+    try {
+      this.data = parseXml(xmlContent);
+    } catch (err) {
+      throw cafError(`Error parseando CAF XML: ${err.message}`, ERROR_CODES.CAF_INVALID, { originalError: err });
+    }
+
+    // Validar estructura
+    if (!this.data.AUTORIZACION) {
+      throw cafError('CAF inválido: falta elemento AUTORIZACION', ERROR_CODES.CAF_INVALID);
+    }
+
+    this.autorizacion = this.data.AUTORIZACION;
+    this.caf = this.autorizacion.CAF;
+    
+    if (!this.caf) {
+      throw cafError('CAF inválido: falta elemento CAF', ERROR_CODES.CAF_INVALID);
+    }
+
+    this.da = this.caf.DA;
+    
+    if (!this.da) {
+      throw cafError('CAF inválido: falta elemento DA (Datos de Autorización)', ERROR_CODES.CAF_INVALID);
+    }
+    
+    // Propiedades principales
+    this.tipo = parseInt(this.da.TD, 10);
+    this.folioDesde = parseInt(this.da.RNG?.D, 10);
+    this.folioHasta = parseInt(this.da.RNG?.H, 10);
+    this.rutEmisor = this.da.RE;
+    
+    if (isNaN(this.folioDesde) || isNaN(this.folioHasta)) {
+      throw cafError('CAF inválido: rango de folios no válido', ERROR_CODES.CAF_INVALID, {
+        folioDesde: this.da.RNG?.D,
+        folioHasta: this.da.RNG?.H,
+      });
+    }
+    
+    // Clave privada del CAF
+    if (!this.autorizacion.RSASK) {
+      throw cafError('CAF inválido: falta clave privada RSASK', ERROR_CODES.CAF_INVALID);
+    }
+
+    this.privateKeyPem = this.autorizacion.RSASK.trim();
+    
+    try {
+      this.privateKey = forge.pki.privateKeyFromPem(this.privateKeyPem);
+    } catch (err) {
+      throw cafError(`Error cargando clave privada del CAF: ${err.message}`, ERROR_CODES.CAF_INVALID, { originalError: err });
+    }
+    
+    // CAF XML original (el SII exige formato exacto)
+    this._originalCafXml = this._extractCafXml(xmlContent);
+
+    log.debug(`CAF cargado: Tipo ${this.tipo}, Folios ${this.folioDesde}-${this.folioHasta}`);
+  }
+  
+  /**
+   * Extraer el CAF XML exacto del archivo original
+   */
+  _extractCafXml(xmlContent) {
+    const cafMatch = xmlContent.match(/<CAF[^>]*>[\s\S]*?<\/CAF>/);
+    if (cafMatch) {
+      // Normalizar: quitar espacios entre tags
+      return cafMatch[0].replace(/>\s+</g, '><');
+    }
+    return null;
+  }
+  
+  // Getters
+  getRutEmisor() { return this.da.RE; }
+  getTipoDTE() { return parseInt(this.da.TD, 10); }
+  getFolioDesde() { return parseInt(this.da.RNG.D, 10); }
+  getFolioHasta() { return parseInt(this.da.RNG.H, 10); }
+  getIDK() { return parseInt(this.da.IDK, 10); }
+  esCertificacion() { return this.getIDK() === IDK_CERTIFICACION; }
+  
+  /**
+   * Obtener nombre del tipo de DTE
+   * @param {boolean} [corto=false] - Si usar nombre corto
+   * @returns {string}
+   */
+  getNombreTipoDTE(corto = false) {
+    return getNombreDte(this.tipo, corto);
+  }
+  
+  /**
+   * Obtener CAF XML para insertar en TED
+   */
+  getCafXml() {
+    if (this._originalCafXml) {
+      return this._originalCafXml;
+    }
+    // Fallback: reconstruir usando builder centralizado
+    return buildXml({ CAF: this.caf });
+  }
+  
+  /**
+   * Firmar datos con la clave privada del CAF (para TED)
+   * IMPORTANTE: Usamos 'latin1' porque así interpreta forge los bytes
+   * y debe coincidir con lo que se pasa al PDF417
+   */
+  sign(data) {
+    const md = forge.md.sha1.create();
+    md.update(data, 'latin1');
+    const signature = this.privateKey.sign(md);
+    return forge.util.encode64(signature);
+  }
+  
+  /**
+   * Verificar si un folio está dentro del rango autorizado
+   * @param {number} folio - Número de folio
+   * @returns {boolean} True si es válido
+   */
+  isFolioValido(folio) {
+    return folio >= this.folioDesde && folio <= this.folioHasta;
+  }
+
+  /**
+   * Validar folio y lanzar error si no es válido
+   * @param {number} folio - Número de folio
+   * @throws {DteSiiError} Si el folio está fuera de rango
+   */
+  validarFolio(folio) {
+    if (!this.isFolioValido(folio)) {
+      throw cafError(
+        `Folio ${folio} fuera de rango autorizado (${this.folioDesde}-${this.folioHasta})`,
+        ERROR_CODES.FOLIO_OUT_OF_RANGE,
+        { folio, folioDesde: this.folioDesde, folioHasta: this.folioHasta, tipo: this.tipo }
+      );
+    }
+  }
+  
+  /**
+   * Obtener folios disponibles
+   */
+  getFoliosDisponibles() {
+    return this.folioHasta - this.folioDesde + 1;
+  }
+}
+
+module.exports = CAF;

package/CafSolicitor.js

@@ -0,0 +1,380 @@
+// Copyright (c) 2026 Devlas SpA — https://devlas.cl
+// Licencia MIT. Ver archivo LICENSE para mas detalles.
+/**
+ * CafSolicitor.js - Solicitador de CAFs al SII
+ * 
+ * Módulo interno del core para solicitar Códigos de Autorización de Folios (CAF)
+ * directamente al SII. Usa SiiSession para evitar duplicación de código.
+ * 
+ * Migrado desde: scripts/cert/test-caf-solicitar.js
+ * Refactorizado: Usa SiiSession para HTTP y utilidades
+ * 
+ * @module CafSolicitor
+ */
+
+const fs = require('fs');
+const path = require('path');
+const SiiSession = require('./SiiSession');
+const { splitRut } = require('./utils/rut');
+
+/**
+ * Clase para solicitar CAFs al SII
+ */
+class CafSolicitor {
+  /**
+   * @param {Object} options - Opciones de configuración
+   * @param {string} options.ambiente - 'certificacion' o 'produccion'
+   * @param {string} options.rutEmisor - RUT del emisor (ej: 76192083-9)
+   * @param {string} options.pfxPath - Ruta absoluta al certificado PFX
+   * @param {string} options.pfxPassword - Contraseña del certificado
+   * @param {string} [options.baseDir] - Directorio base para guardar archivos
+   * @param {string} [options.sessionPath] - Ruta al archivo de sesión compartida
+   * @param {string} [options.runStamp] - Timestamp de la ejecución
+   */
+  constructor(options = {}) {
+    if (!options.ambiente) {
+      throw new Error('CafSolicitor: options.ambiente es obligatorio');
+    }
+    if (!options.rutEmisor) {
+      throw new Error('CafSolicitor: options.rutEmisor es obligatorio');
+    }
+    if (!options.pfxPath) {
+      throw new Error('CafSolicitor: options.pfxPath es obligatorio');
+    }
+    if (!options.pfxPassword) {
+      throw new Error('CafSolicitor: options.pfxPassword es obligatorio');
+    }
+
+    this.ambiente = options.ambiente.toLowerCase();
+    this.rutEmisor = options.rutEmisor;
+    this.baseDir = options.baseDir || path.resolve(__dirname, '..', '..');
+    this.sessionPath = options.sessionPath || null;
+    this.runStamp = options.runStamp || new Date().toISOString().replace(/[:.]/g, '-');
+
+    // Crear SiiSession para manejar HTTP y cookies
+    this.session = new SiiSession({
+      ambiente: this.ambiente,
+      pfxPath: options.pfxPath,
+      pfxPassword: options.pfxPassword,
+    });
+
+    // Cargar sesión compartida si existe
+    if (this.sessionPath) {
+      const loaded = this.session.loadSession(this.sessionPath);
+      if (loaded) {
+        console.log('[CafSolicitor] ✓ Usando sesión compartida');
+      }
+    }
+  }
+
+  /**
+   * Crea directorio para debug de esta solicitud
+   * @private
+   */
+  _getDebugDir(tipoDte) {
+    const rutClean = String(this.rutEmisor).replace(/\./g, '').toUpperCase();
+    const runDir = path.join(this.baseDir, 'debug', 'auto-caf', rutClean, this.runStamp, String(tipoDte));
+    fs.mkdirSync(runDir, { recursive: true });
+    return runDir;
+  }
+
+  /**
+   * Guarda respuesta de debug
+   * @private
+   */
+  _saveDebug(debugDir, filename, content) {
+    const filePath = path.join(debugDir, filename);
+    fs.writeFileSync(filePath, content, 'utf-8');
+    console.log(`${filename}`);
+  }
+
+  /**
+   * Extrae información del CAF desde XML
+   * @private
+   */
+  _extractCafInfo(xml, tipoDte) {
+    const tdMatch = xml.match(/<TD>(\d+)<\/TD>/i);
+    const dMatch = xml.match(/<D>(\d+)<\/D>/i);
+    const hMatch = xml.match(/<H>(\d+)<\/H>/i);
+    const faMatch = xml.match(/<FA>(\d{4}-\d{2}-\d{2})<\/FA>/i);
+    
+    return {
+      tipoDte: tdMatch ? tdMatch[1] : tipoDte,
+      folioDesde: dMatch ? dMatch[1] : 'unknown',
+      folioHasta: hMatch ? hMatch[1] : 'unknown',
+      fechaAutorizacion: faMatch ? faMatch[1] : new Date().toISOString().slice(0, 10),
+    };
+  }
+
+  /**
+   * Guarda el CAF en ubicación organizada
+   * @private
+   */
+  _saveCafOrganized(xml, tipoDte) {
+    const info = this._extractCafInfo(xml, tipoDte);
+    const rutClean = this.rutEmisor.replace(/\./g, '').toUpperCase();
+    
+    const cafDir = path.join(
+      this.baseDir, 'debug', 'caf', this.ambiente,
+      rutClean, String(info.tipoDte), this.runStamp
+    );
+    fs.mkdirSync(cafDir, { recursive: true });
+    
+    const cafFileName = `caf-${info.tipoDte}-${info.folioDesde}-${info.folioHasta}.xml`;
+    const cafPath = path.join(cafDir, cafFileName);
+    fs.writeFileSync(cafPath, xml, 'utf-8');
+    
+    console.log(`✅ CAF guardado: ${cafFileName}`);
+    console.log(`   Ruta: ${cafPath}`);
+    
+    return cafPath;
+  }
+
+  /**
+   * Detecta si la respuesta del SII requiere autenticación con certificado.
+   * @private
+   */
+  _requiresAuthentication(responseBody = '') {
+    if (!responseBody || typeof responseBody !== 'string') return false;
+
+    return (
+      responseBody.includes('Autenticaci') ||
+      responseBody.includes('autInicioDTE.cgi') ||
+      responseBody.includes('cgi_AUT2000') ||
+      responseBody.includes('302 Found')
+    );
+  }
+
+  /**
+   * Solicita un CAF al SII
+   * @param {Object} params - Parámetros
+   * @param {number} params.tipoDte - Tipo de DTE (33, 34, 39, 56, 61, etc.)
+   * @param {number} [params.cantidad=1] - Cantidad de folios a solicitar
+   * @returns {Promise<Object>} - { success, cafPath, xml, error }
+   */
+  async solicitar({ tipoDte, cantidad = 1 }) {
+    const { numero: rut, dv } = splitRut(this.rutEmisor);
+    const debugDir = this._getDebugDir(tipoDte);
+    
+    console.log('─'.repeat(60));
+    console.log(`[CafSolicitor] Solicitando CAF tipo ${tipoDte} x${cantidad}`);
+    console.log(`   RUT: ${this.rutEmisor} | Ambiente: ${this.ambiente}`);
+
+    try {
+      // Paso 1: POST inicial a of_solicita_folios
+      const fields = {
+        RUT_EMP: rut,
+        DV_EMP: dv,
+        COD_DOCTO: tipoDte,
+        CANTIDAD: cantidad,
+      };
+
+      let response = await this.session.submitForm('/cvc_cgi/dte/of_solicita_folios', fields);
+
+      // Manejar autenticación si es necesaria (incluye 302 a autInicioDTE)
+      if (this._requiresAuthentication(response.body)) {
+        const authResult = await this.session.ensureSession('/cvc_cgi/dte/of_solicita_folios');
+        if (authResult.body) {
+          // Reintentar después de autenticación
+          response = await this.session.submitForm('/cvc_cgi/dte/of_solicita_folios', fields);
+        }
+        
+        // Guardar sesión para reutilización
+        if (this.sessionPath) {
+          this.session.saveSession(this.sessionPath);
+        }
+      }
+
+      // Procesar flujo multi-paso del SII
+      response = await this._processMultiStepFlow(response, rut, dv, tipoDte, cantidad, debugDir);
+
+      // Guardar respuesta final
+      this._saveDebug(debugDir, `caf-final-${this.runStamp}.html`, response.body || '');
+
+      // Verificar si obtuvimos el CAF
+      if (response.body && response.body.includes('<AUTORIZACION')) {
+        const cafPath = this._saveCafOrganized(response.body, tipoDte);
+        return { success: true, cafPath, xml: response.body };
+      }
+
+      if (response.body && response.body.includes('Autenticaci')) {
+        return { success: false, error: 'El SII devolvió página de autenticación' };
+      }
+
+      return { success: false, error: 'No se obtuvo CAF en la respuesta' };
+
+    } catch (err) {
+      console.error(`[CafSolicitor] Error: ${err.message}`);
+      return { success: false, error: err.message };
+    }
+  }
+
+  /**
+   * Procesa el flujo multi-paso del SII para obtener CAF
+   * @private
+   */
+  async _processMultiStepFlow(response, rut, dv, tipoDte, cantidad, debugDir) {
+    let currentHtml = response.body || '';
+
+    // Paso 2: of_solicita_folios_dcto
+    if (currentHtml.includes('of_solicita_folios_dcto')) {
+      const formAction = SiiSession.extractFormAction(currentHtml) || '/cvc_cgi/dte/of_solicita_folios_dcto';
+      const hiddenInputs = SiiSession.extractInputValues(currentHtml);
+
+      const step2Fields = {
+        ...hiddenInputs,
+        RUT_EMP: rut,
+        DV_EMP: dv,
+      };
+
+      response = await this.session.submitForm(formAction, step2Fields);
+      currentHtml = response.body || '';
+      this._saveDebug(debugDir, `step2-${this.runStamp}.html`, currentHtml);
+
+      // Selección de tipo de documento
+      if (currentHtml.includes('COD_DOCTO')) {
+        const selectInputs = SiiSession.extractInputValues(currentHtml);
+        const selectFields = {
+          ...selectInputs,
+          RUT_EMP: rut,
+          DV_EMP: dv,
+          COD_DOCTO: tipoDte,
+        };
+
+        response = await this.session.submitForm('/cvc_cgi/dte/of_solicita_folios_dcto', selectFields);
+        currentHtml = response.body || '';
+        this._saveDebug(debugDir, `select-${this.runStamp}.html`, currentHtml);
+      }
+
+      // Paso 3: Solicitar numeración
+      response = await this._processStep3(response, rut, dv, tipoDte, cantidad, debugDir);
+    }
+
+    return response;
+  }
+
+  /**
+   * Procesa paso 3 y siguientes
+   * @private
+   */
+  async _processStep3(response, rut, dv, tipoDte, cantidad, debugDir) {
+    let currentHtml = response.body || '';
+    
+    const formAction3 = SiiSession.extractFormAction(currentHtml) || '/cvc_cgi/dte/of_confirma_folio';
+    const inputs3 = SiiSession.extractInputValues(currentHtml);
+    
+    const step3Fields = {
+      ...inputs3,
+      RUT_EMP: rut,
+      DV_EMP: dv,
+      COD_DOCTO: tipoDte,
+      CANT_DOCTOS: cantidad,
+      ACEPTAR: 'Solicitar Numeración',
+    };
+
+    response = await this.session.submitForm(formAction3, step3Fields);
+    currentHtml = response.body || '';
+    this._saveDebug(debugDir, `step3-${this.runStamp}.html`, currentHtml);
+
+    // Confirmar folio inicial
+    if (currentHtml.includes('of_confirma_folio')) {
+      response = await this._processConfirmFolio(response, debugDir);
+    } else if (currentHtml.includes('of_genera_folio')) {
+      response = await this._processGeneraFolio(response, debugDir);
+    }
+
+    return response;
+  }
+
+  /**
+   * Procesa confirmación de folio
+   * @private
+   */
+  async _processConfirmFolio(response, debugDir) {
+    let currentHtml = response.body || '';
+    
+    const formAction = SiiSession.extractFormAction(currentHtml) || '/cvc_cgi/dte/of_confirma_folio';
+    const inputs = SiiSession.extractInputValues(currentHtml);
+    
+    const fields = {
+      ...inputs,
+      FOLIO_INICIAL: inputs.FOLIO_INICIAL || '1',
+      ACEPTAR: 'Confirmar Folio Inicial',
+    };
+
+    response = await this.session.submitForm(formAction, fields);
+    currentHtml = response.body || '';
+    this._saveDebug(debugDir, `confirm-${this.runStamp}.html`, currentHtml);
+
+    if (currentHtml.includes('of_genera_folio')) {
+      response = await this._processGeneraFolio(response, debugDir);
+    }
+
+    return response;
+  }
+
+  /**
+   * Procesa generación de folio
+   * @private
+   */
+  async _processGeneraFolio(response, debugDir) {
+    let currentHtml = response.body || '';
+    
+    const formAction = SiiSession.extractFormAction(currentHtml) || '/cvc_cgi/dte/of_genera_folio';
+    const inputs = SiiSession.extractInputValues(currentHtml);
+    
+    const fields = {
+      ...inputs,
+      ACEPTAR: 'Obtener Folios',
+    };
+
+    response = await this.session.submitForm(formAction, fields);
+    currentHtml = response.body || '';
+    this._saveDebug(debugDir, `genera-${this.runStamp}.html`, currentHtml);
+
+    // Paso final: of_genera_archivo
+    if (!currentHtml.includes('<AUTORIZACION') && currentHtml.includes('of_genera_archivo')) {
+      response = await this._processGeneraArchivo(response, debugDir);
+    }
+
+    return response;
+  }
+
+  /**
+   * Procesa generación de archivo CAF
+   * @private
+   */
+  async _processGeneraArchivo(response, debugDir) {
+    let currentHtml = response.body || '';
+    
+    const formAction = SiiSession.extractFormAction(currentHtml) || '/cvc_cgi/dte/of_genera_archivo';
+    const inputs = SiiSession.extractInputValues(currentHtml);
+    
+    const fields = {
+      ...inputs,
+      ACEPTAR: 'AQUI',
+    };
+
+    response = await this.session.submitForm(formAction, fields);
+    currentHtml = response.body || '';
+    this._saveDebug(debugDir, `archivo-${this.runStamp}.xml`, currentHtml);
+
+    // A veces hay un paso extra
+    if (!currentHtml.includes('<AUTORIZACION') && currentHtml.includes('of_genera_archivo')) {
+      const formAction2 = SiiSession.extractFormAction(currentHtml) || '/cvc_cgi/dte/of_genera_archivo';
+      const inputs2 = SiiSession.extractInputValues(currentHtml);
+      
+      const fields2 = {
+        ...inputs2,
+        ACEPTAR: 'AQUI',
+      };
+
+      response = await this.session.submitForm(formAction2, fields2);
+      this._saveDebug(debugDir, `archivo2-${this.runStamp}.xml`, response.body || '');
+    }
+
+    return response;
+  }
+}
+
+module.exports = CafSolicitor;