theus-cli-linux-x64 1.2.1 → 1.2.2

package/vendor/chrome-extension/cdp-core.js

@@ -0,0 +1,400 @@
+// Theus en Chrome — lógica PURA de la fase 2 (sin chrome.*, sin CDP en vivo).
+//
+// Este archivo se carga en el service worker con importScripts('cdp-core.js')
+// y también desde los tests del CLI (chrome-extension/cdp-core.test.ts) vía
+// import con efecto lateral: todo lo público cuelga de
+// globalThis.TheusCdpCore. Mantenerlo libre de APIs de extensión.
+
+;(() => {
+  // -------------------------------------------------------------------------
+  // Buffers circulares
+  // -------------------------------------------------------------------------
+
+  /**
+   * Añade `item` a `buffer` respetando el tope `max`. Si desborda, expulsa el
+   * más antiguo y lo devuelve (para que el llamador limpie índices auxiliares).
+   */
+  function pushCircular(buffer, item, max) {
+    buffer.push(item)
+    if (buffer.length > max) {
+      return buffer.shift()
+    }
+    return null
+  }
+
+  // -------------------------------------------------------------------------
+  // Consola: eventos CDP → entradas homogéneas {ts, nivel, texto, url?}
+  // -------------------------------------------------------------------------
+
+  function describirRemoteObject(obj) {
+    if (!obj || typeof obj !== 'object') return String(obj)
+    if (obj.value !== undefined) {
+      if (typeof obj.value === 'string') return obj.value
+      try {
+        return JSON.stringify(obj.value)
+      } catch (_e) {
+        return String(obj.value)
+      }
+    }
+    if (typeof obj.description === 'string') return obj.description
+    return obj.type || 'undefined'
+  }
+
+  /**
+   * Convierte un evento CDP de consola en una entrada del buffer, o null si el
+   * evento no es de consola. Eventos soportados: Runtime.consoleAPICalled,
+   * Runtime.exceptionThrown y Log.entryAdded.
+   */
+  function formatearEventoConsola(method, params, ahoraMs) {
+    const ts = typeof ahoraMs === 'number' ? ahoraMs : Date.now()
+    if (method === 'Runtime.consoleAPICalled') {
+      const args = Array.isArray(params.args) ? params.args : []
+      return {
+        ts,
+        nivel: params.type || 'log',
+        texto: args.map(describirRemoteObject).join(' '),
+      }
+    }
+    if (method === 'Runtime.exceptionThrown') {
+      const det = params.exceptionDetails || {}
+      const desc =
+        (det.exception && det.exception.description) ||
+        (det.exception && det.exception.value) ||
+        ''
+      const texto = [det.text, desc].filter(Boolean).join(' ')
+      const entrada = { ts, nivel: 'error', texto: texto || 'Excepción sin detalle' }
+      if (det.url) entrada.url = det.url
+      return entrada
+    }
+    if (method === 'Log.entryAdded') {
+      const e = params.entry || {}
+      const entrada = { ts, nivel: e.level || 'info', texto: e.text || '' }
+      if (e.url) entrada.url = e.url
+      return entrada
+    }
+    return null
+  }
+
+  const NIVELES_ERROR = new Set(['error', 'assert'])
+
+  // -------------------------------------------------------------------------
+  // Red: pliega Network.* en entradas {id, metodo, url, tipo, estado, tam, …}
+  // -------------------------------------------------------------------------
+
+  /**
+   * Estado de red por pestaña: { entradas: [], porId: Map }. `entradas` es el
+   * buffer circular (orden de llegada); `porId` indexa por requestId para
+   * completar estado/tamaño/duración cuando llegan los eventos posteriores.
+   */
+  function crearEstadoRed() {
+    return { entradas: [], porId: new Map() }
+  }
+
+  /** Devuelve true si el evento era de red y fue plegado. */
+  function plegarEventoRed(estado, method, params, max, ahoraMs) {
+    const ts = typeof ahoraMs === 'number' ? ahoraMs : Date.now()
+    if (method === 'Network.requestWillBeSent') {
+      const entrada = {
+        id: params.requestId,
+        metodo: (params.request && params.request.method) || 'GET',
+        url: (params.request && params.request.url) || '',
+        tipo: params.type || 'Other',
+        estado: null,
+        mime: null,
+        tam: null,
+        inicioMs: ts,
+        duracionMs: null,
+        error: null,
+      }
+      estado.porId.set(params.requestId, entrada)
+      const expulsada = pushCircular(estado.entradas, entrada, max)
+      if (expulsada) estado.porId.delete(expulsada.id)
+      return true
+    }
+    const entrada = estado.porId.get(params && params.requestId)
+    if (!entrada) return method.startsWith('Network.')
+    if (method === 'Network.responseReceived') {
+      entrada.estado = params.response ? params.response.status : null
+      entrada.mime = params.response ? params.response.mimeType || null : null
+      return true
+    }
+    if (method === 'Network.loadingFinished') {
+      if (typeof params.encodedDataLength === 'number') {
+        entrada.tam = params.encodedDataLength
+      }
+      entrada.duracionMs = ts - entrada.inicioMs
+      return true
+    }
+    if (method === 'Network.loadingFailed') {
+      entrada.error = params.errorText || 'fallo de carga'
+      entrada.duracionMs = ts - entrada.inicioMs
+      return true
+    }
+    return method.startsWith('Network.')
+  }
+
+  // -------------------------------------------------------------------------
+  // Filtros de lectura (consola y red)
+  // -------------------------------------------------------------------------
+
+  /**
+   * Filtra entradas por regex (`pattern` sobre `campoTexto`), opcionalmente
+   * solo errores (consola), y corta a las `limit` MÁS RECIENTES. Un pattern
+   * inválido lanza Error con mensaje honesto.
+   */
+  function filtrarEntradas(entradas, opciones) {
+    const { pattern, limit, onlyErrors, campoTexto } = opciones
+    let re = null
+    if (typeof pattern === 'string' && pattern.length > 0) {
+      try {
+        re = new RegExp(pattern)
+      } catch (e) {
+        throw new Error(`El pattern no es una regex válida: ${e.message}`)
+      }
+    }
+    let resultado = entradas
+    if (onlyErrors) {
+      resultado = resultado.filter(e => NIVELES_ERROR.has(e.nivel))
+    }
+    if (re) {
+      resultado = resultado.filter(e => re.test(String(e[campoTexto] ?? '')))
+    }
+    const tope = typeof limit === 'number' && limit > 0 ? Math.floor(limit) : 100
+    return resultado.slice(-tope)
+  }
+
+  // -------------------------------------------------------------------------
+  // Teclado: "ctrl+shift+t" → parámetros de Input.dispatchKeyEvent
+  // -------------------------------------------------------------------------
+
+  const MODIFICADORES = {
+    alt: 1,
+    option: 1,
+    ctrl: 2,
+    control: 2,
+    meta: 4,
+    cmd: 4,
+    command: 4,
+    win: 4,
+    shift: 8,
+  }
+
+  const TECLAS_ESPECIALES = {
+    enter: { key: 'Enter', code: 'Enter', keyCode: 13, text: '\r' },
+    return: { key: 'Enter', code: 'Enter', keyCode: 13, text: '\r' },
+    tab: { key: 'Tab', code: 'Tab', keyCode: 9 },
+    escape: { key: 'Escape', code: 'Escape', keyCode: 27 },
+    esc: { key: 'Escape', code: 'Escape', keyCode: 27 },
+    backspace: { key: 'Backspace', code: 'Backspace', keyCode: 8 },
+    delete: { key: 'Delete', code: 'Delete', keyCode: 46 },
+    space: { key: ' ', code: 'Space', keyCode: 32, text: ' ' },
+    up: { key: 'ArrowUp', code: 'ArrowUp', keyCode: 38 },
+    arrowup: { key: 'ArrowUp', code: 'ArrowUp', keyCode: 38 },
+    down: { key: 'ArrowDown', code: 'ArrowDown', keyCode: 40 },
+    arrowdown: { key: 'ArrowDown', code: 'ArrowDown', keyCode: 40 },
+    left: { key: 'ArrowLeft', code: 'ArrowLeft', keyCode: 37 },
+    arrowleft: { key: 'ArrowLeft', code: 'ArrowLeft', keyCode: 37 },
+    right: { key: 'ArrowRight', code: 'ArrowRight', keyCode: 39 },
+    arrowright: { key: 'ArrowRight', code: 'ArrowRight', keyCode: 39 },
+    home: { key: 'Home', code: 'Home', keyCode: 36 },
+    end: { key: 'End', code: 'End', keyCode: 35 },
+    pageup: { key: 'PageUp', code: 'PageUp', keyCode: 33 },
+    pagedown: { key: 'PageDown', code: 'PageDown', keyCode: 34 },
+    insert: { key: 'Insert', code: 'Insert', keyCode: 45 },
+  }
+  for (let i = 1; i <= 12; i++) {
+    TECLAS_ESPECIALES[`f${i}`] = { key: `F${i}`, code: `F${i}`, keyCode: 111 + i }
+  }
+
+  /**
+   * Parsea una combinación tipo "ctrl+a", "Enter", "ctrl+shift+t".
+   * Devuelve { modifiers, key, code, keyCode, text? } o null si la tecla base
+   * no se reconoce. Con Ctrl/Alt/Meta activos no se emite `text` (no imprime).
+   */
+  function parsearCombinacionTeclas(combo) {
+    if (typeof combo !== 'string' || combo.trim().length === 0) return null
+    const partes = combo
+      .trim()
+      .split('+')
+      .map(p => p.trim())
+      .filter(p => p.length > 0)
+    if (partes.length === 0) return null
+    let modifiers = 0
+    let base = null
+    for (const parte of partes) {
+      const mod = MODIFICADORES[parte.toLowerCase()]
+      if (mod !== undefined && parte !== partes[partes.length - 1]) {
+        modifiers |= mod
+        continue
+      }
+      // Última parte (o parte no-modificador): la tecla base.
+      if (base !== null) return null
+      base = parte
+    }
+    if (base === null) return null
+    const especial = TECLAS_ESPECIALES[base.toLowerCase()]
+    if (especial) {
+      const def = { modifiers, ...especial }
+      if ((modifiers & (1 | 2 | 4)) !== 0) delete def.text
+      return def
+    }
+    if (base.length === 1) {
+      const ch = base
+      const mayus = (modifiers & 8) !== 0 ? ch.toUpperCase() : ch
+      const esLetra = /^[a-zA-Z]$/.test(ch)
+      const esDigito = /^[0-9]$/.test(ch)
+      const def = {
+        modifiers,
+        key: mayus,
+        code: esLetra
+          ? `Key${ch.toUpperCase()}`
+          : esDigito
+            ? `Digit${ch}`
+            : '',
+        keyCode: esLetra
+          ? ch.toUpperCase().charCodeAt(0)
+          : esDigito
+            ? ch.charCodeAt(0)
+            : mayus.charCodeAt(0),
+      }
+      if ((modifiers & (1 | 2 | 4)) === 0) def.text = mayus
+      return def
+    }
+    return null
+  }
+
+  // -------------------------------------------------------------------------
+  // Árbol de accesibilidad → resumen con refs
+  // -------------------------------------------------------------------------
+
+  const ROLES_INTERACTIVOS = new Set([
+    'button',
+    'link',
+    'textbox',
+    'searchbox',
+    'checkbox',
+    'radio',
+    'combobox',
+    'listbox',
+    'option',
+    'menuitem',
+    'menuitemcheckbox',
+    'menuitemradio',
+    'slider',
+    'spinbutton',
+    'switch',
+    'tab',
+    'textfield',
+    'ToggleButton',
+  ])
+
+  const ROLES_ESTRUCTURA = new Set([
+    'heading',
+    'StaticText',
+    'image',
+    'img',
+    'list',
+    'listitem',
+    'table',
+    'row',
+    'cell',
+    'form',
+    'navigation',
+    'main',
+    'banner',
+    'dialog',
+    'alert',
+    'region',
+    'article',
+  ])
+
+  function valorAX(campo) {
+    return campo && campo.value !== undefined && campo.value !== null
+      ? String(campo.value)
+      : ''
+  }
+
+  /**
+   * Resume los nodos de Accessibility.getFullAXTree: filtra por rol
+   * ('interactive' por defecto, 'all' añade estructura), asigna refs numéricos
+   * estables dentro de la lectura y trunca honestamente en `maxElementos`.
+   *
+   * Devuelve { elementos: [{ref, backendDOMNodeId, rol, nombre, valor?}],
+   * truncado, totalCandidatos }.
+   */
+  function resumirArbolAX(nodos, filtro, maxElementos) {
+    const modo = filtro === 'all' ? 'all' : 'interactive'
+    const max = typeof maxElementos === 'number' && maxElementos > 0 ? maxElementos : 150
+    const candidatos = []
+    for (const nodo of nodos || []) {
+      if (!nodo || nodo.ignored) continue
+      const rol = valorAX(nodo.role)
+      if (!rol) continue
+      const interesa =
+        ROLES_INTERACTIVOS.has(rol) || (modo === 'all' && ROLES_ESTRUCTURA.has(rol))
+      if (!interesa) continue
+      if (typeof nodo.backendDOMNodeId !== 'number') continue
+      const nombre = valorAX(nodo.name)
+      if (modo === 'all' && rol === 'StaticText' && nombre.trim().length === 0) continue
+      candidatos.push({
+        backendDOMNodeId: nodo.backendDOMNodeId,
+        rol,
+        nombre: nombre.slice(0, 160),
+        valor: valorAX(nodo.value).slice(0, 160),
+      })
+    }
+    const truncado = candidatos.length > max
+    const elementos = candidatos.slice(0, max).map((c, i) => {
+      const el = {
+        ref: String(i + 1),
+        backendDOMNodeId: c.backendDOMNodeId,
+        rol: c.rol,
+        nombre: c.nombre,
+      }
+      if (c.valor) el.valor = c.valor
+      return el
+    })
+    return { elementos, truncado, totalCandidatos: candidatos.length }
+  }
+
+  // -------------------------------------------------------------------------
+  // Capturas: decisión de reescalado/recompresión (la ejecución con canvas
+  // vive en cdp.js; aquí solo la aritmética, para poder testearla)
+  // -------------------------------------------------------------------------
+
+  /**
+   * Decide si una captura debe reprocesarse y con qué parámetros.
+   * base64Length: longitud de la cadena base64; anchoPx: ancho real del bitmap.
+   */
+  function planRecompresionCaptura(base64Length, anchoPx, opciones) {
+    const maxAncho = (opciones && opciones.maxAncho) || 1600
+    const maxBase64 = (opciones && opciones.maxBase64) || 12 * 1024 * 1024
+    const excedeAncho = anchoPx > maxAncho
+    const excedeTam = base64Length > maxBase64
+    if (!excedeAncho && !excedeTam) return { reprocesar: false }
+    const escala = excedeAncho ? maxAncho / anchoPx : 1
+    return {
+      reprocesar: true,
+      escala,
+      calidad: excedeTam ? 0.6 : 0.8,
+    }
+  }
+
+  function horaLocal(ms) {
+    const d = new Date(ms)
+    const dos = n => String(n).padStart(2, '0')
+    return `${dos(d.getHours())}:${dos(d.getMinutes())}:${dos(d.getSeconds())}`
+  }
+
+  globalThis.TheusCdpCore = {
+    pushCircular,
+    formatearEventoConsola,
+    crearEstadoRed,
+    plegarEventoRed,
+    filtrarEntradas,
+    parsearCombinacionTeclas,
+    resumirArbolAX,
+    planRecompresionCaptura,
+    horaLocal,
+  }
+})()