feat(recon): modo CDP en fingerprint_web_stack para detectar SPAs

Añade fetch_http_fingerprint_cdp_py_browser (domain browser): recoge el HTML
renderizado tras ejecutar JavaScript usando un Chrome remoto via CDP, componiendo
cdp_open_url_and_wait + cdp_eval. Devuelve la misma estructura que el fetch
estático para que detect_web_tech lo consuma sin cambios.

Integra use_cdp en el pipeline fingerprint_web_stack (v1.1.0): combina los headers
reales del fetch estático con el HTML post-JS del CDP. Detecta frameworks de SPA
(React/Vue/Angular/Next) que el fetch estático no ve porque montan el DOM en
runtime. Si no hay Chrome en cdp_port, degrada al fetch estático con un warning
(no rompe). cdp_port=9333 (Chrome aislado) recomendado para terceros, 9222 diario.

Verificado en vivo (Chrome 9333): sobre una SPA cuyo marcador de framework solo
aparece tras ejecutar JS, el estático detecta solo nginx; con use_cdp=True detecta
además Next.js, React y Node.js.

Tests: 48 verdes (error path sin Chrome + happy path mockeado + degradación).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

python/functions/pipelines/fingerprint_web_stack.md

@@ -3,15 +3,16 @@ name: fingerprint_web_stack
 kind: pipeline
 lang: py
 domain: pipelines
-version: "1.0.0"
+version: "1.1.0"
 purity: impure
-signature: "def fingerprint_web_stack(url: str, timeout_s: float = 15.0, verify_tls: bool = True, max_html_bytes: int = 500_000, save: bool = True) -> dict"
-description: "One-shot que detecta la tecnologia web (stack tecnologico estilo Wappalyzer) de una URL: hace el fetch HTTP de las senales (fetch_http_fingerprint) y matchea las firmas (detect_web_tech), devolviendo las tecnologias detectadas — servidor, lenguaje, CMS, framework web, frameworks JS, librerias, analytics, CDN, e-commerce, WAF — con categoria, version y confidence. Reemplaza el patron fetch_http_fingerprint -> detect_web_tech por una sola llamada. El equivalente registry de Wappalyzer / whatweb / un fingerprint de stack de una url. Opcionalmente archiva la evidencia (tabla TECNOLOGIA/CATEGORIA/VERSION/CONFIDENCE) en OSINT. Util para reconocimiento web, auditoria de superficie y averiguar que CMS framework servidor usa un sitio."
-tags: [recon, web-recon, pipelines, cybersecurity, fingerprint, wappalyzer, web-tech, sink]
+signature: "def fingerprint_web_stack(url: str, timeout_s: float = 15.0, verify_tls: bool = True, max_html_bytes: int = 500_000, save: bool = True, use_cdp: bool = False, cdp_port: int = 9222, wait_render_s: float = 2.0) -> dict"
+description: "One-shot que detecta la tecnologia web (stack tecnologico estilo Wappalyzer) de una URL: hace el fetch HTTP de las senales (fetch_http_fingerprint) y matchea las firmas (detect_web_tech), devolviendo las tecnologias detectadas — servidor, lenguaje, CMS, framework web, frameworks JS, librerias, analytics, CDN, e-commerce, WAF — con categoria, version y confidence. Reemplaza el patron fetch_http_fingerprint -> detect_web_tech por una sola llamada. El equivalente registry de Wappalyzer / whatweb / un fingerprint de stack de una url. Con use_cdp=True ademas analiza el HTML RENDERIZADO tras ejecutar JavaScript (fetch_http_fingerprint_cdp via Chrome remoto) para detectar SPAs (React/Vue/Angular/Next) que el fetch estatico no ve; si no hay Chrome degrada a estatico con un warning. Opcionalmente archiva la evidencia (tabla TECNOLOGIA/CATEGORIA/VERSION/CONFIDENCE) en OSINT. Util para reconocimiento web, auditoria de superficie y averiguar que CMS framework servidor usa un sitio, incluidas single-page applications."
+tags: [recon, web-recon, pipelines, cybersecurity, fingerprint, wappalyzer, web-tech, sink, cdp, spa, render]
 uses_functions:
   - fetch_http_fingerprint_py_cybersecurity
   - detect_web_tech_py_cybersecurity
   - save_scan_to_osint_py_cybersecurity
+  - fetch_http_fingerprint_cdp_py_browser
 uses_types: []
 returns: []
 returns_optional: false
@@ -28,9 +29,15 @@ params:
     desc: "Corta el HTML leido a este tamano para no descargar megas. Default 500_000 (500 KB). Se pasa a fetch_http_fingerprint."
   - name: save
     desc: "Si True (default) archiva la evidencia en OSINT via save_scan_to_osint con scan_type='web_tech' (target = host de la URL); si False solo ejecuta el fetch + matching y no toca el vault ni el service osint_db. Politica recon: todo scan se archiva. Si el sink falla, el resultado degrada sin romper (saved.status='error')."
-output: "dict con status ('ok'|'error'), url, final_url (tras redirects), status_code (int), server (cabecera Server o ''), title (titulo de la pagina o ''), technologies (lista de dicts con name, category, version, confidence, evidence — tal cual de detect_web_tech), by_category (dict categoria -> lista de nombres), count (int), saved (dict de save_scan_to_osint con note_path/registered/scan_id, o None si save=False) y raw (tabla legible TECNOLOGIA/CATEGORIA/VERSION/CONFIDENCE con cabecera de url/status/server/title). Si el fetch HTTP falla (host no resuelve, conexion rechazada, timeout) -> {status:error, stage:fetch, url:..., fetch:<dict>}. Nunca lanza."
+  - name: use_cdp
+    desc: "Si True, ademas del fetch estatico hace un fetch via Chrome DevTools Protocol (fetch_http_fingerprint_cdp) para analizar el HTML RENDERIZADO tras ejecutar JavaScript y detectar SPAs (React/Vue/Angular/Next) que el HTML inicial vacio no revela. Requiere un Chrome con remote debugging en cdp_port. Si el CDP no esta disponible, DEGRADA al HTML estatico con un warning (no falla). Default False (comportamiento estatico clasico, sin regresion)."
+  - name: cdp_port
+    desc: "Puerto de remote debugging del Chrome a usar cuando use_cdp=True. Default 9222 (navegador diario, activado global — mezcla tu sesion personal). Para recon de terceros sin contaminar tu sesion, usar 9333 (Chrome aislado del browser_mcp)."
+  - name: wait_render_s
+    desc: "Segundos de espera tras el load event para que la SPA pinte el DOM (solo aplica con use_cdp=True). Default 2.0. Subir (4.0-6.0) para SPAs lentas con mucho data-fetching; un valor corto puede dejar el HTML incompleto."
+output: "dict con status ('ok'|'error'), url, final_url (tras redirects), status_code (int), server (cabecera Server o ''), title (titulo de la pagina o ''), technologies (lista de dicts con name, category, version, confidence, evidence — tal cual de detect_web_tech), by_category (dict categoria -> lista de nombres), count (int), html_source ('static'|'cdp' — fuente del HTML analizado), rendered (bool, True si html_source=='cdp'), warnings (lista de avisos, p.ej. degradacion CDP->estatico; vacia si no hubo), saved (dict de save_scan_to_osint con note_path/registered/scan_id, o None si save=False) y raw (tabla legible TECNOLOGIA/CATEGORIA/VERSION/CONFIDENCE con cabecera de url/status/server/title/html_source). Si el fetch HTTP estatico falla y use_cdp=False (o ambos fallan) -> {status:error, stage:fetch, url:..., fetch:<dict>}. Nunca lanza."
 tested: true
-tests: ["test_golden_fingerprint_servidor_local_wordpress_nginx", "test_save_false_no_archiva_osint", "test_fetch_fallido_propaga_error_sin_red"]
+tests: ["test_golden_fingerprint_servidor_local_wordpress_nginx", "test_save_false_no_archiva_osint", "test_fetch_fallido_propaga_error_sin_red", "test_use_cdp_sin_chrome_degrada_a_estatico"]
 test_file_path: "python/functions/pipelines/fingerprint_web_stack_test.py"
 file_path: "python/functions/pipelines/fingerprint_web_stack.py"
 ---
@@ -56,6 +63,20 @@ print(r["by_category"])  # {"cms": ["WordPress"], "web-server": ["nginx"], ...}
 ```python
 from pipelines.fingerprint_web_stack import fingerprint_web_stack
 
+# Modo CDP: analiza el HTML RENDERIZADO tras el JS (detecta SPAs React/Vue/Angular).
+# Requiere Chrome con remote debugging en cdp_port (9222 diario / 9333 aislado).
+r = fingerprint_web_stack("https://react.dev/", use_cdp=True, cdp_port=9222, save=False)
+print(r["status"])        # "ok"
+print(r["html_source"])   # "cdp" si habia Chrome; "static" (con warning) si no
+print(r["rendered"])      # True si se uso el HTML renderizado
+print(r["warnings"])      # [] si CDP ok; ["cdp no disponible: ...; usando fetch estatico"] si degrado
+for t in r["technologies"]:
+    print(t["name"], t["category"])  # React javascript-framework, etc.
+```
+
+```python
+from pipelines.fingerprint_web_stack import fingerprint_web_stack
+
 # Con archivado en OSINT (default): deja una nota en el vault + POST al osint_db.
 r = fingerprint_web_stack("https://midominio.example")
 print(r["saved"]["note_path"])  # dominios/midominio.example/recon/web_tech-....md
@@ -66,6 +87,8 @@ print(r["saved"]["note_path"])  # dominios/midominio.example/recon/web_tech-....
 ./fn run fingerprint_web_stack https://example.com
 # Flags: --no-save (no archiva OSINT), --no-verify-tls (cert self-signed, inseguro).
 ./fn run fingerprint_web_stack https://example.com --no-save
+# Modo CDP (HTML renderizado tras JS): --cdp [--cdp-port 9333].
+./fn run fingerprint_web_stack https://react.dev/ --cdp --no-save
 ```
 
 ## Cuando usarla
@@ -80,11 +103,26 @@ enriquecer una investigacion OSINT con el stack de un host.
 
 ## Gotchas
 
-- **Fetch estatico: NO ejecuta JavaScript.** Solo ve el HTML inicial que devuelve
-  el servidor. Las SPAs que montan el framework (React/Vue/Angular/Svelte) en
-  runtime suelen servir un HTML casi vacio, asi que esos frameworks pueden NO
-  detectarse. Para sitios JS-pesados, un fingerprint con navegador real (CDP)
-  veria mas; este pipeline es la version sin navegador.
+- **Fetch estatico (use_cdp=False): NO ejecuta JavaScript.** Solo ve el HTML
+  inicial que devuelve el servidor. Las SPAs que montan el framework
+  (React/Vue/Angular/Svelte) en runtime suelen servir un HTML casi vacio, asi que
+  esos frameworks pueden NO detectarse. Para sitios JS-pesados usa `use_cdp=True`
+  (analiza el HTML renderizado tras el JS via Chrome remoto).
+- **`use_cdp=True` requiere Chrome con remote debugging** escuchando en `cdp_port`:
+  9222 (navegador diario, activado global) o 9333 (Chrome aislado del browser_mcp).
+  Si no hay Chrome, el pipeline NO falla: DEGRADA al HTML estatico, marca
+  `html_source="static"` y rellena `warnings` con `"cdp no disponible: ...; usando
+  fetch estatico"`. Comprueba siempre `result["warnings"]` para saber si el CDP se
+  aplico o si caiste al estatico.
+- **Con `cdp_port=9222` se abre un tab en tu navegador PERSONAL** (mezcla cookies e
+  historial de tu sesion diaria). Para fingerprint de TERCEROS sin contaminar ni
+  filtrar tu sesion, usa `cdp_port=9333` (el Chrome aislado del browser_mcp).
+- **`wait_render_s` puede ser corto para SPAs lentas**: el load event NO garantiza
+  el DOM pintado. Si el `html` renderizado sale incompleto (faltan frameworks que
+  deberian aparecer), sube `wait_render_s` a 4.0-6.0.
+- **CDP no expone headers ni status_code**: con `use_cdp=True`, `server`,
+  `status_code` y `headers` siguen viniendo del fetch estatico (que siempre se
+  ejecuta); el CDP solo aporta el `html` renderizado y los nombres de cookie no-httponly.
 - **La tabla de firmas es un subconjunto de Wappalyzer**, no exhaustiva. Un
   tecnologia no listada en `detect_web_tech` no aparecera aunque este presente.
   Para ampliar cobertura, anade entradas a `SIGNATURES` en `detect_web_tech`.
@@ -119,3 +157,7 @@ entero ni valores de cookie (las cookies de `fetch_http_fingerprint` ya son solo
 nombres). El `target` para el archivado OSINT se deriva del host de la URL
 (`urllib.parse.urlparse(...).hostname`). Nunca lanza excepciones: todo fallo se
 refleja en la clave `status` del dict devuelto.
+
+## Capability growth log
+
+- v1.1.0 (2026-06-14) — anade modo use_cdp: usa fetch_http_fingerprint_cdp para analizar el HTML renderizado tras JS y detectar SPAs (React/Vue/Angular) que el fetch estatico no ve; degrada a estatico si no hay Chrome.

python/functions/pipelines/fingerprint_web_stack.py

@@ -4,15 +4,18 @@ One-shot que materializa el flujo "averiguar la tecnologia web (stack) de una
 URL" estilo Wappalyzer: hace el fetch HTTP de las senales (cabeceras, HTML,
 cookies, titulo, servidor) y matchea las firmas para devolver las tecnologias
 detectadas (servidor, lenguaje, CMS, frameworks JS, librerias, analytics, CDN,
-e-commerce, WAF). Opcionalmente archiva la evidencia en OSINT.
+e-commerce, WAF). Con use_cdp=True, ademas analiza el HTML RENDERIZADO tras
+ejecutar JavaScript (via Chrome remoto) para detectar SPAs (React/Vue/Angular)
+que el fetch estatico no ve. Opcionalmente archiva la evidencia en OSINT.
 
 Convierte el patron de 2 llamadas (fetch_http_fingerprint -> detect_web_tech)
 en una sola invocacion. Compone funciones del registry del dominio
-cybersecurity; no reescribe ninguna logica de fetch, matching de firmas ni
-persistencia.
+cybersecurity (y browser para el modo CDP); no reescribe ninguna logica de
+fetch, render, matching de firmas ni persistencia.
 
 Funciones del registry compuestas (importadas, no reimplementadas):
-    fetch_http_fingerprint, detect_web_tech, save_scan_to_osint
+    fetch_http_fingerprint, detect_web_tech, save_scan_to_osint,
+    fetch_http_fingerprint_cdp
 """
 
 from urllib.parse import urlparse
@@ -22,6 +25,7 @@ from cybersecurity import (
     detect_web_tech,
     save_scan_to_osint,
 )
+from browser.fetch_http_fingerprint_cdp import fetch_http_fingerprint_cdp
 
 
 def _build_raw(
@@ -31,6 +35,7 @@ def _build_raw(
     server: str,
     title: str,
     technologies: list[dict],
+    html_source: str = "static",
 ) -> str:
     """Construye una tabla legible TECNOLOGIA/CATEGORIA/VERSION/CONFIDENCE para evidencia.
 
@@ -44,10 +49,13 @@ def _build_raw(
         server: cadena del servidor (cabecera Server), puede ser "".
         title: titulo de la pagina, puede ser "".
         technologies: lista de dicts de tecnologia (ver fingerprint_web_stack).
+        html_source: fuente del HTML analizado ("static" = fetch estatico,
+            "cdp" = HTML renderizado post-JS via Chrome). Default "static".
 
     Returns:
         Bloque de texto multi-linea con cabecera y una fila por tecnologia.
     """
+    html_label = "cdp-rendered (post-JS)" if html_source == "cdp" else "static (sin JS)"
     header_lines = [
         f"# fingerprint_web_stack {url}",
         "",
@@ -56,6 +64,7 @@ def _build_raw(
         f"status_code: {status_code}",
         f"server:      {server or '-'}",
         f"title:       {title or '-'}",
+        f"html_source: {html_label}",
         "",
     ]
     cols = f"{'TECHNOLOGY':<24}{'CATEGORY':<22}{'VERSION':<14}CONFIDENCE"
@@ -96,22 +105,53 @@ def _target_from_url(url: str, final_url: str) -> str:
     return (url or final_url or "unknown").strip()
 
 
+def _union_cookie_names(static_cookies, cdp_cookies) -> list[str]:
+    """Une los nombres de cookie de ambas fuentes (estatico + CDP), deduplicando.
+
+    Preserva el orden: primero los del fetch estatico (incluye httponly que CDP
+    no ve), luego los exclusivos del CDP. Solo nombres, nunca valores.
+
+    Args:
+        static_cookies: lista de nombres de cookie del fetch estatico.
+        cdp_cookies: lista de nombres de cookie del fetch CDP (document.cookie).
+
+    Returns:
+        Lista de nombres unicos en orden estable.
+    """
+    out: list[str] = []
+    seen: set[str] = set()
+    for name in list(static_cookies or []) + list(cdp_cookies or []):
+        if name and name not in seen:
+            seen.add(name)
+            out.append(name)
+    return out
+
+
 def fingerprint_web_stack(
     url: str,
     timeout_s: float = 15.0,
     verify_tls: bool = True,
     max_html_bytes: int = 500_000,
     save: bool = True,
+    use_cdp: bool = False,
+    cdp_port: int = 9222,
+    wait_render_s: float = 2.0,
 ) -> dict:
     """Detecta la tecnologia web (stack) de una URL en un solo paso (estilo Wappalyzer).
 
     Compone, en una sola invocacion:
       1. ``fetch_http_fingerprint(url, ...)`` para recoger las senales crudas de
-         la respuesta (cabeceras, HTML, cookies, titulo, servidor).
-      2. ``detect_web_tech(headers, html, cookies, final_url)`` (PURA) para
-         matchear esas senales contra la tabla de firmas y obtener las
-         tecnologias detectadas.
-      3. Si ``save`` es True, archiva una tabla de evidencia en OSINT via
+         la respuesta (cabeceras, HTML inicial sin JS, cookies, titulo, servidor).
+         Aporta headers/server/status_code reales que CDP no expone.
+      2. Si ``use_cdp`` es True, ``fetch_http_fingerprint_cdp(url, ...)`` para
+         obtener el HTML RENDERIZADO tras ejecutar JavaScript (via Chrome remoto):
+         asi se detectan SPAs (React/Vue/Angular/Next) con HTML inicial vacio que
+         el fetch estatico pierde. Si el CDP falla (sin Chrome, etc.) DEGRADA al
+         HTML estatico sin romper y deja un warning.
+      3. ``detect_web_tech(headers, html, cookies, final_url)`` (PURA) para
+         matchear esas senales contra la tabla de firmas. El HTML analizado es el
+         del CDP cuando esta disponible, si no el del estatico.
+      4. Si ``save`` es True, archiva una tabla de evidencia en OSINT via
          ``save_scan_to_osint`` con ``scan_type="web_tech"`` (target = host de la
          URL).
 
@@ -122,7 +162,7 @@ def fingerprint_web_stack(
         url: URL objetivo. Sin esquema se asume https:// (fallback a http://),
             tal como hace fetch_http_fingerprint.
         timeout_s: timeout de la peticion HTTP en segundos. Default 15.0. Se pasa
-            tal cual a fetch_http_fingerprint.
+            tal cual a fetch_http_fingerprint (y al fetch CDP cuando use_cdp).
         verify_tls: si False, no verifica el certificado TLS (inseguro, solo para
             hosts propios con cert self-signed). Default True. Se pasa a
             fetch_http_fingerprint.
@@ -133,6 +173,17 @@ def fingerprint_web_stack(
             fetch + matching y no toca el vault ni el service osint_db. Politica
             recon: todo scan se archiva. Si el sink falla, el resultado degrada
             sin romper (saved.status="error").
+        use_cdp: si True, ademas del fetch estatico hace un fetch via Chrome
+            DevTools Protocol para analizar el HTML RENDERIZADO tras el JS y
+            detectar SPAs. Requiere un Chrome con remote debugging en cdp_port.
+            Si el CDP no esta disponible, DEGRADA al HTML estatico con un warning
+            (no falla). Default False (comportamiento estatico clasico, intacto).
+        cdp_port: puerto de remote debugging del Chrome a usar cuando use_cdp.
+            Default 9222 (navegador diario, global). Para recon de terceros sin
+            mezclar tu sesion personal, usar 9333 (Chrome aislado del browser_mcp).
+        wait_render_s: segundos de espera tras el load event para que la SPA
+            pinte el DOM (solo aplica con use_cdp). Default 2.0. Subir (4.0-6.0)
+            para SPAs lentas con mucho data-fetching.
 
     Returns:
         dict de estado. Nunca lanza.
@@ -151,23 +202,32 @@ def fingerprint_web_stack(
                 ],
                 "by_category": {<categoria>: [<nombre>, ...], ...},
                 "count": int,
+                "html_source": "static" | "cdp",  # fuente del HTML analizado
+                "rendered": bool,             # True si html_source == "cdp"
+                "warnings": [<str>, ...],     # vacia si no hubo degradacion
                 "saved": <dict de save_scan_to_osint> | None,
                 "raw": "# fingerprint_web_stack ...\nTECHNOLOGY ...",
             }
 
-        error (el fetch HTTP fallo: host no resuelve, conexion rechazada,
-        timeout)::
+        error (el fetch HTTP estatico fallo Y use_cdp es False, o ambos fallaron:
+        host no resuelve, conexion rechazada, timeout)::
 
             {"status": "error", "stage": "fetch", "url": <url>, "fetch": <dict>}
     """
-    # 1. Fetch de senales. Si el fetch falla del todo, propagamos sin continuar.
+    warnings: list[str] = []
+
+    # 1. Fetch estatico SIEMPRE: aporta headers/server/status_code reales (CDP no
+    #    los da). Guardamos el resultado aunque falle: con use_cdp podemos seguir.
     fp = fetch_http_fingerprint(
         url,
         timeout_s=timeout_s,
         verify_tls=verify_tls,
         max_html_bytes=max_html_bytes,
     )
-    if fp.get("status") != "ok":
+    static_ok = fp.get("status") == "ok"
+
+    # Si el estatico falla del todo y NO vamos a intentar CDP, propagamos error.
+    if not static_ok and not use_cdp:
         return {
             "status": "error",
             "stage": "fetch",
@@ -175,25 +235,68 @@ def fingerprint_web_stack(
             "fetch": fp,
         }
 
-    final_url = fp.get("final_url", "") or ""
-    status_code = fp.get("status_code", 0)
-    server = fp.get("server") or ""
-    title = fp.get("title") or ""
+    # Senales de respuesta: del estatico cuando hay (CDP no las expone).
+    headers = fp.get("headers") or {} if static_ok else {}
+    static_cookies = fp.get("cookies") or [] if static_ok else []
+    static_html = fp.get("html") or "" if static_ok else ""
+    final_url = (fp.get("final_url") or "") if static_ok else ""
+    status_code = fp.get("status_code", 0) if static_ok else 0
+    server = (fp.get("server") or "") if static_ok else ""
+    title = (fp.get("title") or "") if static_ok else ""
 
-    # 2. Matching de firmas (puro): no toca red, solo aplica regex deterministas.
+    # 2. Elegir el HTML a analizar y la fuente.
+    html_to_analyze = static_html
+    html_source = "static"
+    cookies = list(static_cookies)
+
+    if use_cdp:
+        cdp = fetch_http_fingerprint_cdp(
+            url,
+            port=cdp_port,
+            wait_render_s=wait_render_s,
+            timeout_s=timeout_s,
+        )
+        if cdp.get("status") == "ok":
+            # HTML renderizado post-JS: la clave para detectar SPAs.
+            html_to_analyze = cdp.get("html") or ""
+            html_source = "cdp"
+            cookies = _union_cookie_names(static_cookies, cdp.get("cookies") or [])
+            # El CDP ve la URL final tras redirects client-side y el titulo
+            # renderizado; preferimos los suyos cuando el estatico no aporta.
+            final_url = final_url or (cdp.get("final_url") or "")
+            if not title:
+                title = cdp.get("title") or ""
+        else:
+            # DEGRADA: sin Chrome (o fallo CDP) seguimos con el HTML estatico.
+            cdp_err = cdp.get("error") or "desconocido"
+            warnings.append(f"cdp no disponible: {cdp_err}; usando fetch estatico")
+            if not static_ok:
+                # Ni estatico ni CDP: ahora si es error (no hay HTML que analizar).
+                return {
+                    "status": "error",
+                    "stage": "fetch",
+                    "url": url,
+                    "fetch": fp,
+                    "cdp": cdp,
+                    "warnings": warnings,
+                }
+
+    # 3. Matching de firmas (puro): no toca red, solo aplica regex deterministas.
     detection = detect_web_tech(
-        fp.get("headers") or {},
-        html=fp.get("html") or "",
-        cookies=fp.get("cookies") or [],
+        headers,
+        html=html_to_analyze,
+        cookies=cookies,
         final_url=final_url,
     )
     technologies = detection.get("technologies", [])
     by_category = detection.get("by_category", {})
     count = detection.get("count", len(technologies))
 
-    raw = _build_raw(url, final_url, status_code, server, title, technologies)
+    raw = _build_raw(
+        url, final_url, status_code, server, title, technologies, html_source
+    )
 
-    # 3. Archiva la evidencia en OSINT si procede (degrada sin romper).
+    # 4. Archiva la evidencia en OSINT si procede (degrada sin romper).
     saved = None
     if save:
         target = _target_from_url(url, final_url)
@@ -202,6 +305,7 @@ def fingerprint_web_stack(
             "by_category": by_category,
             "server": server,
             "status_code": status_code,
+            "html_source": html_source,
         }
         saved = save_scan_to_osint(
             target,
@@ -221,29 +325,52 @@ def fingerprint_web_stack(
         "technologies": technologies,
         "by_category": by_category,
         "count": count,
+        "html_source": html_source,
+        "rendered": html_source == "cdp",
+        "warnings": warnings,
         "saved": saved,
         "raw": raw,
     }
 
 
 def _parse_cli(argv: list[str]) -> dict:
-    """Parsea los args de CLI: <url> [--no-save] [--no-verify-tls].
+    """Parsea los args de CLI: <url> [--no-save] [--no-verify-tls] [--cdp] [--cdp-port N].
 
     Devuelve un dict de kwargs para fingerprint_web_stack.
     """
     positional: list[str] = []
     save = True
     verify_tls = True
+    use_cdp = False
+    cdp_port = 9222
 
-    for arg in argv:
+    i = 0
+    while i < len(argv):
+        arg = argv[i]
         if arg == "--no-save":
             save = False
         elif arg == "--no-verify-tls":
             verify_tls = False
+        elif arg == "--cdp":
+            use_cdp = True
+        elif arg == "--cdp-port":
+            i += 1
+            if i < len(argv):
+                try:
+                    cdp_port = int(argv[i])
+                except ValueError:
+                    pass
         else:
             positional.append(arg)
+        i += 1
 
-    return {"positional": positional, "save": save, "verify_tls": verify_tls}
+    return {
+        "positional": positional,
+        "save": save,
+        "verify_tls": verify_tls,
+        "use_cdp": use_cdp,
+        "cdp_port": cdp_port,
+    }
 
 
 if __name__ == "__main__":
@@ -258,11 +385,16 @@ if __name__ == "__main__":
             target_url,
             verify_tls=parsed["verify_tls"],
             save=parsed["save"],
+            use_cdp=parsed["use_cdp"],
+            cdp_port=parsed["cdp_port"],
         )
         print("status:", result.get("status"))
         if result.get("status") == "ok":
             print(f"url: {result['url']} -> {result['final_url']} ({result['status_code']})")
             print("server:", result["server"] or "-")
+            print("html_source:", result.get("html_source"))
+            for w in result.get("warnings", []):
+                print("warning:", w)
             print("--- technologies ---")
             print(result["raw"])
             saved = result.get("saved") or {}

python/functions/pipelines/fingerprint_web_stack_test.py

@@ -178,3 +178,44 @@ def test_fetch_fallido_propaga_error_sin_red():
     assert result["fetch"]["status"] == "error", result
     # No se intento archivar nada.
     assert save_called["n"] == 0, save_called
+
+
+# --- 4. use_cdp sin Chrome: DEGRADA a estatico con warning (no falla) ---------
+
+def test_use_cdp_sin_chrome_degrada_a_estatico():
+    """use_cdp=True sin Chrome (cdp_port=1) degrada al fetch estatico con warning.
+
+    Levanta el mismo HTTPServer WordPress/nginx/PHP local que el golden y pide
+    use_cdp con cdp_port=1 (donde no hay ningun Chrome escuchando). El fetch CDP
+    falla, el pipeline NO rompe: usa el HTML estatico, marca html_source=static,
+    rellena warnings y sigue detectando WordPress/nginx por el html/headers.
+    """
+    httpd, port, thread = _start_wp_server()
+    try:
+        result = fingerprint_web_stack(
+            f"http://127.0.0.1:{port}/",
+            timeout_s=5.0,
+            save=False,
+            use_cdp=True,
+            cdp_port=1,  # puerto sin Chrome: el fetch CDP falla -> degrada
+            wait_render_s=0.0,
+        )
+    finally:
+        httpd.shutdown()
+        httpd.server_close()
+        thread.join(timeout=2.0)
+
+    # Degrado, no fallo.
+    assert result["status"] == "ok", result
+    # Cayo al HTML estatico (CDP no disponible).
+    assert result["html_source"] == "static", result
+    assert result["rendered"] is False, result
+    # Hubo warning de degradacion.
+    assert result["warnings"], result
+    assert any("cdp no disponible" in w for w in result["warnings"]), result["warnings"]
+    # La deteccion estatica sigue funcionando.
+    names = {t["name"] for t in result["technologies"]}
+    assert "WordPress" in names, names
+    assert "nginx" in names, names
+    # No se archivo (save=False).
+    assert result["saved"] is None, result