@innvisor/conny-ai 9.7.0 → 9.8.0

package/npm/conny.js

@@ -18,6 +18,15 @@ const workspaceConfigPath = path.join(connyHome, "config.json");
 const sharedTelegramRoutesPath = path.join(connyHome, "shared_telegram_routes.json");
 const entrypoint = path.join(repoDir, "conny_app.py");
 const legacyEntrypoint = path.join(repoDir, "conny_cli.py");
+const criticalPythonPackages = [
+  "rich>=13.0.0",
+  "deep-translator>=1.11.0",
+  "httpx==0.27.0",
+  "python-dotenv==1.0.1",
+  "fastapi==0.115.0",
+  "pydantic>=2.0",
+  "questionary>=2.0.0",
+];
 
 const SKIP_NAMES = new Set([
   ".git",
@@ -143,7 +152,7 @@ const commandGroups = [
 function printBanner() {
   console.log();
   console.log(chalk.hex('#EC4899').bold('  conny-agent') + 
-              chalk.hex('#8B5CF6').dim(` · v${packageVersion} · kimika.ai`));
+              chalk.hex('#8B5CF6').dim(` · v${packageVersion} · innvisor.ai`));
   console.log(chalk.hex('#444')('  ─────────────────────────'));
   console.log();
 }
@@ -265,12 +274,54 @@ function runtimeLooksHealthy(runtime) {
   }
   const probe = spawnSync(
     runtime,
-    ["-c", "import fastapi,httpx,dotenv; print('ok')"],
+    ["-c", "import rich,deep_translator,fastapi,httpx,dotenv,pydantic,questionary; print('ok')"],
     { stdio: ["ignore", "pipe", "pipe"], encoding: "utf8", env: process.env }
   );
   return probe.status === 0;
 }
 
+function installRuntimeDependencies(runtime, spinner, allowFullFailure = true) {
+  let result;
+  if (spinner) {
+    spinner.text = chalk.hex('#8B5CF6')("Installing Conny CLI runtime dependencies...");
+  }
+  result = spawnSync(
+    runtime,
+    ["-m", "pip", "install", "--disable-pip-version-check", ...criticalPythonPackages],
+    { stdio: ["ignore", "pipe", "pipe"], env: process.env }
+  );
+  if (result.status !== 0) {
+    if (spinner) spinner.fail(chalk.red("✕ Could not install Conny's required Python packages."));
+    if (result.stderr) console.error(chalk.red(result.stderr.toString()));
+    process.exit(1);
+  }
+
+  const requirementsPath = path.join(repoDir, "requirements.txt");
+  if (fs.existsSync(requirementsPath)) {
+    if (spinner) {
+      spinner.text = chalk.hex('#8B5CF6')("Installing optional production dependencies...");
+    }
+    result = spawnSync(
+      runtime,
+      ["-m", "pip", "install", "--disable-pip-version-check", "-r", requirementsPath],
+      { stdio: ["ignore", "pipe", "pipe"], env: process.env }
+    );
+    if (result.status !== 0 && !allowFullFailure) {
+      if (spinner) spinner.fail(chalk.red("✕ Could not install requirements.txt."));
+      if (result.stderr) console.error(chalk.red(result.stderr.toString()));
+      process.exit(1);
+    }
+    if (result.status !== 0 && spinner) {
+      spinner.text = chalk.hex('#8B5CF6')("Optional dependencies skipped; CLI runtime is ready.");
+    }
+  }
+
+  if (!runtimeLooksHealthy(runtime)) {
+    if (spinner) spinner.fail(chalk.red("✕ Runtime verification failed after dependency installation."));
+    process.exit(1);
+  }
+}
+
 function ensureRuntime(spinner) {
   let runtime = resolveRuntime();
   if (runtime && runtimeLooksHealthy(runtime)) {
@@ -330,16 +381,7 @@ function ensureRuntime(spinner) {
     process.exit(1);
   }
 
-  localSpinner.text = chalk.hex('#8B5CF6')("Instalando dependencias base (requirements.txt)...");
-  result = spawnSync(runtime, ["-m", "pip", "install", "--disable-pip-version-check", "-r", path.join(repoDir, "requirements.txt")], {
-    stdio: ["ignore", "pipe", "pipe"],
-    env: process.env,
-  });
-  if (result.status !== 0) {
-    localSpinner.fail(chalk.red("✕ Falló la instalación de las dependencias."));
-    if (result.stderr) console.error(chalk.red(result.stderr.toString()));
-    process.exit(1);
-  }
+  installRuntimeDependencies(runtime, localSpinner, true);
 
   if (!spinner) {
     localSpinner.succeed(chalk.green("✓ Lista."));
@@ -385,11 +427,11 @@ function bootstrapFromPackage() {
         )
       );
     }
-    console.log(chalk.hex("#8B5CF6")("Verificando dependencias (pip)..."));
-  const runtime = resolveRuntime() || ensureRuntime(spinner);
-  spawnSync(runtime, ["-m", "pip", "install", "--disable-pip-version-check", "-r", path.join(repoDir, "requirements.txt")], { stdio: "ignore" });
+    console.log(chalk.hex("#8B5CF6")("Verifying Python dependencies..."));
+    const runtime = resolveRuntime() || ensureRuntime(spinner);
+    installRuntimeDependencies(runtime, spinner, true);
 
-  if (!fs.existsSync(sharedTelegramRoutesPath)) {
+    if (!fs.existsSync(sharedTelegramRoutesPath)) {
       fs.writeFileSync(sharedTelegramRoutesPath, JSON.stringify({ default_instance: "", routes: {} }, null, 2));
     }
     ensureDir(path.join(connyHome, "instances"));
@@ -405,7 +447,11 @@ function needsBootstrap() {
   if (!fs.existsSync(entrypoint)) {
     return true;
   }
-  if (!resolveRuntime()) {
+  const runtime = resolveRuntime();
+  if (!runtime) {
+    return true;
+  }
+  if (!runtimeLooksHealthy(runtime)) {
     return true;
   }
   if (readInstalledVersion() !== packageVersion) {
@@ -441,6 +487,7 @@ function execConny(argv) {
 const args = process.argv.slice(2);
 const isHelp = args.length === 0 || args.includes("-h") || args.includes("--help") || args.includes("help");
 const isVersion = args.includes("-v") || args.includes("--version") || args.includes("version");
+const isBootstrapCheck = args.includes("--bootstrap-check");
 const isJson = args.includes("--json");
 
 if (isVersion) {
@@ -456,6 +503,15 @@ if (needsBootstrap()) {
   bootstrapFromPackage();
 }
 
+if (isBootstrapCheck) {
+  const runtime = resolveRuntime();
+  if (!runtime || !runtimeLooksHealthy(runtime)) {
+    fail(`Conny runtime is not ready in ${connyHome}`);
+  }
+  console.log(`conny runtime ok ${packageVersion}`);
+  process.exit(0);
+}
+
 if (isHelp) {
   printBanner();
   printCommands();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@innvisor/conny-ai",
-  "version": "9.7.0",
+  "version": "9.8.0",
   "description": "Open-source CLI and runtime for building Conny AI receptionist agents on WhatsApp and Telegram.",
   "license": "MIT",
   "author": "Santiago Rubio",
@@ -21,10 +21,20 @@
     "conny.py",
     "*.py",
     "!patch*.py",
+    "!fix*.py",
+    "!implement_*.py",
+    "!create_dev_account.py",
+    "!verify_*.py",
+    "!conny_watchdog.py",
+    "!conny_ultra*.db*",
     "!scratch*.py",
     "!test_*.py",
     "!chat_conny.py",
-    "brand-assets/**/*",
+    "brand-assets/conny-logo.png",
+    "brand-assets/Conny.web.logo.png",
+    "brand-assets/Logo_Conny_Petalo_Claro.png",
+    "brand-assets/web.background.png",
+    "brand-assets/A_dark_luxury_web_background_202605210700.jpeg",
     "conny_cli.py",
     "conny_cli_bb.py",
     "conny_tui.py",
@@ -99,4 +109,4 @@
     "figlet": "^1.11.0",
     "ora": "^5.4.1"
   }
-}
+}

package/run.sh

@@ -12,6 +12,13 @@ read_env_value() {
   fi
 }
 
+# Export all .env variables so they're available to the Python process
+if [ -f "$ENV_FILE" ]; then
+  set -a
+  source "$ENV_FILE"
+  set +a
+fi
+
 PYTHON_OVERRIDE="${CONNY_PYTHON_BIN:-${PYTHON_BIN:-$(read_env_value CONNY_PYTHON_BIN)}}"
 if [ -z "$PYTHON_OVERRIDE" ]; then
   PYTHON_OVERRIDE="$(read_env_value PYTHON_BIN)"

package/src/conny/admin/dashboard.py

@@ -208,7 +208,17 @@ EJEMPLO MALO:
             log.info(f"[admin] {meta.get('provider','?')} latency={meta.get('latency_ms',0)}ms")
         except Exception as e:
             log.error(f"[admin] LLM error: {e}")
-            response = "perdona, se me fue la señal un momento ||| qué me decías?"
+            if hasattr(e, "public_message"):
+                response = (
+                    "No voy a ocultarte esto con un fallback. ||| "
+                    f"{e.public_message} ||| "
+                    "Continuar con fallback? Responde exactamente: continuar fallback. No recomendado si quieres que todo lo decida el LLM."
+                )
+            else:
+                response = (
+                    f"El cerebro LLM falló antes de responder. Detalle: {str(e)[:500]} ||| "
+                    "Continuar con fallback? Responde exactamente: continuar fallback. No recomendado."
+                )
 
         if not response or not response.strip():
             response = "cuéntame más, estoy tomando nota de todo"
@@ -693,9 +703,13 @@ class AuthEngine:
 
     async def _start_activation(self, chat_id: str, token_raw: str) -> List[str]:
         from conny import db
+        from conny_utils import is_admin_activation_token
         token = token_raw.strip().upper(); td = db.get_activation_token(token)
         if not td: return ["Token no válido."]
-        db.set_auth_session(chat_id, flow="activate", step="name", temp_data={"token": token})
+        token_type = "admin_pro" if is_admin_activation_token(token) else "business_owner"
+        db.set_auth_session(chat_id, flow="activate", step="name", temp_data={"token": token, "token_type": token_type})
+        if token_type == "admin_pro":
+            return ["Código Conny Pro válido. Cómo te llamas?"]
         return ["Código válido. Cómo te llamas?"]
 
     async def _handle_activation_flow(self, chat_id: str, text: str, session: Dict) -> List[str]:
@@ -712,8 +726,25 @@ class AuthEngine:
             tmp["password_hash"] = hash_password(text.strip()); db.set_auth_session(chat_id, "activate", "confirm", tmp)
             return ["Confirmas? (si/no)"]
         if step == "confirm" and text.lower().strip() == "si":
-            db.create_admin(chat_id=chat_id, email=tmp["email"], password_hash=tmp["password_hash"], name=tmp["name"], role="owner")
-            db.clear_auth_session(chat_id); return ["Listo, cuenta creada. Ahora cuéntame del negocio"]
+            from conny_utils import _parse_admin_ids
+            token = tmp.get("token", "")
+            token_type = tmp.get("token_type", "business_owner")
+            role = "admin_pro" if token_type == "admin_pro" else "owner"
+            db.create_admin(chat_id=chat_id, email=tmp["email"], password_hash=tmp["password_hash"], name=tmp["name"], role=role, token=token)
+            if token:
+                db.consume_activation_token(token, chat_id)
+            clinic = db.get_clinic()
+            admin_ids = _parse_admin_ids(clinic.get("admin_chat_ids", []))
+            if chat_id not in admin_ids:
+                admin_ids.append(chat_id)
+                db.update_clinic(admin_chat_ids=admin_ids)
+            db.clear_auth_session(chat_id)
+            if token_type == "admin_pro":
+                return [
+                    "Listo. Conny Pro Admin quedó activado para este chat.",
+                    "Desde aquí puedes administrar la instancia, crear flujos y corregir la operación con permisos de operador."
+                ]
+            return ["Listo, cuenta creada. Ahora cuéntame del negocio"]
         return ["Cancelado."]
 
     async def _handle_login_flow(self, chat_id: str, text: str, session: Dict) -> List[str]:

package/src/conny/admin_memory.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+import json
+import re
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List
+
+
+def _safe_id(value: str) -> str:
+    clean = re.sub(r"[^a-zA-Z0-9_.@-]+", "_", str(value or "").strip())
+    return clean[:96] or "unknown"
+
+
+class AdminSoulMemory:
+    """Filesystem memory for the operator layer, inspired by OpenClaw-style soul folders."""
+
+    def __init__(self, root: str | Path = "soul/admins"):
+        self.root = Path(root)
+
+    def admin_dir(self, chat_id: str) -> Path:
+        path = self.root / _safe_id(chat_id)
+        path.mkdir(parents=True, exist_ok=True)
+        return path
+
+    def load_context(self, chat_id: str, limit_chars: int = 4000) -> str:
+        base = self.admin_dir(chat_id)
+        chunks: List[str] = []
+        for filename, title in (
+            ("profile.json", "Perfil del admin"),
+            ("business_facts.md", "Datos enseñados por el admin"),
+            ("ops_memory.md", "Memoria operativa"),
+        ):
+            path = base / filename
+            if path.exists():
+                text = path.read_text(encoding="utf-8", errors="ignore").strip()
+                if text:
+                    chunks.append(f"## {title}\n{text[-limit_chars:]}")
+        return "\n\n".join(chunks)[-limit_chars:]
+
+    def remember_turn(
+        self,
+        *,
+        chat_id: str,
+        admin_text: str,
+        conny_reply: str,
+        clinic: Dict[str, Any],
+    ) -> None:
+        base = self.admin_dir(chat_id)
+        now = datetime.utcnow().isoformat() + "Z"
+
+        profile_path = base / "profile.json"
+        profile = {}
+        if profile_path.exists():
+            try:
+                profile = json.loads(profile_path.read_text(encoding="utf-8"))
+            except Exception:
+                profile = {}
+        profile.update(
+            {
+                "chat_id": str(chat_id),
+                "last_seen_at": now,
+                "clinic_name": clinic.get("name", ""),
+                "setup_done": bool(clinic.get("setup_done")),
+            }
+        )
+        profile_path.write_text(json.dumps(profile, ensure_ascii=False, indent=2), encoding="utf-8")
+
+        conversation_path = base / "conversation_log.jsonl"
+        with conversation_path.open("a", encoding="utf-8") as fh:
+            fh.write(
+                json.dumps(
+                    {
+                        "ts": now,
+                        "admin": admin_text,
+                        "conny": conny_reply,
+                        "clinic": clinic.get("name", ""),
+                    },
+                    ensure_ascii=False,
+                )
+                + "\n"
+            )
+
+        text_low = admin_text.lower()
+        if any(token in text_low for token in ("precio", "horario", "cliente", "servicio", "api", "instancia", "demo")):
+            facts_path = base / "business_facts.md"
+            with facts_path.open("a", encoding="utf-8") as fh:
+                fh.write(f"\n- {now}: {admin_text.strip()}\n")
+
+        if any(token in text_low for token in ("bug", "error", "falla", "terminal", "pm2", "webhook", "telegram", "whatsapp")):
+            ops_path = base / "ops_memory.md"
+            with ops_path.open("a", encoding="utf-8") as fh:
+                fh.write(f"\n- {now}: {admin_text.strip()}\n")

package/src/conny/api/routes.py

@@ -1197,23 +1197,28 @@ async def api_create_token(request: Request):
     if not clinic_label:
         raise HTTPException(status_code=400, detail="clinic_label requerido")
 
+    token_type = str(body.get("token_type") or body.get("type") or "").strip().lower()
+    admin_requested = bool(body.get("admin")) or token_type in ("admin", "admin_pro", "pro")
+
     # Generar token
-    token = generate_activation_token(clinic_label)
+    token = generate_admin_activation_token(clinic_label) if admin_requested else generate_activation_token(clinic_label)
+    stored_label = f"ADMIN_PRO:{clinic_label}" if admin_requested else clinic_label
 
     # Calcular expiracion
     expires_at = (datetime.now() + timedelta(hours=Config.TOKEN_EXPIRY_HOURS)).isoformat()
 
     # Guardar en DB
-    saved = db.create_activation_token(token, clinic_label, expires_at)
+    saved = db.create_activation_token(token, stored_label, expires_at)
     if not saved:
         raise HTTPException(status_code=500, detail="No se pudo guardar el token")
 
-    log.info(f"[api] token creado para '{clinic_label}': {token[:20]}...")
+    log.info(f"[api] token creado para '{stored_label}': {token[:20]}...")
 
     return {
         "ok": True,
         "token": token,
         "clinic_label": clinic_label,
+        "token_type": "admin_pro" if admin_requested else "business_owner",
         "expires_at": expires_at,
         "instructions": f"Envia este token exacto al administrador de {clinic_label}. Expira en {Config.TOKEN_EXPIRY_HOURS}h."
     }
@@ -1277,7 +1282,7 @@ async def api_auth_register(request: Request):
     if not email or not password or not name or not token:
         raise HTTPException(status_code=400, detail="Faltan campos requeridos")
     
-    if not token.startswith("ACTV-"):
+    if not is_activation_token(token):
         raise HTTPException(status_code=400, detail="Token no valido")
         
     token_data = db.get_activation_token(token)
@@ -1304,10 +1309,11 @@ async def api_auth_register(request: Request):
     pass_hash = hash_password(password)
     try:
         with db._conn() as c:
+            role = "admin_pro" if is_admin_activation_token(token) else "owner"
             c.execute("""
                 INSERT OR REPLACE INTO admins (chat_id, email, password_hash, name, role, activated_by_token, is_active)
-                VALUES (?, ?, ?, ?, 'owner', ?, 1)
-            """, (f"owner_{secrets.token_hex(4)}", email, pass_hash, name, token))
+                VALUES (?, ?, ?, ?, ?, ?, 1)
+            """, (f"owner_{secrets.token_hex(4)}", email, pass_hash, name, role, token))
     except Exception as e:
         log.error(f"Error insertando admin: {e}")
         
@@ -1350,15 +1356,26 @@ async def api_auth_dev_register(request: Request):
     if not email or not password or not dev_token:
         raise HTTPException(status_code=400, detail="Todos los campos son requeridos")
         
-    if not Config.MASTER_API_KEY or not secrets.compare_digest(dev_token, Config.MASTER_API_KEY):
-        raise HTTPException(status_code=401, detail="Token de acceso para desarrolladores incorrecto")
+    if Config.MASTER_API_KEY and secrets.compare_digest(dev_token, Config.MASTER_API_KEY):
+        token_mode = "master"
+    else:
+        token_mode = "admin_pro"
+        if not is_admin_activation_token(dev_token):
+            raise HTTPException(status_code=401, detail="Token de acceso para desarrolladores incorrecto")
+        token_data = db.get_activation_token(dev_token)
+        if not token_data:
+            raise HTTPException(status_code=404, detail="Token Conny Pro Admin inexistente")
+        if token_data.get("used_at"):
+            raise HTTPException(status_code=400, detail="El token Conny Pro Admin ya fue usado")
         
     hashed = hash_password(password)
     success = db.create_dev_account(email, hashed)
     if not success:
         raise HTTPException(status_code=500, detail="Error al registrar la cuenta de desarrollador")
+    if token_mode == "admin_pro":
+        db.consume_activation_token(dev_token, f"dev:{email}")
         
-    return {"ok": True, "message": "Cuenta de desarrollador registrada con exito"}
+    return {"ok": True, "message": "Cuenta de desarrollador registrada con exito", "token_type": token_mode}
 
 @app.get("/api/tokens")
 async def api_list_tokens(request: Request):

package/src/conny/channels/cli.py

@@ -178,7 +178,7 @@ except ImportError:
 # ══════════════════════════════════════════════════════════════════════════════
 # CONFIGURACIÓN
 # ══════════════════════════════════════════════════════════════════════════════
-VERSION = "9.7.0"
+VERSION = "9.8.0"
 CONNY_HOME = os.getenv("CONNY_HOME", str(Path.home() / ".conny"))
 CONNY_DIR = os.getenv("CONNY_DIR", str(Path(__file__).resolve().parent))
 INSTANCES_DIR = os.getenv("INSTANCES_DIR", str(Path.home() / "conny-instances"))
@@ -5149,6 +5149,12 @@ def cmd_demo(args):
 
         ev_path = f"{inst.dir}/.env"
         update_env_key(ev_path, "DEMO_MODE", "false")
+        # Also update project root .env for PM2-managed process
+        if inst.is_base:
+            try:
+                update_env_key("/home/ubuntu/conny/.env", "DEMO_MODE", "false")
+            except Exception:
+                pass
         pm2_name = "conny" if inst.is_base else f"conny-{inst.name}"
         with Spinner("Desactivando modo demo...") as sp:
             pm2("restart", pm2_name)
@@ -5253,6 +5259,11 @@ def cmd_demo(args):
         update_env_key(ev_path, "DEMO_BUSINESS_NAME", business_name)
         update_env_key(ev_path, "DEMO_SECTOR",        demo_sector)
         update_env_key(ev_path, "DEMO_SESSION_TTL",   str(ttl_min * 60))
+        if inst.is_base:
+            try:
+                update_env_key("/home/ubuntu/conny/.env", "DEMO_MODE", "true")
+            except Exception:
+                pass
         load_env.cache_clear()  # Fix Bug 4: forzar lectura fresca del .env
         sp.finish("Configuración aplicada")
 
@@ -6399,11 +6410,15 @@ def cmd_token(args):
     
     Uso:
       conny token                    → genera para la instancia base
+      conny token --admin            → genera token Conny Pro Admin
       conny token 1                  → genera para la instancia 1
       conny token "Clinica Demo"     → genera con ese nombre
       conny token all                → genera para todas las instancias
     """
     name = getattr(args, 'name', '') or getattr(args, 'subcommand', '') or ''
+    admin_mode = bool(getattr(args, "admin", False)) or name.lower() in ("--admin", "admin", "pro")
+    if name.lower() in ("--admin", "admin", "pro"):
+        name = ""
 
     def _gen_token(inst, label_override=""):
         import sqlite3
@@ -6414,11 +6429,11 @@ def cmd_token(args):
         label = label_override or inst.label
         
         # Generar token
-        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"
-        entropy = secrets.token_hex(16).upper()
-        token = f"ACTV-{sanitized}-{entropy}"
+            sanitized = "GENERIC"
+        entropy = secrets.token_hex(18 if admin_mode else 16).upper()
+        token = f"{'ADMN' if admin_mode else 'ACTV'}-{sanitized}-{entropy}"
         
         expires_at = (datetime.now() + timedelta(hours=72)).isoformat()
         
@@ -6435,18 +6450,23 @@ def cmd_token(args):
                     created_at TEXT NOT NULL
                 )
             """)
+            stored_label = f"ADMIN_PRO:{label}" if admin_mode else label
             cur.execute("""
-                INSERT INTO activation_tokens 
+                INSERT INTO activation_tokens
                 (token, clinic_label, expires_at, created_at)
                 VALUES (?, ?, ?, ?)
-            """, (token, label, expires_at, datetime.now().isoformat()))
+            """, (token, stored_label, expires_at, datetime.now().isoformat()))
             conn.commit()
             conn.close()
             
-            ok(f"Token generado offline para: {q(C.YLW, label)}")
+            kind = "Conny Pro Admin" if admin_mode else "activación"
+            ok(f"Token {kind} generado offline para: {q(C.YLW, label)}")
             print(f"\n    {q(C.YLW, token, bold=True)}\n")
             info(f"Expira: {expires_at[:16]}")
-            info("Envíalo al admin — lo usará para desbloquear el Dashboard o en WhatsApp")
+            if admin_mode:
+                info("Activa el modo operador: el admin lo escribe en WhatsApp/Telegram para tomar control de la instancia.")
+            else:
+                info("Envíalo al admin — lo usará para desbloquear el Dashboard o en WhatsApp")
         except Exception as e:
             fail(f"No se pudo generar offline: {e}")
 
@@ -11710,6 +11730,7 @@ def main():
     parser.add_argument("--quiet", "-q", action="store_true")
     parser.add_argument("--json", "-j", action="store_true", help="Output JSON")
     parser.add_argument("--auto", "-y", action="store_true", help="Auto-confirm")
+    parser.add_argument("--admin", action="store_true", help="Genera token Conny Pro Admin")
     parser.add_argument("--dry-run", "-n", action="store_true", dest="dry_run",
                         help="Preview sin ejecutar (sync)")
     parser.add_argument("--no-restart", action="store_true", dest="no_restart",