@gnpdev/rpa-tools 1.0.9 → 1.0.13

package/README.md

@@ -68,7 +68,7 @@ Recupera de forma segura el `usuario`, `password` e `idUsuario` de una aplicaci
 import { logger, rpa } from './lib/rpa.js';
 
 
-logger.info('Optener creddenciales');
+logger.info('Obtener credenciales');
 const credentials = await rpa.getCredentials('Portal CRM');
 
 if (credentials) {
@@ -81,7 +81,7 @@ if (credentials) {
 Activa el watcher pasando la instancia de `page`. El bot detectará cambios en la tabla de la DB para tomar screenshots automáticamente.
 
 ```javascript
-const { chromium } = require('playwright');
+import { chromium } from 'playwright';
 import { rpa } from './lib/rpa.js';
 
 const browser = await chromium.launch();
@@ -90,8 +90,57 @@ const page = await browser.newPage();
 // Inicia el monitoreo (polling cada 3s por defecto)
 rpa.watchDebugFlag(page);
 
+
 // Al terminar el proceso del bot
-// rpa.destroy(); 
+ rpa.destroy(); 
+
+ puedes incluir 
+
+ browser.on('disconnected', () => rpa.destroy());
+```
+
+### 4. Captura Automática de Errores (Screenshot + Trace)
+Captura el estado completo del bot cuando ocurre una excepción: Screenshot (.webp), Trace de Playwright (.zip) y registro en la base de datos `bots.tb_error_bots`.
+
+```javascript
+import { chromium } from 'playwright';
+import { rpa, logger } from './lib/rpa.js';
+
+const browser = await chromium.launch({ headless: true });
+const context = await browser.newContext();
+const page    = await context.newPage();
+
+ // ── Activar tracing ANTES de que empiece la sesión ──────────────────────
+  // screenshots:true  → captura visual en cada snapshot
+  // snapshots:true    → guarda el DOM y estado de red en cada paso
+  await context.tracing.start({
+    screenshots: true,
+    snapshots:   true,
+  });
+
+let currentStep = 'Inicio';
+
+try {
+  // Lógica de tu bot...
+  await page.goto('https://example.com');
+  
+  currentStep = 'Login';
+  await login(page);
+
+  currentStep = 'Procesar Datos';
+  await page.click('#boton-inexistente');
+} catch (err) {
+  // Captura automática de evidencia
+  const { errorId } = await rpa.captureError({
+    page,
+    context,
+    err,
+    step: currentStep 
+  });
+
+  logger.error({ errorId, step: currentStep }, 'Fallo crítico capturado');
+  throw err;
+}
 ```
 
 ## Variables de Entorno Sugeridas

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gnpdev/rpa-tools",
-  "version": "1.0.9",
+  "version": "1.0.13",
   "description": "Libreria para logs y screenshot de bots",
   "author": "Sergio Antonio Trujillo del Valle",
   "main": "src/index.js",
@@ -19,6 +19,7 @@
   "dependencies": {
     "minio": "^8.0.7",
     "pino": "^10.3.1",
+    "pino-pretty": "^13.1.3",
     "sharp": "^0.34.5"
   },
   "devDependencies": {
@@ -26,7 +27,6 @@
     "@commitlint/config-conventional": "^20.5.0",
     "@release-it/conventional-changelog": "^10.0.6",
     "husky": "^9.1.7",
-    "pino-pretty": "^13.1.3",
     "release-it": "^19.2.4"
   },
   "scripts": {

package/src/errorCapture.js

@@ -0,0 +1,149 @@
+'use strict';
+const fs   = require('fs/promises');
+const path = require('path');
+
+/**
+ * Sube un buffer o archivo local a MinIO y retorna el key generado.
+ * @param {import('minio').Client} client
+ * @param {string} bucket
+ * @param {string} key
+ * @param {Buffer|string} source  - Buffer o ruta de archivo local
+ * @param {string} contentType
+ */
+async function uploadToMinio(client, bucket, key, source, contentType) {
+  const buffer = typeof source === 'string'
+    ? await fs.readFile(source)
+    : source;
+
+  await client.putObject(bucket, key, buffer, buffer.length, {
+    'Content-Type': contentType,
+  });
+
+  return key;
+}
+
+/**
+ * Genera el prefijo base para los archivos de error en MinIO.
+ * Estructura: errors/{botId}/{YYYY-MM-DD}/{ISO-timestamp}
+ */
+function errorPrefix(botId) {
+  const now  = new Date();
+  const date = now.toISOString().slice(0, 10);
+  const ts   = now.toISOString().replace(/[:.]/g, '-');
+  return `errors/${botId}/${date}/${ts}`;
+}
+
+/**
+ * Captura el estado completo cuando ocurre un error:
+ *  - Screenshot WebP de la página actual
+ *  - Trace de Playwright (.zip con video, red, consola, DOM snapshots)
+ *  - Registro en bots.tb_error_bots
+ *
+ * @param {object} p
+ * @param {import('playwright').Page}              p.page
+ * @param {import('playwright').BrowserContext}    p.context
+ * @param {Error}                                  p.err
+ * @param {string}                                 p.botId      - UUID del bot
+ * @param {import('pg').Pool}                      p.pool
+ * @param {import('minio').Client}                 p.minioClient
+ * @param {string}                                 p.bucket
+ * @param {import('pino').Logger}                  p.logger
+ * @param {string}                                 [p.step]     - paso donde falló
+ *
+ * @returns {Promise<{ screenshotKey: string|null, traceKey: string|null, errorId: number|null }>}
+ */
+async function captureError({ page, context, err, botId, pool, minioClient, bucket, logger, step }) {
+  const prefix   = errorPrefix(botId);
+  const stepInfo = step ? { step } : {};
+  const result   = { screenshotKey: null, traceKey: null, errorId: null };
+
+  // ── 1. Screenshot ────────────────────────────────────────────────────────
+  try {
+    const buffer = await page.screenshot({
+      type:     'jpeg',
+      quality:  90,
+      fullPage: true,
+    });
+
+    let finalBuffer = buffer;
+    let ext         = 'jpg';
+    let contentType = 'image/jpeg';
+
+    try {
+      const sharp = require('sharp');
+      finalBuffer = await sharp(buffer).webp({ quality: 80 }).toBuffer();
+      ext         = 'webp';
+      contentType = 'image/webp';
+    } catch {
+      // sharp no disponible, se sube en jpeg
+    }
+
+    result.screenshotKey = await uploadToMinio(
+      minioClient, bucket,
+      `${prefix}-error.${ext}`,
+      finalBuffer,
+      contentType
+    );
+
+    logger.info({ ...stepInfo, screenshotKey: result.screenshotKey }, 'Screenshot de error subido');
+  } catch (screenshotErr) {
+    logger.error({ err: screenshotErr }, 'No se pudo capturar screenshot de error');
+  }
+
+  // ── 2. Trace ─────────────────────────────────────────────────────────────
+  const tracePath = path.join(require('os').tmpdir(), `trace-${botId}-${Date.now()}.zip`);
+
+  try {
+    await context.tracing.stop({ path: tracePath });
+
+    result.traceKey = await uploadToMinio(
+      minioClient, bucket,
+      `${prefix}-trace.zip`,
+      tracePath,
+      'application/zip'
+    );
+
+    logger.info({ ...stepInfo, traceKey: result.traceKey }, 'Trace de error subido');
+  } catch (traceErr) {
+    logger.error({ err: traceErr }, 'No se pudo capturar trace de error');
+  } finally {
+    await fs.unlink(tracePath).catch(() => {});
+  }
+
+  // ── 3. Registro en bots.tb_error_bots ───────────────────────────────────
+  try {
+    const { rows } = await pool.query(
+      `INSERT INTO bots.tb_error_bots
+         (bot_id, step, error_message, url, screenshot_key, trace_key)
+       VALUES ($1::uuid, $2, $3, $4, $5, $6)
+       RETURNING id`,
+      [
+        botId,
+        step                 ?? null,
+        err.message,
+        page.url()           ?? null,
+        result.screenshotKey ?? null,
+        result.traceKey      ?? null,
+      ]
+    );
+
+    result.errorId = rows[0].id;
+    logger.info({ ...stepInfo, errorId: result.errorId }, 'Error registrado en BD');
+  } catch (dbErr) {
+    logger.error({ err: dbErr }, 'No se pudo registrar el error en BD');
+  }
+
+  // ── 4. Log estructurado final ────────────────────────────────────────────
+  logger.error({
+    ...stepInfo,
+    err,
+    url:            page.url(),
+    screenshotKey:  result.screenshotKey,
+    traceKey:       result.traceKey,
+    errorId:        result.errorId,
+  }, 'Error capturado en playground');
+
+  return result;
+}
+
+module.exports = { captureError };

package/src/index.d.ts

@@ -57,6 +57,22 @@ export interface RpaTools {
    */
   watchDebugFlag: (page: Page, pollMs?: number) => void;
 
+  /**
+   * Recupera credenciales de una aplicación desde la base de datos.
+   * @param nombre - Nombre de la aplicación (ej. 'Portal CRM')
+   */
+  getCredentials: (nombre: string) => Promise<{ usuario: string; password: string; idUsuario: string } | null>;
+
+  /**
+   * Captura screenshot, trace y registra error en base de datos.
+   */
+  captureError: (params: {
+    page: Page;
+    context: any;
+    err: Error;
+    step?: string;
+  }) => Promise<{ errorId: number | null; screenshotKey: string | null; traceKey: string | null }>;
+
   /** Detiene todos los intervalos. Llamar siempre al cerrar el bot. */
   destroy: () => void;
 }

package/src/index.js

@@ -3,6 +3,7 @@ const { createLogger }                       = require('./logger');
 const { createMinioClient, ensureBucket }    = require('./storage');
 const { ScreenshotWatcher }                  = require('./watcher');
 const { CredentialManager }                  = require('./credentials');
+const { captureError }                     = require('./errorCapture');
 
 /**
  * Factory principal de la librería.
@@ -49,6 +50,7 @@ async function createRpaTools(opts = {}) {
     logger,
     watchDebugFlag: (page, pollMs) => watcher.watch(page, pollMs),
     getCredentials: (nombre) => credentials.getAppCredentials(nombre),
+    captureError: ({ page, context, err, step }) =>  captureError({ page, context, err, step, botId, pool: db, minioClient, bucket, logger }),
     destroy: () => watcher.destroy(),
   };
 }