@devlas/dte-sii 2.12.26 → 2.13.0

package/SiiPortalAuth.js

@@ -26,11 +26,12 @@ const https  = require('https');
 const http   = require('http');
 const fs     = require('fs');
 const path   = require('path');
-const os     = require('os');
 const { URL } = require('url');
 const forge  = require('node-forge');
 const crypto = require('crypto');
 const SiiSessionStore = require('./SiiSessionStore');
+const { resolveDataDir } = require('./utils/paths');
+const { registrarHttpDebug } = require('./utils/httpDebug');
 
 function _cookieObjToStr(obj) {
   return Object.entries(obj).map(([k, v]) => `${k}=${v}`).join('; ');
@@ -57,10 +58,12 @@ const SII_TLS_OPTS = {
 // ─── Ruta del caché de sesión ─────────────────────────────────────────────────
 // Guarda las cookies NETSCAPE_LIVEWIRE.* para reusar entre ejecuciones y evitar
 // el error "máximo de sesiones autenticadas" del SII.
-const SESSION_CACHE_PATH = path.join(
-  process.env.DATADIR || path.join(os.homedir(), 'AppData', 'Roaming', 'POS'),
-  'sii_session_cache.json'
-);
+//
+// El directorio lo define el consumidor vía DATADIR; el fallback es os.tmpdir(),
+// neutral respecto del sistema operativo. Antes caía a `~/AppData/Roaming/POS`,
+// una convención de un producto Windows específico hardcodeada en una librería
+// genérica de DTE — en Linux creaba esa ruta igual, porque Node no la valida.
+const SESSION_CACHE_PATH = path.join(resolveDataDir(), 'sii_session_cache.json');
 
 /**
  * Registro global de instancias SiiPortalAuth por certHash (singleton por certificado).
@@ -196,6 +199,7 @@ class SiiPortalAuth {
 
   _request(urlStr, { method = 'GET', cookieJar = {}, body = null, headers = {}, usarCert = false } = {}) {
     return new Promise((resolve, reject) => {
+      const _t0 = Date.now();
       const url = new URL(urlStr);
       const isHttps = url.protocol === 'https:';
 
@@ -248,7 +252,23 @@ class SiiPortalAuth {
           const encoding = /charset=utf-?8/i.test(ct)
             ? 'utf8'
             : (isSiiHost || /iso-8859|latin-1|windows-1252/i.test(ct)) ? 'latin1' : 'utf8';
-          resolve({ status: res.statusCode, headers: res.headers, body: buf.toString(encoding), cookieJar });
+          const bodyStr = buf.toString(encoding);
+
+          // Cliente HTTP independiente de SiiSession (https nativo, sin código en común):
+          // necesita su propio hook o quedarían fuera las llamadas del flujo de
+          // verificación de autorización, que hoy no dejan ningún rastro.
+          registrarHttpDebug({
+            url: urlStr,
+            method,
+            status: res.statusCode,
+            headers: res.headers,
+            body: bodyStr,
+            reqBody: body,
+            ms: Date.now() - _t0,
+            cliente: 'SiiPortalAuth',
+          });
+
+          resolve({ status: res.statusCode, headers: res.headers, body: bodyStr, cookieJar });
         });
       });
 
@@ -1036,6 +1056,111 @@ if (!fs.existsSync(SESSION_CACHE_PATH)) {
       SiiSessionStore.delete(hash);
     }
   }
+
+  /**
+   * Autentica en el portal SII y devuelve los datos frescos del emisor
+   * (resolución + datos del contribuyente) ya normalizados, junto con el
+   * cookieJar de la sesión iniciada para reutilizarla.
+   *
+   * Es una operación completa del portal —autenticar, consultar dos endpoints,
+   * reintentar con sesión fresca si la cacheada quedó inservible y normalizar el
+   * resultado—, así que vive acá y no en el consumidor: no tiene ningún
+   * conocimiento del proyecto que la use.
+   *
+   * @param {Object} opts
+   * @param {Buffer} opts.pfxBuffer - Contenido del .pfx
+   * @param {string} [opts.pfxPassword] - Contraseña del .pfx
+   * @param {string} [opts.rutEmpresa] - RUT de la empresa (acepta puntos). Si no se
+   *   pasa, se intenta deducir de las cookies del portal tras autenticar.
+   * @param {Function} [opts.onAviso] - Callback para avisos no fatales (default: console.warn).
+   * @returns {Promise<{ emisor: Object, cookieJar: Object }>}
+   * @throws Si no puede autenticar, si el RUT es inválido o si faltan datos de resolución.
+   */
+  static async obtenerEmisor({ pfxBuffer, pfxPassword = '', rutEmpresa = '', onAviso } = {}) {
+    const aviso = onAviso || ((msg) => console.warn(msg));
+    const auth = new SiiPortalAuth({ pfxBuffer, pfxPassword });
+
+    // Se resuelve antes de autenticar para poder reintentar con sesión fresca.
+    let rutNum, dv;
+    if (rutEmpresa) {
+      const rutLimpio = String(rutEmpresa).replace(/\./g, '');
+      const match = rutLimpio.match(/^(\d+)-([0-9Kk])$/);
+      if (!match) {
+        throw new Error(`RUT empresa inválido: "${rutEmpresa}". Formato esperado: "78206276-K"`);
+      }
+      rutNum = match[1];
+      dv = match[2].toUpperCase();
+    }
+
+    let cookieJar = await auth.autenticar();
+
+    const rutDesdeCookies = (jar) => [
+      jar['NETSCAPE_LIVEWIRE.rutm'] || jar['NETSCAPE_LIVEWIRE.rut'] || null,
+      jar['NETSCAPE_LIVEWIRE.dvm'] || jar['NETSCAPE_LIVEWIRE.dv'] || null,
+    ];
+
+    if (!rutNum) {
+      [rutNum, dv] = rutDesdeCookies(cookieJar);
+      if (!rutNum || !dv) {
+        throw new Error(
+          'No se pudo determinar el RUT empresa desde las cookies del portal SII. ' +
+          'Indica el RUT explícitamente en opts.rutEmpresa.',
+        );
+      }
+    }
+
+    // Retry con sesión fresca: a veces la sesión cacheada pasa la validación básica
+    // pero ad_empresa2 devuelve otra página (ej. "Actualización de Datos del
+    // Contribuyente"). Secuencial a propósito: compartir el cookieJar en paralelo
+    // genera una race condition — ce_consulta_muestra_e puede sobreescribir la cookie
+    // Tivoli (TS0xxxxxxx) que ad_empresa1 dejó, y ad_empresa2 responde vacío.
+    let datosResol, datosContrib;
+    for (let intento = 1; intento <= 2; intento++) {
+      try {
+        datosResol = await auth.obtenerDatosEmpresa(rutNum, dv, cookieJar);
+        datosContrib = await auth.obtenerDatosContribuyente(rutNum, dv, cookieJar).catch((e) => {
+          aviso(`[SiiPortalAuth] obtenerDatosContribuyente falló (no crítico): ${e.message}`);
+          return null;
+        });
+        break;
+      } catch (e) {
+        if (intento === 1) {
+          aviso(`[SiiPortalAuth] Sesión cacheada inválida (${e.message}). Re-autenticando...`);
+          SiiPortalAuth.limpiarSesionCache();
+          cookieJar = await auth.autenticar();
+          if (!rutEmpresa) {
+            const [r, d] = rutDesdeCookies(cookieJar);
+            rutNum = r || rutNum;
+            dv = d || dv;
+          }
+          continue;
+        }
+        throw e;
+      }
+    }
+
+    if (!datosResol?.fch_resol) {
+      throw new Error(
+        `No se encontraron datos de resolución para ${rutNum}-${dv} en el portal SII.\n` +
+        'Verifica que la empresa esté habilitada para emitir DTE.',
+      );
+    }
+
+    // fch_resol ya viene normalizada a YYYY-MM-DD desde obtenerDatosEmpresa
+    const emisor = {
+      rut:          `${rutNum}-${dv}`,
+      razon_social: datosContrib?.razonSocial || datosResol.razonSocial || '',
+      giro:         datosContrib?.actividades?.[0]?.descripcion || datosContrib?.glosa || '',
+      acteco:       datosContrib?.acteco || datosContrib?.actividades?.[0]?.codigo || '',
+      direccion:    datosContrib?.direccion || '',
+      comuna:       datosContrib?.comuna || '',
+      ciudad:       datosContrib?.ciudad || datosContrib?.comuna || '',
+      fch_resol:    datosResol.fch_resol,
+      nro_resol:    datosResol.nro_resol ?? 0,
+    };
+
+    return { emisor, cookieJar };
+  }
 }
 
 module.exports = SiiPortalAuth;

package/SiiSession.js

@@ -20,6 +20,8 @@ const {
   getHost,
   createScopedLogger,
 } = require('./utils');
+const { resolveDebugDir, saveDebugFile } = require('./utils/paths');
+const { registrarHttpDebug } = require('./utils/httpDebug');
 
 const log = createScopedLogger('SiiSession');
 
@@ -34,6 +36,8 @@ class SiiSession {
    * @param {string} [options.pfxPath] - Ruta al archivo PFX
    * @param {string} [options.pfxPassword] - Contraseña del PFX
    * @param {Object} [options.certificado] - Instancia de Certificado
+   * @param {string} [options.debugDir] - Dónde escribir HTML de diagnóstico. Si no se
+   *   provee cae a `SII_DEBUG_DIR`; si tampoco existe, no se escribe nada.
    */
   constructor(options = {}) {
     // Validar parámetros obligatorios usando validador centralizado
@@ -41,9 +45,10 @@ class SiiSession {
       throw new Error('SiiSession: options.ambiente es obligatorio');
     }
     this.ambiente = validateAmbiente(options.ambiente);
-    
+
     // Usar host centralizado desde endpoints
     this.baseHost = getHost(this.ambiente);
+    this.debugDir = options.debugDir || null;
     this.cookieJar = '';
     this.tlsOptions = null;
     // Agent nativo con el certificado + flags TLS legacy del SII. got no reenvía
@@ -204,6 +209,7 @@ class SiiSession {
    * @private
    */
   async _doRequest(url, options, isPost) {
+    const _t0 = Date.now();
     const res = await got(url, {
       method: options.method || 'GET',
       headers: {
@@ -257,6 +263,21 @@ class SiiSession {
       bodyStr = buffer.toString('utf8');
     }
 
+    // Punto único por el que pasa TODO el tráfico de SiiSession: cada salto de
+    // redirect, cada submit de formulario y cada reintento. Enganchar acá cubre a
+    // SiiCertificacion, CertRunner, CafSolicitor, FolioService, BoletaCert y
+    // SetsProvider sin tocar ninguno.
+    registrarHttpDebug({
+      url,
+      method: options.method || 'GET',
+      status: res.statusCode,
+      headers: res.headers,
+      body: bodyStr,
+      reqBody: options.body,
+      ms: Date.now() - _t0,
+      cliente: 'SiiSession',
+    });
+
     return {
       status: res.statusCode,
       headers: res.headers,
@@ -352,14 +373,11 @@ class SiiSession {
   async _tryForceCloseSessions(body) {
     if (!body || !body.includes('superado el m')) return false;
 
-    // Guardar HTML para diagnóstico
-    try {
-      const fs = require('fs');
-      const path = require('path');
-      const dbgDir = path.resolve(__dirname, '..', 'devlas-cloud-api-node', 'debug', 'sii-sessions');
-      fs.mkdirSync(dbgDir, { recursive: true });
-      fs.writeFileSync(path.join(dbgDir, `demasiadas-sesiones-${Date.now()}.html`), body, 'utf-8');
-    } catch (_) {}
+    // Guardar HTML para diagnóstico — solo si el consumidor definió dónde.
+    // Antes esto apuntaba a `../devlas-cloud-api-node/debug/sii-sessions`: la librería
+    // nombraba a un repo consumidor y asumía que estaba como carpeta hermana, así que
+    // en cualquier otra instalación escribía en un lugar inesperado o fallaba en silencio.
+    saveDebugFile(resolveDebugDir(this.debugDir), `demasiadas-sesiones-${Date.now()}.html`, body);
 
     // El SII a veces incluye un form o link para cerrar sesiones anteriores
     // Buscamos: action con "CierraAnt", "cerrar", "logout" o "Anular"

package/WsReclamo.js

@@ -15,6 +15,10 @@
  */
 
 const forge = require('node-forge');
+const { fetchRegistrado } = require('./utils/httpDebug');
+
+/** `fetchRegistrado` con el cliente ya fijado, para no repetirlo en cada llamada. */
+const fetchRegistradoWs = (url, opciones) => fetchRegistrado(url, opciones, 'WsReclamo');
 const {
   SOAP_ENDPOINTS,
   WSRECLAMO_ENDPOINTS,
@@ -82,14 +86,13 @@ class WsReclamo {
   <soapenv:Body><getSeed/></soapenv:Body>
 </soapenv:Envelope>`;
 
-    const res = await fetch(this._seedUrl, {
+    const { response: res, text: xml } = await fetchRegistradoWs(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;
@@ -114,14 +117,13 @@ class WsReclamo {
   </soapenv:Body>
 </soapenv:Envelope>`;
 
-    const res = await fetch(this._tokenUrl, {
+    const { response: res, text: xml } = await fetchRegistradoWs(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);
@@ -247,7 +249,7 @@ class WsReclamo {
   </soapenv:Body>
 </soapenv:Envelope>`;
 
-    const res = await fetch(this._wsUrl, {
+    const { response: res, text: xml } = await fetchRegistradoWs(this._wsUrl, {
       method: 'POST',
       headers: {
         'Content-Type': 'text/xml; charset=utf-8',
@@ -268,7 +270,6 @@ class WsReclamo {
       throw siiError(`WSRECLAMO ${metodo}: HTTP ${res.status}`, ERROR_CODES.SII_CONNECTION_FAILED);
     }
 
-    const xml = await res.text();
     return xml;
   }
 

package/cert/BoletaCert.js

@@ -22,6 +22,7 @@
 
 const path = require('path');
 const fs = require('fs');
+const { registrarHttpDebug } = require('../utils/httpDebug');
 
 class BoletaCert {
   /**
@@ -663,14 +664,23 @@ class BoletaCert {
     
     // Hacer request
     const requestWithCert = (options, payload) => new Promise((resolve, reject) => {
+      const t0 = Date.now();
       const req = https.request({ ...options, ...tlsOptions }, (res) => {
         let data = '';
         res.on('data', (chunk) => (data += chunk));
-        res.on('end', () => resolve({
-          status: res.statusCode,
-          text: data,
-          headers: res.headers,
-        }));
+        res.on('end', () => {
+          registrarHttpDebug({
+            url: `https://${options.hostname}${options.path}`,
+            method: options.method || 'GET',
+            status: res.statusCode,
+            headers: res.headers,
+            body: data,
+            reqBody: payload,
+            ms: Date.now() - t0,
+            cliente: 'BoletaCert',
+          });
+          resolve({ status: res.statusCode, text: data, headers: res.headers });
+        });
       });
       req.on('error', reject);
       if (payload) req.write(payload);
@@ -784,14 +794,23 @@ class BoletaCert {
     
     // Hacer request
     const requestWithCert = (options, payload) => new Promise((resolve, reject) => {
+      const t0 = Date.now();
       const req = https.request({ ...options, ...tlsOptions }, (res) => {
         let data = '';
         res.on('data', (chunk) => (data += chunk));
-        res.on('end', () => resolve({
-          status: res.statusCode,
-          text: data,
-          headers: res.headers,
-        }));
+        res.on('end', () => {
+          registrarHttpDebug({
+            url: `https://${options.hostname}${options.path}`,
+            method: options.method || 'GET',
+            status: res.statusCode,
+            headers: res.headers,
+            body: data,
+            reqBody: payload,
+            ms: Date.now() - t0,
+            cliente: 'BoletaCert',
+          });
+          resolve({ status: res.statusCode, text: data, headers: res.headers });
+        });
       });
       req.on('error', reject);
       if (payload) req.write(payload);