@innvisor/conny-ai 9.7.0

package/conny_tui_select.py

@@ -0,0 +1,202 @@
+"""conny_tui_select.py — Arrow-key interactive selection menu (Nova-style)."""
+from __future__ import annotations
+
+import getpass
+import os
+import sys
+import shutil
+import select as _select
+from typing import List, Optional
+
+IS_WINDOWS = sys.platform.startswith("win")
+if not IS_WINDOWS:
+    import termios
+    import tty
+else:
+    import msvcrt
+
+# Brand colors
+PURPLE = "\033[38;5;141m"
+MAGENTA = "\033[38;5;213m"
+CYAN = "\033[38;5;159m"
+DIM = "\033[38;5;242m"
+BOLD = "\033[1m"
+RESET = "\033[0m"
+GREEN = "\033[38;5;114m"
+WHITE = "\033[38;5;231m"
+
+
+def is_tty() -> bool:
+    try:
+        return bool(sys.stdin.isatty()) and bool(sys.stdout.isatty())
+    except Exception:
+        return False
+
+
+def _term_width() -> int:
+    return shutil.get_terminal_size((80, 24)).columns
+
+
+def select_menu(
+    options: List[str],
+    *,
+    title: str = "",
+    descriptions: Optional[List[str]] = None,
+    default: int = 0,
+) -> int:
+    """Interactive menu with arrow key navigation. Returns selected index."""
+    if not options:
+        return 0
+    if not is_tty():
+        return _fallback(options, title=title, default=default)
+
+    descriptions = descriptions or []
+    current = max(0, min(default, len(options) - 1))
+    line_count = 0
+
+    def draw(first=False):
+        nonlocal line_count
+        out = []
+        if not first and line_count:
+            out.append(f"\033[{line_count}F")
+            for _ in range(line_count):
+                out.append("\033[2K\033[1E")
+            out.append(f"\033[{line_count}F")
+
+        lc = 0
+        if title:
+            out.append(f"\n  {CYAN}{BOLD}{title}{RESET}\n")
+            lc += 2
+
+        for i, opt in enumerate(options):
+            if i == current:
+                out.append(f"  {MAGENTA}▶ {WHITE}{BOLD}{opt}{RESET}\n")
+            else:
+                out.append(f"    {DIM}{opt}{RESET}\n")
+            lc += 1
+            if i < len(descriptions) and descriptions[i]:
+                out.append(f"      {DIM}{descriptions[i][:60]}{RESET}\n")
+                lc += 1
+
+        out.append(f"\n  {DIM}↑/↓ select · Enter confirm{RESET}\n")
+        lc += 2
+        line_count = lc
+        sys.stdout.write("".join(out))
+        sys.stdout.flush()
+
+    def read_key_unix():
+        fd = sys.stdin.fileno()
+        old = termios.tcgetattr(fd)
+        tty.setraw(fd)
+        try:
+            ch = os.read(fd, 1)
+            if ch in (b"\r", b"\n"):
+                termios.tcflush(fd, termios.TCIFLUSH)
+                return "ENTER"
+            if ch == b"\x03":
+                return "CTRL_C"
+            if ch == b"\x1b":
+                ready, _, _ = _select.select([fd], [], [], 0.05)
+                if not ready:
+                    return "ESC"
+                ch2 = os.read(fd, 1)
+                if ch2 == b"[":
+                    ready2, _, _ = _select.select([fd], [], [], 0.05)
+                    if not ready2:
+                        return "["
+                    ch3 = os.read(fd, 1)
+                    if ch3 == b"A": return "UP"
+                    if ch3 == b"B": return "DOWN"
+                return ""
+            return ch.decode(errors="ignore")
+        finally:
+            termios.tcsetattr(fd, termios.TCSADRAIN, old)
+
+    def read_key_win():
+        while True:
+            if msvcrt.kbhit():
+                ch = msvcrt.getch()
+                if ch in (b"\r", b"\n"):
+                    return "ENTER"
+                if ch == b"\x03":
+                    return "CTRL_C"
+                if ch in (b"\x00", b"\xe0"):
+                    ch2 = msvcrt.getch()
+                    if ch2 == b"H": return "UP"
+                    if ch2 == b"P": return "DOWN"
+                return ch.decode(errors="ignore")
+
+    read_key = read_key_win if IS_WINDOWS else read_key_unix
+
+    draw(first=True)
+    while True:
+        key = read_key()
+        if key == "ENTER":
+            sys.stdout.write("\n")
+            return current
+        if key == "CTRL_C":
+            sys.stdout.write("\n")
+            raise KeyboardInterrupt
+        if key == "UP" and current > 0:
+            current -= 1; draw()
+        elif key == "DOWN" and current < len(options) - 1:
+            current += 1; draw()
+        elif key.isdigit():
+            idx = int(key) - 1
+            if 0 <= idx < len(options):
+                current = idx; draw()
+
+
+def _fallback(options, title="", default=0):
+    if title:
+        print(f"\n  {title}")
+    for i, opt in enumerate(options, 1):
+        marker = "▸" if i - 1 == default else " "
+        print(f"  {marker} {i}. {opt}")
+    try:
+        ans = input("\n  → ")
+    except (EOFError, KeyboardInterrupt):
+        return default
+    if ans.isdigit() and 0 < int(ans) <= len(options):
+        return int(ans) - 1
+    return default
+
+
+def confirm(text: str, default: bool = True) -> bool:
+    """Y/N as arrow-key selector (never disappears)."""
+    if not is_tty():
+        try:
+            ans = input(f"  {text} (y/n) ")
+            return ans.lower() in ("y", "yes", "s", "si", "sí", "")
+        except: return default
+
+    options = ["Yes", "No"] if default else ["No", "Yes"]
+    idx = select_menu(options, title=f" {text}", default=0)
+    if default:
+        return idx == 0
+    else:
+        return idx == 1
+
+
+def text_input(label: str, default: str = "", required: bool = True, is_password: bool = False) -> str:
+    """Text input that stays visible."""
+    suffix = f" {DIM}(default: {default}){RESET}" if default and not is_password else ""
+    while True:
+        try:
+            sys.stdout.write(f"  {MAGENTA}▶{RESET} {WHITE}{BOLD}{label}{RESET}{suffix}: ")
+            sys.stdout.flush()
+            if is_password:
+                val = getpass.getpass(prompt="")
+            else:
+                val = sys.stdin.readline().strip()
+        except (EOFError, KeyboardInterrupt):
+            print()
+            return default
+        if val:
+            return val
+        if default:
+            return default
+        if not required:
+            return ""
+        sys.stdout.write(f"    {DIM}(required){RESET}\n")
+        sys.stdout.flush()

package/conny_ultra_config.py

@@ -0,0 +1,411 @@
+#!/usr/bin/env python3
+"""CONNY ULTRA CONFIG v9.7.0 — interactive runtime control panel."""
+from __future__ import annotations
+
+import asyncio
+import json
+import shlex
+import subprocess
+import sys
+from pathlib import Path
+from typing import Any, Dict, List, Tuple
+
+from conny_runtime_ops import (
+    detect_tunnel_processes,
+    find_pm2_processes,
+    health_payload,
+    instance_runtime_info,
+    port_is_open,
+    python_candidates,
+    resolve_python,
+    rewrite_tunnel_command_port,
+    telegram_webhook_info,
+    write_env_value,
+)
+from conny_tui_select import (
+    BOLD,
+    CYAN,
+    DIM,
+    GREEN,
+    MAGENTA,
+    RESET,
+    WHITE,
+    confirm,
+    select_menu,
+    text_input,
+)
+
+
+def clear_screen() -> None:
+    print("\033[H\033[J", end="")
+
+
+def wait_for_enter() -> None:
+    input(f"\n{DIM}[Presiona Enter para continuar]{RESET}")
+
+
+def _mask(value: str) -> str:
+    value = str(value or "").strip()
+    if not value:
+        return "vacía"
+    if len(value) <= 8:
+        return "*" * len(value)
+    return value[:4] + "…" + value[-4:]
+
+
+def _load_state(instance_name: str) -> Dict[str, Any]:
+    info = instance_runtime_info(instance_name)
+    health = health_payload(info["port"]) or {}
+    pm2_rows = find_pm2_processes(info["name"])
+    python = resolve_python(info["name"])
+    webhook = telegram_webhook_info(info["telegram_token"]) if info["platform"] == "telegram" else {}
+    tunnels = detect_tunnel_processes()
+    return {
+        "info": info,
+        "health": health,
+        "pm2": pm2_rows,
+        "python": python,
+        "webhook": webhook,
+        "tunnels": tunnels,
+    }
+
+
+def _render_header(instance_name: str, subtitle: str) -> None:
+    clear_screen()
+    print(f"┌{'─'*68}┐")
+    print(f"│{BOLD}                    CONNY ULTRA CONFIG v9.7.0                    {RESET}│")
+    print(f"├{'─'*68}┤")
+    print(f"│ {WHITE}{BOLD}Instancia:{RESET} {instance_name or 'base':<57}│")
+    print(f"│ {CYAN}{subtitle:<66}{RESET}│")
+    print(f"└{'─'*68}┘")
+    print()
+
+
+def _provider_env_keys() -> List[Tuple[str, str]]:
+    return [
+        ("GEMINI_API_KEY", "Gemini 1"),
+        ("GEMINI_API_KEY_2", "Gemini 2"),
+        ("GEMINI_API_KEY_3", "Gemini 3"),
+        ("GEMINI_API_KEY_4", "Gemini 4"),
+        ("GEMINI_API_KEY_5", "Gemini 5"),
+        ("GEMINI_API_KEY_6", "Gemini 6"),
+        ("GEMINI_API_KEY_7", "Gemini 7"),
+        ("OPENAI_API_KEY", "OpenAI"),
+        ("OPENROUTER_API_KEY", "OpenRouter"),
+        ("GROQ_API_KEY", "Groq"),
+        ("ANTHROPIC_API_KEY", "Anthropic"),
+        ("BRAVE_API_KEY", "Brave Search"),
+        ("APIFY_API_KEY", "Apify"),
+        ("SERP_API_KEY", "SerpAPI"),
+    ]
+
+
+def _test_provider(provider_key: str, secret: str) -> Tuple[bool, str]:
+    provider_key = provider_key.upper()
+    secret = str(secret or "").strip()
+    if not secret:
+        return False, "sin API key"
+    try:
+        import httpx
+    except Exception:
+        return False, "httpx no disponible"
+    try:
+        with httpx.Client(timeout=12.0) as client:
+            if provider_key.startswith("GEMINI"):
+                response = client.post(
+                    f"https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash:generateContent?key={secret}",
+                    json={"contents": [{"parts": [{"text": "ping"}]}]},
+                )
+            elif provider_key == "OPENAI_API_KEY":
+                response = client.get(
+                    "https://api.openai.com/v1/models",
+                    headers={"Authorization": f"Bearer {secret}"},
+                )
+            elif provider_key == "OPENROUTER_API_KEY":
+                response = client.get(
+                    "https://openrouter.ai/api/v1/models",
+                    headers={"Authorization": f"Bearer {secret}"},
+                )
+            elif provider_key == "GROQ_API_KEY":
+                response = client.get(
+                    "https://api.groq.com/openai/v1/models",
+                    headers={"Authorization": f"Bearer {secret}"},
+                )
+            elif provider_key == "ANTHROPIC_API_KEY":
+                response = client.get(
+                    "https://api.anthropic.com/v1/models",
+                    headers={"x-api-key": secret, "anthropic-version": "2023-06-01"},
+                )
+            elif provider_key == "BRAVE_API_KEY":
+                response = client.get(
+                    "https://api.search.brave.com/res/v1/web/search",
+                    params={"q": "Conny AI"},
+                    headers={"X-Subscription-Token": secret},
+                )
+            elif provider_key == "APIFY_API_KEY":
+                response = client.get(
+                    "https://api.apify.com/v2/users/me",
+                    params={"token": secret},
+                )
+            elif provider_key == "SERP_API_KEY":
+                response = client.get(
+                    "https://serpapi.com/account",
+                    params={"api_key": secret},
+                )
+            else:
+                return False, "proveedor no soportado"
+    except Exception as exc:
+        return False, str(exc)[:90]
+    if response.status_code < 300:
+        return True, f"HTTP {response.status_code}"
+    return False, f"HTTP {response.status_code}"
+
+
+def _sync_telegram_webhook(state: Dict[str, Any]) -> Tuple[bool, str]:
+    info = state["info"]
+    token = info["telegram_token"]
+    base_url = info["base_url"]
+    secret = info["webhook_secret"]
+    if not token or not base_url or not secret:
+        return False, "faltan TELEGRAM_TOKEN, BASE_URL o WEBHOOK_SECRET"
+    target_url = f"{base_url.rstrip('/')}/webhook/{secret}"
+    try:
+        import httpx
+        with httpx.Client(timeout=10.0) as client:
+            response = client.post(
+                f"https://api.telegram.org/bot{token}/setWebhook",
+                json={"url": target_url},
+            )
+        payload = response.json()
+        if response.status_code == 200 and payload.get("ok"):
+            return True, target_url
+        return False, payload.get("description", f"HTTP {response.status_code}")
+    except Exception as exc:
+        return False, str(exc)[:90]
+
+
+def _retarget_tunnels(target_port: int, tunnels: List[Dict[str, Any]]) -> Tuple[bool, str]:
+    changed = 0
+    for tunnel in 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)
+            subprocess.Popen(
+                ["bash", "-lc", f"nohup {new_cmd} >/tmp/conny-tunnel-{tunnel['pid']}.log 2>&1 &"],
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+            )
+            changed += 1
+        except Exception:
+            continue
+    if changed:
+        return True, f"{changed} túnel(es) reorientados a :{target_port}"
+    return False, "no encontré túneles compatibles para reorientar"
+
+
+def module_network(instance_name: str) -> None:
+    state = _load_state(instance_name)
+    info = state["info"]
+    pm2_rows = state["pm2"]
+    tunnels = state["tunnels"]
+    port = info["port"]
+    _render_header(instance_name or "base", "NETWORK MANAGEMENT")
+    pm2_status = pm2_rows[0].get("pm2_env", {}).get("status", "offline") if pm2_rows else "not registered"
+    print(f"{GREEN}Puerto local esperado:{RESET} {port}")
+    print(f"{GREEN}Escucha en localhost:{RESET} {'sí' if port_is_open(port) else 'no'}")
+    print(f"{GREEN}Proceso PM2:{RESET} {info['pm2_name']} ({pm2_status})")
+    print(f"{GREEN}Túneles detectados:{RESET}")
+    if tunnels:
+        for tunnel in tunnels:
+            ports = ", ".join(str(p) for p in tunnel.get("ports", [])) or "sin puerto parseado"
+            print(f"  {DIM}pid={tunnel['pid']} ports={ports} :: {tunnel['command'][:100]}{RESET}")
+    else:
+        print(f"  {DIM}ninguno detectado{RESET}")
+
+    options = [
+        "Cambiar puerto de la instancia",
+        "Reorientar túneles al puerto actual",
+        "Volver",
+    ]
+    choice = select_menu(options, title="Acción de red")
+    if choice == 0:
+        new_port = text_input("Nuevo puerto", default=str(port))
+        if new_port.isdigit():
+            write_env_value(info["env_path"], "PORT", new_port)
+            meta_path = Path(info["root"]) / "instance.json"
+            if meta_path.exists():
+                try:
+                    meta = json.loads(meta_path.read_text(encoding="utf-8"))
+                    meta["port"] = int(new_port)
+                    meta_path.write_text(json.dumps(meta, indent=2, ensure_ascii=False), encoding="utf-8")
+                except Exception:
+                    pass
+            print(f"\n{GREEN}✓ Puerto actualizado a {new_port}. Reinicia la instancia para aplicarlo.{RESET}")
+    elif choice == 1:
+        ok, msg = _retarget_tunnels(port, tunnels)
+        tone = GREEN if ok else MAGENTA
+        print(f"\n{tone}{msg}{RESET}")
+    wait_for_enter()
+
+
+def module_models(instance_name: str) -> None:
+    state = _load_state(instance_name)
+    info = state["info"]
+    env = info["env"]
+    _render_header(instance_name or "base", "MODELS & LLM PROVIDERS")
+    print(f"{GREEN}Modelos activos:{RESET}")
+    print(f"  reasoning: {env.get('LLM_REASONING', 'google/gemini-2.5-pro')}")
+    print(f"  fast:      {env.get('LLM_FAST', 'google/gemini-2.5-flash')}")
+    print(f"  lite:      {env.get('LLM_LITE', 'google/gemini-2.5-flash-lite')}")
+    print()
+    for key, label in _provider_env_keys():
+        print(f"  {label:<14} {DIM}{_mask(env.get(key, ''))}{RESET}")
+    print()
+
+    options = [
+        "Editar API key",
+        "Probar API key",
+        "Cambiar modelo por tier",
+        "Volver",
+    ]
+    choice = select_menu(options, title="Acción de modelos")
+    if choice == 0:
+        idx = select_menu([label for _, label in _provider_env_keys()], title="¿Cuál key quieres editar?")
+        key, label = _provider_env_keys()[idx]
+        current = env.get(key, "")
+        new_value = text_input(f"{label} API key", default=current, is_password=bool(current), required=False)
+        write_env_value(info["env_path"], key, new_value)
+        print(f"\n{GREEN}✓ {label} actualizada{RESET}")
+    elif choice == 1:
+        idx = select_menu([label for _, label in _provider_env_keys()], title="¿Cuál key quieres probar?")
+        key, label = _provider_env_keys()[idx]
+        ok, msg = _test_provider(key, env.get(key, ""))
+        print(f"\n{GREEN if ok else MAGENTA}{label}: {msg}{RESET}")
+    elif choice == 2:
+        tier = select_menu(["LLM_REASONING", "LLM_FAST", "LLM_LITE"], title="Tier")
+        keys = ["LLM_REASONING", "LLM_FAST", "LLM_LITE"]
+        selected = keys[tier]
+        current = env.get(selected, "")
+        new_value = text_input(f"{selected}", default=current or "google/gemini-2.5-flash")
+        write_env_value(info["env_path"], selected, new_value)
+        print(f"\n{GREEN}✓ {selected} actualizado{RESET}")
+    wait_for_enter()
+
+
+def module_gateway(instance_name: str) -> None:
+    state = _load_state(instance_name)
+    info = state["info"]
+    webhook = state["webhook"]
+    _render_header(instance_name or "base", "GATEWAY & WEBHOOKS")
+    expected = f"{info['base_url'].rstrip('/')}/webhook/{info['webhook_secret']}" if info["base_url"] and info["webhook_secret"] else "incompleto"
+    print(f"{GREEN}BASE_URL:{RESET} {info['base_url'] or 'vacío'}")
+    print(f"{GREEN}Webhook esperado:{RESET} {expected}")
+    print(f"{GREEN}Webhook Telegram actual:{RESET} {webhook.get('url', 'sin registrar')}")
+    print(f"{GREEN}Pendientes:{RESET} {webhook.get('pending_update_count', 0)}")
+    if webhook.get("last_error_message"):
+        print(f"{MAGENTA}Último error:{RESET} {webhook['last_error_message']}")
+    print()
+    choice = select_menu(
+        ["Auto-sincronizar webhook", "Editar BASE_URL", "Volver"],
+        title="Acción de gateway",
+    )
+    if choice == 0:
+        ok, msg = _sync_telegram_webhook(state)
+        print(f"\n{GREEN if ok else MAGENTA}{msg}{RESET}")
+    elif choice == 1:
+        new_url = text_input("Nueva BASE_URL", default=info["base_url"], required=False)
+        write_env_value(info["env_path"], "BASE_URL", new_url)
+        print(f"\n{GREEN}✓ BASE_URL actualizada{RESET}")
+    wait_for_enter()
+
+
+def module_environment(instance_name: str) -> None:
+    state = _load_state(instance_name)
+    info = state["info"]
+    _render_header(instance_name or "base", "ENVIRONMENT & PATH TUNING")
+    print(f"{GREEN}Intérprete activo detectado:{RESET} {state['python']['path'] if state['python'] else 'ninguno'}")
+    print(f"{GREEN}Candidatos:{RESET}")
+    candidates = python_candidates(info["name"])
+    for candidate in candidates:
+        marker = "✓" if candidate["exists"] else "·"
+        print(f"  {marker} {candidate['source']:<18} {DIM}{candidate['path']}{RESET}")
+    print()
+    choice = select_menu(
+        ["Fijar intérprete manual para esta instancia", "Verificar run.sh", "Volver"],
+        title="Acción de entorno",
+    )
+    if choice == 0:
+        valid = [c for c in candidates if c["exists"]]
+        if not valid:
+            print(f"\n{MAGENTA}No encontré candidatos válidos.{RESET}")
+        else:
+            idx = select_menu([f"{c['source']} :: {c['path']}" for c in valid], title="Selecciona intérprete")
+            selected = valid[idx]
+            write_env_value(info["env_path"], "CONNY_PYTHON_BIN", selected["path"])
+            print(f"\n{GREEN}✓ CONNY_PYTHON_BIN fijado a {selected['path']}{RESET}")
+    elif choice == 1:
+        run_path = Path(info["root"]) / "run.sh"
+        print(f"\n{GREEN}{run_path}{RESET}")
+        print(run_path.read_text(encoding="utf-8", errors="replace")[:2000] if run_path.exists() else "run.sh no existe")
+    wait_for_enter()
+
+
+def module_doctor(instance_name: str) -> None:
+    _render_header(instance_name or "base", "ADVANCED SYSTEM DOCTOR")
+    print(f"{MAGENTA}Iniciando Self-Healing...{RESET}\n")
+    try:
+        import conny_doctor
+        doctor = conny_doctor.ConnyDoctor(instance_name or "base")
+        asyncio.run(doctor.run_self_healing())
+    except Exception as exc:
+        print(f"{MAGENTA}Error ejecutando doctor: {exc}{RESET}")
+    wait_for_enter()
+
+
+def run_ultra_config(instance_name: str = "") -> None:
+    active = (instance_name or "base").strip()
+    while True:
+        _render_header(active, "CONTROL TOTAL DEL USUARIO")
+        state = _load_state(active)
+        port = state["info"]["port"]
+        health = "online" if state["health"].get("status") == "online" else "offline"
+        print(f"{GREEN}Estado rápido:{RESET} puerto :{port} · health {health} · pm2 {state['info']['pm2_name']}")
+        print()
+        options = [
+            "NETWORK MANAGEMENT",
+            "MODELS & LLM PROVIDERS",
+            "GATEWAY & WEBHOOKS",
+            "ENVIRONMENT & PATH TUNING",
+            "ADVANCED SYSTEM DOCTOR",
+            "SALIR",
+        ]
+        descs = [
+            "Puertos locales, PM2 y túneles públicos",
+            "API keys, pruebas y tiering de modelos",
+            "Webhook esperado, URL activa y resincronización",
+            "Intérprete Python, overrides y run.sh",
+            "Autorreparación de runtime, deps y procesos",
+            "Cerrar configuración",
+        ]
+        choice = select_menu(options, title="Conny config", descriptions=descs)
+        if choice == 0:
+            module_network(active)
+        elif choice == 1:
+            module_models(active)
+        elif choice == 2:
+            module_gateway(active)
+        elif choice == 3:
+            module_environment(active)
+        elif choice == 4:
+            module_doctor(active)
+        else:
+            clear_screen()
+            return
+
+
+if __name__ == "__main__":
+    selected = sys.argv[1] if len(sys.argv) > 1 else ""
+    run_ultra_config(selected)