@innvisor/conny-ai 9.7.0 → 9.8.2

package/conny_init.py

@@ -12,13 +12,75 @@ import shutil
 import urllib.request
 import urllib.error
 import subprocess
+import socket
 from deep_translator import GoogleTranslator
 
-CURRENT_LANG = 'es'
+CURRENT_LANG = os.environ.get("CONNY_INIT_LANG", "en").lower()
+
+TRANSLATIONS = {
+    "en": {
+        "Selección de idioma": "Language selection",
+        "Idioma preferido para Conny": "Preferred language for Conny",
+        "¿Comenzar configuración?": "Start guided setup?",
+        "Operación cancelada.": "Setup cancelled.",
+        "Tiempo estimado: ~3 min": "Estimated time: ~3 min",
+        "Identidad": "Identity",
+        "Nombre del negocio": "Business name",
+        "Dominio e Industria": "Domain and industry",
+        "Sector Principal": "Primary sector",
+        "Canales de Conectividad": "Connectivity channels",
+        "Canal Principal de Acceso": "Primary access channel",
+        "Gateway público": "Public gateway",
+        "¿Cómo deseas configurar el enlace público (BASE_URL)?": "How do you want to configure the public link (BASE_URL)?",
+        "Generar túnel automático (localhost.run)": "Generate automatic tunnel (localhost.run)",
+        "Configurar enlace manualmente (ingresar URL personalizada)": "Configure manually (enter a custom URL)",
+        "Introduce la URL pública de tu webhook": "Enter your public webhook URL",
+        "Levantando túnel seguro hacia localhost.run...": "Starting secure tunnel through localhost.run...",
+        "Túnel activo:": "Tunnel active:",
+        "No pude obtener un túnel automático. Ingresa una URL manual.": "I could not get an automatic tunnel. Enter a manual URL.",
+        "Dashboard web": "Web dashboard",
+        "¿Cómo quieres exponer la página web de Conny?": "How do you want to expose Conny's web dashboard?",
+        "Solo local (localhost)": "Local only (localhost)",
+        "Red/IP externa de este dispositivo": "Network/external IP for this device",
+        "URL pública personalizada": "Custom public URL",
+        "No configurar dashboard ahora": "Do not configure dashboard now",
+        "Introduce la URL pública del dashboard": "Enter the public dashboard URL",
+        "Motor de Inteligencia": "Intelligence engine",
+        "Tipo de proveedor": "Provider type",
+        "Proveedor Cloud": "Cloud provider",
+        "Modelo Específico": "Specific model",
+        "Modelo de Ollama": "Ollama model",
+        "Modelo NIM": "NIM model",
+        "Humanización y Tono": "Humanization and tone",
+        "Perfil de Voz": "Voice profile",
+        "Infraestructura y Secretos": "Infrastructure and secrets",
+        "Verificación Final": "Final verification",
+        "¿Procesar e Implementar Infraestructura?": "Provision and deploy infrastructure?",
+        "Cancelado.": "Cancelled.",
+        "Creando recursos...": "Creating resources...",
+        "Resumen de Configuración": "Configuration summary",
+        "Negocio:": "Business:",
+        "Sector:": "Sector:",
+        "Canal:": "Channel:",
+        "Proveedor:": "Provider:",
+        "Modelo:": "Model:",
+        "Voz:": "Voice:",
+        "Secretos:": "Secrets:",
+        "Directorio:": "Directory:",
+        "Control:": "Control:",
+        "Check:": "Check:",
+        "Lanzar:": "Launch:",
+        "Infraestructura Desplegada Exitosamente": "Infrastructure deployed successfully",
+        "Validando API key...": "Validating API key...",
+        "✅ API key validada correctamente.": "✅ API key validated successfully.",
+    }
+}
 
 def _t(text):
     if CURRENT_LANG == 'es' or not text:
         return text
+    if CURRENT_LANG in TRANSLATIONS and text in TRANSLATIONS[CURRENT_LANG]:
+        return TRANSLATIONS[CURRENT_LANG][text]
     try:
         # Limpiar texto de colores si es necesario, o traducir directo
         return GoogleTranslator(source='es', target=CURRENT_LANG).translate(text)
@@ -30,6 +92,12 @@ from datetime import datetime
 sys.path.insert(0, str(Path(__file__).parent))
 
 from conny_tui_select import select_menu as _orig_select_menu, confirm as _orig_confirm, text_input as _orig_text_input
+try:
+    from conny_runtime_ops import mirror_instance_env_to_base, set_active_instance, start_localhost_run_tunnel
+except Exception:
+    mirror_instance_env_to_base = None
+    set_active_instance = None
+    start_localhost_run_tunnel = None
 
 def select_menu(options, title="", **kwargs):
     if title: title = _t(title)
@@ -61,7 +129,8 @@ C_ACCENT  = "\033[38;5;159m"         # Cyan
 B1 = "\033[1m"
 R = "\033[0m"
 
-INSTANCES_DIR = Path(os.environ.get("INSTANCES_DIR", str(Path.home() / ".conny-instances")))
+CONNY_HOME = Path(os.environ.get("CONNY_HOME", str(Path.home() / ".conny")))
+INSTANCES_DIR = Path(os.environ.get("INSTANCES_DIR", str(CONNY_HOME / "instances")))
 CONNY_DIR = Path(os.environ.get("CONNY_DIR", os.path.dirname(os.path.abspath(__file__))))
 
 SECTORS = [
@@ -93,8 +162,8 @@ TONES = [
 ]
 
 LANGUAGES = [
-    ("es", "Español"),
     ("en", "English"),
+    ("es", "Español"),
     ("pt", "Português"),
 ]
 
@@ -138,13 +207,124 @@ def check_gpu():
 
 def validate_api_key(provider, key):
     # Dummy validation with spinner
-    sys.stdout.write(f"  {C_MUTED}Validando API key...{R}")
+    sys.stdout.write(f"  {C_MUTED}{_t('Validando API key...')}{R}")
     sys.stdout.flush()
     time.sleep(1.5)
-    sys.stdout.write(f"\r  {C_SUCCESS}✅ API key validada correctamente.{R}       \n")
+    sys.stdout.write(f"\r  {C_SUCCESS}{_t('✅ API key validada correctamente.')}{R}       \n")
     return True
 
 
+def _persist_language(lang: str) -> None:
+    try:
+        workspace_config_path = Path(os.environ.get("CONNY_WORKSPACE_CONFIG", str(CONNY_HOME / "config.json")))
+        workspace_config_path.parent.mkdir(parents=True, exist_ok=True)
+        payload = {}
+        if workspace_config_path.exists():
+            try:
+                payload = json.loads(workspace_config_path.read_text(encoding="utf-8"))
+                if not isinstance(payload, dict):
+                    payload = {}
+            except Exception:
+                payload = {}
+        payload["language"] = lang
+        payload["ui_language"] = lang
+        workspace_config_path.write_text(json.dumps(payload, indent=2, ensure_ascii=False), encoding="utf-8")
+    except Exception:
+        pass
+
+
+def _next_available_port() -> int:
+    existing_ports = []
+    if INSTANCES_DIR.exists():
+        for d in INSTANCES_DIR.iterdir():
+            env = d / ".env"
+            if not env.exists():
+                continue
+            for line in env.read_text(encoding="utf-8", errors="replace").splitlines():
+                if line.startswith("PORT="):
+                    try:
+                        existing_ports.append(int(line.split("=", 1)[1].strip()))
+                    except Exception:
+                        pass
+    return max(existing_ports + [8003]) + 1
+
+
+def _configure_gateway(port: int) -> dict:
+    options = [
+        "Generar túnel automático (localhost.run)",
+        "Configurar enlace manualmente (ingresar URL personalizada)",
+    ]
+    choice = select_menu(options, title="¿Cómo deseas configurar el enlace público (BASE_URL)?")
+    if choice == 0 and start_localhost_run_tunnel:
+        print(f"\n  {C_MUTED}{_t('Levantando túnel seguro hacia localhost.run...')}{R}")
+        result = start_localhost_run_tunnel(port)
+        if result.get("ok") and result.get("url"):
+            print(f"  {C_SUCCESS}✓ {_t('Túnel activo:')} {result['url']}{R}")
+            return {
+                "mode": "localhost.run",
+                "base_url": str(result["url"]).rstrip("/"),
+                "tunnel_pid": str(result.get("pid") or ""),
+                "tunnel_command": str(result.get("command") or ""),
+            }
+        print(f"  {C_WARNING}⚠ {_t('No pude obtener un túnel automático. Ingresa una URL manual.')}{R}")
+
+    base_url = text_input(
+        "Introduce la URL pública de tu webhook",
+        default=os.environ.get("BASE_URL", ""),
+        required=False,
+    ).strip()
+    return {
+        "mode": "manual",
+        "base_url": base_url.rstrip("/"),
+        "tunnel_pid": "",
+        "tunnel_command": "",
+    }
+
+
+def _local_ip() -> str:
+    try:
+        with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as sock:
+            sock.connect(("8.8.8.8", 80))
+            return sock.getsockname()[0]
+    except Exception:
+        return "127.0.0.1"
+
+
+def _configure_dashboard(port: int) -> dict:
+    options = [
+        "Solo local (localhost)",
+        "Red/IP externa de este dispositivo",
+        "URL pública personalizada",
+        "No configurar dashboard ahora",
+    ]
+    choice = select_menu(options, title="¿Cómo quieres exponer la página web de Conny?")
+    if choice == 0:
+        return {
+            "host": "127.0.0.1",
+            "dashboard_url": f"http://localhost:{port}/dashboard",
+            "public_dashboard_url": "",
+        }
+    if choice == 1:
+        ip = _local_ip()
+        return {
+            "host": "0.0.0.0",
+            "dashboard_url": f"http://{ip}:{port}/dashboard",
+            "public_dashboard_url": f"http://{ip}:{port}/dashboard",
+        }
+    if choice == 2:
+        url = text_input("Introduce la URL pública del dashboard", default="", required=False).strip().rstrip("/")
+        return {
+            "host": "0.0.0.0",
+            "dashboard_url": url,
+            "public_dashboard_url": url,
+        }
+    return {
+        "host": "127.0.0.1",
+        "dashboard_url": "",
+        "public_dashboard_url": "",
+    }
+
+
 def run_wizard():
 
     clear()
@@ -198,27 +378,27 @@ def run_wizard():
         print(f"  {line}")
 
     print()
-    print(f"  {C_PRIMARY}{B1}Conny CLI {VERSION}{R} · {C_ACCENT}Autonomous Dynamic Receptionist{R} · {C_MUTED}⏱ Tiempo estimado: ~3 min{R}")
+    print(f"  {C_PRIMARY}{B1}Conny CLI {VERSION}{R} · {C_ACCENT}Autonomous Dynamic Receptionist{R} · {C_MUTED}⏱ {_t('Tiempo estimado: ~3 min')}{R}")
     print(f"  {C_MUTED}{'─' * 70}{R}")
     print()
 
 
 
     if not confirm("¿Comenzar configuración?"):
-        print(f"\n  {C_MUTED}Operación cancelada.{R}\n")
+        print(f"\n  {C_MUTED}{_t('Operación cancelada.')}{R}\n")
         return
 
-    TOTAL_STEPS = 7
+    TOTAL_STEPS = 9
     ctx = ""
 
     # 0. Language (Optional pre-step)
     clear()
     print(f"\n  {C_PRIMARY}🌐 {_t('Selección de idioma')}{R}")
     i = select_menu([l[1] for l in LANGUAGES], title="Idioma preferido para Conny")
-    i = select_menu([l[1] for l in LANGUAGES], title="Idioma preferido para Conny")
     lang = LANGUAGES[i][0]
     global CURRENT_LANG
     CURRENT_LANG = lang
+    _persist_language(lang)
 
     # 1. Identity
     clear()
@@ -241,9 +421,20 @@ def run_wizard():
     i = select_menu([c[1] for c in CHANNELS], title="Canal Principal de Acceso")
     channel = CHANNELS[i][0]
 
-    # 4. Intelligence
+    # 4. Gateway / Webhook
+    port = _next_available_port()
     clear()
-    step_header(4, TOTAL_STEPS, "Motor de Inteligencia", ctx)
+    step_header(4, TOTAL_STEPS, "Gateway público", f"{ctx}Canal: {channel} | Puerto: {port}")
+    gateway = _configure_gateway(port)
+
+    # 5. Web dashboard
+    clear()
+    step_header(5, TOTAL_STEPS, "Dashboard web", f"{ctx}Puerto: {port}")
+    dashboard = _configure_dashboard(port)
+
+    # 6. Intelligence
+    clear()
+    step_header(6, TOTAL_STEPS, "Motor de Inteligencia", ctx)
     
     # Level 1
     llm_types = [
@@ -322,15 +513,15 @@ def run_wizard():
         provider_id = "manual"
         model_id = text_input("Model ID")
 
-    # 5. Personality
+    # 7. Personality
     clear()
-    step_header(5, TOTAL_STEPS, "Humanización y Tono", ctx)
+    step_header(7, TOTAL_STEPS, "Humanización y Tono", ctx)
     i = select_menu([t[1] for t in TONES], title="Perfil de Voz")
     tone = TONES[i][0]
 
-    # 6. Credentials
+    # 8. Credentials
     clear()
-    step_header(6, TOTAL_STEPS, "Infraestructura y Secretos", ctx)
+    step_header(8, TOTAL_STEPS, "Infraestructura y Secretos", ctx)
 
     secrets_map = {}
 
@@ -371,9 +562,9 @@ def run_wizard():
         secrets_map["WA_CLOUD_TOKEN"] = text_input("WA Cloud API Token", is_password=True)
         secrets_map["WA_PHONE_NUMBER_ID"] = text_input("Phone Number ID")
 
-    # 7. Confirmation
+    # 9. Confirmation
     clear()
-    step_header(7, TOTAL_STEPS, "Verificación Final")
+    step_header(9, TOTAL_STEPS, "Verificación Final")
     
     print(f"  ┌────────────────────────────────────────────────────────┐")
     print(f"  │ {C_PRIMARY}{B1}Resumen de Configuración{R}                               │")
@@ -385,56 +576,58 @@ def run_wizard():
     print(f"  │ {C_MUTED}Modelo:{R}    {model_id.ljust(44)}│")
     print(f"  │ {C_MUTED}Voz:{R}       {tone.ljust(44)}│")
     print(f"  │ {C_MUTED}Secretos:{R}  {str(len(secrets_map)).ljust(44)}│")
+    print(f"  │ {C_MUTED}BASE_URL:{R}  {(gateway.get('base_url') or 'pending').ljust(44)[:44]}│")
+    print(f"  │ {C_MUTED}Dashboard:{R} {(dashboard.get('dashboard_url') or 'local only').ljust(44)[:44]}│")
     print(f"  └────────────────────────────────────────────────────────┘\n")
 
     if not confirm("¿Procesar e Implementar Infraestructura?"):
         print(f"\n  {C_MUTED}Cancelado.{R}\n")
         return
 
-    print(f"\n  {C_PRIMARY}Creando recursos...{R}")
-    _create(name, instance_id, sector, channel, provider_id, model_id, tone, secrets_map, lang)
+    print(f"\n  {C_PRIMARY}{_t('Creando recursos...')}{R}")
+    _create(name, instance_id, sector, channel, provider_id, model_id, tone, secrets_map, lang, port, gateway, dashboard)
 
     print(f"""
-  {C_SUCCESS}{B1}🚀 Infraestructura Desplegada Exitosamente{R}
+  {C_SUCCESS}{B1}🚀 {_t('Infraestructura Desplegada Exitosamente')}{R}
 
-    {C_MUTED}Directorio:{R}  {INSTANCES_DIR / instance_id}
-    {C_MUTED}Control:{R}     {C_PRIMARY}conny status {instance_id}{R}
-    {C_MUTED}Check:{R}       {C_PRIMARY}conny doctor{R}
-    {C_MUTED}Lanzar:{R}      {C_PRIMARY}pm2 start {INSTANCES_DIR / instance_id}/run.sh --name conny-{instance_id}{R}
+    {C_MUTED}{_t('Directorio:')}{R}  {INSTANCES_DIR / instance_id}
+    {C_MUTED}{_t('Control:')}{R}     {C_PRIMARY}conny status {instance_id}{R}
+    {C_MUTED}{_t('Check:')}{R}       {C_PRIMARY}conny doctor{R}
+    {C_MUTED}{_t('Lanzar:')}{R}      {C_PRIMARY}pm2 start {INSTANCES_DIR / instance_id}/run.sh --name conny-{instance_id}{R}
 """)
 
     # Post-onboarding commands
     if is_local and provider_id == "ollama":
         print(f"  {C_WARNING}💡 Asegúrate de descargar el modelo: `ollama run {model_id}`{R}\n")
 
-def _create(name, iid, sector, channel, provider, model_id, tone, secrets_map, lang):
+def _create(name, iid, sector, channel, provider, model_id, tone, secrets_map, lang, port, gateway, dashboard):
     idir = INSTANCES_DIR / iid
     idir.mkdir(parents=True, exist_ok=True)
 
-    existing_ports = []
-    if INSTANCES_DIR.exists():
-        for d in INSTANCES_DIR.iterdir():
-            env = d / ".env"
-            if env.exists():
-                for line in env.read_text().splitlines():
-                    if line.startswith("PORT="):
-                        try:
-                            parts = line.split("=")
-                            if len(parts) > 1:
-                                existing_ports.append(int(parts[1]))
-                        except: pass
-
-    port = max(existing_ports + [8003]) + 1
     webhook_secret = f"conny_{iid}_{secrets.token_hex(6)}"
+    base_url = str((gateway or {}).get("base_url") or "").rstrip("/")
+    tunnel_command = str((gateway or {}).get("tunnel_command") or "").replace('"', '\\"')
+    dashboard = dashboard or {}
+    host = str(dashboard.get("host") or "127.0.0.1").strip()
+    dashboard_url = str(dashboard.get("dashboard_url") or "").rstrip("/")
+    public_dashboard_url = str(dashboard.get("public_dashboard_url") or "").rstrip("/")
 
     env_lines = [
         f"INSTANCE_ID={iid}",
         f"PORT={port}",
+        f"HOST={host}",
+        f"BASE_URL={base_url}",
+        f"PUBLIC_BASE_URL={base_url}",
+        f"DASHBOARD_URL={dashboard_url}",
+        f"PUBLIC_DASHBOARD_URL={public_dashboard_url}",
         "DEMO_MODE=false",
         f"PLATFORM={channel}",
         f"SECTOR={sector}",
         f"BUSINESS_NAME=\"{name}\"",
         f"WEBHOOK_SECRET={webhook_secret}",
+        f"TUNNEL_PROVIDER={(gateway or {}).get('mode', '')}",
+        f"TUNNEL_PID={(gateway or {}).get('tunnel_pid', '')}",
+        f"TUNNEL_COMMAND=\"{tunnel_command}\"",
         f"LLM_PROVIDER={provider}",
         f"LLM_MODEL={model_id}",
         "DEBUG=false"
@@ -473,7 +666,10 @@ llm:
 
     for f in core:
         src = CONNY_DIR / f
-        if src.exists(): shutil.copy2(src, idir / f)
+        if src.exists():
+            dst = idir / f
+            dst.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(src, dst)
 
     for d in ["soul", "teachings", "memory_store", "knowledge_gaps", "integrations/vault", "logs"]:
         (idir / d).mkdir(parents=True, exist_ok=True)
@@ -486,10 +682,27 @@ llm:
         "status": "configured",
         "timestamp": datetime.now().isoformat(),
         "instance": iid,
-        "provider": provider
+        "provider": provider,
+        "port": port,
+        "base_url": base_url,
+        "dashboard": {
+            "host": host,
+            "url": dashboard_url,
+            "public_url": public_dashboard_url,
+        },
+        "tunnel": {
+            "provider": (gateway or {}).get("mode", ""),
+            "pid": (gateway or {}).get("tunnel_pid", ""),
+            "command": (gateway or {}).get("tunnel_command", ""),
+        },
     }
     (idir / "conny.state.json").write_text(json.dumps(state, indent=2))
 
+    if set_active_instance:
+        set_active_instance(iid)
+    if mirror_instance_env_to_base:
+        mirror_instance_env_to_base(iid)
+
 def _slug(name):
     s = name.lower().strip()
     for a, b in [("á","a"),("é","e"),("í","i"),("ó","o"),("ú","u"),("ñ","n")]: