@gnpdev/rpa-tools 1.0.17 → 1.0.19

package/README.md

@@ -92,9 +92,25 @@ if (credentials) {
 }
 ```
 
-### 4. Capturas de Pantalla bajo demanda (Playwright)
-Activa el watcher pasando la instancia de `page`. El bot detectará cambios en la tabla de la DB para tomar screenshots automáticamente.
+### 4. Verificar Estado del Bot (Kill Switch)
+Permite consultar si el bot debe seguir en ejecución según la base de datos (columna `estado` en `bots.tb_bots`). Útil para implementar una parada de emergencia desde el panel de control.
 
+```javascript
+import { rpa, logger } from './lib/rpa.js';
+
+const active = await rpa.isActive();
+
+if (!active) {
+  logger.warn('El bot ha sido desactivado desde la base de datos. Finalizando...');
+  await rpa.destroy();
+  process.exit(0);
+}
+```
+
+### 5. Capturas de Pantalla bajo demanda (Playwright / Puppeteer)
+Activa el watcher pasando la instancia de `page`. El bot detectará cambios en la tabla de la DB para tomar screenshots automáticamente. Compatible con ambos motores.
+
+#### Ejemplo con Playwright
 ```javascript
 import { chromium } from 'playwright';
 import { rpa } from './lib/rpa.js';
@@ -102,20 +118,25 @@ import { rpa } from './lib/rpa.js';
 const browser = await chromium.launch();
 const page = await browser.newPage();
 
-// Inicia el monitoreo (polling cada 3s por defecto)
 rpa.watchDebugFlag(page);
+```
 
+#### Ejemplo con Puppeteer
+```javascript
+import puppeteer from 'puppeteer';
+import { rpa } from './lib/rpa.js';
 
-// Al terminar el proceso del bot
-rpa.destroy(); 
+const browser = await puppeteer.launch();
+const page = await browser.newPage();
 
-// Sugerencia: limpiar al desconectar
-browser.on('disconnected', () => rpa.destroy());
+rpa.watchDebugFlag(page);
 ```
 
-### 5. Captura Automática de Errores (Screenshot + Trace)
+### 6. Captura Automática de Errores (Screenshot + Trace)
 Captura el estado completo del bot cuando ocurre una excepción. **`captureError` detecta automáticamente el paso actual** definido con `step()`.
 
+> **Nota:** El soporte de `tracing` (archivos .zip de depuración) es exclusivo de **Playwright**. En **Puppeteer** se capturará el error y el screenshot, pero el `traceKey` será nulo.
+
 ```javascript
 import { chromium } from 'playwright';
 import { rpa, logger, step } from './lib/rpa.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gnpdev/rpa-tools",
-  "version": "1.0.17",
+  "version": "1.0.19",
   "description": "Libreria para logs y screenshot de bots",
   "author": "Sergio Antonio Trujillo del Valle",
   "main": "src/index.js",

package/src/errorCapture.js

@@ -35,13 +35,13 @@ function errorPrefix(botId) {
 
 /**
  * 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)
+ *  - Screenshot WebP de la página actual (Playwright/Puppeteer)
+ *  - Trace de Playwright (.zip con video, red, consola, DOM snapshots) [Opcional]
  *  - Registro en bots.tb_error_bots
  *
  * @param {object} p
- * @param {import('playwright').Page}              p.page
- * @param {import('playwright').BrowserContext}    p.context
+ * @param {any}                                    p.page       - Instancia de Page (Playwright o Puppeteer)
+ * @param {any}                                    [p.context]  - BrowserContext (solo Playwright para tracing)
  * @param {Error}                                  p.err
  * @param {string}                                 p.botId      - UUID del bot
  * @param {import('pg').Pool}                      p.pool

package/src/index.d.ts

@@ -74,6 +74,12 @@ export interface RpaTools {
    */
   getCredentials: (nombre: string) => Promise<{ usuario: string; password: string; idUsuario: string } | null>;
 
+  /**
+   * Consulta si el bot está activo en la base de datos (columna 'estado').
+   * @returns {Promise<boolean>}
+   */
+  isActive: () => Promise<boolean>;
+
   /**
    * Captura screenshot, trace y registra error en base de datos.
    */

package/src/index.js

@@ -14,7 +14,7 @@ const { captureError }                     = require('./errorCapture');
  * @param {object}  opts.minio          - config de MinIO
  * @param {object}  [opts.log]          - opciones de Pino
  *
- * @returns {{ logger, watchDebugFlag, getCredentials, destroy }}
+ * @returns {{ logger, state, step, watchDebugFlag, getCredentials, isActive, captureError, destroy }}
  */
 async function createRpaTools(opts = {}) {
   const {
@@ -55,8 +55,33 @@ async function createRpaTools(opts = {}) {
       state.currentStep = name;
       logger.info(name + ' - Nuevo paso');
     },
+    /**
+     * Inicia el polling que activa/desactiva screenshots según bot_debug_config.
+     * @param {any} page - Objeto Page de Playwright o Puppeteer
+     * @param {number} [pollMs=3000] - Intervalo de polling en ms
+     */
     watchDebugFlag: (page, pollMs) => watcher.watch(page, pollMs),
     getCredentials: (nombre) => credentials.getAppCredentials(nombre),
+    /**
+     * Consulta si el bot está activo en la base de datos (columna 'estado').
+     * @returns {Promise<boolean>}
+     */
+    isActive: async () => {
+      try {
+        const { rows } = await db.query(
+          'SELECT estado FROM bots.tb_bots WHERE id = $1',
+          [botId]
+        );
+        return rows.length > 0 ? rows[0].estado : false;
+      } catch (err) {
+        logger.error({ err }, 'Error consultando estado en isActive');
+        return false;
+      }
+    },
+    /**
+     * Captura screenshot y registra error en base de datos. 
+     * Soporta Playwright (con tracing opcional) y Puppeteer.
+     */
     captureError: ({ page, context, err, step }) => captureError({
       page,
       context,

package/src/watcher.js

@@ -1,137 +1,139 @@
-'use strict';
-const { uploadScreenshot } = require('./storage');
-
-class ScreenshotWatcher {
-  /**
-   * @param {object} p
-   * @param {string}                p.botId
-   * @param {import('pg').Pool}     p.pool
-   * @param {import('minio').Client} p.minioClient
-   * @param {string}                p.bucket
-   * @param {import('pino').Logger} p.logger
-   * @param {object}                [p.screenshot]
-   * @param {'webp'|'jpeg'}         [p.screenshot.format='webp']
-   * @param {number}                [p.screenshot.quality=70]   - calidad conversión 1-100
-   * @param {number}                [p.screenshot.captureQuality=90] - calidad captura Playwright
-   */
-  constructor({ botId, pool, minioClient, bucket, logger, screenshot = {} }) {
-    this.botId       = botId;
-    this.pool        = pool;
-    this.minioClient = minioClient;
-    this.bucket      = bucket;
-    this.logger      = logger;
-
-    this.screenshotOpts = {
-      format:         screenshot.format         ?? 'webp',
-      quality:        screenshot.quality        ?? 70,
-      captureQuality: screenshot.captureQuality ?? 90,
-    };
-
-    this._watchTimer = null;
-    this._shotTimer  = null;
-  }
-
-  /**
-   * Inicia el polling que activa/desactiva screenshots según bot_debug_config.
-   * Llama una sola vez al arrancar el bot.
-   *
-   * @param {import('playwright').Page} page
-   * @param {number} [pollMs=3000] - cada cuántos ms revisar la BD
-   */
-  watch(page, pollMs = 3000) {
-    if (this._watchTimer) {
-      this.logger.warn('ScreenshotWatcher ya está corriendo, ignorando llamada duplicada');
-      return;
-    }
-
-    this.logger.info({ pollMs }, 'Iniciando polling de debug config');
-
-    this._watchTimer = setInterval(async () => {
-      try {
-        const { rows } = await this.pool.query(
-          `SELECT screenshots_activo, intervalo_sec
-             FROM bots.tb_bots
-            WHERE id = $1`,
-          [this.botId]
-        );
-
-        const cfg = rows[0];
-        // console.log('DEBUG CONFIG', cfg); // <-- loguear config para debug
-
-        if (!cfg) {
-          this.logger.debug('Sin config en bot_debug_config para este bot');
-          return;
-        }
-
-        if (cfg.screenshots_activo && !this._shotTimer) {
-          this.logger.info({ intervalSec: cfg.intervalo_sec }, 'Screenshots activados');
-          this._startScreenshots(page, cfg.intervalo_sec * 1000);
-          return;
-        }
-
-        if (!cfg.screenshots_activo && this._shotTimer) {
-          this.logger.info('Screenshots desactivados');
-          this._stopScreenshots();
-        }
-      } catch (err) {
-        this.logger.error({ err }, 'Error leyendo bot_debug_config');
-      }
-    }, pollMs);
-  }
-
-  /**
-   * @private
-   */
-  _startScreenshots(page, intervalMs) {
-    this._shotTimer = setInterval(async () => {
-      const t0 = Date.now();
-
-      try {
-        // Playwright captura en jpeg (más rápido), sharp convierte a WebP después
-        const rawBuffer = await page.screenshot({
-          type:     'jpeg',
-          quality:  this.screenshotOpts.captureQuality,
-          fullPage: false,
-        });
-
-        const key = await uploadScreenshot(
-          this.minioClient,
-          this.bucket,
-          this.botId,
-          rawBuffer,
-          {
-            format:  this.screenshotOpts.format,
-            quality: this.screenshotOpts.quality,
-          }
-        );
-
-        this.logger.debug(
-          { key, ms: Date.now() - t0 },
-          'Screenshot subido'
-        );
-      } catch (err) {
-        this.logger.error({ err }, 'Error capturando o subiendo screenshot');
-      }
-    }, intervalMs);
-  }
-
-  /**
-   * @private
-   */
-  _stopScreenshots() {
-    clearInterval(this._shotTimer);
-    this._shotTimer = null;
-  }
-
-  /**
-   * Detiene todos los intervalos. Llamar siempre al cerrar el bot.
-   */
-  destroy() {
-    this._stopScreenshots();
-    clearInterval(this._watchTimer);
-    this._watchTimer = null;
-    this.logger.info('ScreenshotWatcher destruido');
-  }
-}
-
+'use strict';
+const { uploadScreenshot } = require('./storage');
+
+class ScreenshotWatcher {
+  /**
+   * @param {object} p
+   * @param {string}                p.botId
+   * @param {import('pg').Pool}     p.pool
+   * @param {import('minio').Client} p.minioClient
+   * @param {string}                p.bucket
+   * @param {import('pino').Logger} p.logger
+   * @param {object}                [p.screenshot]
+   * @param {'webp'|'jpeg'}         [p.screenshot.format='webp']
+   * @param {number}                [p.screenshot.quality=70]   - calidad conversión 1-100
+   * @param {number}                [p.screenshot.captureQuality=90] - calidad captura Playwright
+   */
+  constructor({ botId, pool, minioClient, bucket, logger, screenshot = {} }) {
+    this.botId       = botId;
+    this.pool        = pool;
+    this.minioClient = minioClient;
+    this.bucket      = bucket;
+    this.logger      = logger;
+
+    this.screenshotOpts = {
+      format:         screenshot.format         ?? 'webp',
+      quality:        screenshot.quality        ?? 70,
+      captureQuality: screenshot.captureQuality ?? 90,
+    };
+
+    this._watchTimer = null;
+    this._shotTimer  = null;
+  }
+
+  /**
+   * Inicia el polling que activa/desactiva screenshots según bot_debug_config.
+   * Llama una sola vez al arrancar el bot.
+   *
+   * @param {any} page - Objeto Page de Playwright o Puppeteer
+   * @param {number} [pollMs=3000] - cada cuántos ms revisar la BD
+   */
+  watch(page, pollMs = 3000) {
+    if (this._watchTimer) {
+      this.logger.warn('ScreenshotWatcher ya está corriendo, ignorando llamada duplicada');
+      return;
+    }
+
+    this.logger.info({ pollMs }, 'Iniciando polling de debug config');
+
+    this._watchTimer = setInterval(async () => {
+      try {
+        const { rows } = await this.pool.query(
+          `SELECT screenshots_activo, intervalo_sec
+             FROM bots.tb_bots
+            WHERE id = $1`,
+          [this.botId]
+        );
+
+        const cfg = rows[0];
+        // console.log('DEBUG CONFIG', cfg); // <-- loguear config para debug
+
+        if (!cfg) {
+          this.logger.debug('Sin config en bot_debug_config para este bot');
+          return;
+        }
+
+        if (cfg.screenshots_activo && !this._shotTimer) {
+          this.logger.info({ intervalSec: cfg.intervalo_sec }, 'Screenshots activados');
+          this._startScreenshots(page, cfg.intervalo_sec * 1000);
+          return;
+        }
+
+        if (!cfg.screenshots_activo && this._shotTimer) {
+          this.logger.info('Screenshots desactivados');
+          this._stopScreenshots();
+        }
+      } catch (err) {
+        this.logger.error({ err }, 'Error leyendo bot_debug_config');
+      }
+    }, pollMs);
+  }
+
+  /**
+   * @private
+   */
+  _startScreenshots(page, intervalMs) {
+    this._shotTimer = setInterval(async () => {
+      const t0 = Date.now();
+
+      try {
+        // Playwright captura en jpeg (más rápido), sharp convierte a WebP después
+        const rawBuffer = await page.screenshot({
+          type:     'jpeg',
+          quality:  this.screenshotOpts.captureQuality,
+          fullPage: false,
+        });
+
+        const key = await uploadScreenshot(
+          this.minioClient,
+          this.bucket,
+          this.botId,
+          rawBuffer,
+          {
+            format:  this.screenshotOpts.format,
+            quality: this.screenshotOpts.quality,
+            pool:    this.pool,
+            logger:  this.logger,
+          }
+        );
+
+        this.logger.debug(
+          { key, ms: Date.now() - t0 },
+          'Screenshot subido'
+        );
+      } catch (err) {
+        this.logger.error({ err }, 'Error capturando o subiendo screenshot');
+      }
+    }, intervalMs);
+  }
+
+  /**
+   * @private
+   */
+  _stopScreenshots() {
+    clearInterval(this._shotTimer);
+    this._shotTimer = null;
+  }
+
+  /**
+   * Detiene todos los intervalos. Llamar siempre al cerrar el bot.
+   */
+  destroy() {
+    this._stopScreenshots();
+    clearInterval(this._watchTimer);
+    this._watchTimer = null;
+    this.logger.info('ScreenshotWatcher destruido');
+  }
+}
+
 module.exports = { ScreenshotWatcher };