@innvisor/conny-ai 9.7.0

package/conny_pairing.py

@@ -0,0 +1,253 @@
+import os
+import json
+import time
+import secrets
+import re
+from typing import List, Dict, Optional, Tuple, Any
+
+# Configuration constants
+PAIRING_CODE_LENGTH = 8
+PAIRING_CODE_ALPHABET = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789"
+PAIRING_PENDING_TTL = 3600  # 1 hour in seconds
+PAIRING_PENDING_MAX = 3
+
+# Base directory for storing pairing data
+# Ensures it respects user's home directory and creates the structure if it doesn't exist
+CONNY_PAIRING_BASE_DIR = os.path.join(os.path.expanduser("~"), ".conny", "pairing")
+
+# Ensure the base directory exists
+os.makedirs(CONNY_PAIRING_BASE_DIR, exist_ok=True)
+
+def _now_iso() -> str:
+    """Returns the current time in ISO format."""
+    return time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
+
+def _load_json(path: str, fallback: Any = None) -> Any:
+    """Loads JSON data from a file, returns fallback if file not found or invalid."""
+    try:
+        if os.path.exists(path):
+            with open(path, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+                # Basic validation for structure if fallback is provided
+                if fallback is not None and isinstance(data, dict) and "version" not in data:
+                    return fallback
+                return data
+        else:
+            return fallback
+    except (json.JSONDecodeError, OSError):
+        return fallback
+
+def _save_json(path: str, data: Any) -> None:
+    """Saves data to a JSON file."""
+    try:
+        with open(path, 'w', encoding='utf-8') as f:
+            json.dump(data, f, indent=2)
+    except OSError as e:
+        print(f"Error saving JSON to {path}: {e}") # Basic logging
+
+def _generate_code() -> str:
+    """Generates a random pairing code."""
+    return ''.join(secrets.choice(PAIRING_CODE_ALPHABET) for _ in range(PAIRING_CODE_LENGTH))
+
+def _get_channel_paths(channel: str) -> Tuple[str, str]:
+    """Returns the file paths for pairing requests and allow list for a given channel."""
+    channel_safe = re.sub(r'[\\/:*?"<>|]', '_', channel.lower()) # Sanitize channel name for filename
+    pairing_path = os.path.join(CONNY_PAIRING_BASE_DIR, f"{channel_safe}-pairing.json")
+    allow_path = os.path.join(CONNY_PAIRING_BASE_DIR, f"{channel_safe}-allowFrom.json")
+    return pairing_path, allow_path
+
+def load_pending(channel: str) -> List[Dict]:
+    """Loads pending pairing requests for a channel."""
+    path, _ = _get_channel_paths(channel)
+    fallback = {"version": 1, "requests": []}
+    data = _load_json(path, fallback)
+    # Ensure requests are loaded and pruned for expiry
+    now = time.time()
+    loaded_requests = data.get("requests", [])
+    active_requests = [req for req in loaded_requests if now - int(req.get("timestamp", 0)) < PAIRING_PENDING_TTL]
+    if len(active_requests) != len(loaded_requests):
+        _save_json(path, {"version": 1, "requests": active_requests}) # Save pruned list
+    return active_requests
+
+def save_pending(channel: str, requests: List[Dict]) -> None:
+    """Saves pending pairing requests for a channel."""
+    path, _ = _get_channel_paths(channel)
+    _save_json(path, {"version": 1, "requests": requests})
+
+def load_allow(channel: str) -> List[str]:
+    """Loads the allow list for a channel."""
+    _, path = _get_channel_paths(channel)
+    fallback = {"version": 1, "allowed_chat_ids": []}
+    data = _load_json(path, fallback)
+    return data.get("allowed_chat_ids", [])
+
+def save_allow(channel: str, allowed_chat_ids: List[str]) -> None:
+    """Saves the allow list for a channel."""
+    _, path = _get_channel_paths(channel)
+    _save_json(path, {"version": 1, "allowed_chat_ids": allowed_chat_ids})
+
+def generate_code_for_chat(chat_id: str, channel: str) -> str:
+    """
+    Generates a pairing code for a chat_id if not already pending or allowed.
+    Returns the code and updates the pending requests.
+    """
+    pending_requests = load_pending(channel)
+    allowed_ids = load_allow(channel)
+
+    # Check if already allowed
+    if chat_id in allowed_ids:
+        return "already_paired" # Special indicator
+
+    # Check if already has a pending request
+    for req in pending_requests:
+        if req.get("chat_id") == chat_id:
+            # Return existing code if not expired
+            if time.time() - req.get("timestamp", 0) < PAIRING_PENDING_TTL:
+                return req.get("code")
+            else:
+                break # Expired, will be removed
+
+    # Prune expired requests before adding a new one
+    now = time.time()
+    active_pending = [req for req in pending_requests if now - req.get("timestamp", 0) < PAIRING_PENDING_TTL]
+
+    # Check if limit is reached
+    if len(active_pending) >= PAIRING_PENDING_MAX:
+        # Remove oldest to make space, if allowed by logic (or return error/indicator)
+        # Simple approach: return error/indicator that limit reached
+        return "limit_reached"
+
+    code = _generate_code()
+    new_request = {
+        "chat_id": chat_id,
+        "code": code,
+        "timestamp": int(now),
+        "channel": channel,
+    }
+    active_pending.append(new_request)
+    save_pending(channel, active_pending)
+    return code
+
+def list_pending(channel: str) -> List[Dict]:
+    """Returns all active pending pairing requests for a channel."""
+    return load_pending(channel)
+
+def approve_code(code: str, channel: str, chat_id: Optional[str] = None) -> bool:
+    """
+    Approves a pairing code. Adds chat_id to allow list and removes the request.
+    Returns True if successful, False otherwise.
+    """
+    pending_requests = load_pending(channel)
+    allowed_ids = load_allow(channel)
+    
+    original_request = None
+    new_pending_requests = []
+    for req in pending_requests:
+        if req.get("code") == code:
+            original_request = req
+            # Don't add this request to the new list (effectively removing it)
+        else:
+            new_pending_requests.append(req)
+
+    if original_request:
+        # Add the chat_id to the allow list if provided and not already there
+        request_chat_id = original_request.get("chat_id")
+        target_chat_id = chat_id or request_chat_id # Use provided chat_id if available, else from request
+
+        if target_chat_id and target_chat_id not in allowed_ids:
+            allowed_ids.append(target_chat_id)
+            save_allow(channel, allowed_ids)
+        
+        save_pending(channel, new_pending_requests)
+        return True
+    return False
+
+def is_paired(chat_id: str, channel: str) -> bool:
+    """Checks if a chat_id is in the allow list for a channel."""
+    allowed_ids = load_allow(channel)
+    return chat_id in allowed_ids
+
+def ensure_pairing_for_chat(chat_id: str, channel: str) -> str:
+    """
+    Ensures a chat_id is either paired or has an active pending request.
+    Returns the pairing code if a new one was generated, 'already_paired' if already allowed,
+    or 'limit_reached' if max pending requests are active.
+    """
+    if is_paired(chat_id, channel):
+        return "already_paired"
+    else:
+        return generate_code_for_chat(chat_id, channel)
+
+# Example usage (for testing, not part of the main module export)
+if __name__ == "__main__":
+    # Example for Telegram channel
+    TEST_CHANNEL = "telegram"
+    TEST_CHAT_ID_1 = "123456789"
+    TEST_CHAT_ID_2 = "987654321"
+    TEST_CHAT_ID_3 = "111111111"
+    TEST_CHAT_ID_4 = "222222222"
+
+    print(f"--- Testing Pairing Module for Channel: {TEST_CHANNEL} ---")
+
+    # Generate code for chat 1
+    code1 = ensure_pairing_for_chat(TEST_CHAT_ID_1, TEST_CHANNEL)
+    print(f"Ensure pairing for {TEST_CHAT_ID_1}: {code1}")
+
+    # Generate code for chat 2
+    code2 = ensure_pairing_for_chat(TEST_CHAT_ID_2, TEST_CHANNEL)
+    print(f"Ensure pairing for {TEST_CHAT_ID_2}: {code2}")
+
+    # Generate code for chat 3
+    code3 = ensure_pairing_for_chat(TEST_CHAT_ID_3, TEST_CHANNEL)
+    print(f"Ensure pairing for {TEST_CHAT_ID_3}: {code3}")
+
+    # Try to generate code for chat 4 (should hit limit if MAX is 3)
+    code4_limit = ensure_pairing_for_chat(TEST_CHAT_ID_4, TEST_CHANNEL)
+    print(f"Ensure pairing for {TEST_CHAT_ID_4} (expect limit): {code4_limit}")
+
+    # List pending
+    pending = list_pending(TEST_CHANNEL)
+    print(f"Pending requests: {pending}")
+
+    # Approve code for chat 1
+    print(f"\nApproving code {code1} for {TEST_CHAT_ID_1}...")
+    success_approve1 = approve_code(code1, TEST_CHANNEL, TEST_CHAT_ID_1)
+    print(f"Approval successful: {success_approve1}")
+
+    # Check if chat 1 is now paired
+    print(f"Is {TEST_CHAT_ID_1} paired? {is_paired(TEST_CHAT_ID_1, TEST_CHANNEL)}")
+    print(f"Is {TEST_CHAT_ID_2} paired? {is_paired(TEST_CHAT_ID_2, TEST_CHANNEL)}")
+
+    # List pending again (should be less)
+    pending_after_approve = list_pending(TEST_CHANNEL)
+    print(f"Pending requests after approve: {pending_after_approve}")
+
+    # Try to approve a non-existent or already approved code
+    print("\nApproving non-existent code 'ABCDEFGH'...")
+    fail_approve = approve_code("ABCDEFGH", TEST_CHANNEL)
+    print(f"Approval successful: {fail_approve}")
+    
+    print(f"\nApproving {code2} again for {TEST_CHAT_ID_2}...")
+    success_approve2 = approve_code(code2, TEST_CHANNEL, TEST_CHAT_ID_2)
+    print(f"Approval successful: {success_approve2}")
+
+    # Test ensure_pairing for already paired chat
+    print(f"\nEnsure pairing for {TEST_CHAT_ID_1} (already paired):")
+    code_already = ensure_pairing_for_chat(TEST_CHAT_ID_1, TEST_CHANNEL)
+    print(f"Result: {code_already}")
+
+    print("\n--- Test Cleanup ---")
+    # Clean up created files
+    try:
+        os.remove(os.path.join(CONNY_PAIRING_BASE_DIR, f"{TEST_CHANNEL}-pairing.json"))
+        os.remove(os.path.join(CONNY_PAIRING_BASE_DIR, f"{TEST_CHANNEL}-allowFrom.json"))
+        print("Cleanup successful.")
+    except OSError as e:
+        print(f"Cleanup failed: {e}")
+    finally:
+        # Remove base dir if empty
+        try:
+            if not os.listdir(CONNY_PAIRING_BASE_DIR):
+                os.rmdir(CONNY_PAIRING_BASE_DIR)
+        except OSError:
+            pass

package/conny_patch.py

@@ -0,0 +1,291 @@
+#!/usr/bin/env python3
+"""
+conny_patch.py — Aplica todos los fixes de producción a conny.py
+
+Fixes:
+  1. Presencia online al recibir mensaje (soluciona checkmark gris)
+  2. Typing más humano con presencia antes de cada burbuja  
+  3. Comando /token para generar códigos de activación desde el chat
+  4. Comando /activar para activar instancia sin API externa
+  5. Help actualizado con nuevos comandos
+  
+Uso: python3 conny_patch.py /home/ubuntu/conny/conny.py
+"""
+
+import sys
+import shutil
+from pathlib import Path
+from datetime import datetime
+
+if len(sys.argv) < 2:
+    print("Uso: python3 conny_patch.py /ruta/a/conny.py")
+    sys.exit(1)
+
+target = Path(sys.argv[1])
+if not target.exists():
+    print(f"Error: {target} no existe")
+    sys.exit(1)
+
+# Backup
+backup = target.with_suffix(f".py.bak_{datetime.now().strftime('%Y%m%d_%H%M%S')}")
+shutil.copy2(target, backup)
+print(f"Backup: {backup}")
+
+src = target.read_text(encoding="utf-8")
+original_len = len(src)
+
+# ══════════════════════════════════════════════════════════════════════════════
+# PATCH 1 — _typing_action: agregar presencia available antes del typing
+# Soluciona el checkmark gris — WA necesita saber que estamos online
+# ══════════════════════════════════════════════════════════════════════════════
+
+OLD_TYPING = '''            elif platform == "whatsapp":
+                if Config.WHATSAPP_BRIDGE_URL:
+                    async with httpx.AsyncClient(timeout=8.0) as client:
+                        # Solo typing — el /read se dispara por separado con delay natural
+                        await client.post(
+                            f"{Config.WHATSAPP_BRIDGE_URL}/typing",
+                            json={"to": chat_id, "duration": duration}
+                        )'''
+
+NEW_TYPING = '''            elif platform == "whatsapp":
+                if Config.WHATSAPP_BRIDGE_URL:
+                    async with httpx.AsyncClient(timeout=8.0) as client:
+                        # 1. Aparecer online ANTES de typing — soluciona checkmark gris
+                        # WhatsApp solo entrega mensajes cuando el remitente está online
+                        try:
+                            await client.post(
+                                f"{Config.WHATSAPP_BRIDGE_URL}/presence",
+                                json={"status": "available", "timeout": 120000},
+                                timeout=3.0
+                            )
+                        except Exception:
+                            pass
+                        # 2. Typing proporcional al mensaje
+                        await client.post(
+                            f"{Config.WHATSAPP_BRIDGE_URL}/typing",
+                            json={"to": chat_id, "duration": duration}
+                        )'''
+
+if OLD_TYPING in src:
+    src = src.replace(OLD_TYPING, NEW_TYPING)
+    print("✓ PATCH 1 aplicado: presencia online antes de typing")
+else:
+    print("⚠ PATCH 1 no encontrado — puede que ya esté aplicado")
+
+# ══════════════════════════════════════════════════════════════════════════════
+# PATCH 2 — webhook WhatsApp: marcar presencia available al recibir mensaje
+# Esto hace que Conny aparezca online inmediatamente cuando llega un mensaje
+# ══════════════════════════════════════════════════════════════════════════════
+
+OLD_WEBHOOK_WA = '''    if not chat_id:
+        return {"ok": True}
+
+    if audio_id:
+        await conny._typing_action(chat_id)'''
+
+NEW_WEBHOOK_WA = '''    if not chat_id:
+        return {"ok": True}
+
+    # Aparecer online al recibir — soluciona checkmark gris y "último vez visto"
+    if platform == "whatsapp" and Config.WHATSAPP_BRIDGE_URL:
+        async def _go_online():
+            try:
+                async with httpx.AsyncClient(timeout=3.0) as _hx:
+                    await _hx.post(
+                        f"{Config.WHATSAPP_BRIDGE_URL}/presence",
+                        json={"status": "available", "timeout": 180000}
+                    )
+            except Exception:
+                pass
+        asyncio.create_task(_go_online())
+
+    if audio_id:
+        await conny._typing_action(chat_id)'''
+
+if OLD_WEBHOOK_WA in src:
+    src = src.replace(OLD_WEBHOOK_WA, NEW_WEBHOOK_WA)
+    print("✓ PATCH 2 aplicado: presencia online al recibir mensaje")
+else:
+    print("⚠ PATCH 2 no encontrado")
+
+# ══════════════════════════════════════════════════════════════════════════════
+# PATCH 3 — Comandos /token y /activar en el handler admin
+# /token [nombre] → genera un código de activación
+# /activar         → activa esta instancia si ya tiene datos
+# ══════════════════════════════════════════════════════════════════════════════
+
+OLD_REGLAS_CMD = '''            elif cmd == "/reglas":
+                return await self._admin_show_trust_rules()'''
+
+NEW_REGLAS_CMD = '''            elif cmd == "/reglas":
+                return await self._admin_show_trust_rules()
+
+            # ── Tokens de activacion ───────────────────────────────────────
+            elif cmd == "/token" or cmd.startswith("/token "):
+                # /token              → genera token para esta instancia
+                # /token Clinica Demo → genera token con ese nombre
+                label = cmd.split("/token", 1)[1].strip() if " " in cmd else ""
+                if not label:
+                    clinic_name = clinic.get("name") or "Mi Negocio"
+                    label = clinic_name
+                new_token = generate_activation_token(label)
+                expires_at = (datetime.now() + timedelta(hours=Config.TOKEN_EXPIRY_HOURS)).isoformat()
+                saved = db.create_activation_token(new_token, label, expires_at)
+                if saved:
+                    return [
+                        f"Token de activacion generado para: {label}",
+                        f"{new_token}",
+                        f"Expira en {Config.TOKEN_EXPIRY_HOURS}h. Enviaselo al administrador del negocio."
+                    ]
+                return ["No pude generar el token. Intenta de nuevo."]
+
+            elif cmd == "/activar":
+                # Activa esta instancia directamente (para instancias ya configuradas)
+                clinic_name = clinic.get("name") or ""
+                if not clinic_name:
+                    db.update_clinic(setup_step="idle")
+                    return [
+                        "Para activar, primero dime el nombre de tu negocio.",
+                        "Escribe el nombre y te configuro de una."
+                    ]
+                db.update_clinic(setup_done=1)
+                admin_ids = clinic.get("admin_chat_ids", [])
+                if isinstance(admin_ids, str):
+                    try: admin_ids = json.loads(admin_ids) if admin_ids else []
+                    except: admin_ids = []
+                if chat_id not in admin_ids:
+                    admin_ids.append(chat_id)
+                    db.update_clinic(admin_chat_ids=json.dumps(admin_ids))
+                return [
+                    f"Instancia activada.",
+                    f"Negocio: {clinic_name}",
+                    f"Ya puedo atender pacientes. Escribe /config para ver todo."
+                ]'''
+
+if OLD_REGLAS_CMD in src:
+    src = src.replace(OLD_REGLAS_CMD, NEW_REGLAS_CMD)
+    print("✓ PATCH 3 aplicado: comandos /token y /activar")
+else:
+    print("⚠ PATCH 3 no encontrado")
+
+# ══════════════════════════════════════════════════════════════════════════════
+# PATCH 4 — Help actualizado con nuevos comandos
+# ══════════════════════════════════════════════════════════════════════════════
+
+OLD_HELP = '''            elif cmd.startswith("/"):
+                return [
+                    "Comandos disponibles:\\n\\n"
+                    "/citas — citas pendientes\\n"
+                    "/chats — ver conversaciones de pacientes\\n"
+                    "/chat [id] — conversación completa\\n"
+                    "/reglas — lo aprendido del feedback\\n"
+                    "/sector — ver/cambiar sector del negocio\\n"
+                    "/nova — motor de gobernanza\\n"
+                    "/whatsapp — conectar WhatsApp Business\\n"
+                    "/agenda — estado del calendario\\n"
+                    "/personalidad — ajustar personalidad\\n"
+                    "/config — ver configuración\\n"
+                    "/metricas — métricas\\n\\n"
+                    "V6.0 — Inteligencia:\\n"
+                    "/pipeline — leads por temperatura (frío/tibio/caliente)\\n"
+                    "/perdidos — por qué se van los clientes\\n"
+                    "/coach — feedback de ventas de la semana\\n"
+                    "/estilo — clonar tu forma de escribir\\n\\n"
+                    "V6.0 — Automatización:\\n"
+                    "/reactivar — reactivar clientes 60+ días inactivos\\n"
+                    "/seguimiento — estado de follow-ups automáticos\\n"
+                    "/reporte — reporte ahora mismo\\n"
+                    "/broadcast [msg] — mensaje masivo a pacientes\\n\\n"
+                    "V6.0 — Canales y pagos:\\n"
+                    "/instagram — conectar DMs de Instagram\\n"
+                    "/pagos — pagos desde el chat (Wompi/MercadoPago)\\n"
+                    "/preconsulta — formulario pre-cita automático\\n\\n"
+                    "O escríbeme en lenguaje natural."
+                ]'''
+
+NEW_HELP = '''            elif cmd.startswith("/"):
+                return [
+                    "Comandos disponibles:\\n\\n"
+                    "Atencion:\\n"
+                    "/citas — citas pendientes\\n"
+                    "/chats — ver conversaciones de pacientes\\n"
+                    "/chat [id] — conversacion completa\\n"
+                    "/reglas — reglas aprendidas\\n"
+                    "/broadcast [msg] — mensaje masivo\\n\\n"
+                    "Configuracion:\\n"
+                    "/config — ver configuracion\\n"
+                    "/sector — ver/cambiar sector\\n"
+                    "/personalidad — ajustar personalidad\\n"
+                    "/whatsapp — conectar WhatsApp\\n"
+                    "/agenda — estado del calendario\\n"
+                    "/nova — motor de gobernanza\\n"
+                    "/metricas — metricas\\n\\n"
+                    "Activacion:\\n"
+                    "/token [nombre] — generar codigo de activacion\\n"
+                    "/activar — activar esta instancia\\n\\n"
+                    "Inteligencia (V7):\\n"
+                    "/pipeline — leads por temperatura\\n"
+                    "/perdidos — analisis de perdidos\\n"
+                    "/coach — feedback de ventas\\n"
+                    "/reactivar — reactivar clientes inactivos\\n"
+                    "/reporte — reporte inmediato\\n\\n"
+                    "O escribe en lenguaje natural."
+                ]'''
+
+if OLD_HELP in src:
+    src = src.replace(OLD_HELP, NEW_HELP)
+    print("✓ PATCH 4 aplicado: help actualizado")
+else:
+    print("⚠ PATCH 4 no encontrado — ayuda sin cambios")
+
+# ══════════════════════════════════════════════════════════════════════════════
+# PATCH 5 — _send_bubbles: marcar offline después de enviar todas las burbujas
+# Comportamiento humano: aparece online → escribe → desaparece
+# ══════════════════════════════════════════════════════════════════════════════
+
+OLD_SEND_BUBBLES_END = '''            if i < len(bubbles) - 1:
+                # Pausa inter-burbuja más humana — evita que WA trate las ráfagas como spam
+                inter_pause = random.uniform(1.4, 2.8) if is_wa else random.uniform(0.8, 1.8)
+                await asyncio.sleep(inter_pause)'''
+
+NEW_SEND_BUBBLES_END = '''            if i < len(bubbles) - 1:
+                # Pausa inter-burbuja más humana — evita que WA trate las ráfagas como spam
+                inter_pause = random.uniform(1.4, 2.8) if is_wa else random.uniform(0.8, 1.8)
+                await asyncio.sleep(inter_pause)
+
+        # Después de enviar todo: volver a unavailable con delay natural
+        # Simula comportamiento humano: escribe, manda, se desconecta
+        if is_wa and Config.WHATSAPP_BRIDGE_URL:
+            async def _go_offline_delayed():
+                await asyncio.sleep(random.uniform(8.0, 18.0))
+                try:
+                    async with httpx.AsyncClient(timeout=3.0) as _hx:
+                        await _hx.post(
+                            f"{Config.WHATSAPP_BRIDGE_URL}/presence",
+                            json={"status": "unavailable"}
+                        )
+                except Exception:
+                    pass
+            asyncio.create_task(_go_offline_delayed())'''
+
+if OLD_SEND_BUBBLES_END in src:
+    src = src.replace(OLD_SEND_BUBBLES_END, NEW_SEND_BUBBLES_END)
+    print("✓ PATCH 5 aplicado: offline después de enviar (comportamiento humano)")
+else:
+    print("⚠ PATCH 5 no encontrado")
+
+# ══════════════════════════════════════════════════════════════════════════════
+# Escribir resultado
+# ══════════════════════════════════════════════════════════════════════════════
+
+target.write_text(src, encoding="utf-8")
+new_len = len(src)
+
+print(f"\n{'='*60}")
+print(f"Archivo actualizado: {target}")
+print(f"Tamaño: {original_len:,} → {new_len:,} chars (+{new_len - original_len:,})")
+print(f"Backup guardado en: {backup}")
+print(f"\nSiguiente paso:")
+print(f"  pm2 restart conny --update-env")
+print(f"  pm2 logs conny --lines 20 --nostream")