theus-cli-linux-x64 1.2.1 → 1.3.0

package/vendor/chrome-extension/manifest.json

@@ -0,0 +1,36 @@
+{
+  "manifest_version": 3,
+  "name": "Theus en Chrome",
+  "version": "0.3.0",
+  "description": "Conecta tu navegador con Theus: el CLI ve tus pestañas, lee páginas, hace capturas y ejecuta acciones que tú autorizas.",
+  "key": "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAocpSkZEGHsT5kMKBGvvbJaKq7E+JzkAOdTAmmLyWjpKkzTlu7rkjnwhByTr2wjfToqvH7cfyRYUg98HoxO80Pqck3lWhMhqWro8VfGvIQyxoGJenF9nG4At9HWZIdPlVZp6npgLgUUuGXRpWLbqJvbmfMGjIQTrp9gStkatCFQWzK04PrGadbxHM05K+YNedA7/+4O95bsGccHgo7lCpQ71s47KKYrDC7EKRaAIIvkq34mJiy4T+LxMP4iSLqTHBC+nt0sDvT+UZ39Q51LNAW1VNYqG5/E2NPzzCjnn06Qzsotbo6zu6YW6VQbYQIqgu/OLeV/1aGqhrL0mxdHqLlwIDAQAB",
+  "permissions": [
+    "nativeMessaging",
+    "tabs",
+    "scripting",
+    "activeTab",
+    "debugger"
+  ],
+  "host_permissions": [
+    "<all_urls>"
+  ],
+  "background": {
+    "service_worker": "background.js"
+  },
+  "action": {
+    "default_popup": "popup.html",
+    "default_title": "Theus en Chrome",
+    "default_icon": {
+      "16": "icons/icon16.png",
+      "32": "icons/icon32.png",
+      "48": "icons/icon48.png",
+      "128": "icons/icon128.png"
+    }
+  },
+  "icons": {
+    "16": "icons/icon16.png",
+    "32": "icons/icon32.png",
+    "48": "icons/icon48.png",
+    "128": "icons/icon128.png"
+  }
+}

package/vendor/chrome-extension/popup.html

@@ -0,0 +1,78 @@
+<!doctype html>
+<html lang="es">
+  <head>
+    <meta charset="utf-8" />
+    <title>Theus en Chrome</title>
+    <style>
+      body {
+        font-family: -apple-system, "Segoe UI", Roboto, sans-serif;
+        background: #0d0d10;
+        color: #f2f2f2;
+        margin: 0;
+        min-width: 260px;
+        padding: 16px;
+      }
+      h1 {
+        font-size: 14px;
+        margin: 0 0 12px;
+        letter-spacing: 0.04em;
+      }
+      .fila {
+        display: flex;
+        align-items: center;
+        gap: 8px;
+        margin: 8px 0;
+        font-size: 13px;
+      }
+      .punto {
+        width: 9px;
+        height: 9px;
+        border-radius: 50%;
+        background: #666;
+        flex: none;
+      }
+      .punto.ok { background: #3ecf6a; }
+      .punto.mal { background: #d9534f; }
+      .nota {
+        margin-top: 12px;
+        font-size: 11px;
+        color: #9a9aa2;
+        line-height: 1.5;
+      }
+      #error {
+        margin-top: 8px;
+        font-size: 11px;
+        color: #e0a1a1;
+        word-break: break-word;
+        display: none;
+      }
+    </style>
+  </head>
+  <body>
+    <h1>THEUS EN CHROME</h1>
+    <div class="fila">
+      <span id="punto-host" class="punto"></span>
+      <span id="texto-host">Comprobando host nativo…</span>
+    </div>
+    <div class="fila">
+      <span id="punto-cli" class="punto"></span>
+      <span id="texto-cli">Comprobando CLI…</span>
+    </div>
+    <div id="error"></div>
+    <p class="nota">
+      El host nativo lo sirve el CLI de Theus. Si aparece desconectado,
+      ejecuta <strong>theus --chrome</strong> en tu terminal y reabre este
+      panel. El comando <strong>/chrome</strong> dentro del CLI muestra el
+      estado completo de la integración.
+    </p>
+    <p class="nota">
+      Theus puede controlar tus pestañas: clics, tecleo, capturas de pantalla
+      y lectura de consola y de red. Mientras una pestaña esté bajo control,
+      Chrome muestra la barra «Theus en Chrome ha empezado a depurar este
+      navegador»: es un aviso del propio Chrome, inevitable, y desaparece al
+      terminar. Si pulsas «Cancelar» en esa barra, el control se corta (Theus
+      lo retoma en la siguiente acción).
+    </p>
+    <script src="popup.js"></script>
+  </body>
+</html>

package/vendor/chrome-extension/popup.js

@@ -0,0 +1,47 @@
+// Popup de estado de «Theus en Chrome».
+function pintar(estado) {
+  const puntoHost = document.getElementById('punto-host')
+  const textoHost = document.getElementById('texto-host')
+  const puntoCli = document.getElementById('punto-cli')
+  const textoCli = document.getElementById('texto-cli')
+  const errorEl = document.getElementById('error')
+
+  if (estado && estado.hostConnected) {
+    puntoHost.className = 'punto ok'
+    textoHost.textContent = 'Host nativo: conectado'
+  } else {
+    puntoHost.className = 'punto mal'
+    textoHost.textContent = 'Host nativo: desconectado'
+  }
+
+  if (estado && estado.cliConnected) {
+    puntoCli.className = 'punto ok'
+    textoCli.textContent =
+      estado.cliClients > 1
+        ? `CLI de Theus: conectado (${estado.cliClients} sesiones)`
+        : 'CLI de Theus: conectado'
+  } else {
+    puntoCli.className = 'punto mal'
+    textoCli.textContent = 'CLI de Theus: sin sesión conectada'
+  }
+
+  if (estado && estado.lastError) {
+    errorEl.style.display = 'block'
+    errorEl.textContent = `Último error: ${estado.lastError}`
+  } else {
+    errorEl.style.display = 'none'
+  }
+}
+
+function refrescar() {
+  chrome.runtime.sendMessage({ type: 'get_state' }, estado => {
+    if (chrome.runtime.lastError) {
+      pintar(null)
+      return
+    }
+    pintar(estado)
+  })
+}
+
+refrescar()
+setInterval(refrescar, 2000)

package/vendor/chrome-extension/recorder.js

@@ -0,0 +1,316 @@
+// Theus en Chrome — grabador de Kuti (fase 1), CONTENT SCRIPT.
+//
+// chrome.debugger NO reporta el input del usuario (el dominio Input de CDP es
+// solo INYECCIÓN). Para GRABAR lo que la persona hace de verdad hace falta un
+// content script que escuche los eventos del DOM. Este archivo lo inyecta
+// background.js con chrome.scripting.executeScript cuando arranca /grabar auto,
+// y lo reinyecta tras cada navegación (el content script muere al cambiar de
+// página).
+//
+// Por cada evento calcula un DESCRIPTOR del elemento por INTENCIÓN (rol ARIA,
+// nombre accesible, texto visible, selector css corto, name/id/placeholder/
+// tipo/autocomplete) y lo manda a background.js por chrome.runtime.sendMessage.
+//
+// PRIVACIDAD: nunca se envía el texto tecleado carácter a carácter. El valor
+// final de un campo se toma del evento `change` (o del `focusout`). Los campos
+// sensibles (password, autocomplete cc-*, name/id/placeholder con clave/token/
+// cvv…) se registran SIN su valor: background/CLI los volverán {{secreto}}.
+
+;(function () {
+  // Idempotencia: si ya estamos grabando en este documento, no dupliques
+  // escuchas (una reinyección accidental no debe multiplicar eventos).
+  if (window.__kutiGrabadorActivo) return
+  window.__kutiGrabadorActivo = true
+
+  const RE_NOMBRE_SECRETO =
+    /(contrase|clave|password|passwd|\bpwd\b|secret|token|api[\s_-]?key|\bcvv\b|\bcvc\b|\bcsc\b|\botp\b|\bpin\b|codigo\s*de\s*seguridad|security\s*code)/i
+
+  // Recuerda el último valor enviado por elemento, para no duplicar `escribir`
+  // cuando change y focusout disparan por el mismo cambio.
+  const ultimoEnviado = new WeakMap()
+  // Marca de «sucio»: un input cambió y aún no se ha confirmado con change.
+  const sucios = new WeakSet()
+
+  function enviar(evento) {
+    try {
+      chrome.runtime.sendMessage({ type: 'kuti_recorder_event', evento })
+    } catch (_e) {
+      // El contexto de la extensión puede haberse invalidado (recarga): ignora.
+    }
+  }
+
+  // ---- Descriptor del elemento ------------------------------------------
+
+  function rolImplicito(el) {
+    const tag = el.tagName ? el.tagName.toLowerCase() : ''
+    if (tag === 'a' && el.hasAttribute('href')) return 'link'
+    if (tag === 'button') return 'button'
+    if (tag === 'select') return 'combobox'
+    if (tag === 'textarea') return 'textbox'
+    if (tag === 'summary') return 'button'
+    if (tag === 'input') {
+      const t = (el.getAttribute('type') || 'text').toLowerCase()
+      if (t === 'checkbox') return 'checkbox'
+      if (t === 'radio') return 'radio'
+      if (t === 'button' || t === 'submit' || t === 'reset') return 'button'
+      if (t === 'range') return 'slider'
+      return 'textbox'
+    }
+    return undefined
+  }
+
+  function textoDe(el) {
+    const t = (el.innerText || el.textContent || '').replace(/\s+/g, ' ').trim()
+    return t ? t.slice(0, 200) : ''
+  }
+
+  function nombreAccesible(el) {
+    const aria = el.getAttribute && el.getAttribute('aria-label')
+    if (aria && aria.trim()) return aria.trim()
+    const labelledby = el.getAttribute && el.getAttribute('aria-labelledby')
+    if (labelledby) {
+      const partes = labelledby
+        .split(/\s+/)
+        .map(id => {
+          const ref = document.getElementById(id)
+          return ref ? textoDe(ref) : ''
+        })
+        .filter(Boolean)
+      if (partes.length) return partes.join(' ').slice(0, 200)
+    }
+    // <label for="id"> o <label> envolvente.
+    if (el.id) {
+      const lab = document.querySelector(`label[for="${cssEscape(el.id)}"]`)
+      if (lab) {
+        const t = textoDe(lab)
+        if (t) return t
+      }
+    }
+    if (el.closest) {
+      const lab = el.closest('label')
+      if (lab) {
+        const t = textoDe(lab)
+        if (t) return t
+      }
+    }
+    const tag = el.tagName ? el.tagName.toLowerCase() : ''
+    // Botones/enlaces: su texto ES su nombre.
+    if (tag === 'button' || tag === 'a' || tag === 'summary') {
+      const t = textoDe(el)
+      if (t) return t
+    }
+    if (tag === 'input') {
+      const type = (el.getAttribute('type') || 'text').toLowerCase()
+      if ((type === 'submit' || type === 'button') && el.value) return el.value
+    }
+    const title = el.getAttribute && el.getAttribute('title')
+    if (title && title.trim()) return title.trim()
+    const ph = el.getAttribute && el.getAttribute('placeholder')
+    if (ph && ph.trim()) return ph.trim()
+    const name = el.getAttribute && el.getAttribute('name')
+    if (name && name.trim()) return name.trim()
+    return ''
+  }
+
+  function cssEscape(s) {
+    if (window.CSS && typeof window.CSS.escape === 'function') return CSS.escape(s)
+    return String(s).replace(/["\\#.:>\s]/g, '\\$&')
+  }
+
+  function selectorCorto(el) {
+    if (el.id) return `#${cssEscape(el.id)}`
+    const partes = []
+    let nodo = el
+    while (nodo && nodo.nodeType === 1 && partes.length < 5) {
+      let parte = nodo.tagName.toLowerCase()
+      if (nodo.id) {
+        partes.unshift(`#${cssEscape(nodo.id)}`)
+        break
+      }
+      const padre = nodo.parentElement
+      if (padre) {
+        const hermanos = Array.from(padre.children).filter(
+          c => c.tagName === nodo.tagName,
+        )
+        if (hermanos.length > 1) {
+          parte += `:nth-of-type(${hermanos.indexOf(nodo) + 1})`
+        }
+      }
+      partes.unshift(parte)
+      nodo = nodo.parentElement
+    }
+    return partes.join(' > ')
+  }
+
+  function tipoDe(el) {
+    const tag = el.tagName ? el.tagName.toLowerCase() : ''
+    if (tag === 'input') return (el.getAttribute('type') || 'text').toLowerCase()
+    if (tag === 'select') return 'select'
+    if (tag === 'textarea') return 'textarea'
+    return tag
+  }
+
+  function descriptor(el) {
+    const d = {}
+    const rol = (el.getAttribute && el.getAttribute('role')) || rolImplicito(el)
+    if (rol) d.rol = rol
+    const nombre = nombreAccesible(el)
+    if (nombre) d.nombre = nombre
+    const texto = textoDe(el)
+    if (texto) d.texto = texto
+    const css = selectorCorto(el)
+    if (css) d.css = css
+    const name = el.getAttribute && el.getAttribute('name')
+    if (name) d.name = name
+    if (el.id) d.id = el.id
+    const ph = el.getAttribute && el.getAttribute('placeholder')
+    if (ph) d.placeholder = ph
+    d.tipo = tipoDe(el)
+    const auto = el.getAttribute && el.getAttribute('autocomplete')
+    if (auto) d.autocomplete = auto
+    return d
+  }
+
+  function esSecreto(el, d) {
+    const tipo = (d.tipo || '').toLowerCase()
+    if (tipo === 'password') return true
+    const auto = (d.autocomplete || '').toLowerCase().trim()
+    if (auto.startsWith('cc-') || auto === 'one-time-code') return true
+    const heno = [d.name, d.id, d.placeholder, d.nombre]
+      .filter(Boolean)
+      .join(' ')
+      .normalize('NFD')
+      .replace(/[\u0300-\u036f]/g, '')
+    return RE_NOMBRE_SECRETO.test(heno)
+  }
+
+  function valorDe(el, d) {
+    const tag = el.tagName ? el.tagName.toLowerCase() : ''
+    if (tag === 'select') {
+      const opt = el.options && el.options[el.selectedIndex]
+      return opt ? (opt.textContent || opt.value || '').trim() : el.value || ''
+    }
+    if (tag === 'input') {
+      const t = (d.tipo || 'text')
+      if (t === 'checkbox' || t === 'radio') return el.checked ? 'true' : 'false'
+      return el.value != null ? String(el.value) : ''
+    }
+    if (tag === 'textarea') return el.value != null ? String(el.value) : ''
+    if (el.isContentEditable) return textoDe(el)
+    return ''
+  }
+
+  function esCampo(el) {
+    const tag = el.tagName ? el.tagName.toLowerCase() : ''
+    return (
+      tag === 'input' ||
+      tag === 'select' ||
+      tag === 'textarea' ||
+      (el.isContentEditable === true)
+    )
+  }
+
+  // ---- Envío de un cambio de campo (change/focusout) --------------------
+
+  function emitirCambio(el) {
+    if (!el || !esCampo(el)) return
+    const d = descriptor(el)
+    const secreto = esSecreto(el, d)
+    const valor = secreto ? undefined : valorDe(el, d)
+    // Dedupe: mismo valor ya enviado → no repitas.
+    const firma = secreto ? '\u0000secreto' : String(valor)
+    if (ultimoEnviado.get(el) === firma) return
+    ultimoEnviado.set(el, firma)
+    sucios.delete(el)
+    const evento = { t: 'change', objetivo: d }
+    if (secreto) evento.secreto = true
+    else evento.valor = valor
+    enviar(evento)
+  }
+
+  // ---- Escuchas ---------------------------------------------------------
+
+  function onClick(e) {
+    const el = e.target && e.target.closest ? e.target.closest('*') : e.target
+    if (!el || el.nodeType !== 1) return
+    // Los selects/checks/radios se registran por su change, no por el clic.
+    const tag = el.tagName ? el.tagName.toLowerCase() : ''
+    const tipo = tipoDe(el)
+    if (tag === 'select' || tipo === 'checkbox' || tipo === 'radio') return
+    // Interesan controles y elementos accionables; ignora clics en el vacío.
+    const accionable =
+      el.closest('a, button, [role="button"], [onclick], summary, input, label') ||
+      el
+    enviar({ t: 'click', objetivo: descriptor(accionable) })
+  }
+
+  function onInput(e) {
+    const el = e.target
+    if (el && esCampo(el)) sucios.add(el)
+  }
+
+  function onChange(e) {
+    emitirCambio(e.target)
+  }
+
+  function onFocusOut(e) {
+    // Red de seguridad: si el input cambió pero no disparó change (SPAs), el
+    // valor final igual se captura al perder el foco.
+    const el = e.target
+    if (el && sucios.has(el)) emitirCambio(el)
+  }
+
+  const TECLAS_SUELTAS = new Set(['Enter', 'Tab', 'Escape'])
+
+  function onKeyDown(e) {
+    // Solo teclas «de control» y atajos; NUNCA el texto tecleado.
+    const combo = e.ctrlKey || e.metaKey || e.altKey
+    if (!combo && !TECLAS_SUELTAS.has(e.key)) return
+    // Antes de una tecla de acción, asegura el valor del campo con foco.
+    const activo = document.activeElement
+    if (activo && sucios.has(activo)) emitirCambio(activo)
+    let tecla = ''
+    if (e.ctrlKey) tecla += 'ctrl+'
+    if (e.metaKey) tecla += 'meta+'
+    if (e.altKey) tecla += 'alt+'
+    if (e.shiftKey && (combo || e.key.length > 1)) tecla += 'shift+'
+    tecla += e.key
+    enviar({ t: 'key', tecla })
+  }
+
+  function onSubmit(e) {
+    const el = e.target
+    enviar({ t: 'submit', objetivo: el ? descriptor(el) : undefined })
+  }
+
+  const opciones = { capture: true, passive: true }
+  document.addEventListener('click', onClick, opciones)
+  document.addEventListener('input', onInput, opciones)
+  document.addEventListener('change', onChange, opciones)
+  document.addEventListener('focusout', onFocusOut, opciones)
+  document.addEventListener('keydown', onKeyDown, true)
+  document.addEventListener('submit', onSubmit, opciones)
+
+  function desmontar() {
+    document.removeEventListener('click', onClick, opciones)
+    document.removeEventListener('input', onInput, opciones)
+    document.removeEventListener('change', onChange, opciones)
+    document.removeEventListener('focusout', onFocusOut, opciones)
+    document.removeEventListener('keydown', onKeyDown, true)
+    document.removeEventListener('submit', onSubmit, opciones)
+    window.__kutiGrabadorActivo = false
+  }
+
+  // background.js manda parar cuando el usuario cierra la grabación.
+  chrome.runtime.onMessage.addListener(function alParar(msg) {
+    if (msg && msg.type === 'kuti_recorder_stop') {
+      desmontar()
+      try {
+        chrome.runtime.onMessage.removeListener(alParar)
+      } catch (_e) {
+        // ignore
+      }
+    }
+    return false
+  })
+})()