@devlas/dte-sii 2.8.2 → 2.9.2

package/CafSolicitor.js

@@ -200,6 +200,11 @@ class CafSolicitor {
         return { success: false, error: 'El SII devolvió página de autenticación' };
       }
 
+      // Detectar error de límite diario del SII
+      if (response.body && response.body.includes('menor o igual al m')) {
+        return { success: false, error: 'Límite diario de folios SII agotado (MAX_AUTOR). Reintenta mañana.' };
+      }
+
       return { success: false, error: 'No se obtuvo CAF en la respuesta' };
 
     } catch (err) {
@@ -233,11 +238,15 @@ class CafSolicitor {
       // Selección de tipo de documento
       if (currentHtml.includes('COD_DOCTO')) {
         const selectInputs = SiiSession.extractInputValues(currentHtml);
+        // Respetar MAX_AUTOR que el SII informa en el formulario.
+        const maxAutorSelect = parseInt(selectInputs.MAX_AUTOR || '999', 10);
+        const cantSelect = Math.min(cantidad, maxAutorSelect);
         const selectFields = {
           ...selectInputs,
           RUT_EMP: rut,
           DV_EMP: dv,
           COD_DOCTO: tipoDte,
+          CANT_DOCTOS: cantSelect,
         };
 
         response = await this.session.submitForm('/cvc_cgi/dte/of_solicita_folios_dcto', selectFields);
@@ -262,12 +271,15 @@ class CafSolicitor {
     const formAction3 = SiiSession.extractFormAction(currentHtml) || '/cvc_cgi/dte/of_confirma_folio';
     const inputs3 = SiiSession.extractInputValues(currentHtml);
     
+    // Respetar MAX_AUTOR si viene en este paso también
+    const maxAutorStep3 = parseInt(inputs3.MAX_AUTOR || '999', 10);
+    const cantStep3 = Math.min(cantidad, maxAutorStep3);
     const step3Fields = {
       ...inputs3,
       RUT_EMP: rut,
       DV_EMP: dv,
       COD_DOCTO: tipoDte,
-      CANT_DOCTOS: cantidad,
+      CANT_DOCTOS: cantStep3,
       ACEPTAR: 'Solicitar Numeración',
     };
 
@@ -321,9 +333,17 @@ class CafSolicitor {
     
     const formAction = SiiSession.extractFormAction(currentHtml) || '/cvc_cgi/dte/of_genera_folio';
     const inputs = SiiSession.extractInputValues(currentHtml);
-    
+
+    // Respetar el máximo autorizado por el SII (puede ser menor a lo solicitado)
+    const maxAutor = parseInt(inputs.MAX_AUTOR || '999', 10);
+    const folioIni = parseInt(inputs.FOLIO_INI || '1', 10);
+    const cantOriginal = parseInt(inputs.CANT_DOCTOS || '1', 10);
+    const cantReal = Math.min(cantOriginal, maxAutor);
+
     const fields = {
       ...inputs,
+      CANT_DOCTOS: String(cantReal),
+      FOLIO_FIN: String(folioIni + cantReal - 1),
       ACEPTAR: 'Obtener Folios',
     };
 

package/DTE.js

@@ -71,8 +71,9 @@ class DTE {
   
   _convertirDatosSimplificados(d) {
     const esExenta = d.tipo === 41;
-    const { detalle, mntBruto, mntExento } = this._procesarItems(d.items, esExenta);
-    const totales = this._calcularTotales(mntBruto, mntExento, esExenta);
+    const precioConIva = d.precioConIva === true;
+    const { detalle, mntNeto, mntExento } = this._procesarItems(d.items, esExenta, precioConIva);
+    const totales = this._calcularTotales(mntNeto, mntExento, esExenta);
     
     const resultado = {
       Encabezado: {
@@ -86,6 +87,7 @@ class DTE {
         Receptor: {
           RUTRecep: d.receptor?.RUTRecep ?? '66666666-6',
           RznSocRecep: sanitizeSiiText(d.receptor?.RznSocRecep ?? 'Consumidor Final'),
+          ...(d.receptor?.GiroRecep ? { GiroRecep: d.receptor.GiroRecep } : {}),
           DirRecep: sanitizeSiiText(d.receptor?.DirRecep ?? 'Sin Direccion'),
           CmnaRecep: d.receptor?.CmnaRecep ?? 'Santiago',
         },
@@ -105,24 +107,29 @@ class DTE {
     return resultado;
   }
   
-  _procesarItems(items, esExenta) {
-    let mntBruto = 0;
+  _procesarItems(items, esExenta, precioConIva = false) {
+    let mntNeto = 0;
     let mntExento = 0;
     
     const detalle = items.map((item, idx) => {
       const qty = item.QtyItem || 1;
-      const prc = item.PrcItem;
+      const esItemExento = esExenta || item.IndExe === 1;
+      // Si precioConIva=true y el ítem no es exento, el PrcItem viene con IVA incluido
+      // (precio al consumidor del POS) → convertir a neto dividiendo por 1+TASA_IVA.
+      const prc = (precioConIva && !esItemExento)
+        ? Math.round(item.PrcItem / (1 + TASA_IVA / 100))
+        : item.PrcItem;
       const montoItem = Math.round(qty * prc);
       
-      if (esExenta || item.IndExe === 1) {
+      if (esItemExento) {
         mntExento += montoItem;
       } else {
-        mntBruto += montoItem;
+        mntNeto += montoItem;
       }
       
       const det = {
         NroLinDet: idx + 1,
-        ...(esExenta || item.IndExe ? { IndExe: 1 } : {}),
+        ...(esItemExento ? { IndExe: 1 } : {}),
         NmbItem: sanitizeSiiText(item.NmbItem),
         QtyItem: qty,
         ...(item.UnmdItem ? { UnmdItem: item.UnmdItem } : {}),
@@ -133,18 +140,21 @@ class DTE {
       return det;
     });
     
-    return { detalle, mntBruto, mntExento };
+    return { detalle, mntNeto, mntExento };
   }
   
-  _calcularTotales(mntBruto, mntExento, esExenta) {
-    const mntNeto = esExenta ? 0 : Math.round(mntBruto / (1 + (TASA_IVA / 100)));
-    const iva = esExenta ? 0 : (mntBruto - mntNeto);
-    const mntTotal = mntNeto + iva + mntExento;
+  // PrcItem = precio neto unitario (o precio con IVA si se usa precioConIva:true).
+  // IVA = mntNeto * TasaIVA.
+  _calcularTotales(mntNeto, mntExento, esExenta) {
+    const neto = esExenta ? 0 : mntNeto;
+    const iva  = esExenta ? 0 : Math.round(neto * TASA_IVA / 100);
+    const mntTotal = neto + iva + mntExento;
     
     const totales = {};
-    if (mntNeto > 0) totales.MntNeto = mntNeto;
+    if (neto > 0) totales.MntNeto = neto;
+    if (neto > 0) totales.TasaIVA = TASA_IVA;  // requerido en facturas
     if (mntExento > 0) totales.MntExe = mntExento;
-    if (mntNeto > 0) totales.IVA = iva;
+    if (neto > 0) totales.IVA = iva;
     totales.MntTotal = mntTotal;
     
     return totales;

package/SiiPortalAuth.js

@@ -121,7 +121,9 @@ class SiiPortalAuth {
       if (cookieStr) options.headers['Cookie'] = cookieStr;
 
       if (body) {
-        options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
+        if (!options.headers['Content-Type']) {
+          options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
+        }
         options.headers['Content-Length'] = Buffer.byteLength(body);
       }
 
@@ -493,6 +495,117 @@ if (!fs.existsSync(SESSION_CACHE_PATH)) {
       fecha_autorizacion: datos['Fecha Autorización'] || null,
     };
   }
+
+  // ─── Consemitidos (www4.sii.cl/consemitidosinternetui) ───────────────────────
+
+  /**
+   * Navega a consemitidosinternetui para obtener el TOKEN de sesión.
+   * El TOKEN es el mismo valor que CSESSIONID y va como conversationId en el body.
+   * @private
+   */
+  async _obtenerTokenConsemitidos(cookieJar) {
+    await this._request('https://www4.sii.cl/consemitidosinternetui/', { cookieJar });
+    const token = cookieJar['TOKEN'] || cookieJar['CSESSIONID'];
+    if (!token) {
+      throw new Error('SiiPortalAuth: no se pudo obtener TOKEN de sesión de consemitidosinternetui');
+    }
+    return token;
+  }
+
+  /**
+   * Llama a un endpoint JSON de la API consemitidosinternetui.
+   * @private
+   */
+  async _callConsemitidos(method, data, token, cookieJar) {
+    const body = JSON.stringify({
+      metaData: {
+        namespace:      `cl.sii.sdi.lob.diii.consemitidos.data.api.interfaces.FacadeService/${method}`,
+        conversationId: token,
+        transactionId:  crypto.randomUUID(),
+        page:           null,
+      },
+      data,
+    });
+    const res = await this._request(
+      `https://www4.sii.cl/consemitidosinternetui/services/data/facadeService/${method}`,
+      {
+        method:  'POST',
+        body,
+        cookieJar,
+        headers: {
+          'Content-Type': 'application/json',
+          'Accept':       'application/json, text/plain, */*',
+          'Origin':       'https://www4.sii.cl',
+          'Referer':      'https://www4.sii.cl/consemitidosinternetui/',
+        },
+      }
+    );
+    try {
+      return JSON.parse(res.body);
+    } catch {
+      throw new Error(`SiiPortalAuth: respuesta no-JSON de ${method}: ${res.body.slice(0, 300)}`);
+    }
+  }
+
+  /**
+   * Obtiene el detalle de DTEs emitidos o recibidos desde www4.sii.cl.
+   *
+   * @param {string} rut       - RUT sin DV (ej: "78206276")
+   * @param {string} dv        - DV (ej: "K")
+   * @param {string} periodo   - Período YYYY-MM (ej: "2026-05")
+   * @param {number} operacion - 1 = compras / recibidos, 2 = ventas / emitidos
+   * @param {Object} [cookieJar] - Sesión ya autenticada (opcional)
+   * @returns {Promise<{ resumen: Array, detalles: Array }>}
+   */
+  async obtenerDetalleDtes(rut, dv, periodo, operacion = 2, cookieJar = null) {
+    const jar   = cookieJar || await this.autenticar();
+    const token = await this._obtenerTokenConsemitidos(jar);
+
+    // Mapeo de convención interna → convención SII:
+    //   interno: 1 = compras/recibidos,  2 = ventas/emitidos
+    //   SII:     1 = emitidos,            2 = recibidos
+    const siiOperacion = operacion === 2 ? 1 : 2;
+    const esEmitidos   = siiOperacion === 1;
+
+    // 1. Resumen mensual — saber qué tipos de DTE hay en el período
+    const resumenResp = await this._callConsemitidos('getResumen', {
+      periodo,
+      rutContribuyente: rut,
+      dvContribuyente:  dv,
+      operacion: siiOperacion,
+    }, token, jar);
+
+    const resumen = resumenResp.data?.resumenDte ?? [];
+    if (resumen.length === 0) return { resumen: [], detalles: [] };
+
+    // 2. Detalle por cada tipo DTE encontrado en el resumen
+    const detallesArr = await Promise.all(
+      resumen.map(async (t) => {
+        // Para emitidos tipo 33/34, el SII expone un método específico
+        const metodo = esEmitidos && (t.tipoDoc === 33 || t.tipoDoc === 34)
+          ? 'getDetalleEmitidos3334'
+          : 'getDetalleRecibidos';
+        const resp = await this._callConsemitidos(metodo, {
+          tipoDoc:    String(t.tipoDoc),
+          rut,
+          dv,
+          periodo,
+          operacion:  siiOperacion,
+          derrCodigo: String(t.tipoDoc),
+          refNCD:     '0',
+        }, token, jar);
+        const items = resp.dataResp?.detalles ?? [];
+        // Completar tipoDoc y tipoDocDesc desde el resumen si no vienen en el detalle
+        return items.map((d) => ({
+          ...d,
+          tipoDoc:     t.tipoDoc,
+          tipoDocDesc: d.descTipoDoc || t.tipoDocDesc,
+        }));
+      })
+    );
+
+    return { resumen, detalles: detallesArr.flat() };
+  }
 }
 
 module.exports = SiiPortalAuth;

package/WsReclamo.js

@@ -0,0 +1,434 @@
+// Copyright (c) 2026 Devlas SpA — https://devlas.cl
+// Licencia MIT. Ver archivo LICENSE para mas detalles.
+/**
+ * WsReclamo.js — Cliente SOAP para el WS de Aceptación/Reclamo de DTEs del SII
+ *
+ * Implementa el "WS Consulta y Registro de Aceptación/Reclamo a DTE recibido" v1.2
+ * Fuente oficial: https://www.sii.cl/factura_electronica/factura_mercado/WSREGISTRORECLAMODTESERVICIO.pdf
+ *
+ * Métodos expuestos:
+ *   listarEventosHistDoc(rutEmisor, dvEmisor, tipoDoc, folio) → { codResp, descResp, eventos[] }
+ *   consultarEstadoReceptor(rutEmisor, dvEmisor, tipoDoc, folio) → 'sin_accion'|'aceptada'|'tacita'|'reclamada'
+ *   ingresarAceptacion(rutEmisor, dvEmisor, tipoDoc, folio, accion) → { codResp, descResp }
+ *
+ * Autenticación: TOKEN SII vía flujo seed/firma SOAP (mismo que EnviadorSII.getTokenSoap).
+ */
+
+const forge = require('node-forge');
+const {
+  SOAP_ENDPOINTS,
+  WSRECLAMO_ENDPOINTS,
+  validateAmbiente,
+  createScopedLogger,
+  getCachedToken,
+  setCachedToken,
+  extractTagContent,
+  decodeXmlEntities,
+  parseXmlNoNs,
+  siiError,
+  ERROR_CODES,
+} = require('./utils');
+
+const log = createScopedLogger('WsReclamo');
+
+// ─── Acciones válidas para ingresarAceptacionReclamoDoc ───────────────────────
+/** @typedef {'ACD'|'ERM'|'RCD'|'RFP'|'RFT'} AccionReclamo */
+
+// ─── Mapeo codEvento → estado normalizado ────────────────────────────────────
+// Mapeo de codEvento WSRECLAMO → estado receptor
+// 'tacita' NO es un evento del WS — es una presunción legal cuando pasan 8 días
+// sin eventos (codResp=16). Se calcula en capa de negocio, no aquí.
+const ESTADO_POR_EVENTO = {
+  ACD: 'aceptada',      // Acepta Contenido del Documento (explícito)
+  ERM: 'acuse_recibo', // Otorga Recibo de Mercaderías/Servicios (explícito)
+  RCD: 'reclamada',    // Reclamo al Contenido del Documento
+  RFP: 'reclamada',    // Reclamo por Falta Parcial de Mercaderías
+  RFT: 'reclamada',    // Reclamo por Falta Total de Mercaderías
+  NCA: 'sin_accion',   // NC de anulación que referencia el doc (no registrable por WS)
+  ENC: 'sin_accion',   // NC distinta de anulación que referencia el doc (no registrable)
+};
+
+class WsReclamo {
+  /**
+   * @param {Object} certificado  — instancia de Certificado con privateKey y cert
+   * @param {string} ambiente     — 'certificacion' | 'produccion'
+   * @param {Object} [options]
+   * @param {boolean} [options.useTokenCache=true]
+   */
+  constructor(certificado, ambiente, options = {}) {
+    if (!certificado) throw new Error('WsReclamo: certificado es obligatorio');
+    this.certificado = certificado;
+    this.ambiente = validateAmbiente(ambiente);
+    this.useTokenCache = options.useTokenCache !== false;
+
+    this.rutCert = certificado.rut || 'unknown';
+
+    this._tokenSoap = null;
+
+    // URLs
+    this._seedUrl  = SOAP_ENDPOINTS[this.ambiente].seed;
+    this._tokenUrl = SOAP_ENDPOINTS[this.ambiente].token;
+    this._wsUrl    = WSRECLAMO_ENDPOINTS[this.ambiente].replace('?wsdl', '');
+  }
+
+  // ══════════════════════════════════════════════════════════════════════════════
+  // AUTENTICACIÓN — mismo flujo que EnviadorSII.getTokenSoap
+  // ══════════════════════════════════════════════════════════════════════════════
+
+  /** Obtiene semilla del servicio SOAP del SII */
+  async _getSemilla() {
+    const envelope = `<?xml version="1.0" encoding="UTF-8"?>
+<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/">
+  <soapenv:Body><getSeed/></soapenv:Body>
+</soapenv:Envelope>`;
+
+    const res = await fetch(this._seedUrl, {
+      method: 'POST',
+      headers: { 'Content-Type': 'text/xml; charset=utf-8', SOAPAction: '' },
+      body: envelope,
+    });
+    if (!res.ok) throw siiError(`Error semilla: ${res.status}`, ERROR_CODES.SII_CONNECTION_FAILED);
+
+    const xml = await res.text();
+    const semilla = extractTagContent(decodeXmlEntities(xml), 'SEMILLA');
+    if (!semilla) throw siiError('No se obtuvo semilla del SII', ERROR_CODES.SII_INVALID_RESPONSE);
+    return semilla;
+  }
+
+  /** Firma la semilla y obtiene el TOKEN SOAP */
+  async _fetchTokenSoap() {
+    const semilla = await this._getSemilla();
+    const xmlFirmado = this._firmarSemilla(semilla);
+
+    const escaped = xmlFirmado
+      .replace(/&/g, '&amp;')
+      .replace(/</g, '&lt;')
+      .replace(/>/g, '&gt;');
+
+    const envelope = `<?xml version="1.0" encoding="UTF-8"?>
+<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/">
+  <soapenv:Body>
+    <getToken>
+      <pszXml>${escaped}</pszXml>
+    </getToken>
+  </soapenv:Body>
+</soapenv:Envelope>`;
+
+    const res = await fetch(this._tokenUrl, {
+      method: 'POST',
+      headers: { 'Content-Type': 'text/xml; charset=utf-8', SOAPAction: '' },
+      body: envelope,
+    });
+    if (!res.ok) throw siiError(`Error token: ${res.status}`, ERROR_CODES.SII_CONNECTION_FAILED);
+
+    const xml = await res.text();
+    const decoded = xml.replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&amp;/g, '&');
+    const token = extractTagContent(decoded, 'TOKEN');
+    if (!token) throw siiError('No se obtuvo TOKEN del SII', ERROR_CODES.SII_AUTH_FAILED);
+
+    return token;
+  }
+
+  /** Obtiene o reutiliza el token SOAP (con cache opcional) */
+  async _ensureToken() {
+    if (this.useTokenCache) {
+      const cached = getCachedToken(this.ambiente, 'soap', this.rutCert);
+      if (cached) {
+        this._tokenSoap = cached;
+        return cached;
+      }
+    }
+
+    const token = await this._fetchTokenSoap();
+    this._tokenSoap = token;
+
+    if (this.useTokenCache) {
+      setCachedToken(this.ambiente, 'soap', this.rutCert, token);
+    }
+    return token;
+  }
+
+  /** Invalida el token cacheado para forzar renovación */
+  invalidarToken() {
+    this._tokenSoap = null;
+    // invalidateToken no está disponible en utils — limpiamos el caché con un token vacío
+    // o simplemente seteamos nulo; el cache expira por TTL
+  }
+
+  // ══════════════════════════════════════════════════════════════════════════════
+  // FIRMA DE SEMILLA — idéntico a EnviadorSII._crearXMLSemilla
+  // ══════════════════════════════════════════════════════════════════════════════
+
+  _firmarSemilla(semilla) {
+    const xmlContent = `<getToken><item><Semilla>${semilla}</Semilla></item></getToken>`;
+
+    const md = forge.md.sha1.create();
+    md.update(xmlContent, 'utf8');
+    const digestValue = forge.util.encode64(md.digest().bytes());
+
+    const signedInfoParaFirmar = [
+      '<SignedInfo xmlns="http://www.w3.org/2000/09/xmldsig#">',
+      '<CanonicalizationMethod Algorithm="http://www.w3.org/TR/2001/REC-xml-c14n-20010315"></CanonicalizationMethod>',
+      '<SignatureMethod Algorithm="http://www.w3.org/2000/09/xmldsig#rsa-sha1"></SignatureMethod>',
+      '<Reference URI=""><Transforms>',
+      '<Transform Algorithm="http://www.w3.org/2000/09/xmldsig#enveloped-signature"></Transform>',
+      '</Transforms>',
+      '<DigestMethod Algorithm="http://www.w3.org/2000/09/xmldsig#sha1"></DigestMethod>',
+      `<DigestValue>${digestValue}</DigestValue>`,
+      '</Reference></SignedInfo>',
+    ].join('');
+
+    const mdSign = forge.md.sha1.create();
+    mdSign.update(signedInfoParaFirmar, 'utf8');
+    const signature = this.certificado.privateKey.sign(mdSign);
+    const signatureValue = this._wordwrap(forge.util.encode64(signature), 64);
+
+    const modulus  = this._wordwrap(this.certificado.getModulus(), 64);
+    const exponent = this.certificado.getExponent();
+    const cert     = this._wordwrap(this.certificado.getCertificateBase64(), 64);
+
+    return [
+      '<?xml version="1.0" encoding="UTF-8"?>',
+      `<getToken><item><Semilla>${semilla}</Semilla></item>`,
+      '<Signature xmlns="http://www.w3.org/2000/09/xmldsig#">',
+      '<SignedInfo xmlns="http://www.w3.org/2000/09/xmldsig#">',
+      '<CanonicalizationMethod Algorithm="http://www.w3.org/TR/2001/REC-xml-c14n-20010315"/>',
+      '<SignatureMethod Algorithm="http://www.w3.org/2000/09/xmldsig#rsa-sha1"/>',
+      '<Reference URI=""><Transforms>',
+      '<Transform Algorithm="http://www.w3.org/2000/09/xmldsig#enveloped-signature"/>',
+      '</Transforms>',
+      '<DigestMethod Algorithm="http://www.w3.org/2000/09/xmldsig#sha1"/>',
+      `<DigestValue>${digestValue}</DigestValue>`,
+      '</Reference></SignedInfo>',
+      `<SignatureValue>${signatureValue}</SignatureValue>`,
+      '<KeyInfo><KeyValue><RSAKeyValue>',
+      `<Modulus>${modulus}</Modulus>`,
+      `<Exponent>${exponent}</Exponent>`,
+      '</RSAKeyValue></KeyValue>',
+      `<X509Data><X509Certificate>${cert}</X509Certificate></X509Data>`,
+      '</KeyInfo></Signature></getToken>',
+    ].join('');
+  }
+
+  _wordwrap(str, width) {
+    const lines = [];
+    for (let i = 0; i < str.length; i += width) {
+      lines.push(str.substring(i, i + width));
+    }
+    return lines.join('\n');
+  }
+
+  // ══════════════════════════════════════════════════════════════════════════════
+  // LLAMADAS SOAP AL WSRECLAMO
+  // ══════════════════════════════════════════════════════════════════════════════
+
+  // Namespace oficial del servicio (fuente: WSDL producción/certificación)
+  static NS = 'http://ws.registroreclamodte.diii.sdi.sii.cl';
+
+  /**
+   * Realiza una llamada SOAP al WSRECLAMO con autenticación via TOKEN cookie.
+   * Namespace verificado desde: https://ws2.sii.cl/WSREGISTRORECLAMODTECERT/registroreclamodteservice?wsdl
+   * @private
+   */
+  async _llamar(metodo, params, reintentar = true) {
+    const token = await this._ensureToken();
+    const ns = WsReclamo.NS;
+
+    const innerXml = Object.entries(params)
+      .map(([k, v]) => `<${k}>${v}</${k}>`)
+      .join('');
+
+    // El body usa el prefijo ws: con el namespace del servicio
+    const envelope = `<?xml version="1.0" encoding="UTF-8"?>
+<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:ws="${ns}">
+  <soapenv:Header/>
+  <soapenv:Body>
+    <ws:${metodo}>${innerXml}</ws:${metodo}>
+  </soapenv:Body>
+</soapenv:Envelope>`;
+
+    const res = await fetch(this._wsUrl, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'text/xml; charset=utf-8',
+        SOAPAction: '',
+        Cookie: `TOKEN=${token}`,
+      },
+      body: envelope,
+    });
+
+    // Si el SII devuelve 403/401, el token puede haber expirado — reintentar una vez
+    if ((res.status === 401 || res.status === 403) && reintentar) {
+      log.log(`[WsReclamo] Token expirado (${res.status}), renovando...`);
+      this._tokenSoap = null;
+      return this._llamar(metodo, params, false);
+    }
+
+    if (!res.ok) {
+      throw siiError(`WSRECLAMO ${metodo}: HTTP ${res.status}`, ERROR_CODES.SII_CONNECTION_FAILED);
+    }
+
+    const xml = await res.text();
+    return xml;
+  }
+
+  /**
+   * Lista todos los eventos históricos de aceptación/reclamo para un DTE.
+   *
+   * @param {string} rutEmisor   — RUT sin DV ni puntos, ej: '76354771'
+   * @param {string} dvEmisor    — DV del RUT, ej: 'K'
+   * @param {number} tipoDoc     — Tipo de DTE, ej: 33 (factura afecta)
+   * @param {number} folio       — Número de folio
+   * @returns {Promise<{codResp: number, descResp: string, eventos: Array<{codEvento: string, descEvento: string, rutResponsable: string, dvResponsable: string, fechaEvento: string}>}>}
+   */
+  async listarEventosHistDoc(rutEmisor, dvEmisor, tipoDoc, folio) {
+    log.log(`[WsReclamo] listarEventosHistDoc RUT=${rutEmisor}-${dvEmisor} tipo=${tipoDoc} folio=${folio}`);
+
+    const xml = await this._llamar('listarEventosHistDoc', {
+      rutEmisor,
+      dvEmisor,
+      tipoDoc,
+      folio,
+    });
+
+    return this._parsearRespuestaEventos(xml);
+  }
+
+  /**
+   * Consulta el estado resumido del receptor para un DTE emitido.
+   * Devuelve el estado derivado del evento más reciente.
+   *
+   * Códigos relevantes de listarEventosHistDoc (doc SII v1.2):
+   *   15 = Listado de eventos del documento (hay eventos)
+   *   16 = Documento no presenta eventos de reclamos o acuse de recibo
+   *   18 = Documento no ha sido recibido por el receptor
+   *
+   * @returns {Promise<'sin_accion'|'aceptada'|'tacita'|'reclamada'>}
+   */
+  async consultarEstadoReceptor(rutEmisor, dvEmisor, tipoDoc, folio) {
+    const { codResp, eventos } = await this.listarEventosHistDoc(rutEmisor, dvEmisor, tipoDoc, folio);
+
+    // 16 = sin eventos de reclamo/acuse | 18 = no recibido aún
+    if (codResp === 16 || codResp === 18) {
+      return 'sin_accion';
+    }
+
+    // 15 = hay eventos — tomar el más reciente
+    if (codResp === 15 && eventos && eventos.length > 0) {
+      const ultimo = eventos[eventos.length - 1];
+      return ESTADO_POR_EVENTO[ultimo.codEvento] ?? 'sin_accion';
+    }
+
+    return 'sin_accion';
+  }
+
+  /**
+   * Ingresa una acción de aceptación o reclamo sobre un DTE recibido.
+   * Uso típico: el receptor registra su decisión.
+   *
+   * @param {string} rutEmisor
+   * @param {string} dvEmisor
+   * @param {number} tipoDoc
+   * @param {number} folio
+   * @param {AccionReclamo} accionDoc  — 'ACD'|'ERM'|'RCD'|'RFP'|'RFT'
+   * @returns {Promise<{codResp: number, descResp: string}>}
+   */
+  async ingresarAceptacion(rutEmisor, dvEmisor, tipoDoc, folio, accionDoc) {
+    const ACCIONES_VALIDAS = ['ACD', 'ERM', 'RCD', 'RFP', 'RFT'];
+    if (!ACCIONES_VALIDAS.includes(accionDoc)) {
+      throw new Error(`WsReclamo: accionDoc inválida '${accionDoc}'. Debe ser una de: ${ACCIONES_VALIDAS.join(', ')}`);
+    }
+
+    log.log(`[WsReclamo] ingresarAceptacion RUT=${rutEmisor}-${dvEmisor} tipo=${tipoDoc} folio=${folio} accion=${accionDoc}`);
+
+    const xml = await this._llamar('ingresarAceptacionReclamoDoc', {
+      rutEmisor,
+      dvEmisor,
+      tipoDoc,
+      folio,
+      accionDoc,
+    });
+
+    return this._parsearRespuestaSimple(xml);
+  }
+
+  // ══════════════════════════════════════════════════════════════════════════════
+  // PARSERS XML
+  // ══════════════════════════════════════════════════════════════════════════════
+
+  /**
+   * Parsea respuesta de listarEventosHistDoc.
+   *
+   * Estructura real (verificada en doc SII v1.2 y SoapUI screenshot):
+   * <return>
+   *   <codResp>15</codResp>
+   *   <descResp>Listado de eventos del documento</descResp>
+   *   <listaEventosDoc>
+   *     <codEvento>ACD</codEvento>
+   *     <descEvento>Acepta Contenido del Documento</descEvento>
+   *     <rutResponsable>45000055</rutResponsable>
+   *     <dvResponsable>8</dvResponsable>
+   *     <fechaEvento>29-12-2016 12:05:36</fechaEvento>
+   *   </listaEventosDoc>
+   * </return>
+   */
+  _parsearRespuestaEventos(xml) {
+    // Decode HTML entities del wrapper SOAP
+    const decoded = xml
+      .replace(/&lt;/g, '<')
+      .replace(/&gt;/g, '>')
+      .replace(/&amp;/g, '&')
+      .replace(/&quot;/g, '"');
+
+    // Extraer el bloque <return>...</return>
+    const returnMatch = decoded.match(/<return>([\s\S]*?)<\/return>/i);
+    const bloque = returnMatch ? returnMatch[1] : decoded;
+
+    const codResp  = parseInt(extractTagContent(bloque, 'codResp') ?? '16', 10);
+    const descResp = extractTagContent(bloque, 'descResp') ?? '';
+
+    // Extraer cada <listaEventosDoc>...</listaEventosDoc>
+    const eventos = [];
+    const itemRegex = /<listaEventosDoc>([\s\S]*?)<\/listaEventosDoc>/gi;
+    let match;
+    while ((match = itemRegex.exec(bloque)) !== null) {
+      const item = match[1];
+      eventos.push({
+        codEvento:       extractTagContent(item, 'codEvento')      ?? '',
+        descEvento:      extractTagContent(item, 'descEvento')     ?? '',
+        rutResponsable:  extractTagContent(item, 'rutResponsable') ?? '',
+        dvResponsable:   extractTagContent(item, 'dvResponsable')  ?? '',
+        fechaEvento:     extractTagContent(item, 'fechaEvento')    ?? '',
+      });
+    }
+
+    return { codResp, descResp, eventos };
+  }
+
+  /**
+   * Parsea respuesta de ingresarAceptacionReclamoDoc y consultarDocDteCedible.
+   *
+   * Estructura:
+   * <return>
+   *   <codResp>0</codResp>
+   *   <descResp>Acción completada OK</descResp>
+   * </return>
+   *
+   * codResp 0 = OK (ingresarAceptacion)
+   */
+  _parsearRespuestaSimple(xml) {
+    const decoded = xml
+      .replace(/&lt;/g, '<')
+      .replace(/&gt;/g, '>')
+      .replace(/&amp;/g, '&');
+
+    const returnMatch = decoded.match(/<return>([\s\S]*?)<\/return>/i);
+    const bloque = returnMatch ? returnMatch[1] : decoded;
+
+    const codResp  = parseInt(extractTagContent(bloque, 'codResp') ?? '-1', 10);
+    const descResp = extractTagContent(bloque, 'descResp') ?? '';
+    return { codResp, descResp };
+  }
+}
+
+module.exports = WsReclamo;

package/index.js

@@ -35,6 +35,9 @@ const LibroGuia = require('./LibroGuia');
 // Helpers para certificación
 const CertFolioHelper = require('./cert/CertFolioHelper');
 
+// WS Aceptación/Reclamo DTE (v2.9.0)
+const WsReclamo = require('./WsReclamo');
+
 const utils = require('./utils');
 
 // Re-exports de utilidades para compatibilidad
@@ -240,6 +243,11 @@ module.exports = {
   // ─────────────────────────────────────────
   CertFolioHelper,
 
+  // ─────────────────────────────────────────
+  // WS Aceptación/Reclamo DTE (v2.9.0)
+  // ─────────────────────────────────────────
+  WsReclamo,
+
   // ─────────────────────────────────────────
   // UTILIDADES (todo el namespace)
   // ─────────────────────────────────────────

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devlas/dte-sii",
-  "version": "2.8.2",
+  "version": "2.9.2",
   "description": "Facturación y boletas electrónicas para el SII de Chile. Genera, timbra, firma y envía DTEs, libros electrónicos y automatiza la certificación.",
   "main": "index.js",
   "types": "dte-sii.d.ts",

package/utils/endpoints.js

@@ -51,6 +51,89 @@ const SOAP_ENDPOINTS = {
   },
 };
 
+/**
+ * Web Service SOAP oficial — Aceptación/Reclamo de DTE recibido
+ * Fuente: "WS Consulta y Registro de Aceptación/Reclamo a DTE recibido" v1.2, 07/08/2017, SII
+ *
+ * Métodos disponibles:
+ *   ingresarAceptacionReclamoDoc(rutEmisor, dvEmisor, tipoDoc, folio, accionDoc)
+ *     accionDoc: ACD | ERM | RCD | RFP | RFT
+ *   listarEventosHistDoc(rutEmisor, dvEmisor, tipoDoc, folio)
+ *   consultarDocDteCedible(rutEmisor, dvEmisor, tipoDoc, folio)
+ *   consultarFechaRecepcionSii(rutEmisor, dvEmisor, tipoDoc, folio)
+ *
+ * Autenticación: token SII vía cookie `TOKEN=...` (mismo flujo seed/token de SOAP_ENDPOINTS,
+ * NO usa cookies NETSCAPE_LIVEWIRE del portal). Ver SiiSession.js getToken().
+ *
+ * Respuestas:
+ *   ingresarAceptacionReclamoDoc → { codResp: number, descResp: string }
+ *   listarEventosHistDoc         → { codResp, descResp, listaEventosDoc: [{ codEvento, descEvento,
+ *                                    rutResponsable, dvResponsable, fechaEvento }] }
+ *                                    codEvento extra (solo en lista): NCA | ENC
+ *   consultarDocDteCedible       → { codResp: number, descResp: string }
+ *   consultarFechaRecepcionSii   → string VARCHAR(100), ej: '21-02-2017 19:02:03'
+ */
+const WSRECLAMO_ENDPOINTS = {
+  certificacion: 'https://ws2.sii.cl/WSREGISTRORECLAMODTECERT/registroreclamodteservice?wsdl',
+  produccion:    'https://ws1.sii.cl/WSREGISTRORECLAMODTE/registroreclamodteservice?wsdl',
+};
+
+/**
+ * Acciones válidas para ingresarAceptacionReclamoDoc
+ */
+const WSRECLAMO_ACCIONES = {
+  ACD: 'Acepta Contenido del Documento',
+  ERM: 'Otorga Recibo de Mercaderías o Servicios',
+  RCD: 'Reclamo al Contenido del Documento',
+  RFP: 'Reclamo por Falta Parcial de Mercaderías',
+  RFT: 'Reclamo por Falta Total de Mercaderías',
+};
+
+/**
+ * Códigos de respuesta compartidos (ingresarAceptacionReclamoDoc + listarEventosHistDoc)
+ * Fuente: WS v1.2, 07/08/2017, tablas de parámetros de salida
+ */
+const WSRECLAMO_CODIGOS = {
+  0:  'Acción Completada OK',
+  1:  'Rut Emisor Erróneo',
+  2:  'Número de Folio Erróneo',
+  3:  'Tipo de documento no corresponde (distinto de 33, 34, 43)',
+  4:  'Acción inválida',
+  5:  'DTE ya está reclamado por XXX (RFP, RFT o RCD)',
+  6:  'No se puede acusar recibo de mercadería de DTE previamente reclamado por XXX (RFP, RFT, RCD)',
+  7:  'Evento registrado previamente',
+  8:  'Pasados 8 días después de la recepción no es posible registrar reclamos o eventos',
+  9:  'No existen registros de acuerdo a los parámetros ingresados',
+  10: 'Documento no emitido y/o recibido en el SII desde el 14 de enero de 2017 en adelante',
+  11: 'No se puede reclamar DTE previamente aceptado',
+  12: 'No se puede dar por aceptado DTE previamente rechazado por XXX (RFP, RFT, RCD)',
+  13: 'No se puede reclamar DTE previamente registrado como acuso recibo mercadería',
+  14: 'Acción autorizada sólo para empresa receptora o emisora',
+  15: 'Listado de eventos del documento',
+  16: 'Documento no presenta eventos de reclamos o acuse de recibo',
+  17: 'Acción autorizada solo para empresa receptora',
+  18: 'Documento no ha sido recibido',
+  19: 'Reclamo de mercaderías ya realizado',
+  '-1': 'Error Interno — Rut Receptor debe reintentar más tarde',
+};
+
+/**
+ * Códigos de respuesta exclusivos de consultarDocDteCedible
+ * Fuente: WS v1.2, tabla parámetros de salida consultarDocDteCedible
+ */
+const WSRECLAMO_CODIGOS_CEDIBLE = {
+  1:  'Rut Emisor Erróneo',
+  2:  'Número de Folio Erróneo',
+  10: 'Documento no emitido y/o recibido en el SII desde el 14 de enero de 2017 en adelante',
+  18: 'Documento no ha sido recibido',
+  20: 'Tipo de documento no es cedible',
+  21: 'DTE No cedible — referenciado por nota de crédito de anulación del emisor dentro de los primeros 8 días',
+  22: 'No existe registro de reclamo o de recepción de mercadería o servicios',
+  23: 'DTE Cedible, sin reclamos',
+  24: 'DTE No Cedible — reclamado por el receptor',
+  25: 'DTE Cedible — habiendo pasado 8 días se entiende dado acuse de recibo',
+};
+
 /**
  * Endpoints REST para Boletas Electrónicas
  */
@@ -213,6 +296,10 @@ module.exports = {
   SOAP_ENDPOINTS,
   REST_ENDPOINTS,
   CERT_ENDPOINTS,
+  WSRECLAMO_ENDPOINTS,
+  WSRECLAMO_ACCIONES,
+  WSRECLAMO_CODIGOS,
+  WSRECLAMO_CODIGOS_CEDIBLE,
   
   // Funciones
   getHost,