@devlas/dte-sii 2.12.8 → 2.12.10

package/CafSolicitor.js

@@ -209,7 +209,6 @@ class CafSolicitor {
     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,
@@ -217,20 +216,28 @@ class CafSolicitor {
         CANTIDAD: cantidad,
       };
 
-      let response = await this.session.submitForm('/cvc_cgi/dte/of_solicita_folios', fields);
+      // Paso 1: asegurar sesión con un GET real ANTES de cualquier POST.
+      // El SII liga la cookie de sesión al GET que la originó (Tivoli/F5); un POST
+      // que no fue precedido de un GET fresco al mismo path en la misma sesión es
+      // tratado como fuera de contexto y redirige a autInicioDTE aunque las cookies
+      // sean válidas. Replicamos el flujo real de un browser: GET formulario →
+      // parsear <form action> + hidden fields → submit con esos campos + los propios.
+      const authResponse = await this.session.ensureSession('/cvc_cgi/dte/of_solicita_folios');
+
+      let response;
+      if (this._requiresAuthentication(authResponse.body)) {
+        // Sesión sigue inválida tras ensureSession — el chequeo de más abajo
+        // detectará esto sobre el body final y retornará SESSION_EXPIRED.
+        response = authResponse;
+      } else {
+        const formAction = SiiSession.extractFormAction(authResponse.body) || '/cvc_cgi/dte/of_solicita_folios';
+        const hiddenFields = SiiSession.extractInputValues(authResponse.body);
+        response = await this.session.submitForm(formAction, { ...hiddenFields, ...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);
-        }
+      // Guardar sesión para reutilización
+      if (this.sessionPath) {
+        this.session.saveSession(this.sessionPath);
       }
 
       // Procesar flujo multi-paso del SII

package/SiiSession.js

@@ -14,6 +14,8 @@ const {
   loadPfxFromBuffer,
   loadPfxFromFile,
   createTlsOptions,
+  createTlsAgent,
+  createTlsAgentFromPem,
   validateAmbiente,
   getHost,
   createScopedLogger,
@@ -44,6 +46,10 @@ class SiiSession {
     this.baseHost = getHost(this.ambiente);
     this.cookieJar = '';
     this.tlsOptions = null;
+    // Agent nativo con el certificado + flags TLS legacy del SII. got no reenvía
+    // secureOptions/maxVersion a través de su opción `https` bajo ningún nombre de
+    // clave, así que estos flags solo se pueden aplicar vía un https.Agent nativo.
+    this.tlsAgent = null;
 
     // Configurar TLS desde certificado
     if (options.certificado) {
@@ -61,15 +67,19 @@ class SiiSession {
    */
   _configureTlsFromCertificado(certificado) {
     try {
+      const keyPem = certificado.getPrivateKeyPEM();
+      const certPem = certificado.getCertificatePEM();
       this.tlsOptions = {
-        key: certificado.getPrivateKeyPEM(),
-        cert: certificado.getCertificatePEM(),
-        certificate: certificado.getCertificatePEM(),
+        key: keyPem,
+        cert: certPem,
+        certificate: certPem,
         rejectUnauthorized: false,
       };
+      this.tlsAgent = createTlsAgentFromPem(keyPem, certPem);
     } catch (error) {
       log.error('Error configurando TLS desde certificado:', error.message);
       this.tlsOptions = null;
+      this.tlsAgent = null;
     }
   }
 
@@ -81,9 +91,11 @@ class SiiSession {
     try {
       const pfxData = loadPfxFromBuffer(pfxBuffer, password);
       this.tlsOptions = createTlsOptions(pfxData);
+      this.tlsAgent = createTlsAgent(pfxData);
     } catch (error) {
       log.error('Error configurando TLS desde PFX:', error.message);
       this.tlsOptions = null;
+      this.tlsAgent = null;
     }
   }
 
@@ -95,9 +107,11 @@ class SiiSession {
     try {
       const pfxData = loadPfxFromFile(pfxPath, password);
       this.tlsOptions = createTlsOptions(pfxData);
+      this.tlsAgent = createTlsAgent(pfxData);
     } catch (error) {
       log.error('Error configurando TLS desde archivo PFX:', error.message);
       this.tlsOptions = null;
+      this.tlsAgent = null;
     }
   }
 
@@ -215,6 +229,11 @@ class SiiSession {
       followRedirect: false,
       throwHttpErrors: false,
       https: this.tlsOptions || { rejectUnauthorized: false },
+      // got remapea `https` a un set fijo de claves y NO reenvía secureOptions/
+      // maxVersion bajo ningún nombre — sin el Agent nativo aquí, el certificado
+      // cliente se autentica con handshake TLS incompleto contra el SII (ver
+      // utils/pfx.js createTlsAgent).
+      ...(this.tlsAgent ? { agent: { https: this.tlsAgent } } : {}),
       responseType: 'buffer',
       timeout: { request: options.timeoutMs ?? 20000 },
     });

package/WsReclamo.js

@@ -1,434 +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;
+// 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devlas/dte-sii",
-  "version": "2.12.8",
+  "version": "2.12.10",
   "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/pfx.js

@@ -10,9 +10,24 @@
  */
 
 const fs = require('fs');
+const https = require('https');
+const crypto = require('crypto');
 const forge = require('node-forge');
 const { certError, ERROR_CODES } = require('./error');
 
+/**
+ * Flags TLS que la infraestructura legacy del SII requiere para completar la
+ * autenticación con certificado cliente (mismo set que SiiPortalAuth.SII_TLS_OPTS).
+ * Sin `maxVersion: 'TLSv1.2'` + renegociación insegura habilitada, el handshake
+ * de client-cert contra los servidores del SII no se completa correctamente.
+ */
+const SII_LEGACY_TLS_FLAGS = {
+  maxVersion: 'TLSv1.2',
+  secureOptions:
+    crypto.constants.SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION |
+    crypto.constants.SSL_OP_LEGACY_SERVER_CONNECT,
+};
+
 /**
  * Resultado de cargar un PFX
  * @typedef {Object} PfxData
@@ -217,17 +232,56 @@ function getDaysUntilExpiry(notAfter) {
 
 /**
  * Crear opciones TLS desde datos PFX
+ *
+ * IMPORTANTE: `got` (usado por SiiSession) remapea su opción `https` a un set
+ * fijo de claves y solo reconoce `certificate` para el certificado cliente —
+ * NO `cert` (ver got/dist/source/core/index.js, "HTTPS options remapping").
+ * Se incluyen ambas claves (`cert` para consumidores que usan `https` nativo,
+ * `certificate` para got) para que el certificado se envíe en ambos casos.
+ *
  * @param {PfxData} pfxData - Datos del PFX
  * @returns {Object} Opciones TLS para https/got
  */
 function createTlsOptions(pfxData) {
+  const certPem = pfxData.certificateChainPem || pfxData.certificatePem;
   return {
     key: pfxData.privateKeyPem,
-    cert: pfxData.certificateChainPem || pfxData.certificatePem,
+    cert: certPem,
+    certificate: certPem,
     rejectUnauthorized: false,
   };
 }
 
+/**
+ * Crea un https.Agent nativo con el certificado cliente + los flags TLS legacy
+ * que el SII requiere. `got` no reenvía `secureOptions`/`maxVersion` a través de
+ * su opción `https` bajo ningún nombre de clave — la única forma de aplicarlos
+ * es con un Agent nativo pasado como `agent.https` en las opciones de got.
+ *
+ * @param {PfxData} pfxData - Datos del PFX
+ * @returns {https.Agent}
+ */
+function createTlsAgent(pfxData) {
+  return createTlsAgentFromPem(pfxData.privateKeyPem, pfxData.certificateChainPem || pfxData.certificatePem);
+}
+
+/**
+ * Crea un https.Agent nativo desde un par key/cert PEM ya extraído (ej. desde
+ * una instancia de Certificado), con los mismos flags legacy que createTlsAgent.
+ *
+ * @param {string} keyPem
+ * @param {string} certPem
+ * @returns {https.Agent}
+ */
+function createTlsAgentFromPem(keyPem, certPem) {
+  return new https.Agent({
+    ...SII_LEGACY_TLS_FLAGS,
+    key: keyPem,
+    cert: certPem,
+    rejectUnauthorized: false,
+  });
+}
+
 module.exports = {
   loadPfxFromBuffer,
   loadPfxFromFile,
@@ -236,4 +290,6 @@ module.exports = {
   isCertificateExpired,
   getDaysUntilExpiry,
   createTlsOptions,
+  createTlsAgent,
+  createTlsAgentFromPem,
 };