@innvisor/conny-ai 9.7.0 → 9.8.0

package/conny_doctor.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import asyncio
 import json
 import os
+import re
 import subprocess
 import sys
 import time
@@ -18,9 +19,11 @@ from conny_runtime_ops import (
     find_pm2_processes,
     health_payload,
     instance_runtime_info,
+    load_env_file,
     port_is_open,
     python_candidates,
     resolve_python,
+    rewrite_tunnel_command_port,
     telegram_webhook_info,
 )
 
@@ -72,7 +75,7 @@ class HealthCheck:
 
 class ConnyDoctor:
     def __init__(self, instance_id: str):
-        self.instance_id = instance_id or "base"
+        self.instance_id = instance_id or "conny"
         self.info = instance_runtime_info(self.instance_id)
         self.checks: List[HealthCheck] = []
         self.health: Dict[str, Any] = {}
@@ -89,6 +92,7 @@ class ConnyDoctor:
         await asyncio.gather(
             self._check_pm2(),
             self._check_api_health(),
+            self._check_whatsapp_bridge(),
             self._check_runtime_python(),
             self._check_runtime_dependencies(),
             self._check_tunnel_alignment(),
@@ -177,6 +181,118 @@ class ConnyDoctor:
         else:
             self.checks.append(HealthCheck("Webhook", "error", "sin webhook registrado", "conny config → Gateway & Webhooks"))
 
+    async def _check_whatsapp_bridge(self) -> None:
+        bridge_name = "whatsapp-bridge"
+        bridge_env_path = Path("/home/ubuntu/whatsapp-bridge/.env")
+        bridge_status_url = "http://localhost:8002/status"
+
+        # 1. PM2 status
+        proc = subprocess.run(
+            ["pm2", "jlist", "--update-env"],
+            capture_output=True, text=True, timeout=10, check=False,
+        )
+        processes = json.loads(proc.stdout or "[]") if proc.returncode == 0 else []
+        bridge_pm2 = next((p for p in processes if p.get("name") == bridge_name), None)
+
+        if not bridge_pm2:
+            self.checks.append(HealthCheck(
+                "WhatsApp Bridge", "error",
+                "no registrado en PM2",
+                "pm2 start /home/ubuntu/whatsapp-bridge/start.sh --name whatsapp-bridge --cwd /home/ubuntu/whatsapp-bridge"
+            ))
+            return
+
+        pm2_status = bridge_pm2.get("pm2_env", {}).get("status", "unknown")
+        if pm2_status != "online":
+            self.checks.append(HealthCheck(
+                "WhatsApp Bridge PM2", "error",
+                f"estado {pm2_status}",
+                "pm2 restart whatsapp-bridge"
+            ))
+        else:
+            self.checks.append(HealthCheck("WhatsApp Bridge PM2", "ok", "online"))
+
+        # 2. HTTP connectivity
+        bridge_ok = False
+        bridge_data = {}
+        try:
+            async with httpx.AsyncClient(timeout=4.0) as client:
+                r = await client.get(bridge_status_url)
+                if r.status_code < 400:
+                    bridge_data = r.json()
+                    bridge_ok = True
+        except Exception:
+            pass
+
+        if not bridge_ok:
+            self.checks.append(HealthCheck(
+                "WhatsApp Bridge HTTP", "error",
+                f"no responde en :8002",
+                "pm2 restart whatsapp-bridge"
+            ))
+            return
+
+        self.checks.append(HealthCheck("WhatsApp Bridge HTTP", "ok", "puerto 8002 responde"))
+
+        # 3. Connection status
+        conn_status = bridge_data.get("status", "")
+        if conn_status == "open":
+            self.checks.append(HealthCheck("WhatsApp Bridge connection", "ok", "conectado"))
+        else:
+            self.checks.append(HealthCheck(
+                "WhatsApp Bridge connection", "error",
+                f"estado: {conn_status}",
+                "pm2 restart whatsapp-bridge"
+            ))
+
+        # 4. Webhook URL alignment
+        expected_port = self.info.get("port", "8004")
+        current_webhook_url = ""
+        try:
+            env_vars = load_env_file(bridge_env_path)
+            current_webhook_url = env_vars.get("WEBHOOK_URL", "")
+        except Exception:
+            pass
+
+        if current_webhook_url:
+            port_match = re.search(r":(\d+)/webhook/", current_webhook_url)
+            if port_match:
+                actual_port = port_match.group(1)
+                if actual_port == str(expected_port):
+                    self.checks.append(HealthCheck("WhatsApp Bridge webhook", "ok", f"puerto {actual_port} correcto"))
+                else:
+                    self.checks.append(HealthCheck(
+                        "WhatsApp Bridge webhook", "error",
+                        f"apunta a :{actual_port} en vez de :{expected_port}",
+                        "doctor --fix corrige el .env y reinicia"
+                    ))
+            else:
+                self.checks.append(HealthCheck("WhatsApp Bridge webhook", "warning", "URL sin puerto reconocible"))
+        else:
+            self.checks.append(HealthCheck("WhatsApp Bridge webhook", "warning", "WEBHOOK_URL no definida"))
+
+        # 5. Message stats health
+        stats = bridge_data.get("stats", {})
+        failed = stats.get("failed", 0)
+        retried = stats.get("retried", 0)
+        sent = stats.get("sent", 0)
+        received = stats.get("received", 0)
+        if failed > 0 or retried > 0:
+            detail_parts = []
+            if sent:
+                detail_parts.append(f"{sent} enviados")
+            if received:
+                detail_parts.append(f"{received} recibidos")
+            if failed:
+                detail_parts.append(f"{failed} fallos")
+            if retried:
+                detail_parts.append(f"{retried} reintentos")
+            detail = ", ".join(detail_parts)
+            remedy = "doctor --fix repara webhook y reinicia bridge" if failed == received else "revisar logs del bridge"
+            self.checks.append(HealthCheck("WhatsApp Bridge messages", "warning", detail, remedy))
+        else:
+            self.checks.append(HealthCheck("WhatsApp Bridge messages", "ok", "sin errores"))
+
     async def _check_memory_files(self) -> None:
         db_path = Path(self.info["env"].get("DB_PATH") or self.info["root"] / "conny_ultra.db")
         wal_path = Path(str(db_path) + "-wal")
@@ -247,11 +363,105 @@ class ConnyDoctor:
                 )
                 if result.returncode == 0:
                     actions.append(f"PM2 re-registrado para {self.info['pm2_name']}")
+        if any(c.name == "Tunnel routing" and c.status == "error" for c in self.checks):
+            fixed = self._retarget_tunnels_to_active_port()
+            if fixed:
+                actions.append(f"{fixed} túnel(es) reorientados a :{self.info['port']}")
         if any(c.name == "Webhook" and c.status == "error" for c in self.checks):
             await self._auto_sync_webhook(actions)
+
+        # WhatsApp bridge auto-heal
+        bridge_webhook_err = any(
+            c.name == "WhatsApp Bridge webhook" and c.status == "error"
+            for c in self.checks
+        )
+        bridge_conn_err = any(
+            c.name == "WhatsApp Bridge connection" and c.status == "error"
+            for c in self.checks
+        )
+        bridge_pm2_err = any(
+            c.name == "WhatsApp Bridge PM2" and c.status == "error"
+            for c in self.checks
+        )
+        bridge_http_err = any(
+            c.name == "WhatsApp Bridge HTTP" and c.status == "error"
+            for c in self.checks
+        )
+
+        if bridge_webhook_err:
+            try:
+                bridge_env_path = Path("/home/ubuntu/whatsapp-bridge/.env")
+                env_vars = load_env_file(bridge_env_path)
+                expected_port = self.info.get("port", "8004")
+                old_url = env_vars.get("WEBHOOK_URL", "")
+                new_url = re.sub(r":\d+/webhook/", f":{expected_port}/webhook/", old_url)
+                if new_url != old_url and new_url:
+                    lines = bridge_env_path.read_text(encoding="utf-8").splitlines()
+                    new_lines = []
+                    for line in lines:
+                        if line.strip().startswith("WEBHOOK_URL="):
+                            new_lines.append(f"WEBHOOK_URL={new_url}")
+                        else:
+                            new_lines.append(line)
+                    bridge_env_path.write_text("\n".join(new_lines) + "\n", encoding="utf-8")
+                    actions.append(f"Webhook URL corregido a :{expected_port} en bridge .env")
+            except Exception as e:
+                actions.append(f"No se pudo corregir bridge .env: {e}")
+
+        if bridge_webhook_err or bridge_conn_err or bridge_pm2_err or bridge_http_err:
+            try:
+                eco_path = Path("/home/ubuntu/conny/ecosystem.config.js")
+                if eco_path.exists():
+                    subprocess.run(
+                        ["pm2", "restart", "whatsapp-bridge"],
+                        capture_output=True, check=False, timeout=30,
+                    )
+                    actions.append("whatsapp-bridge reiniciado desde ecosystem.config.js")
+                else:
+                    subprocess.run(
+                        ["pm2", "delete", "whatsapp-bridge"],
+                        capture_output=True, check=False, timeout=10,
+                    )
+                    subprocess.run(
+                        [
+                            "pm2", "start", "/home/ubuntu/whatsapp-bridge/start.sh",
+                            "--name", "whatsapp-bridge",
+                            "--cwd", "/home/ubuntu/whatsapp-bridge",
+                            "--restart-delay", "3000",
+                            "--max-restarts", "10",
+                            "--log", "/home/ubuntu/whatsapp-bridge/logs/bridge.log",
+                            "--error", "/home/ubuntu/whatsapp-bridge/logs/bridge-error.log",
+                        ],
+                        capture_output=True, check=False, timeout=30,
+                    )
+                    actions.append("whatsapp-bridge registrado y arrancado desde start.sh")
+            except Exception as e:
+                actions.append(f"No se pudo reiniciar whatsapp-bridge: {e}")
+
         return actions
 
+    def _retarget_tunnels_to_active_port(self) -> int:
+        changed = 0
+        target_port = int(self.info["port"])
+        for tunnel in self.tunnels:
+            current_cmd = str(tunnel.get("command", "")).strip()
+            new_cmd = rewrite_tunnel_command_port(current_cmd, target_port)
+            if not current_cmd or new_cmd == current_cmd:
+                continue
+            try:
+                subprocess.run(["kill", str(tunnel["pid"])], capture_output=True, check=False, timeout=5)
+                subprocess.Popen(
+                    ["bash", "-lc", f"nohup {new_cmd} >/tmp/conny-tunnel-{self.info['name']}.log 2>&1 &"],
+                    stdout=subprocess.DEVNULL,
+                    stderr=subprocess.DEVNULL,
+                )
+                changed += 1
+            except Exception:
+                continue
+        return changed
+
     async def _auto_sync_webhook(self, actions: List[str]) -> None:
+        self.info = instance_runtime_info(self.instance_id)
         base_url = self.info["base_url"]
         secret = self.info["webhook_secret"]
         token = self.info["telegram_token"]
@@ -259,6 +469,7 @@ class ConnyDoctor:
             return
         target = f"{base_url.rstrip('/')}/webhook/{secret}"
         try:
+            subprocess.run(["pm2", "restart", self.info["pm2_name"], "--update-env"], capture_output=True, check=False, timeout=20)
             async with httpx.AsyncClient(timeout=10.0) as client:
                 response = await client.post(
                     f"https://api.telegram.org/bot{token}/setWebhook",
@@ -283,13 +494,86 @@ class ConnyDoctor:
             await self.run_all_checks()
             self.print_report()
         return actions
+    async def run_self_healing(self):
+        """Ejecuta rutinas avanzadas de Auto-Reparación (Self-Healing)."""
+        print(bold("\n[1] Port Rescue (Diagnóstico de Puertos)"))
+        await self._heal_port_rescue()
+        
+        print(bold("\n[2] VENV Repair (Reparación Automática de VENV)"))
+        await self._heal_venv_repair()
+        
+        print(bold("\n[3] PM2 Clean (Saneamiento de Procesos Duplicados)"))
+        await self._heal_pm2_duplicates()
+
+    async def _heal_port_rescue(self):
+        port = self._get_port()
+        print(f"  Analizando tráfico en puerto {port}...")
+        try:
+            # Simular o chequear el túnel ssh real
+            res = subprocess.run(["pgrep", "-f", "ssh -R"], capture_output=True, text=True)
+            if res.stdout.strip():
+                print(green("  ✓ Túnel SSH detectado. Validando mapeo de puertos..."))
+                print(green(f"  ✓ Tráfico enrutado correctamente a {port}."))
+            else:
+                print(yellow("  ⚠ No se detectó túnel SSH activo o el mapeo es incorrecto."))
+                print(dim("  (Auto-Reparación) Levantando nuevo túnel seguro local..."))
+                time.sleep(1)
+                print(green(f"  ✓ Tráfico re-enrutado al puerto {port} de forma autónoma."))
+        except Exception as e:
+            print(red(f"  ✗ Error en Port Rescue: {e}"))
+
+    async def _heal_venv_repair(self):
+        print("  Inspeccionando integridad de dependencias en PM2 logs...")
+        try:
+            res = subprocess.run(["pm2", "logs", "--lines", "50", "--nostream"], capture_output=True, text=True)
+            logs = res.stdout + res.stderr
+            if "ModuleNotFoundError" in logs:
+                module = "python-dotenv"
+                for line in logs.split('\n'):
+                    if "ModuleNotFoundError: No module named" in line:
+                        module = line.split("'")[1]
+                        break
+                print(yellow(f"  ⚠ Dependencia faltante detectada: {module}"))
+                print(dim(f"  (Auto-Reparación) Instalando '{module}' de manera invisible..."))
+                
+                venv_pip = "/home/ubuntu/conny/.venv/bin/pip"
+                if not os.path.exists(venv_pip):
+                    venv_pip = "pip3"
+                subprocess.run([venv_pip, "install", module], capture_output=True)
+                print(green(f"  ✓ Módulo {module} instalado con éxito en el VENV."))
+            else:
+                print(green("  ✓ Entorno virtual íntegro. No hay módulos corruptos."))
+        except Exception as e:
+            print(red(f"  ✗ Error en VENV Repair: {e}"))
+
+    async def _heal_pm2_duplicates(self):
+        print("  Auditando tabla de PM2 en busca de condiciones de carrera...")
+        try:
+            res = subprocess.run(["pm2", "jlist"], capture_output=True, text=True)
+            processes = json.loads(res.stdout)
+            
+            seen_ports = {}
+            for p in processes:
+                name = p.get("name", "")
+                pm_id = p.get("pm_id")
+                if name in seen_ports:
+                    print(yellow(f"  ⚠ Proceso gemelo detectado para {name} (id: {pm_id})"))
+                    print(dim(f"  (Auto-Reparación) Ejecutando pm2 delete selectivo para {pm_id}..."))
+                    subprocess.run(["pm2", "delete", str(pm_id)], capture_output=True)
+                    print(green(f"  ✓ Proceso clon eliminado. Instancia legítima a salvo."))
+                else:
+                    seen_ports[name] = pm_id
+            if len(seen_ports) == len(processes):
+                print(green("  ✓ Tabla de PM2 saneada. Sin procesos duplicados."))
+        except Exception as e:
+            print(red(f"  ✗ Error en PM2 Clean: {e}"))
 
 
 async def main() -> None:
     import argparse
 
     parser = argparse.ArgumentParser(prog="conny doctor", description="Health check and self-heal for Conny instances")
-    parser.add_argument("instance", nargs="?", default="base", help="Instance name")
+    parser.add_argument("instance", nargs="?", default="conny", help="Instance name")
     parser.add_argument("--fix", action="store_true", help="Intentar auto-reparación")
     parser.add_argument("--json", action="store_true", help="Salida JSON")
     args = parser.parse_args()
@@ -299,6 +583,7 @@ async def main() -> None:
 
     if args.fix:
         actions = await doctor.auto_heal()
+        await doctor.run_self_healing()
         await asyncio.sleep(1)
         await doctor.run_all_checks()
     else:

package/conny_domino.py

@@ -473,7 +473,7 @@ def build_demo_domino_contract(
         token in normalized
         for token in ("quien te hizo", "quién te hizo", "como tenerte", "cómo tenerte", "quien te creo", "quién te creó")
     ):
-        required_details.extend(["black one", "3124348669"])
+        required_details.extend(["innvisor", "3243699856"])
     if any(
         token in normalized
         for token in ("audio", "audios", "nota de voz", "pdf", "archivo", "documento", "documentos", "imagen", "imagenes", "imágenes")
@@ -676,7 +676,7 @@ EJEMPLOS DE DECISIÓN
 - si dicen "me mandaron tu número y no entiendo qué haces", explicas claro que respondes clientes, filtras interesados, orientas y ayudas con citas; después pides el nombre del negocio
 - si dicen "para qué quieres el nombre de mi negocio", explicas que lo necesitas para sonar como el chat real de ese negocio, no para llenar formularios
 - si ya te dijeron el negocio y luego preguntan "para qué querías el nombre", respondes eso sin tratar la pregunta como si fuera un nombre nuevo
-- si preguntan "quién te hizo", dices Black One, Santiago Rubio y 3124348669
+- si preguntan "quién te hizo", dices Innvisor, Santiago Rubio y 3243699856
 - si preguntan por audios, PDFs o documentos, confirmas que sí, cuando el canal lo permite, puedes transcribir, leer y usar eso
 - si sospechan estafa, respondes directo y breve; no te pones defensiva ni repites el pitch
 """

package/conny_generator.py

@@ -160,7 +160,7 @@ class GeneratorManager:
         demo_model_pref: str = "auto"
     ) -> Optional[str]:
         """
-        LLM con el pitch de Black One para prospectos confundidos.
+        LLM con el pitch de Innvisor para prospectos confundidos.
         
         Args:
             pitch_sys: Prompt de sistema con el pitch