@gnpdev/rpa-tools 1.0.16 → 1.0.18

package/package.json

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

package/src/errorCapture.js

@@ -1,149 +1,155 @@
-'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;
-}
-
+'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 {
+    if (context?.tracing) {
+      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');
+    } else {
+      logger.debug('Tracing no disponible (Puppeteer o no activado)');
+    }
+  } catch (traceErr) {
+    logger.error({ err: traceErr }, 'No se pudo capturar trace de error');
+  } finally {
+    if (context?.tracing) {
+      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

@@ -63,10 +63,10 @@ export interface RpaTools {
   /**
    * Inicia el polling que activa/desactiva screenshots
    * según bot_debug_config en la BD.
-   * @param page      - Objeto Page de Playwright
+   * @param page      - Objeto Page de Playwright o Puppeteer
    * @param pollMs    - Intervalo de polling en ms. Default: 3000
    */
-  watchDebugFlag: (page: Page, pollMs?: number) => void;
+  watchDebugFlag: (page: any, pollMs?: number) => void;
 
   /**
    * Recupera credenciales de una aplicación desde la base de datos.
@@ -78,8 +78,8 @@ export interface RpaTools {
    * Captura screenshot, trace y registra error en base de datos.
    */
   captureError: (params: {
-    page: Page;
-    context: any;
+    page: any;
+    context?: any;
     err: Error;
     step?: string;
   }) => Promise<{ errorId: number | null; screenshotKey: string | null; traceKey: string | null }>;

package/src/index.js

@@ -53,7 +53,7 @@ async function createRpaTools(opts = {}) {
     state,
     step: (name) => {
       state.currentStep = name;
-      logger.info({ step: name }, 'Nuevo paso');
+      logger.info(name + ' - Nuevo paso');
     },
     watchDebugFlag: (page, pollMs) => watcher.watch(page, pollMs),
     getCredentials: (nombre) => credentials.getAppCredentials(nombre),

package/src/storage.js

@@ -1,83 +1,101 @@
-'use strict';
-const Minio = require('minio');
-const sharp = require('sharp');
-
-/**
- * Crea y retorna el cliente de MinIO.
- * @param {object} cfg
- * @param {string}  cfg.endPoint
- * @param {number}  [cfg.port=9000]
- * @param {boolean} [cfg.useSSL=false]
- * @param {string}  cfg.accessKey
- * @param {string}  cfg.secretKey
- */
-function createMinioClient(cfg) {
-  return new Minio.Client({
-    endPoint:  cfg.endPoint,
-    port:      cfg.port     ?? 9000,
-    useSSL:    cfg.useSSL   ?? false,
-    accessKey: cfg.accessKey,
-    secretKey: cfg.secretKey,
-  });
-}
-
-/**
- * Garantiza que el bucket exista; lo crea si no.
- * @param {import('minio').Client} client
- * @param {string} bucket
- * @param {string} [region='us-east-1']
- */
-async function ensureBucket(client, bucket, region = 'us-east-1') {
-  const exists = await client.bucketExists(bucket);
-  if (!exists) await client.makeBucket(bucket, region);
-}
-
-/**
- * Convierte un buffer de imagen a WebP usando sharp.
- * @param {Buffer} buffer  - buffer fuente (jpeg/png)
- * @param {number} [quality=70]
- * @returns {Promise<Buffer>}
- */
-async function toWebp(buffer, quality = 70) {
-  return sharp(buffer)
-    .webp({ quality })
-    .toBuffer();
-}
-
-/**
- * Sube un screenshot a MinIO.
- * Si format='webp' convierte el buffer antes de subir.
- * Ruta generada: {botId}/{YYYY-MM-DD}/{ISO-timestamp}.{ext}
- *
- * @param {import('minio').Client} client
- * @param {string} bucket
- * @param {string} botId
- * @param {Buffer} buffer       - buffer raw de Playwright (jpeg)
- * @param {object} [opts]
- * @param {'webp'|'jpeg'}  [opts.format='webp']
- * @param {number}         [opts.quality=70]      - calidad 1-100
- * @returns {Promise<string>}   - object key en MinIO
- */
-async function uploadScreenshot(client, bucket, botId, buffer, opts = {}) {
-  const { format = 'webp', quality = 70 } = opts;
-
-  const finalBuffer = format === 'webp'
-    ? await toWebp(buffer, quality)
-    : buffer;
-
-  const contentType = format === 'webp' ? 'image/webp' : 'image/jpeg';
-  const ext         = format === 'webp' ? 'webp' : 'jpg';
-
-  const now  = new Date();
-  const date = now.toISOString().slice(0, 10);           // 2025-06-01
-  const ts   = now.toISOString().replace(/[:.]/g, '-');  // 2025-06-01T12-30-00-000Z
-  const key  = `${botId}.${ext}`;
-
-  await client.putObject(bucket, key, finalBuffer, finalBuffer.length, {
-    'Content-Type': contentType,
-  });
-
-  return key;
-}
-
+'use strict';
+const Minio = require('minio');
+const sharp = require('sharp');
+
+/**
+ * Crea y retorna el cliente de MinIO.
+ * @param {object} cfg
+ * @param {string}  cfg.endPoint
+ * @param {number}  [cfg.port=9000]
+ * @param {boolean} [cfg.useSSL=false]
+ * @param {string}  cfg.accessKey
+ * @param {string}  cfg.secretKey
+ */
+function createMinioClient(cfg) {
+  return new Minio.Client({
+    endPoint:  cfg.endPoint,
+    port:      cfg.port     ?? 9000,
+    useSSL:    cfg.useSSL   ?? false,
+    accessKey: cfg.accessKey,
+    secretKey: cfg.secretKey,
+  });
+}
+
+/**
+ * Garantiza que el bucket exista; lo crea si no.
+ * @param {import('minio').Client} client
+ * @param {string} bucket
+ * @param {string} [region='us-east-1']
+ */
+async function ensureBucket(client, bucket, region = 'us-east-1') {
+  const exists = await client.bucketExists(bucket);
+  if (!exists) await client.makeBucket(bucket, region);
+}
+
+/**
+ * Convierte un buffer de imagen a WebP usando sharp.
+ * @param {Buffer} buffer  - buffer fuente (jpeg/png)
+ * @param {number} [quality=70]
+ * @returns {Promise<Buffer>}
+ */
+async function toWebp(buffer, quality = 70) {
+  return sharp(buffer)
+    .webp({ quality })
+    .toBuffer();
+}
+
+/**
+ * Sube un screenshot a MinIO.
+ * Si format='webp' convierte el buffer antes de subir.
+ * Ruta generada: {botId}/{YYYY-MM-DD}/{ISO-timestamp}.{ext}
+ *
+ * @param {import('minio').Client} client
+ * @param {string} bucket
+ * @param {string} botId
+ * @param {Buffer} buffer       - buffer raw de Playwright (jpeg)
+ * @param {object} [opts]
+ * @param {'webp'|'jpeg'}  [opts.format='webp']
+ * @param {number}         [opts.quality=70]      - calidad 1-100
+ * @param {object}         [opts.pool]            - Pool de base de datos
+ * @param {object}         [opts.logger]          - Instancia de logger
+ * @returns {Promise<string>}   - object key en MinIO
+ */
+async function uploadScreenshot(client, bucket, botId, buffer, opts = {}) {
+  const { format = 'webp', quality = 70, pool, logger } = opts;
+
+  const finalBuffer = format === 'webp'
+    ? await toWebp(buffer, quality)
+    : buffer;
+
+  const contentType = format === 'webp' ? 'image/webp' : 'image/jpeg';
+  const ext         = format === 'webp' ? 'webp' : 'jpg';
+  const key  = `${botId}.${ext}`;
+
+  await client.putObject(bucket, key, finalBuffer, finalBuffer.length, {
+    'Content-Type': contentType,
+  });
+
+  // ── 3. Registro en base de datos ─────────────────────────────────────────
+  if (pool) {
+    try {
+      await pool.query(
+        `UPDATE bots.tb_bots
+         SET url_screenshot = $1,
+             updated_at = NOW()
+         WHERE id = $2::uuid`,
+        [key, botId]
+      );
+      
+    } catch (err) {
+      if (logger) {
+        logger.error({ err, botId, key }, 'No se pudo actualizar url_screenshot en BD');
+      } else {
+        console.error(`[Storage] Error BD (${botId}):`, err.message);
+      }
+    }
+  }
+
+  return key;
+}
+
 module.exports = { createMinioClient, ensureBucket, uploadScreenshot };

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 {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,
+            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 };