@innvisor/conny-ai 9.7.0 → 9.8.2

package/conny_runtime_ops.py

@@ -6,18 +6,23 @@ import json
 import os
 import re
 import shutil
+import select
+import shlex
 import socket
 import subprocess
 import sys
+import time
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 
 
 CONNY_HOME = Path(os.getenv("CONNY_HOME", str(Path.home() / ".conny")))
 CONNY_DIR = Path(os.getenv("CONNY_DIR", str(Path(__file__).resolve().parent)))
-INSTANCES_DIR = Path(os.getenv("INSTANCES_DIR", str(Path.home() / "conny-instances")))
+INSTANCES_DIR = Path(os.getenv("INSTANCES_DIR", str(CONNY_HOME / "instances")))
+ACTIVE_INSTANCE_PATH = Path(os.getenv("CONNY_ACTIVE_INSTANCE", str(CONNY_HOME / "active_instance")))
 
 _TUNNEL_PORT_PATTERNS = (
+    re.compile(r"-R\s+\d+:(?:localhost|127\.0\.0\.1|0\.0\.0\.0):(\d+)", re.I),
     re.compile(r"localhost:(\d+)"),
     re.compile(r"127\.0\.0\.1:(\d+)"),
     re.compile(r"0\.0\.0\.0:(\d+)"),
@@ -26,6 +31,30 @@ _TUNNEL_PORT_PATTERNS = (
     re.compile(r"lt\s+--port\s+(\d+)", re.I),
 )
 
+_PUBLIC_URL_PATTERN = re.compile(r"https://[a-zA-Z0-9.-]+(?:lhr\.life|localhost\.run)(?:/[^\s]*)?")
+
+
+_ENV_KEY_PATTERN = re.compile(r"^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=")
+
+
+def _clean_env_value(value: str) -> str:
+    value = str(value or "").strip()
+    if len(value) >= 2 and value[0] == value[-1] and value[0] in {"'", '"'}:
+        value = value[1:-1].strip()
+    if value.lower() in {"pending", "none", "null"}:
+        return ""
+    return value
+
+
+def _format_env_line(key: str, value: str) -> str:
+    value = _clean_env_value(value)
+    if not value:
+        return f"{key}="
+    if any(ch.isspace() for ch in value) or any(ch in value for ch in ['"', "'", "#"]):
+        escaped = value.replace("\\", "\\\\").replace('"', '\\"')
+        return f'{key}="{escaped}"'
+    return f"{key}={value}"
+
 
 def load_env_file(path: Path) -> Dict[str, str]:
     data: Dict[str, str] = {}
@@ -36,7 +65,10 @@ def load_env_file(path: Path) -> Dict[str, str]:
         if not line or line.startswith("#") or "=" not in line:
             continue
         key, value = line.split("=", 1)
-        data[key.strip()] = value.strip().strip('"').strip("'")
+        key = key.strip()
+        if key.startswith("export "):
+            key = key.split(None, 1)[1].strip()
+        data[key] = _clean_env_value(value)
     return data
 
 
@@ -47,22 +79,51 @@ def write_env_value(path: Path, key: str, value: str) -> None:
         lines = path.read_text(encoding="utf-8", errors="replace").splitlines()
     updated: List[str] = []
     for raw_line in lines:
-        if raw_line.strip().startswith(f"{key}="):
-            updated.append(f"{key}={value}")
+        match = _ENV_KEY_PATTERN.match(raw_line)
+        if match and match.group(1) == key:
+            updated.append(_format_env_line(key, value))
             found = True
         else:
             updated.append(raw_line)
     if not found:
         if updated and updated[-1].strip():
             updated.append("")
-        updated.append(f"{key}={value}")
+        updated.append(_format_env_line(key, value))
     path.parent.mkdir(parents=True, exist_ok=True)
     path.write_text("\n".join(updated).rstrip() + "\n", encoding="utf-8")
 
 
+def active_instance_name() -> str:
+    explicit = os.getenv("CONNY_INSTANCE", "").strip()
+    if explicit:
+        return explicit
+    if ACTIVE_INSTANCE_PATH.exists():
+        return ACTIVE_INSTANCE_PATH.read_text(encoding="utf-8", errors="replace").strip()
+    return ""
+
+
+def set_active_instance(instance_name: str) -> None:
+    instance_name = str(instance_name or "").strip()
+    if not instance_name:
+        return
+    ACTIVE_INSTANCE_PATH.parent.mkdir(parents=True, exist_ok=True)
+    ACTIVE_INSTANCE_PATH.write_text(instance_name + "\n", encoding="utf-8")
+
+
 def instance_root(instance_name: str) -> Path:
     normalized = (instance_name or "").strip()
-    if normalized in {"", "base", "conny", "default"}:
+    if normalized == "base":
+        return CONNY_DIR
+    if normalized in {"", "conny", "default"}:
+        active = active_instance_name()
+        if active:
+            active_root = INSTANCES_DIR / active
+            if active_root.exists():
+                return active_root
+        if normalized in {"conny", "default"}:
+            candidate = INSTANCES_DIR / normalized
+            if candidate.exists():
+                return candidate
         return CONNY_DIR
     return INSTANCES_DIR / normalized
 
@@ -98,6 +159,64 @@ def instance_runtime_info(instance_name: str) -> Dict[str, Any]:
     }
 
 
+MIRRORED_ENV_KEYS = {
+    "INSTANCE_ID",
+    "PORT",
+    "HOST",
+    "BASE_URL",
+    "PUBLIC_BASE_URL",
+    "DASHBOARD_URL",
+    "PUBLIC_DASHBOARD_URL",
+    "DEMO_MODE",
+    "PLATFORM",
+    "SECTOR",
+    "BUSINESS_NAME",
+    "WEBHOOK_SECRET",
+    "TUNNEL_PROVIDER",
+    "TUNNEL_PID",
+    "TUNNEL_COMMAND",
+    "TELEGRAM_TOKEN",
+    "LLM_PROVIDER",
+    "LLM_MODEL",
+    "LLM_REASONING",
+    "LLM_FAST",
+    "LLM_LITE",
+    "CUSTOM_API_BASE",
+    "OPENAI_API_KEY",
+    "ANTHROPIC_API_KEY",
+    "GEMINI_API_KEY",
+    "GEMINI_API_KEY_2",
+    "GEMINI_API_KEY_3",
+    "GEMINI_API_KEY_4",
+    "GEMINI_API_KEY_5",
+    "GEMINI_API_KEY_6",
+    "GEMINI_API_KEY_7",
+    "GROQ_API_KEY",
+    "OPENROUTER_API_KEY",
+    "BRAVE_API_KEY",
+    "APIFY_API_KEY",
+    "SERP_API_KEY",
+    "WA_CLOUD_TOKEN",
+    "WA_PHONE_NUMBER_ID",
+    "CONNY_PYTHON_BIN",
+}
+
+
+def mirror_instance_env_to_base(instance_name: str) -> None:
+    info = instance_runtime_info(instance_name)
+    if info["root"] == CONNY_DIR:
+        return
+    env = load_env_file(info["env_path"])
+    if not env:
+        return
+    base_env_path = CONNY_DIR / ".env"
+    for key in sorted(MIRRORED_ENV_KEYS):
+        if key in env:
+            write_env_value(base_env_path, key, env.get(key, ""))
+    write_env_value(base_env_path, "ACTIVE_INSTANCE", info["name"])
+    set_active_instance(info["name"])
+
+
 def port_is_open(port: int, host: str = "127.0.0.1", timeout: float = 0.5) -> bool:
     try:
         with socket.create_connection((host, int(port)), timeout=timeout):
@@ -186,6 +305,7 @@ def extract_tunnel_target_ports(command_line: str) -> List[int]:
 def rewrite_tunnel_command_port(command_line: str, new_port: int) -> str:
     updated = str(command_line or "")
     replacements = [
+        (re.compile(r"(-R\s+\d+:(?:localhost|127\.0\.0\.1|0\.0\.0\.0):)(\d+)", re.I), rf"\g<1>{int(new_port)}"),
         (re.compile(r"(localhost:)(\d+)"), rf"\g<1>{int(new_port)}"),
         (re.compile(r"(127\.0\.0\.1:)(\d+)"), rf"\g<1>{int(new_port)}"),
         (re.compile(r"(0\.0\.0\.0:)(\d+)"), rf"\g<1>{int(new_port)}"),
@@ -200,6 +320,78 @@ def rewrite_tunnel_command_port(command_line: str, new_port: int) -> str:
     return updated
 
 
+def localhost_run_command(port: int) -> List[str]:
+    return [
+        "ssh",
+        "-o", "StrictHostKeyChecking=no",
+        "-o", "UserKnownHostsFile=/dev/null",
+        "-o", "ServerAliveInterval=60",
+        "-N",
+        "-R", f"80:localhost:{int(port)}",
+        "nokey@localhost.run",
+    ]
+
+
+def start_localhost_run_tunnel(port: int, timeout: float = 25.0) -> Dict[str, Any]:
+    if not shutil.which("ssh"):
+        return {"ok": False, "url": "", "pid": None, "error": "ssh no está instalado"}
+    command = localhost_run_command(port)
+    try:
+        proc = subprocess.Popen(
+            command,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            bufsize=1,
+            start_new_session=True,
+        )
+    except Exception as exc:
+        return {"ok": False, "url": "", "pid": None, "error": str(exc)}
+
+    deadline = time.time() + float(timeout)
+    output: List[str] = []
+    stream = proc.stdout
+    while time.time() < deadline:
+        if proc.poll() is not None:
+            break
+        if stream is None:
+            time.sleep(0.25)
+            continue
+        try:
+            ready, _, _ = select.select([stream], [], [], 0.5)
+        except Exception:
+            ready = []
+        if not ready:
+            continue
+        line = stream.readline()
+        if not line:
+            continue
+        output.append(line.rstrip())
+        match = _PUBLIC_URL_PATTERN.search(line)
+        if match:
+            return {
+                "ok": True,
+                "url": match.group(0).rstrip("/"),
+                "pid": proc.pid,
+                "command": shlex.join(command),
+                "port": int(port),
+                "output": "\n".join(output[-10:]),
+            }
+
+    try:
+        proc.terminate()
+    except Exception:
+        pass
+    return {
+        "ok": False,
+        "url": "",
+        "pid": proc.pid,
+        "command": shlex.join(command),
+        "port": int(port),
+        "error": "\n".join(output[-10:]) or f"no public URL received after {int(timeout)}s",
+    }
+
+
 def detect_tunnel_processes() -> List[Dict[str, Any]]:
     try:
         result = subprocess.run(

package/conny_tui.py

@@ -30,6 +30,13 @@ CONNY_DIR   = os.getenv("CONNY_DIR",   str(Path(__file__).resolve().parent))
 INSTANCES_DIR = os.getenv("INSTANCES_DIR", str(Path.home() / "conny-instances"))
 CLI_SCRIPT    = os.getenv("CONNY_CLI",   str(Path(__file__).resolve().parent / "conny_cli.py"))
 
+try:
+    _package_path = Path(CONNY_DIR) / "package.json"
+    if _package_path.exists():
+        VERSION = json.loads(_package_path.read_text(encoding="utf-8")).get("version", VERSION)
+except Exception:
+    pass
+
 # ── Colores curses (índices de par) ─────────────────────────────────────────
 CP_LOGO1  = 1   # Rosa — letras CONNY (gradiente línea 1)
 CP_LOGO2  = 10  # Rosa claro (gradiente línea 2)

package/conny_ultra_config.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-"""CONNY ULTRA CONFIG v9.7.0 — interactive runtime control panel."""
+"""Interactive runtime control panel for Conny."""
 from __future__ import annotations
 
 import asyncio
@@ -15,6 +15,7 @@ from conny_runtime_ops import (
     find_pm2_processes,
     health_payload,
     instance_runtime_info,
+    mirror_instance_env_to_base,
     port_is_open,
     python_candidates,
     resolve_python,
@@ -70,14 +71,19 @@ def _load_state(instance_name: str) -> Dict[str, Any]:
     }
 
 
+def _mirror_if_needed(info: Dict[str, Any]) -> None:
+    if info["name"] == "base":
+        return
+    try:
+        mirror_instance_env_to_base(info["name"])
+    except Exception:
+        pass
+
+
 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(f"{MAGENTA}{BOLD}Conny Config{RESET}  {DIM}· {instance_name or 'base'} · {subtitle}{RESET}")
+    print(f"{DIM}{'─' * 60}{RESET}")
     print()
 
 
@@ -162,7 +168,7 @@ def _test_provider(provider_key: str, secret: str) -> Tuple[bool, str]:
 
 
 def _sync_telegram_webhook(state: Dict[str, Any]) -> Tuple[bool, str]:
-    info = state["info"]
+    info = instance_runtime_info(state["info"]["name"])
     token = info["telegram_token"]
     base_url = info["base_url"]
     secret = info["webhook_secret"]
@@ -170,6 +176,8 @@ def _sync_telegram_webhook(state: Dict[str, Any]) -> Tuple[bool, str]:
         return False, "faltan TELEGRAM_TOKEN, BASE_URL o WEBHOOK_SECRET"
     target_url = f"{base_url.rstrip('/')}/webhook/{secret}"
     try:
+        if info.get("pm2_name"):
+            subprocess.run(["pm2", "restart", info["pm2_name"], "--update-env"], capture_output=True, check=False, timeout=20)
         import httpx
         with httpx.Client(timeout=10.0) as client:
             response = client.post(
@@ -235,6 +243,7 @@ def module_network(instance_name: str) -> None:
         new_port = text_input("Nuevo puerto", default=str(port))
         if new_port.isdigit():
             write_env_value(info["env_path"], "PORT", new_port)
+            _mirror_if_needed(info)
             meta_path = Path(info["root"]) / "instance.json"
             if meta_path.exists():
                 try:
@@ -278,6 +287,7 @@ def module_models(instance_name: str) -> None:
         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)
+        _mirror_if_needed(info)
         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?")
@@ -291,6 +301,7 @@ def module_models(instance_name: str) -> None:
         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)
+        _mirror_if_needed(info)
         print(f"\n{GREEN}✓ {selected} actualizado{RESET}")
     wait_for_enter()
 
@@ -318,6 +329,8 @@ def module_gateway(instance_name: str) -> None:
     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)
+        write_env_value(info["env_path"], "PUBLIC_BASE_URL", new_url)
+        _mirror_if_needed(info)
         print(f"\n{GREEN}✓ BASE_URL actualizada{RESET}")
     wait_for_enter()
 
@@ -345,6 +358,7 @@ def module_environment(instance_name: str) -> None:
             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"])
+            _mirror_if_needed(info)
             print(f"\n{GREEN}✓ CONNY_PYTHON_BIN fijado a {selected['path']}{RESET}")
     elif choice == 1:
         run_path = Path(info["root"]) / "run.sh"
@@ -358,7 +372,7 @@ def module_doctor(instance_name: str) -> None:
     print(f"{MAGENTA}Iniciando Self-Healing...{RESET}\n")
     try:
         import conny_doctor
-        doctor = conny_doctor.ConnyDoctor(instance_name or "base")
+        doctor = conny_doctor.ConnyDoctor(instance_name or "conny")
         asyncio.run(doctor.run_self_healing())
     except Exception as exc:
         print(f"{MAGENTA}Error ejecutando doctor: {exc}{RESET}")
@@ -366,9 +380,9 @@ def module_doctor(instance_name: str) -> None:
 
 
 def run_ultra_config(instance_name: str = "") -> None:
-    active = (instance_name or "base").strip()
+    active = (instance_name or "conny").strip()
     while True:
-        _render_header(active, "CONTROL TOTAL DEL USUARIO")
+        _render_header(active, "Runtime overview")
         state = _load_state(active)
         port = state["info"]["port"]
         health = "online" if state["health"].get("status") == "online" else "offline"

package/conny_utils.py

@@ -6,12 +6,21 @@ import re
 from typing import Any, Dict, List, Optional
 
 ACTIVATION_PREFIX = "ACTV-"
+ADMIN_ACTIVATION_PREFIX = "ADMN-"
 INVITE_PREFIX = "JINV-"
 
 def is_activation_token(text: str) -> bool:
     """Detecta si el mensaje es un token de activacion."""
     t = text.strip().upper()
-    return t.startswith(ACTIVATION_PREFIX) and len(t) >= 30
+    return (
+        (t.startswith(ACTIVATION_PREFIX) and len(t) >= 30)
+        or is_admin_activation_token(t)
+    )
+
+def is_admin_activation_token(text: str) -> bool:
+    """Detecta tokens de Conny Pro Admin."""
+    t = text.strip().upper()
+    return t.startswith(ADMIN_ACTIVATION_PREFIX) and len(t) >= 30
 
 def is_invite_token(text: str) -> bool:
     """Detecta si el mensaje es un token de invitacion."""
@@ -24,12 +33,21 @@ def generate_activation_token(label: str) -> str:
     Formato: ACTV-[label_sanitizado]-[32_chars_hex]
     """
     import string
-    sanitized = re.sub(r'[^a-zA-Z0-9]', '', label.lower())[:10]
+    sanitized = re.sub(r'[^a-zA-Z0-9]', '', label.lower())[:10].upper()
     if not sanitized:
-        sanitized = "generic"
+        sanitized = "GENERIC"
     entropy = secrets.token_hex(16).upper()
     return f"{ACTIVATION_PREFIX}{sanitized}-{entropy}"
 
+def generate_admin_activation_token(label: str) -> str:
+    """
+    Genera un token de activacion para Conny Pro Admin.
+    Este token activa una cuenta operadora, no una conversacion de cliente.
+    """
+    sanitized = (re.sub(r'[^a-zA-Z0-9]', '', label.lower())[:10] or "admin").upper()
+    entropy = secrets.token_hex(18).upper()
+    return f"{ADMIN_ACTIVATION_PREFIX}{sanitized}-{entropy}"
+
 def hash_password(password: str) -> str:
     """Hash de contrasena con PBKDF2 + salt."""
     salt = secrets.token_hex(16)

package/ecosystem.config.js

@@ -10,6 +10,16 @@ module.exports = {
       error_file: "/home/ubuntu/conny/logs/conny-error.log",
       watch: false,
     },
+    {
+      name: "whatsapp-bridge",
+      script: "/home/ubuntu/whatsapp-bridge/start.sh",
+      cwd: "/home/ubuntu/whatsapp-bridge",
+      restart_delay: 3000,
+      max_restarts: 10,
+      out_file: "/home/ubuntu/whatsapp-bridge/logs/bridge.log",
+      error_file: "/home/ubuntu/whatsapp-bridge/logs/bridge-error.log",
+      watch: false,
+    },
     {
       name: "conny-clinica-de-las-americas",
       script: "/home/ubuntu/conny-instances/clinica-de-las-americas/run.sh",
@@ -21,4 +31,4 @@ module.exports = {
       watch: false,
     }
   ]
-}
+};

package/install.sh

@@ -6,11 +6,54 @@ set -e
 C_PRIMARY="\033[38;5;135m"
 C_SUCCESS="\033[38;5;46m"
 C_MUTED="\033[38;5;240m"
+C_WARN="\033[38;5;214m"
 BOLD="\033[1m"
 RESET="\033[0m"
 
-echo -e "\n  ${C_PRIMARY}${BOLD}✦ Conny AI - Ultimate Installer${RESET}"
-echo -e "  ${C_MUTED}─────────────────────────────────────────${RESET}"
+echo -e "\n  ${C_PRIMARY}${BOLD}✦ Conny AI Installer${RESET}"
+echo -e "  ${C_MUTED}Production-ready AI receptionist runtime for WhatsApp and Telegram.${RESET}"
+echo -e "  ${C_MUTED}────────────────────────────────────────────────────────${RESET}"
+
+TMP_LOGS=()
+
+cleanup_logs() {
+    for log_file in "${TMP_LOGS[@]}"; do
+        [ -f "$log_file" ] && rm -f "$log_file"
+    done
+}
+trap cleanup_logs EXIT
+
+run_with_activity() {
+    local label="$1"
+    shift
+    local log_file
+    log_file="$(mktemp)"
+    TMP_LOGS+=("$log_file")
+
+    echo -ne "  ${C_PRIMARY}⠋${RESET} ${label}"
+    "$@" >"$log_file" 2>&1 &
+    local pid=$!
+    local frames=("⠋" "⠙" "⠹" "⠸" "⠼" "⠴" "⠦" "⠧" "⠇" "⠏")
+    local i=0
+    local elapsed=0
+
+    while kill -0 "$pid" 2>/dev/null; do
+        printf "\r  ${C_PRIMARY}%s${RESET} %s ${C_MUTED}(%ss)${RESET}" "${frames[$((i % ${#frames[@]}))]}" "$label" "$elapsed"
+        sleep 1
+        i=$((i + 1))
+        elapsed=$((elapsed + 1))
+    done
+
+    if wait "$pid"; then
+        printf "\r  ${C_SUCCESS}✓${RESET} %s ${C_MUTED}(%ss)${RESET}\n" "$label" "$elapsed"
+        return 0
+    fi
+
+    printf "\r  \033[31m✕${RESET} %s\n" "$label"
+    echo -e "  \033[31mCommand failed. Installer log:${RESET}"
+    sed 's/^/    /' "$log_file"
+    return 1
+}
 
 # Handle sudo gracefully (Termux / Root environments)
 SUDO=""
@@ -18,20 +61,22 @@ if command -v sudo &> /dev/null; then
     SUDO="sudo"
 fi
 
-# 1. Install chafa if possible
+# 1. Install chafa if possible. In Termux/proot, `pkg` exists but cannot run as root.
 if ! command -v chafa &> /dev/null; then
-    echo -e "\n  ${BOLD}1. Instalando motor True-Color (chafa)...${RESET}"
-    if command -v pkg &> /dev/null; then
-        pkg install -y chafa || true
+    echo -e "\n  ${BOLD}1. Preparing terminal visuals${RESET}"
+    CURRENT_UID="$(id -u 2>/dev/null || echo 1)"
+    if command -v pkg &> /dev/null && [ "$CURRENT_UID" != "0" ]; then
+        run_with_activity "Installing optional True-Color renderer with pkg" pkg install -y chafa || true
     elif command -v apt-get &> /dev/null; then
-        $SUDO apt-get update -yqq && $SUDO apt-get install -yqq chafa || true
+        run_with_activity "Installing optional True-Color renderer with apt" bash -c "$SUDO apt-get update -yqq && $SUDO apt-get install -yqq chafa" || true
     elif command -v brew &> /dev/null; then
-        brew install chafa || true
+        run_with_activity "Installing optional True-Color renderer with Homebrew" brew install chafa || true
     else
-        echo -e "  ${C_MUTED}No se pudo instalar chafa automáticamente. Se usará el logo clásico.${RESET}"
+        echo -e "  ${C_WARN}!${RESET} Optional renderer not available. Conny will use the classic logo."
     fi
 else
-    echo -e "\n  ${BOLD}1. Motor True-Color detectado (chafa).${RESET}"
+    echo -e "\n  ${BOLD}1. Terminal visuals ready${RESET}"
+    echo -e "  ${C_SUCCESS}✓${RESET} True-Color renderer detected."
 fi
 
 # 2. Verify Python sanely (3.9+), without hardcoding minor versions
@@ -51,28 +96,39 @@ done
 
 if [ -n "$PYTHON_BIN" ]; then
     PY_VERSION="$($PYTHON_BIN -c 'import sys; print(".".join(map(str, sys.version_info[:3])))')"
-    echo -e "\n  ${BOLD}2. Python detectado:${RESET} ${C_SUCCESS}${PYTHON_BIN} (${PY_VERSION})${RESET}"
+    echo -e "\n  ${BOLD}2. Runtime compatibility${RESET}"
+    echo -e "  ${C_SUCCESS}✓${RESET} Python runtime detected: ${C_SUCCESS}${PYTHON_BIN} ${PY_VERSION}${RESET}"
 else
-    echo -e "\n  ${BOLD}2. Python 3.9+ no detectado localmente.${RESET}"
-    echo -e "  ${C_MUTED}Conny intentará crear su runtime cuando se ejecute por primera vez.${RESET}"
+    echo -e "\n  ${BOLD}2. Runtime compatibility${RESET}"
+    echo -e "  ${C_WARN}!${RESET} Python 3.9+ was not detected locally."
+    echo -e "  ${C_MUTED}Conny will try to provision its isolated runtime on first launch.${RESET}"
 fi
 
 # 3. Install NPM Package
 if ! command -v npm &> /dev/null; then
-    echo -e "\n  \033[31mError: Node.js y npm son requeridos. Instálalos primero.\033[0m"
+    echo -e "\n  \033[31mError: Node.js and npm are required before installing Conny.\033[0m"
     exit 1
 fi
 
-echo -e "\n  ${BOLD}3. Limpiando versiones anteriores...${RESET}"
-npm uninstall -g conny-ai @blackboss/conny || true
+echo -e "\n  ${BOLD}3. Removing previous global builds${RESET}"
+run_with_activity "Cleaning old Conny packages" npm uninstall -g conny-ai @innvisor/conny-ai @blackboss/conny || true
 
-echo -e "\n  ${BOLD}4. Instalando Conny CLI y Motor AI...${RESET}"
-npm install -g "${CONNY_INSTALL_PACKAGE:-conny-ai@latest}"
+echo -e "\n  ${BOLD}4. Installing Conny from GitHub${RESET}"
+echo -e "  ${C_MUTED}Source: ${CONNY_INSTALL_PACKAGE:-github:sxrubyo/conny#main}${RESET}"
+run_with_activity "Downloading and linking Conny CLI" npm install -g "${CONNY_INSTALL_PACKAGE:-github:sxrubyo/conny#main}"
 
-echo -e "\n  ${BOLD}5. Verificando bootstrap del CLI...${RESET}"
+echo -e "\n  ${BOLD}5. Verifying the command line experience${RESET}"
 if command -v conny >/dev/null 2>&1; then
-    conny --version || true
+    if ! conny --version; then
+        echo -e "\n  \033[31mError: Conny was installed, but the CLI could not start.\033[0m"
+        exit 1
+    fi
+    run_with_activity "Preparing Python runtime and required CLI packages" conny --bootstrap-check
+else
+    echo -e "\n  \033[31mError: npm finished, but the 'conny' command is not available in PATH.\033[0m"
+    exit 1
 fi
 
-echo -e "\n  ${C_SUCCESS}${BOLD}✔ ¡Conny instalado con éxito!${RESET}"
-echo -e "  Ejecuta ${C_PRIMARY}conny init${RESET} en tu terminal para empezar la magia.\n"
+echo -e "\n  ${C_SUCCESS}${BOLD}✓ Conny is installed and ready.${RESET}"
+echo -e "  Start your first guided setup with ${C_PRIMARY}conny init${RESET}."
+echo -e "  For system repair and diagnostics, run ${C_PRIMARY}conny doctor --fix${RESET}.\n"