theus-cli-linux-x64 1.2.0 → 1.2.2

package/vendor/chrome-extension/cdp.js

@@ -0,0 +1,672 @@
+// Theus en Chrome — fase 2: control total vía chrome.debugger (CDP).
+//
+// Este archivo se carga con importScripts('cdp-core.js', 'cdp.js') desde
+// background.js. Aporta:
+//   - Gestor de sesiones CDP por pestaña: attach perezoso (la primera tool
+//     que lo exige), detach al cerrar la pestaña, reattach transparente si
+//     Chrome suelta el debugger (con aviso honesto de que el buffer se cortó).
+//   - Buffers circulares de consola y red que arrancan en el attach.
+//   - Handlers de: computer, read_page, form_input, resize_window,
+//     read_console_messages y read_network_requests.
+//
+// Nota inevitable: mientras una pestaña está instrumentada, Chrome muestra la
+// barra «Theus en Chrome ha empezado a depurar este navegador». Es el precio
+// de chrome.debugger y no se puede ocultar.
+
+const CDP_VERSION = '1.3'
+const MAX_ENTRADAS_CONSOLA = 1000
+const MAX_ENTRADAS_RED = 1000
+const MAX_ELEMENTOS_PAGINA = 150
+const MAX_ELEMENTOS_CON_BOUNDS = 100
+const MAX_ESPERA_S = 15
+// Debe casar con MAX_CHANNEL_MESSAGE_BYTES del CLI
+// (vendor/theus-packages/theus-for-chrome-mcp/constants.ts).
+const LIMITE_CANAL_BYTES = 16 * 1024 * 1024
+// Margen para el JSON envolvente: si el base64 excede esto, se recomprime.
+const MAX_CAPTURA_BASE64 = 12 * 1024 * 1024
+const MAX_ANCHO_CAPTURA = 1600
+
+const Core = globalThis.TheusCdpCore
+
+// tabId → sesión
+const sesionesCdp = new Map()
+
+function crearSesion(tabId) {
+  return {
+    tabId,
+    adjunta: false,
+    adjuntadaDesdeMs: 0,
+    cortes: 0, // reattaches: el buffer tuvo huecos
+    consola: [],
+    red: Core.crearEstadoRed(),
+    refs: new Map(), // ref (string) → backendDOMNodeId, de la última read_page
+  }
+}
+
+function enviarComando(tabId, metodo, parametros) {
+  return new Promise((resolve, reject) => {
+    chrome.debugger.sendCommand({ tabId }, metodo, parametros || {}, resultado => {
+      if (chrome.runtime.lastError) {
+        reject(new Error(chrome.runtime.lastError.message))
+      } else {
+        resolve(resultado)
+      }
+    })
+  })
+}
+
+function adjuntarDebugger(tabId) {
+  return new Promise((resolve, reject) => {
+    chrome.debugger.attach({ tabId }, CDP_VERSION, () => {
+      if (chrome.runtime.lastError) {
+        reject(new Error(chrome.runtime.lastError.message))
+      } else {
+        resolve()
+      }
+    })
+  })
+}
+
+function soltarDebugger(tabId) {
+  return new Promise(resolve => {
+    chrome.debugger.detach({ tabId }, () => {
+      // Ignorar lastError: puede no estar adjunto.
+      void chrome.runtime.lastError
+      resolve()
+    })
+  })
+}
+
+/**
+ * Garantiza una sesión CDP viva sobre la pestaña (attach perezoso + reattach
+ * transparente). Devuelve la sesión.
+ */
+async function asegurarSesion(tabId) {
+  let sesion = sesionesCdp.get(tabId)
+  if (sesion && sesion.adjunta) {
+    return sesion
+  }
+  if (!sesion) {
+    sesion = crearSesion(tabId)
+    sesionesCdp.set(tabId, sesion)
+  }
+  try {
+    await adjuntarDebugger(tabId)
+  } catch (e) {
+    const msg = String(e && e.message ? e.message : e)
+    if (/already attached/i.test(msg)) {
+      // El service worker se reinició dejando el debugger adjunto sin estado:
+      // soltar y volver a adjuntar para reinstrumentar limpio.
+      await soltarDebugger(tabId)
+      await adjuntarDebugger(tabId)
+    } else {
+      throw new Error(
+        `No se pudo instrumentar la pestaña ${tabId}: ${msg}. ` +
+          'Las páginas del navegador (chrome://…) y la Web Store no se pueden depurar.',
+      )
+    }
+  }
+  sesion.adjunta = true
+  if (sesion.adjuntadaDesdeMs === 0) {
+    sesion.adjuntadaDesdeMs = Date.now()
+  }
+  // Instrumentación: los buffers de consola/red graban desde este momento.
+  await enviarComando(tabId, 'Runtime.enable')
+  await enviarComando(tabId, 'Log.enable')
+  await enviarComando(tabId, 'Network.enable')
+  await enviarComando(tabId, 'Page.enable')
+  await enviarComando(tabId, 'DOM.enable')
+  await enviarComando(tabId, 'Accessibility.enable').catch(() => {})
+  // Que el agente DOM conozca el documento (necesario para backendNodeIds).
+  await enviarComando(tabId, 'DOM.getDocument', { depth: 0 }).catch(() => {})
+  return sesion
+}
+
+chrome.debugger.onEvent.addListener((origen, metodo, parametros) => {
+  const sesion = origen && typeof origen.tabId === 'number' ? sesionesCdp.get(origen.tabId) : null
+  if (!sesion) return
+  const params = parametros || {}
+  // Kuti fase 1: navegaciones del frame principal → paso `navegar`. CDP
+  // complementa al content script, que muere al cambiar de página y no puede
+  // reportar la navegación por sí mismo.
+  if (metodo === 'Page.frameNavigated') {
+    const frame = params.frame
+    const grab = globalThis.__kuti
+    if (
+      frame &&
+      !frame.parentId &&
+      grab &&
+      grab.grabando &&
+      origen.tabId === grab.tabGrabada &&
+      typeof globalThis.kutiEmitirNavegacion === 'function'
+    ) {
+      const url = frame.url || ''
+      if (grab.capturas) {
+        capturarBase64(sesion).then(
+          b64 => globalThis.kutiEmitirNavegacion(origen.tabId, url, b64),
+          () => globalThis.kutiEmitirNavegacion(origen.tabId, url),
+        )
+      } else {
+        globalThis.kutiEmitirNavegacion(origen.tabId, url)
+      }
+    }
+    return
+  }
+  if (
+    metodo === 'Runtime.consoleAPICalled' ||
+    metodo === 'Runtime.exceptionThrown' ||
+    metodo === 'Log.entryAdded'
+  ) {
+    const entrada = Core.formatearEventoConsola(metodo, params)
+    if (entrada) Core.pushCircular(sesion.consola, entrada, MAX_ENTRADAS_CONSOLA)
+    return
+  }
+  if (metodo.startsWith('Network.')) {
+    Core.plegarEventoRed(sesion.red, metodo, params, MAX_ENTRADAS_RED)
+  }
+})
+
+chrome.debugger.onDetach.addListener(origen => {
+  const sesion = origen && typeof origen.tabId === 'number' ? sesionesCdp.get(origen.tabId) : null
+  if (!sesion) return
+  // Chrome soltó el debugger (usuario pulsó «Cancelar», DevTools, etc.):
+  // marcamos el corte; el próximo tool re-adjunta y lo cuenta honesto.
+  sesion.adjunta = false
+  sesion.cortes += 1
+})
+
+chrome.tabs.onRemoved.addListener(tabId => {
+  sesionesCdp.delete(tabId)
+})
+
+function notaBuffer(sesion) {
+  let nota = `Buffer grabando desde las ${Core.horaLocal(sesion.adjuntadaDesdeMs)} (la pestaña no estaba instrumentada antes).`
+  if (sesion.cortes > 0) {
+    nota += ` Ojo: la instrumentación se cortó ${sesion.cortes} ${sesion.cortes === 1 ? 'vez' : 'veces'}; hay huecos.`
+  }
+  return nota
+}
+
+// ---------------------------------------------------------------------------
+// computer
+// ---------------------------------------------------------------------------
+
+async function resolverPunto(sesion, args) {
+  if (Array.isArray(args.coordinate) && args.coordinate.length === 2) {
+    return { x: Number(args.coordinate[0]), y: Number(args.coordinate[1]) }
+  }
+  if (typeof args.ref === 'string') {
+    return centroDeRef(sesion, args.ref)
+  }
+  throw new Error('Indica coordinate [x, y] o un ref de read_page.')
+}
+
+async function centroDeRef(sesion, ref) {
+  const backendNodeId = sesion.refs.get(ref)
+  if (!backendNodeId) {
+    throw new Error(
+      `Ref desconocido: ${ref}. Llama a read_page para obtener refs vigentes (se invalidan al navegar).`,
+    )
+  }
+  await enviarComando(sesion.tabId, 'DOM.scrollIntoViewIfNeeded', { backendNodeId })
+  const { quads } = await enviarComando(sesion.tabId, 'DOM.getContentQuads', {
+    backendNodeId,
+  })
+  if (!quads || quads.length === 0) {
+    throw new Error(`El elemento ${ref} no tiene geometría visible (¿oculto?).`)
+  }
+  const q = quads[0] // [x1,y1, x2,y2, x3,y3, x4,y4]
+  return {
+    x: (q[0] + q[2] + q[4] + q[6]) / 4,
+    y: (q[1] + q[3] + q[5] + q[7]) / 4,
+  }
+}
+
+function eventoRaton(tabId, tipo, x, y, boton, clicks) {
+  return enviarComando(tabId, 'Input.dispatchMouseEvent', {
+    type: tipo,
+    x,
+    y,
+    button: boton,
+    clickCount: clicks || 0,
+  })
+}
+
+async function clic(sesion, args, boton, dobles) {
+  const { x, y } = await resolverPunto(sesion, args)
+  await eventoRaton(sesion.tabId, 'mouseMoved', x, y, 'none', 0)
+  await eventoRaton(sesion.tabId, 'mousePressed', x, y, boton, 1)
+  await eventoRaton(sesion.tabId, 'mouseReleased', x, y, boton, 1)
+  if (dobles) {
+    await eventoRaton(sesion.tabId, 'mousePressed', x, y, boton, 2)
+    await eventoRaton(sesion.tabId, 'mouseReleased', x, y, boton, 2)
+  }
+  return { x, y }
+}
+
+async function centroViewport(tabId) {
+  const metricas = await enviarComando(tabId, 'Page.getLayoutMetrics')
+  const vv = metricas.cssVisualViewport || metricas.visualViewport || {}
+  return {
+    x: (vv.clientWidth || 800) / 2,
+    y: (vv.clientHeight || 600) / 2,
+  }
+}
+
+async function capturarPantalla(sesion) {
+  const res = await enviarComando(sesion.tabId, 'Page.captureScreenshot', {
+    format: 'jpeg',
+    quality: 80,
+  })
+  let base64 = res.data
+  // Recompresión/escala si la captura amenaza el límite del canal o es
+  // más ancha que MAX_ANCHO_CAPTURA px.
+  try {
+    base64 = await recomprimirCaptura(base64)
+  } catch (_e) {
+    // Si la recompresión falla y aun así cabe en el canal, se envía tal cual.
+    if (base64.length > MAX_CAPTURA_BASE64) {
+      throw new Error(
+        'La captura excede el límite del canal y no se pudo recomprimir.',
+      )
+    }
+  }
+  return {
+    content: [{ type: 'image', data: base64, mimeType: 'image/jpeg' }],
+  }
+}
+
+// Kuti: base64 JPEG (recomprimido/escalado) de la pestaña, para la captura
+// por paso opcional del grabador. Devuelve solo la cadena base64.
+async function capturarBase64(sesion) {
+  const res = await enviarComando(sesion.tabId, 'Page.captureScreenshot', {
+    format: 'jpeg',
+    quality: 60,
+  })
+  let base64 = res.data
+  try {
+    base64 = await recomprimirCaptura(base64)
+  } catch (_e) {
+    // Si no se pudo recomprimir se devuelve tal cual (el llamador acota tamaño).
+  }
+  return base64
+}
+
+async function recomprimirCaptura(base64) {
+  const respuesta = await fetch(`data:image/jpeg;base64,${base64}`)
+  const blob = await respuesta.blob()
+  const bitmap = await createImageBitmap(blob)
+  const plan = Core.planRecompresionCaptura(base64.length, bitmap.width, {
+    maxAncho: MAX_ANCHO_CAPTURA,
+    maxBase64: MAX_CAPTURA_BASE64,
+  })
+  if (!plan.reprocesar) {
+    bitmap.close()
+    return base64
+  }
+  const ancho = Math.max(1, Math.round(bitmap.width * plan.escala))
+  const alto = Math.max(1, Math.round(bitmap.height * plan.escala))
+  const lienzo = new OffscreenCanvas(ancho, alto)
+  const ctx = lienzo.getContext('2d')
+  ctx.drawImage(bitmap, 0, 0, ancho, alto)
+  bitmap.close()
+  const salida = await lienzo.convertToBlob({
+    type: 'image/jpeg',
+    quality: plan.calidad,
+  })
+  const bytes = new Uint8Array(await salida.arrayBuffer())
+  let binario = ''
+  const TROZO = 0x8000
+  for (let i = 0; i < bytes.length; i += TROZO) {
+    binario += String.fromCharCode.apply(null, bytes.subarray(i, i + TROZO))
+  }
+  return btoa(binario)
+}
+
+async function accionComputer(args) {
+  const tabId = requireTabId(args)
+  const accion = args.action
+  if (typeof accion !== 'string') {
+    throw new Error('Falta el parámetro action.')
+  }
+  const sesion = await asegurarSesion(tabId)
+
+  switch (accion) {
+    case 'screenshot':
+      return capturarPantalla(sesion)
+
+    case 'left_click': {
+      const p = await clic(sesion, args, 'left', false)
+      return textResult(`Clic izquierdo en (${Math.round(p.x)}, ${Math.round(p.y)}).`)
+    }
+    case 'right_click': {
+      const p = await clic(sesion, args, 'right', false)
+      return textResult(`Clic derecho en (${Math.round(p.x)}, ${Math.round(p.y)}).`)
+    }
+    case 'middle_click': {
+      const p = await clic(sesion, args, 'middle', false)
+      return textResult(`Clic central en (${Math.round(p.x)}, ${Math.round(p.y)}).`)
+    }
+    case 'double_click': {
+      const p = await clic(sesion, args, 'left', true)
+      return textResult(`Doble clic en (${Math.round(p.x)}, ${Math.round(p.y)}).`)
+    }
+
+    case 'left_click_drag': {
+      if (!Array.isArray(args.coordinate) || args.coordinate.length !== 2) {
+        throw new Error('left_click_drag exige coordinate [x, y] como destino.')
+      }
+      let inicio
+      if (Array.isArray(args.start_coordinate) && args.start_coordinate.length === 2) {
+        inicio = {
+          x: Number(args.start_coordinate[0]),
+          y: Number(args.start_coordinate[1]),
+        }
+      } else if (typeof args.ref === 'string') {
+        inicio = await centroDeRef(sesion, args.ref)
+      } else {
+        throw new Error(
+          'left_click_drag exige el origen: start_coordinate [x, y] o un ref.',
+        )
+      }
+      const fin = { x: Number(args.coordinate[0]), y: Number(args.coordinate[1]) }
+      await eventoRaton(tabId, 'mouseMoved', inicio.x, inicio.y, 'none', 0)
+      await eventoRaton(tabId, 'mousePressed', inicio.x, inicio.y, 'left', 1)
+      const PASOS = 8
+      for (let i = 1; i <= PASOS; i++) {
+        const x = inicio.x + ((fin.x - inicio.x) * i) / PASOS
+        const y = inicio.y + ((fin.y - inicio.y) * i) / PASOS
+        await eventoRaton(tabId, 'mouseMoved', x, y, 'left', 0)
+      }
+      await eventoRaton(tabId, 'mouseReleased', fin.x, fin.y, 'left', 1)
+      return textResult(
+        `Arrastre de (${Math.round(inicio.x)}, ${Math.round(inicio.y)}) a (${Math.round(fin.x)}, ${Math.round(fin.y)}).`,
+      )
+    }
+
+    case 'type': {
+      if (typeof args.text !== 'string' || args.text.length === 0) {
+        throw new Error('type exige el parámetro text.')
+      }
+      await enviarComando(tabId, 'Input.insertText', { text: args.text })
+      return textResult(
+        `Texto tecleado (${args.text.length} caracteres) en el elemento con foco.`,
+      )
+    }
+
+    case 'key': {
+      if (typeof args.text !== 'string' || args.text.length === 0) {
+        throw new Error('key exige el parámetro text (p. ej. "ctrl+a" o "Enter").')
+      }
+      const def = Core.parsearCombinacionTeclas(args.text)
+      if (!def) {
+        throw new Error(`Combinación de teclas no reconocida: «${args.text}».`)
+      }
+      const comun = {
+        modifiers: def.modifiers,
+        key: def.key,
+        code: def.code,
+        windowsVirtualKeyCode: def.keyCode,
+        nativeVirtualKeyCode: def.keyCode,
+      }
+      await enviarComando(tabId, 'Input.dispatchKeyEvent', {
+        type: def.text ? 'keyDown' : 'rawKeyDown',
+        ...comun,
+        ...(def.text ? { text: def.text } : {}),
+      })
+      await enviarComando(tabId, 'Input.dispatchKeyEvent', {
+        type: 'keyUp',
+        ...comun,
+      })
+      return textResult(`Pulsado: ${args.text}.`)
+    }
+
+    case 'scroll': {
+      const direccion = args.scroll_direction
+      if (!['up', 'down', 'left', 'right'].includes(direccion)) {
+        throw new Error('scroll exige scroll_direction: up, down, left o right.')
+      }
+      const punto =
+        Array.isArray(args.coordinate) && args.coordinate.length === 2
+          ? { x: Number(args.coordinate[0]), y: Number(args.coordinate[1]) }
+          : typeof args.ref === 'string'
+            ? await centroDeRef(sesion, args.ref)
+            : await centroViewport(tabId)
+      const PASO = 600
+      const deltaX = direccion === 'left' ? -PASO : direccion === 'right' ? PASO : 0
+      const deltaY = direccion === 'up' ? -PASO : direccion === 'down' ? PASO : 0
+      await enviarComando(tabId, 'Input.dispatchMouseEvent', {
+        type: 'mouseWheel',
+        x: punto.x,
+        y: punto.y,
+        deltaX,
+        deltaY,
+      })
+      return textResult(`Scroll ${direccion} (${PASO}px).`)
+    }
+
+    case 'wait': {
+      const segundos = Math.min(
+        Math.max(typeof args.duration === 'number' ? args.duration : 1, 0),
+        MAX_ESPERA_S,
+      )
+      await new Promise(resolve => setTimeout(resolve, segundos * 1000))
+      return textResult(`Esperados ${segundos} s.`)
+    }
+
+    default:
+      throw new Error(`Acción de computer no soportada: ${accion}.`)
+  }
+}
+
+// ---------------------------------------------------------------------------
+// read_page
+// ---------------------------------------------------------------------------
+
+async function leerPagina(args) {
+  const tabId = requireTabId(args)
+  const sesion = await asegurarSesion(tabId)
+  const { nodes } = await enviarComando(tabId, 'Accessibility.getFullAXTree')
+  const resumen = Core.resumirArbolAX(nodes, args.filter, MAX_ELEMENTOS_PAGINA)
+
+  // Refs nuevos: los anteriores dejan de valer (lectura nueva = mapa nuevo).
+  sesion.refs = new Map()
+  const filas = []
+  for (const el of resumen.elementos) {
+    sesion.refs.set(el.ref, el.backendDOMNodeId)
+    const fila = { ref: el.ref, rol: el.rol, nombre: el.nombre }
+    if (el.valor) fila.valor = el.valor
+    filas.push(fila)
+  }
+
+  // Bounds (px CSS del viewport) para los primeros MAX_ELEMENTOS_CON_BOUNDS.
+  for (let i = 0; i < filas.length && i < MAX_ELEMENTOS_CON_BOUNDS; i++) {
+    try {
+      const { quads } = await enviarComando(tabId, 'DOM.getContentQuads', {
+        backendNodeId: resumen.elementos[i].backendDOMNodeId,
+      })
+      if (quads && quads.length > 0) {
+        const q = quads[0]
+        const xs = [q[0], q[2], q[4], q[6]]
+        const ys = [q[1], q[3], q[5], q[7]]
+        const x = Math.min(...xs)
+        const y = Math.min(...ys)
+        filas[i].bounds = [
+          Math.round(x),
+          Math.round(y),
+          Math.round(Math.max(...xs) - x),
+          Math.round(Math.max(...ys) - y),
+        ]
+      }
+    } catch (_e) {
+      // Sin geometría (oculto/desprendido): la fila va sin bounds.
+    }
+  }
+
+  const cabecera = [
+    `Elementos: ${filas.length}` +
+      (resumen.truncado
+        ? ` (truncado: había ${resumen.totalCandidatos} candidatos; usa filter o find para acotar)`
+        : ''),
+    'Los refs sirven para computer (clic por ref) y form_input; se invalidan al navegar o al volver a llamar a read_page.',
+  ].join('\n')
+  return textResult(
+    truncate(`${cabecera}\n${JSON.stringify(filas, null, 1)}`, MAX_TEXT_CHARS),
+  )
+}
+
+// ---------------------------------------------------------------------------
+// form_input
+// ---------------------------------------------------------------------------
+
+async function fijarCampo(args) {
+  const tabId = requireTabId(args)
+  if (typeof args.ref !== 'string' || args.ref.length === 0) {
+    throw new Error('Falta el parámetro ref (de read_page).')
+  }
+  if (typeof args.value !== 'string') {
+    throw new Error('Falta el parámetro value (string).')
+  }
+  const sesion = await asegurarSesion(tabId)
+  const backendNodeId = sesion.refs.get(args.ref)
+  if (!backendNodeId) {
+    throw new Error(
+      `Ref desconocido: ${args.ref}. Llama a read_page para obtener refs vigentes.`,
+    )
+  }
+  const { object } = await enviarComando(tabId, 'DOM.resolveNode', { backendNodeId })
+  const resultado = await enviarComando(tabId, 'Runtime.callFunctionOn', {
+    objectId: object.objectId,
+    functionDeclaration: `function (valor) {
+      const el = this
+      const tag = (el.tagName || '').toLowerCase()
+      const disparar = () => {
+        el.dispatchEvent(new Event('input', { bubbles: true }))
+        el.dispatchEvent(new Event('change', { bubbles: true }))
+      }
+      if (tag === 'select') {
+        let encontrada = false
+        for (const opt of el.options) {
+          if (opt.value === valor || opt.textContent.trim() === valor.trim()) {
+            el.value = opt.value
+            encontrada = true
+            break
+          }
+        }
+        if (!encontrada) return { ok: false, error: 'Opción no encontrada en el select: ' + valor }
+        disparar()
+        return { ok: true, tipo: 'select', valor: el.value }
+      }
+      if (tag === 'input' && (el.type === 'checkbox' || el.type === 'radio')) {
+        const marcado = valor === 'true' || valor === '1' || valor === 'on'
+        // Setter nativo para que React/Vue vean el cambio.
+        const setter = Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, 'checked').set
+        setter.call(el, marcado)
+        el.dispatchEvent(new Event('click', { bubbles: true }))
+        disparar()
+        return { ok: true, tipo: el.type, valor: String(el.checked) }
+      }
+      if (tag === 'input' || tag === 'textarea') {
+        const proto = tag === 'input' ? HTMLInputElement.prototype : HTMLTextAreaElement.prototype
+        const setter = Object.getOwnPropertyDescriptor(proto, 'value').set
+        el.focus()
+        setter.call(el, valor)
+        disparar()
+        return { ok: true, tipo: tag, valor: el.value }
+      }
+      if (el.isContentEditable) {
+        el.focus()
+        el.textContent = valor
+        disparar()
+        return { ok: true, tipo: 'contenteditable', valor: el.textContent }
+      }
+      return { ok: false, error: 'El elemento no es un campo de formulario (es <' + tag + '>).' }
+    }`,
+    arguments: [{ value: args.value }],
+    returnByValue: true,
+  })
+  const salida = resultado && resultado.result ? resultado.result.value : null
+  if (!salida || !salida.ok) {
+    throw new Error(salida && salida.error ? salida.error : 'No se pudo fijar el valor.')
+  }
+  return textResult(
+    `Campo ${args.ref} (${salida.tipo}) fijado a «${truncate(String(salida.valor), 200)}» con eventos input/change disparados.`,
+  )
+}
+
+// ---------------------------------------------------------------------------
+// resize_window · lectores de consola y red
+// ---------------------------------------------------------------------------
+
+async function redimensionarVentana(args) {
+  const tabId = requireTabId(args)
+  const width = args.width
+  const height = args.height
+  if (typeof width !== 'number' || typeof height !== 'number' || width <= 0 || height <= 0) {
+    throw new Error('resize_window exige width y height positivos (píxeles).')
+  }
+  const pestana = await chrome.tabs.get(tabId)
+  await chrome.windows.update(pestana.windowId, {
+    width: Math.round(width),
+    height: Math.round(height),
+    state: 'normal',
+  })
+  return jsonResult({ tabId, windowId: pestana.windowId, width, height })
+}
+
+async function leerConsola(args) {
+  const tabId = requireTabId(args)
+  const sesion = await asegurarSesion(tabId)
+  const entradas = Core.filtrarEntradas(sesion.consola, {
+    pattern: typeof args.pattern === 'string' ? args.pattern : undefined,
+    limit: typeof args.limit === 'number' ? args.limit : 100,
+    onlyErrors: args.onlyErrors === true,
+    campoTexto: 'texto',
+  })
+  const lineas = entradas.map(e => {
+    const url = e.url ? ` (${e.url})` : ''
+    return `[${Core.horaLocal(e.ts)}] [${e.nivel}] ${e.texto}${url}`
+  })
+  const cuerpo =
+    lineas.length > 0 ? lineas.join('\n') : 'Sin mensajes que casen con el filtro.'
+  return textResult(
+    truncate(`${notaBuffer(sesion)}\nMensajes: ${lineas.length}\n${cuerpo}`, MAX_TEXT_CHARS),
+  )
+}
+
+async function leerRed(args) {
+  const tabId = requireTabId(args)
+  const sesion = await asegurarSesion(tabId)
+  const entradas = Core.filtrarEntradas(sesion.red.entradas, {
+    pattern: typeof args.pattern === 'string' ? args.pattern : undefined,
+    limit: typeof args.limit === 'number' ? args.limit : 100,
+    campoTexto: 'url',
+  })
+  const filas = entradas.map(e => ({
+    metodo: e.metodo,
+    url: e.url,
+    estado: e.error ? `ERROR: ${e.error}` : (e.estado ?? 'pendiente'),
+    tipo: e.tipo,
+    ...(e.mime ? { mime: e.mime } : {}),
+    ...(e.tam !== null ? { bytes: e.tam } : {}),
+    ...(e.duracionMs !== null ? { ms: Math.round(e.duracionMs) } : {}),
+  }))
+  return textResult(
+    truncate(
+      `${notaBuffer(sesion)}\nPeticiones: ${filas.length}\n${JSON.stringify(filas, null, 1)}`,
+      MAX_TEXT_CHARS,
+    ),
+  )
+}
+
+// Handlers de fase 2 que background.js fusiona en TOOL_HANDLERS.
+// requireTabId, textResult, jsonResult, truncate y MAX_TEXT_CHARS los define
+// background.js — importScripts comparte el ámbito global del service worker.
+const CDP_TOOL_HANDLERS = {
+  computer: accionComputer,
+  read_page: leerPagina,
+  form_input: fijarCampo,
+  resize_window: redimensionarVentana,
+  read_console_messages: leerConsola,
+  read_network_requests: leerRed,
+}