Ocultar la consola en aplicaciones Tauri

Es posible ocultar la ventana de la consola de comandos, de manera que solamente se muestre la interfaz de tauri (aplicación .exe), de acuerdo a:

#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]

use std::process::{Command, Stdio}; use std::env; use std::path::{Path, PathBuf}; use std::sync::{Arc, Mutex, Once}; use tauri::Manager;

static INIT: Once = Once::new(); static mut APP_STATE: Option<Arc<Mutex<AppState>>> = None;

#[derive(Clone)] struct AppState { python_exe: PathBuf, app_dir: PathBuf, }

fn run_command(command: &str, args: &[&str]) -> Result<(), String> { println!("Ejecutando: {} {:?}", command, args); let output = Command::new(command) .args(args) .stdout(Stdio::null()) .stderr(Stdio::null()) .output() .map_err(|e| format!("Failed to execute command: {}", e))?; if !output.status.success() { return Err(format!("Command failed with exit code: {:?}", output.status.code())); } Ok(()) }

fn find_python_exe(venv_path: &Path) -> Result<PathBuf, String> { let python_exe = if cfg!(windows) { venv_path.join("Scripts").join("python.exe") } else { venv_path.join("bin").join("python") }; if !python_exe.exists() { return Err(format!("Python executable not found: {:?}", python_exe)); } Ok(python_exe) }

fn initialize() -> Result<(), String> { let current_dir = env::current_dir().map_err(|e| format!("Failed to get current directory: {}", e))?; let venv_path = current_dir.join("venv_postgreSQL");

if !venv_path.exists() {
    return Err(format!("El entorno virtual no existe en: {:?}", venv_path));
}

let python_exe = find_python_exe(&venv_path)?;
let app_dir = current_dir.join("mindfortune2");

if cfg!(windows) {
    let activate_script = venv_path.join("Scripts").join("activate.bat");
    if !activate_script.exists() {
        return Err(format!("Activation script not found: {:?}", activate_script));
    }
    run_command("cmd", &["/C", "call", activate_script.to_str().unwrap()])?;
}

env::set_current_dir(&app_dir).map_err(|e| format!("Failed to change directory: {}", e))?;

if !Path::new("manage.py").exists() {
    return Err("Error: No se encuentra el archivo manage.py en el directorio actual.".to_string());
}

unsafe {
    APP_STATE = Some(Arc::new(Mutex::new(AppState {
        python_exe,
        app_dir,
    })));
}

Ok(())

}

#[tauri::command] fn run_django_server() -> Result<(), String> { INIT.call_once(|| { if let Err(e) = initialize() { eprintln!("Initialization error: {}", e); } });

let state = unsafe { 
    APP_STATE.as_ref()
        .ok_or("App state not initialized")?
        .lock()
        .map_err(|_| "Failed to lock app state")?
        .clone()
};

std::thread::spawn(move || {
    println!("Intentando ejecutar el servidor Django...");
    if let Err(e) = run_command(state.python_exe.to_str().unwrap(), &["manage.py", "runserver"]) {
        eprintln!("Error al ejecutar el servidor Django: {}", e);
    }
});

Ok(())

}

#[tauri::command] fn stop_django_server() -> Result<(), String> { if cfg!(target_os = "windows") { Command::new("taskkill") .args(&["/F", "/IM", "python.exe"]) .spawn() .map_err(|e| e.to_string())?; } else { Command::new("pkill") .arg("python") .spawn() .map_err(|e| e.to_string())?; }

Ok(())

}

fn main() { tauri::Builder::default() .setup(|mindfortune2| { let window = mindfortune2.get_webview_window("main").unwrap(); window.set_title("MindFortune3").unwrap(); Ok(()) }) .invoke_handler(tauri::generate_handler![run_django_server, stop_django_server]) .run(tauri::generate_context!()) .expect("error while running tauri application"); }

?

Para ocultar la ventana de la consola de comandos en una aplicación de Tauri, puedes utilizar la configuración windows_subsystem = "windows" en tu archivo main.rs. Esto es lo que ya tienes en tu código:

#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]

Esta línea indica que, cuando compiles tu aplicación en modo de lanzamiento (release), la aplicación no mostrará la consola de comandos de Windows. Sin embargo, en modo de depuración (debug), la consola seguirá apareciendo para que puedas ver los mensajes de depuración y errores.

Asegúrate de lo siguiente:

1. Compilación en modo release: Para asegurarte de que la consola no aparezca, debes compilar tu aplicación en modo release. Puedes hacerlo ejecutando el siguiente comando en tu terminal:

   cargo build --release
   

   Esto generará un archivo ejecutable en la carpeta target/release, y al ejecutar este archivo, no debería aparecer la consola de comandos.

2. Uso de println!: Ten en cuenta que cualquier uso de println! o eprintln! en tu código no se mostrará en la consola si esta está oculta. Si necesitas registrar información para depuración, considera usar un sistema de registro que escriba en un archivo o en otro lugar en lugar de imprimir en la consola.

3. Verificación de la configuración: Asegúrate de que la línea #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] esté al principio de tu archivo main.rs, antes de cualquier otra declaración.

Ejemplo de cómo debería verse tu archivo main.rs:

#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]

use std::process::{Command, Stdio};
use std::env;
use std::path::{Path, PathBuf};
use std::sync::{Arc, Mutex, Once};
use tauri::Manager;

static INIT: Once = Once::new();
static mut APP_STATE: Option<Arc<Mutex<AppState>>> = None;

#[derive(Clone)]
struct AppState {
    python_exe: PathBuf,
    app_dir: PathBuf,
}

// ... (resto de tu código)

fn main() {
    tauri::Builder::default()
        .setup(|mindfortune2| {
            let window = mindfortune2.get_webview_window("main").unwrap();
            window.set_title("MindFortune3").unwrap();
            Ok(())
        })
        .invoke_handler(tauri::generate_handler![run_django_server, stop_django_server])
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}

Siguiendo estos pasos, deberías poder ejecutar tu aplicación Tauri sin que aparezca la ventana de la consola de comandos en Windows.