webscope-mcp 0.2.0__py3-none-any.whl

webscope_adaptadores/__init__.py

@@ -0,0 +1 @@
+"""Scripts incluidos con Webscope; un manifiesto los nombra con `{adaptadores}/<script>.py` en `cmd`."""

webscope_adaptadores/costo_sesion.py

@@ -0,0 +1,187 @@
+#!/usr/bin/env python3
+"""Costo de una sesión de Claude Code: llamadas por herramienta, contexto releído, salidas grandes, repeticiones y si convenía delegar.
+
+Uso: python3 -I costo_sesion.py [<sesión.jsonl>] [--desde HH:MM] [--raiz <carpeta del proyecto>]
+Sin archivo toma la sesión más reciente del proyecto (`~/.claude/projects/<raíz con / y espacios como ->`).
+El contexto releído de una llamada es entrada + caché creado + caché leído del mensaje que la pidió: es lo que se
+paga en cada vuelta. Un subagente arranca con ~30 k de contexto; con eso se estima cuánto costaría delegar.
+"""
+import json
+import re
+import sys
+from collections import Counter, defaultdict
+from pathlib import Path
+
+ARRANQUE_SUBAGENTE = 30_000
+# USD por millón de tokens (entrada, salida, caché leído), lista de oct 2026; escribir en caché: 1,25× (5 min) o 2× (1 h)
+PRECIOS = {
+    "claude-fable-5-1": (10, 50, 0.25),
+    "claude-opus-5-5": (4, 20, 0.20),
+    "claude-sonnet-5-5": (2, 10, 0.10),
+    # shortcut: precio de haiku para prompts de hasta 100 k; por encima cobra 0,50/2,50/0,05, separar si un subagente haiku pasa de 100 k
+    "claude-haiku-5-5": (0.10, 0.50, 0.01),
+}
+
+
+def sesion(argv):
+    """Ruta del .jsonl pedido o el más reciente del proyecto."""
+    archivo = next((a for a in argv if a.endswith(".jsonl")), None)
+    if archivo:
+        return Path(archivo)
+    raiz = argv[argv.index("--raiz") + 1] if "--raiz" in argv else str(Path.cwd())
+    carpeta = Path.home() / ".claude/projects" / re.sub(r"[^A-Za-z0-9]", "-", raiz)
+    sesiones = list(carpeta.glob("*.jsonl"))
+    if not sesiones:
+        sys.exit(f"sin sesiones de Claude Code para {raiz} (se buscan en {carpeta}); usa --raiz <carpeta del proyecto>")
+    return max(sesiones, key=lambda f: f.stat().st_mtime)
+
+
+def subagentes(archivo):
+    """Transcripts de los subagentes de la sesión (`<sesión>/subagents/agent-*.jsonl`)."""
+    return sorted((archivo.parent / archivo.stem / "subagents").glob("agent-*.jsonl"))
+
+
+def analizar(lineas, desde=None, lateral=False):
+    """Devuelve llamadas [(herramienta, contexto, entrada, tamaño de salida)] y el contexto total releído; lateral lee un subagente."""
+    nombres, llamadas, vistos, total = {}, {}, set(), 0
+    for linea in lineas:
+        d = json.loads(linea)
+        if (d.get("isSidechain") and not lateral) or (desde and d.get("timestamp", "")[11:16] < desde):
+            continue
+        m = d.get("message") or {}
+        if d.get("type") == "assistant":
+            u = m.get("usage") or {}
+            ctx = u.get("input_tokens", 0) + u.get("cache_creation_input_tokens", 0) + u.get("cache_read_input_tokens", 0)
+            if m.get("id") not in vistos:
+                vistos.add(m.get("id"))
+                total += ctx
+            for c in m.get("content", []):
+                if c.get("type") == "tool_use":
+                    nombres[c["id"]] = c["name"]
+                    llamadas[c["id"]] = [c["name"], ctx, json.dumps(c.get("input"), sort_keys=True, ensure_ascii=False), 0]
+        elif d.get("type") == "user" and isinstance(m.get("content"), list):
+            for c in m["content"]:
+                if c.get("type") == "tool_result" and c.get("tool_use_id") in llamadas:
+                    llamadas[c["tool_use_id"]][3] = len(json.dumps(c.get("content"), ensure_ascii=False))
+    return list(llamadas.values()), total
+
+
+def tipos(lineas, lateral=False):
+    """Tokens por modelo {modelo: [entrada, escrito 5 min, escrito 1 h, leído, salida]}; el escrito sin desglose cuenta como 5 min.
+
+    Un mensaje ocupa varias líneas; cuenta el uso de la última, que trae la salida completa.
+    """
+    por, ultimo = defaultdict(lambda: [0, 0, 0, 0, 0]), {}
+    for linea in lineas:
+        d = json.loads(linea)
+        m = d.get("message") or {}
+        if d.get("type") == "assistant" and not (d.get("isSidechain") and not lateral):
+            ultimo[m.get("id")] = m
+    for m in ultimo.values():
+        u, t = m.get("usage") or {}, por[m.get("model", "?")]
+        hora = (u.get("cache_creation") or {}).get("ephemeral_1h_input_tokens", 0)
+        t[0] += u.get("input_tokens", 0)
+        t[1] += u.get("cache_creation_input_tokens", 0) - hora
+        t[2] += hora
+        t[3] += u.get("cache_read_input_tokens", 0)
+        t[4] += u.get("output_tokens", 0)
+    return por
+
+
+def advisor(lineas):
+    """Llamadas al advisor de la sesión: [llamadas, entrada, salida, modelos], de las iteraciones `advisor_message` del uso."""
+    t, vistos = [0, 0, 0, set()], set()
+    for linea in lineas:
+        d = json.loads(linea)
+        m = d.get("message") or {}
+        if d.get("type") != "assistant" or m.get("id") in vistos:
+            continue
+        vistos.add(m.get("id"))
+        for it in (m.get("usage") or {}).get("iterations") or []:
+            if it.get("type") == "advisor_message":
+                t[0] += 1
+                t[1] += it.get("input_tokens", 0) + it.get("cache_creation_input_tokens", 0) + it.get("cache_read_input_tokens", 0)
+                t[2] += it.get("output_tokens", 0)
+                t[3].add(it.get("model", "?"))
+    return t
+
+
+def peso(t):
+    """Tokens de entrada equivalentes según la tarifa: escrito ×1,25 (5 min) o ×2 (1 h), leído ×0,1, salida ×5."""
+    return int(t[0] + t[1] * 1.25 + t[2] * 2 + t[3] * 0.1 + t[4] * 5)
+
+
+def usd(modelo, t):
+    """USD de los tokens t = [entrada, escrito 5 min, escrito 1 h, leído, salida] con PRECIOS; None si el modelo no está."""
+    p = PRECIOS.get(modelo.removesuffix(" (subagente)"))
+    if not p:
+        return None
+    return (t[0] * p[0] + t[1] * p[0] * 1.25 + t[2] * p[0] * 2 + t[3] * p[2] + t[4] * p[1]) / 1_000_000
+
+
+def informe_tipos(por, extra=0.0):
+    """Una línea por modelo con lo escrito, lo leído, el peso y los USD, más el total en USD (con `extra`, el advisor)."""
+    lineas, total = [], extra
+    for m, t in sorted(por.items()):
+        dinero = usd(m, t)
+        total += dinero or 0
+        lineas.append(f"modelo {m}: escrito {(t[1] + t[2]) // 1000} k (1 h: {t[2] // 1000} k), leído {t[3] // 1000} k, "
+                      f"salida {t[4] // 1000} k; peso {peso(t) // 1000} k de entrada equivalente; "
+                      + (f"{dinero:.2f} USD" if dinero is not None else "sin precio"))
+    return lineas + [f"total {total:.2f} USD (precios de lista, con el advisor; sin lo que sale «sin precio»)"]
+
+
+def informe(llamadas, total, sub=(0, 0, 0)):
+    """Texto con el resumen por herramienta, las salidas grandes, las repeticiones y los candidatos a subagente.
+
+    sub = (subagentes, llamadas, contexto releído) de los subagentes de la sesión.
+    """
+    por = defaultdict(lambda: [0, 0, 0])
+    for nombre, ctx, _, tam in llamadas:
+        por[nombre][0] += 1
+        por[nombre][1] += ctx
+        por[nombre][2] += tam
+    salida = [f"Costo de la sesión: {len(llamadas)} llamadas, {total // 1000} k tokens de contexto releído en total. "
+              "Sigue: pasar a script lo repetido y delegar lo marcado como subagente."]
+    if sub[0]:
+        salida.append(f"subagentes: {sub[0]}, {sub[1]} llamadas, {sub[2] // 1000} k releídos; "
+                      f"sesión + subagentes: {(total + sub[2]) // 1000} k")
+    for nombre, (n, ctx, tam) in sorted(por.items(), key=lambda x: -x[1][1])[:12]:
+        salida.append(f"herramienta {nombre}: {n} llamadas, {ctx // 1000} k releídos (media {ctx // n // 1000} k), salida {tam // 1000} k caracteres")
+    for nombre, ctx, entrada, tam in sorted(llamadas, key=lambda x: -x[3])[:5]:
+        salida.append(f"salida grande {tam // 1000} k caracteres: {nombre} {entrada[:90]}")
+    for (nombre, entrada), n in Counter((x[0], x[2]) for x in llamadas).most_common(5):
+        if n > 1:
+            salida.append(f"repetida {n} veces: {nombre} {entrada[:90]}")
+    for nombre, (n, ctx, _) in por.items():
+        if nombre in ("Edit", "Write") or n < 10:
+            continue
+        # el subagente arranca en ARRANQUE_SUBAGENTE y suma cada salida (≈4 caracteres por token) y ~500 tokens por vuelta
+        acumulado, estimado = ARRANQUE_SUBAGENTE, 0
+        for x in (x for x in llamadas if x[0] == nombre):
+            estimado += acumulado
+            acumulado += x[3] // 4 + 500
+        if estimado * 2 < ctx:
+            salida.append(f"subagente conviene para {nombre}: {ctx // 1000} k aquí contra ~{estimado // 1000} k en un subagente "
+                          f"({n} llamadas), si vuelve solo la conclusión")
+    return "\n".join(salida)
+
+
+if __name__ == "__main__":
+    argv = sys.argv[1:]
+    desde = argv[argv.index("--desde") + 1] if "--desde" in argv else None
+    archivo = sesion(argv)
+    laterales = [analizar(f.read_text().splitlines(), desde, lateral=True) for f in subagentes(archivo)]
+    sub = (len(laterales), sum(len(l) for l, _ in laterales), sum(t for _, t in laterales))
+    print(informe(*analizar(archivo.read_text().splitlines(), desde), sub))
+    por = tipos(archivo.read_text().splitlines())
+    for f in subagentes(archivo):
+        for m, t in tipos(f.read_text().splitlines(), lateral=True).items():
+            por[f"{m} (subagente)"] = [a + b for a, b in zip(por[f"{m} (subagente)"], t)]
+    a = advisor(archivo.read_text().splitlines())
+    dinero = usd(next(iter(a[3])), [a[1], 0, 0, 0, a[2]]) if len(a[3]) == 1 else None
+    print("\n".join(informe_tipos(por, dinero or 0.0)))
+    if a[0]:
+        print(f"advisor: {a[0]} llamadas, entrada {a[1] // 1000} k (sin caché), salida {a[2] // 1000} k; "
+              f"peso {(a[1] + a[2] * 5) // 1000} k de entrada equivalente; modelo {','.join(sorted(a[3]))}"
+              + (f"; {dinero:.2f} USD" if dinero is not None else "; sin precio"))

webscope_adaptadores/e2e_chrome.py

@@ -0,0 +1,259 @@
+#!/usr/bin/env python3
+"""Script listo para pegar en `javascript_tool` de Claude in Chrome: recorre rutas del frontend en una sola llamada.
+
+Uso: python3 -I e2e_chrome.py <ruta> [<ruta> ...]
+Cada ruta es la del router (`/crm/quotes`); si la app vive bajo un prefijo (`proyecto.prefijo_rutas` del manifiesto, p. ej.
+`/demo`), se acepta con o sin él delante. Las rutas con `:param` se omiten.
+Imprime una línea de instrucciones y el JavaScript; la pestaña debe tener la app abierta y con sesión iniciada.
+`--captura` solo instala el registro de peticiones a /api/ (método, cuerpo y forma de la respuesta, sin claves secretas);
+tras hacer un flujo en la pantalla, `--detalle [desde]` imprime el JavaScript corto que lista lo capturado.
+La primera llamada deja el recorrido instalado en la página como `window.__e2e.run`; `--llamar <ruta> ...` imprime la
+llamada corta que lo reutiliza (si la página se recargó y el recorrido ya no está, la respuesta lo dice).
+`--servir [puerto carpeta]` arranca el receptor local (no termina); `--cargar [puerto]` da la línea que instala captura y
+formularios desde él, y `--guardar <nombre> [puerto]` la que le manda la captura entera para escribirla a archivo.
+`--exportar <captura> <url del módulo> [salida.spec.js]` escribe un test de Playwright que repite sin modelo los pasos que
+`__f` anotó en la captura.
+Al guardar, el receptor deja también los pasos en `.claude/webscope/recorridos/<nombre>.json` (desde la raíz del proyecto);
+`--repetir <nombre>` da la línea que los repite en una sola llamada mientras el front no cambie.
+"""
+import json
+import os
+import re
+import sys
+from pathlib import Path
+from urllib.parse import urlparse
+
+WEB = Path(__file__).resolve().parent / "web"
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+import proyecto  # noqa: E402
+
+
+def validas(rutas):
+    """Rutas del router sin `:param` y sin el prefijo de la app (`proyecto.prefijo_rutas`)."""
+    prefijo = proyecto.config()["prefijo_rutas"].strip("/")
+    return ["/" + (r.strip("/").removeprefix(prefijo + "/") if prefijo else r.strip("/")) for r in rutas if ":" not in r]
+
+
+LINEAS = (
+    "const t=v=>v===null?'null':Array.isArray(v)?'array'+v.length:"
+    "v&&typeof v.n==='number'&&Object.keys(v).every(k=>k==='n'||k==='claves')?'array'+v.n+(v.claves?'{'+v.claves.join(',')+'}':''):"
+    "typeof v==='object'?'obj{'+Object.keys(v).join(',')+'}':typeof v+'('+String(v).slice(0,60)+')';"
+    "window.__e2e.detalle.slice({desde}).map(d=>[d.m,d.s,d.u.replace(/^.*\\/api\\//,''),'q',d.q&&typeof d.q==='object'?Object.entries(d.q).map(([k,v])=>k+':'+t(v)).join(' '):'-',"
+    "'r',d.r&&typeof d.r==='object'?Object.entries(d.r).map(([k,v])=>k+':'+t(v)).join(' '):'-'].concat(d.f?['f',JSON.stringify(d.f)]:[]).join(' ')).join('\\n')"
+)
+
+
+def formulario():
+    """JavaScript que instala `window.__f` (llenar por etiqueta y leer de vuelta, pulsar con foto del formulario)."""
+    js = (WEB / "form.js").read_text()
+    return js[js.index("(() =>"):].strip()
+
+
+def detalle(desde=0):
+    """JavaScript corto que lista los intercambios capturados desde el índice `desde`, una línea cada uno, sin vaciar el registro."""
+    return LINEAS.replace("{desde}", str(int(desde)))
+
+
+def llamar(rutas):
+    """Llamada corta a `window.__e2e.run` con las rutas válidas (sin `:param`); avisa si el recorrido no está instalado."""
+    return f"window.__e2e&&window.__e2e.run?await window.__e2e.run({json.dumps(validas(rutas))}):'sin recorrido instalado: pega el script completo'"
+
+
+def cargar(puerto=5199):
+    """JavaScript corto que carga la captura y `window.__f` desde el receptor local, sin pegar los scripts enteros."""
+    return (f"const carga=s=>new Promise((ok,no)=>{{const e=document.createElement('script');e.src='http://127.0.0.1:{int(puerto)}/'+s+'?'+Date.now();"
+            "e.onload=ok;e.onerror=no;document.head.appendChild(e);});"
+            "await carga('c.js');await new Promise(r=>setTimeout(r,800));await carga('f.js');({captura:!!window.__e2e?.detalle,form:typeof window.__f})")
+
+
+def guardar(nombre, puerto=5199):
+    """JavaScript corto que manda todo lo capturado, más una línea `consola …` por error de consola, al receptor, que lo escribe en `<carpeta>/<nombre>.txt`."""
+    return (f"await (await fetch('http://127.0.0.1:{int(puerto)}/guardar?nombre={nombre}',{{method:'POST',body:(()=>{{{detalle(0).replace(';window', ';return window', 1)}}})()"
+            "+(window.__e2e.consola||[]).map(c=>'\\nconsola '+c).join('')"
+            "+(window.__e2e.pasos||[]).map(p=>'\\npaso '+JSON.stringify(p)).join('')"
+            "+window.__e2e.detalle.filter(d=>d.ms!=null).map(d=>'\\nms '+d.ms+' '+d.m+' '+d.s+' '+d.u.replace(/^.*\\/api\\//,'')).join('')})).text()")
+
+
+RECORRIDOS = Path(".claude/webscope/recorridos")
+
+
+def pasos_de(texto):
+    """Pasos anotados por `__f` (líneas `paso [...]`) de una captura."""
+    return [json.loads(l[5:]) for l in texto.splitlines() if l.startswith("paso ")]
+
+
+def lentas(texto, n=5):
+    """Las `n` llamadas más lentas de una captura (líneas `ms <ms> <método> <estado> <ruta>`), de la más lenta a la menos."""
+    tiempos = [l.split(" ", 4)[1:] for l in texto.splitlines() if re.match(r"ms \d+ ", l)]
+    return [f"{ms} ms {m} {s} {u}" for ms, m, s, u in sorted(tiempos, key=lambda t: -int(t[0]))[:n]]
+
+
+def repetir(nombre):
+    """JavaScript que repite en una llamada los pasos guardados de `nombre`, con sello por corrida en los valores ZZ_E2E…."""
+    if not re.fullmatch(r"[\w.-]+", nombre):
+        raise ValueError("nombre inválido")
+    pasos = json.loads((RECORRIDOS / f"{nombre}.json").read_text())
+    return f"await __f.pasos({json.dumps(pasos, ensure_ascii=False)}, {{ sello: true }})"
+
+
+PRUEBA = """// Test generado por webscope desde {captura}: repite el recorrido sin modelo.
+// Uso: BASE=<url de la app> [STORAGE=<sesión guardada con `npx playwright codegen --save-storage`>] npx playwright test {archivo}
+const {{ test, expect }} = require('@playwright/test');
+const PASOS = {pasos};
+test.use({{ storageState: process.env.STORAGE || undefined }});
+// Sello por corrida en los valores ZZ_E2E…, para no chocar con filas (p. ej. borradas lógicamente) de corridas anteriores.
+const S = Date.now().toString(36).toUpperCase();
+const sellar = (v, fila) => typeof v === 'string' ? (/^ZZ_E2E/.test(v) ? v.replace(/_(?=[A-Z]*\\d)[0-9A-Z]{{8}}$/, '') + (fila ? `.*_${{S}}` : `_${{S}}`) : v)
+  : v && typeof v === 'object' && !Array.isArray(v) ? Object.fromEntries(Object.entries(v).map(([k, x]) => [k, sellar(x)])) : v;
+test('recorrido {nombre}', async ({{ page }}) => {{
+  await page.addInitScript({{ path: require('path').join(__dirname, '{ayudantes}') }});
+  await page.goto((process.env.BASE || '') + {ruta});
+  await page.waitForLoadState('networkidle');
+  expect(new URL(page.url()).pathname, 'la app redirigió: guarda la sesión y pásala en STORAGE').toBe({ruta}.split('?')[0]);
+  for (const [m, ...a] of PASOS) {{
+    const paso = [m, ...a.map((x, i) => sellar(x, m === 'fila' && i === 0))];
+    const r = await page.evaluate(async ([m, ...a]) => {{
+      if (m === 'fila') a[0] = new RegExp(a[0]);
+      if (m === 'elegir') m = 'poner';
+      if (m === 'pulsar') a = a.slice(0, 1);
+      return window.__f[m](...a);
+    }}, paso);
+    const mal = (r && r.error) || (Array.isArray(r) && r.length && r) || (typeof r === 'string' && /^(❌|sin |diálogo)/.test(r) && r);
+    expect(mal, JSON.stringify(paso)).toBeFalsy();
+    if (paso[0] === 'pulsar') for (const e of paso[2]) expect((r.red || []).map((x) => x.replace(/ \\d+ /, ' ').replace(/\\/\\d+(?=\\/|$)/g, '/{{}}')), `${{e}} tras ${{paso[1]}}`).toContain(e);
+  }}
+  const malas = await page.evaluate(() => window.__e2e.detalle.filter((d) => d.s >= 400 || d.s === 'ERR').map((d) => `${{d.m}} ${{d.s}} ${{d.u}}`));
+  expect(malas).toEqual([]);
+  expect(await page.evaluate(() => window.__e2e.consola)).toEqual([]);
+}});
+"""
+
+
+def exportar(captura, url, salida=None):
+    """Escribe un test de Playwright que repite los pasos anotados en la captura, más el JavaScript de captura y `__f` que inyecta.
+
+    Devuelve las rutas escritas. Los clics en iconos sin texto (`mdi-*`) se repiten por selector."""
+    captura = Path(captura)
+    pasos = pasos_de(captura.read_text(errors="ignore"))
+    for p in pasos:
+        if p[0] == "clic" and str(p[1]).startswith("mdi-"):
+            p[1] = "." + p[1]
+    if not pasos:
+        raise ValueError(f"{captura} no tiene líneas `paso`: guárdala con un __f que anote pasos")
+    salida = Path(salida) if salida else captura.with_suffix(".spec.js")
+    nombre = salida.name.removesuffix(".spec.js")
+    ayudantes = salida.with_name(f"{nombre}.ayudantes.js")
+    ayudantes.write_text(construir(["--captura"])[0].removeprefix("await ") + ";\n" + formulario() + "\n")
+    u = urlparse(url)
+    ruta = (u.path or "/") + (f"?{u.query}" if u.query else "") if u.scheme else url
+    salida.write_text(PRUEBA.format(captura=captura.name, archivo=salida.name, pasos=json.dumps(pasos, ensure_ascii=False, indent=1),
+                                    nombre=nombre, ayudantes=ayudantes.name, ruta=json.dumps(ruta)))
+    return salida, ayudantes
+
+
+def servir(puerto, carpeta):
+    """Receptor local: GET /c.js (captura) y /f.js (formularios) generados al vuelo; POST /guardar?nombre= escribe la captura."""
+    import http.server
+    from urllib.parse import parse_qs, urlparse
+
+    carpeta = Path(carpeta).resolve()
+    carpeta.mkdir(parents=True, exist_ok=True)
+
+    class Manejador(http.server.BaseHTTPRequestHandler):
+        """Sirve los ayudantes y guarda capturas; solo escucha en 127.0.0.1."""
+
+        def responder(self, codigo, cuerpo, tipo="text/plain"):
+            self.send_response(codigo)
+            self.send_header("Content-Type", tipo + "; charset=utf-8")
+            self.send_header("Access-Control-Allow-Origin", "*")
+            self.end_headers()
+            self.wfile.write(cuerpo.encode())
+
+        def do_GET(self):
+            ruta = urlparse(self.path).path
+            js = {"/c.js": lambda: construir(["--captura"])[0].removeprefix("await "), "/f.js": formulario}.get(ruta)
+            if ruta == "/":
+                return self.responder(200, "receptor e2e en marcha")
+            self.responder(200, js(), "application/javascript") if js else self.responder(404, "no existe")
+
+        def do_POST(self):
+            nombre = parse_qs(urlparse(self.path).query).get("nombre", [""])[0]
+            if not re.fullmatch(r"[\w.-]+", nombre):
+                return self.responder(400, "nombre inválido")
+            cuerpo = self.rfile.read(int(self.headers.get("Content-Length", 0)))
+            (carpeta / f"{nombre}.txt").write_bytes(cuerpo)
+            consola = cuerpo.count(b"\nconsola ")
+            ruta = os.path.relpath(carpeta / f"{nombre}.txt")
+            texto = cuerpo.decode(errors="ignore")
+            pasos, lento = pasos_de(texto), lentas(texto)
+            if pasos:
+                RECORRIDOS.mkdir(parents=True, exist_ok=True)
+                (RECORRIDOS / f"{nombre}.json").write_text(json.dumps(pasos, ensure_ascii=False, indent=1) + "\n")
+            self.responder(200, f"{len(cuerpo)} bytes; errores de consola: {consola}. Captura: {ruta} "
+                                "(pásala tal cual a --exportar, mapa --cobertura y mapa_back --obligatorios)"
+                                + (f". Recorrido: {RECORRIDOS / nombre}.json, {len(pasos)} pasos (--repetir {nombre})" if pasos else "")
+                                + (f". Más lentas: {'; '.join(lento)}" if lento else ""))
+
+        def log_message(self, *a):
+            pass
+
+    print(f"receptor en http://127.0.0.1:{puerto} -> {carpeta}", flush=True)
+    http.server.ThreadingHTTPServer(("127.0.0.1", int(puerto)), Manejador).serve_forever()
+
+
+def construir(rutas):
+    """JavaScript con RUTAS y el chequeo de UI antepuestos al cuerpo del recorrido, más las rutas omitidas."""
+    if rutas == ["--captura"]:
+        buenas, omitidas = [], []
+    else:
+        buenas, omitidas = validas(rutas), [r for r in rutas if ":" in r]
+    chequeo = (WEB / "chequeo-ui.js").read_text().rstrip().removesuffix("();")
+    chequeo = chequeo[chequeo.index("(() =>"):]
+    cuerpo = (WEB / "e2e-rutas.js").read_text()
+    cuerpo = cuerpo[cuerpo.index("(async"):].strip()
+    return f"await (async()=>{{const RUTAS={json.dumps(buenas)};\nconst chequeo={chequeo};\nreturn await {cuerpo};\n}})()", omitidas
+
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        sys.exit(__doc__)
+    if sys.argv[1] == "--detalle":
+        print("Pega el JavaScript en una llamada a javascript_tool; guarda la salida con Write en un archivo DENTRO del proyecto (p. ej. capturas/<flujo>.txt; correr rechaza rutas fuera de la raíz) y pásalo a payload_check. "
+              "Una línea por petición: método estado ruta q <campo:tipo(valor)> r <campo:tipo(valor)>.\n" + detalle(*sys.argv[2:3] or [0]))
+        sys.exit(0)
+    if sys.argv[1] == "--form":
+        print("Pega en javascript_tool tras --captura. Pantalla sin capturas: `__f.estado()`, `await __f.clic('Texto')`, "
+              "`await __f.ir('/ruta')`, `await __f.pasos([['clic','Nuevo'],['llenar',{...}],['pulsar','Guardar']])`. "
+              "Abre el formulario, `__f.abrir()`, `await __f.llenar({Etiqueta: valor})` "
+              "(devuelve solo lo que no quedó), `await __f.pulsar('Guardar')` (red, aviso y errores). --detalle trae la sección f.\n" + formulario())
+        sys.exit(0)
+    if sys.argv[1] == "--servir":
+        servir(*(sys.argv[2:4] if len(sys.argv) > 3 else [5199, "capturas"]))
+    if sys.argv[1] == "--cargar":
+        print("Pega en javascript_tool con el receptor en marcha (--servir); instala captura y formularios.\n" + cargar(*sys.argv[2:3]))
+        sys.exit(0)
+    if sys.argv[1] == "--guardar":
+        print("Pega en javascript_tool; el receptor escribe la captura completa y responde la ruta. Luego payload_check o vue_ts --cobertura.\n"
+              + guardar(*sys.argv[2:4]))
+        sys.exit(0)
+    if sys.argv[1] == "--llamar":
+        print("Pega esta línea en javascript_tool (sin capturas); lee el mismo JSON que el script completo.\n" + llamar(sys.argv[2:]))
+        sys.exit(0)
+    if sys.argv[1] == "--repetir":
+        try:
+            js = repetir(sys.argv[2])
+        except (OSError, ValueError, IndexError) as e:
+            sys.exit(f"ERR {e}: guarda antes la captura con --guardar <nombre> (el receptor escribe {RECORRIDOS}/<nombre>.json)")
+        print("Pega en javascript_tool tras --cargar, en la pantalla del módulo: repite los pasos en una llamada y para en el "
+              "primero que falla (si falla, el front cambió: sigue a mano desde ahí y vuelve a guardar).\n" + js)
+        sys.exit(0)
+    if sys.argv[1] == "--exportar":
+        try:
+            spec, js = exportar(*sys.argv[2:5])
+        except (OSError, ValueError, TypeError) as e:
+            sys.exit(f"ERR {e}")
+        print(f"Test escrito: {spec} (inyecta {js.name}). Córrelo con BASE=<url de la app> npx playwright test {spec.name}; no gasta modelo.")
+        sys.exit(0)
+    js, omitidas = construir(sys.argv[1:])
+    aviso = f" Omitidas por llevar :param: {', '.join(omitidas)}." if omitidas else ""
+    print(f"Pega el JavaScript en una sola llamada a javascript_tool (sin capturas) y lee el JSON: ruta, ms, filas, malas (red >=400), consola, ui. Si dice «navigated», repite la misma llamada: continúa donde quedó. Para repetir el recorrido sin volver a pegar esto usa `--llamar` (~100 tokens).{aviso}\n{js}")