pispas_elevator/

service.rs

#[cfg(target_os = "windows")]
use {
    windows_service::{
        service::{
            ServiceAccess, ServiceErrorControl, ServiceInfo, ServiceStartType, ServiceType,
        },
        service_manager::{ServiceManager, ServiceManagerAccess},
    },std::{
        ffi::OsString,
        thread::sleep
    }
};

use easy_trace::instruments::tracing;
#[cfg(not(target_os = "windows"))]
use
{ users::get_user_by_uid,
 users::os::unix::UserExt
};
#[cfg(target_os = "windows")]
pub fn start_service() -> sharing::PisPasResult<()> {
    let manager = ServiceManager::local_computer(None::<&str>, ServiceManagerAccess::CONNECT)?;
    let service = manager.open_service(sharing::SERVICE_NAME, ServiceAccess::START)?;
    service.start(&[""])?;
    Ok(())
}

#[cfg(target_os = "windows")]
pub fn stop_service() -> sharing::PisPasResult<()> {
    let manager = ServiceManager::local_computer(None::<&str>, ServiceManagerAccess::CONNECT)?;
    let service = manager.open_service(sharing::SERVICE_NAME, ServiceAccess::STOP)?;
    service.stop()?;
    Ok(())
}

#[cfg(target_os = "windows")]
pub fn unregister_service() -> sharing::PisPasResult<()> {
    match sharing::natives::api::stop_pispas_modules() {
        Ok(_) => tracing::info!("Pispas modules stopped successfully"),
        Err(e) => tracing::error!("Error stopping pispas modules: {}", e),
    }
    sleep(std::time::Duration::from_secs(1));
    let manager = ServiceManager::local_computer(None::<&str>, ServiceManagerAccess::CONNECT)?;
    let  service = manager.open_service(sharing::SERVICE_NAME, ServiceAccess::DELETE)?;
    service.delete()?;
    Ok(())
}
#[cfg(windows)]
pub fn register_service() -> sharing::PisPasResult<()> {
    let manager_access = ServiceManagerAccess::CONNECT | ServiceManagerAccess::CREATE_SERVICE;
    let service_manager = ServiceManager::local_computer(None::<&str>, manager_access)?;

    let service_binary_path = sharing::paths::bin_dir().join(sharing::SERVICE_NAME_EXE);

    let service_info = ServiceInfo {
        name: OsString::from(sharing::SERVICE_NAME),
        display_name: OsString::from(sharing::SERVICE_NAME),
        service_type: ServiceType::OWN_PROCESS,
        start_type: ServiceStartType::AutoStart,
        error_control: ServiceErrorControl::Normal,
        executable_path: service_binary_path,
        launch_arguments: vec![],
        dependencies: vec![],
        account_name: None, // run as System
        account_password: None,
    };
    match service_manager.open_service(
        sharing::SERVICE_NAME,
        ServiceAccess::CHANGE_CONFIG,
    ) {
        Ok(service) => {
            service.change_config(&service_info)?;
            tracing::info!("Service {} update", sharing::SERVICE_NAME);
            sleep(std::time::Duration::from_secs(1));
        }
        Err(e) => {
            let service = service_manager.create_service(&service_info, ServiceAccess::CHANGE_CONFIG)?;
            service.set_description(sharing::SERVICE_NAME)?;
            sleep(std::time::Duration::from_secs(1));
            tracing::info!("Service {} does not exist error {}", sharing::SERVICE_NAME, e);
            match service.start(&[""]) {
                Ok(_) => tracing::info!("Service {} started", sharing::SERVICE_NAME),
                Err(e) => tracing::error!("Service {} start error {}", sharing::SERVICE_NAME, e),
            }
        }
    }
    Ok(())
}
// ===== FUNCIONES PRINCIPALES =====

#[cfg(target_os = "macos")]
pub fn register_service_as_daemon() -> sharing::PisPasResult<()> {
    use std::fs;

    let service_name = sharing::SERVICE_NAME;
    let plist_content = create_launch_daemon_plist()?;

    // LaunchDaemon va en /Library/LaunchDaemons/ (requiere sudo)
    let plist_path = std::path::PathBuf::from("/Library/LaunchDaemons")
        .join(format!("{}.plist", service_name));

    // Escribir el archivo plist (requiere sudo)
    fs::write(&plist_path, plist_content)?;
    tracing::info!("Created LaunchDaemon plist: {}", plist_path.display());

    // Establecer permisos correctos
    std::process::Command::new("chown")
        .args(&["root:wheel", &plist_path.to_string_lossy()])
        .output()?;

    std::process::Command::new("chmod")
        .args(&["644", &plist_path.to_string_lossy()])
        .output()?;

    // Bootstrap como daemon del sistema
    let bootstrap_output = std::process::Command::new("launchctl")
        .args(&["bootstrap", "system", &plist_path.to_string_lossy()])
        .output()?;

    if !bootstrap_output.status.success() {
        let error = String::from_utf8_lossy(&bootstrap_output.stderr);
        tracing::error!("Failed to bootstrap daemon: {}", error);
        return Err(anyhow::anyhow!("Failed to bootstrap daemon: {}", error));
    }

    // Habilitar para auto-start
    let service_target = format!("system/{}", service_name);
    let enable_output = std::process::Command::new("launchctl")
        .args(&["enable", &service_target])
        .output()?;

    if !enable_output.status.success() {
        let error = String::from_utf8_lossy(&enable_output.stderr);
        tracing::warn!("Failed to enable daemon: {}", error);
    }

    tracing::info!("Service {} bootstrapped and enabled as daemon", service_name);
    Ok(())
}
#[cfg(target_os = "macos")]
pub fn register_service() -> sharing::PisPasResult<()> {
    // Para instalación/registro usa la función de limpieza completa
    register_service_as_daemon()
}

#[cfg(target_os = "macos")]
pub fn unregister_service() -> sharing::PisPasResult<()> {
    let service_name = sharing::SERVICE_NAME;

    tracing::info!("Unregistering service: {}", service_name);

    // Parar el servicio si está ejecutándose
    let _ = stop_service();

    // Usar LaunchAgent path
    let home_dir = dirs::home_dir().ok_or_else(|| anyhow::anyhow!("Cannot get home directory"))?;
    let plist_path = home_dir.join("Library/LaunchAgents").join(format!("{}.plist", service_name));

    // Descargar el servicio (sin sudo)
    if plist_path.exists() {
        let output = std::process::Command::new("launchctl")
            .args(&["unload", &plist_path.to_string_lossy()])
            .output()?;

        if !output.status.success() {
            let error = String::from_utf8_lossy(&output.stderr);
            tracing::warn!("Failed to unload service: {}", error);
        }

        std::fs::remove_file(&plist_path)?;
        tracing::info!("Service plist removed: {}", plist_path.display());
    }

    // También limpiar cualquier daemon residual (por si acaso)
    let daemon_plist = format!("/Library/LaunchDaemons/{}.plist", service_name);
    if std::path::Path::new(&daemon_plist).exists() {
        let _ = std::process::Command::new("sudo")
            .args(&["launchctl", "unload", &daemon_plist])
            .output();
        let _ = std::process::Command::new("sudo")
            .args(&["rm", "-f", &daemon_plist])
            .output();
        tracing::info!("Cleaned up legacy daemon plist");
    }

    tracing::info!("Service {} unregistered successfully", service_name);
    Ok(())
}

// ===== FUNCIONES DE CONTROL =====

#[cfg(target_os = "macos")]
pub fn start_service() -> sharing::PisPasResult<()> {
    let service_name = sharing::SERVICE_NAME;
    let service_target = format!("system/{}", service_name);  // ✅ system domain

    // Verificar si ya está corriendo
    let print_output = std::process::Command::new("launchctl")
        .args(&["print", &service_target])
        .output()?;

    if print_output.status.success() {
        tracing::info!("Service {} is already loaded", service_name);
        return Ok(());
    }

    // Kickstart para forzar inicio
    let output = std::process::Command::new("launchctl")
        .args(&["kickstart", &service_target])
        .output()?;

    if !output.status.success() {
        let error = String::from_utf8_lossy(&output.stderr);
        tracing::error!("Failed to start service: {}", error);
        return Err(anyhow::anyhow!("Failed to start service: {}", error));
    }

    tracing::info!("Service {} started successfully", service_name);
    Ok(())
}

#[cfg(target_os = "macos")]
pub fn stop_service() -> sharing::PisPasResult<()> {
    let service_name = sharing::SERVICE_NAME;
    let service_target = format!("system/{}", service_name);  // ✅ system domain

    let output = std::process::Command::new("launchctl")
        .args(&["kill", "SIGTERM", &service_target])
        .output()?;

    if !output.status.success() {
        let error = String::from_utf8_lossy(&output.stderr);
        tracing::warn!("Failed to stop service: {}", error);
    }

    tracing::info!("Service {} stopped", service_name);
    Ok(())
}


#[cfg(target_os = "macos")]
pub fn restart_service() -> sharing::PisPasResult<()> {
    tracing::info!("Restarting service...");

    let _ = stop_service();
    std::thread::sleep(std::time::Duration::from_secs(1));
    start_service()?;

    tracing::info!("Service restarted successfully");
    Ok(())
}

// ===== FUNCIONES DE INSTALACIÓN =====

#[cfg(target_os = "macos")]
pub fn install_service() -> sharing::PisPasResult<()> {
    tracing::info!("Installing pispas service on macOS...");
    clean_and_register_service()
}

#[cfg(target_os = "macos")]
pub fn clean_and_register_service() -> sharing::PisPasResult<()> {
    use std::fs;
    use std::process::Command;

    tracing::info!("Cleaning existing pispas services...");

    // 1. MATAR todos los procesos pispas
    let _ = Command::new("sudo").args(&["pkill", "-f", "pispas"]).output();
    let _ = Command::new("sudo").args(&["pkill", "-f", "pispas-modules"]).output();
    let _ = Command::new("sudo").args(&["pkill", "-f", "pispas-service"]).output();
    let _ = Command::new("sudo").args(&["pkill", "-f", "pispas-tray-app"]).output();


    std::thread::sleep(std::time::Duration::from_secs(2));

    // 2. ELIMINAR todos los plists existentes
    let service_name = sharing::SERVICE_NAME;

    // LaunchDaemons (nivel sistema)
    let daemon_plist = format!("/Library/LaunchDaemons/{}.plist", service_name);
    let _ = Command::new("sudo").args(&["launchctl", "unload", &daemon_plist]).output();
    let _ = Command::new("sudo").args(&["rm", "-f", &daemon_plist]).output();

    // LaunchAgents nivel sistema
    let system_agent_plist = format!("/Library/LaunchAgents/{}.plist", service_name);
    let _ = Command::new("sudo").args(&["rm", "-f", &system_agent_plist]).output();

    // LaunchAgents de usuario
    let home_dir = dirs::home_dir().ok_or_else(|| anyhow::anyhow!("Cannot get home directory"))?;
    let user_agent_plist = home_dir.join("Library/LaunchAgents").join(format!("{}.plist", service_name));

    if user_agent_plist.exists() {
        let _ = Command::new("launchctl")
            .args(&["unload", &user_agent_plist.to_string_lossy()])
            .output();
        let _ = fs::remove_file(&user_agent_plist);
    }

    // En el paso 3, cambia esto:
    let _ = Command::new("sudo").args(&["launchctl", "remove", service_name]).output();
    let _ = Command::new("launchctl").args(&["remove", service_name]).output();

    // Por esto:
    let uid = unsafe { libc::getuid() };
    let domain = format!("gui/{}", uid);
    let _ = Command::new("launchctl").args(&["bootout", &domain, &user_agent_plist.to_string_lossy()]).output();

    tracing::info!("Cleanup completed. Registering new service...");

    // 4. Crear el symlink del binario si no existe
    let service_binary = sharing::paths::bin_dir().join(sharing::SERVICE_NAME_EXE);
    if !service_binary.exists() {
        let modules_binary = sharing::paths::bin_dir().join("pispas-modules");
        if modules_binary.exists() {
            std::os::unix::fs::symlink(&modules_binary, &service_binary)?;
            tracing::info!("Created symlink: {} -> {}",
                service_binary.display(), modules_binary.display());
        } else {
            return Err(anyhow::anyhow!("Neither pispas-service nor pispas-modules binary found"));
        }
    }

    // 5. Registrar el nuevo servicio como LaunchDaemon
    register_service_as_daemon()?;

    Ok(())
}

#[cfg(target_os = "macos")]
fn create_launch_daemon_plist() -> sharing::PisPasResult<String> {
    match sharing::natives::api::get_first_logged_user() {
        Ok((_username, uid)) => {
            if let Some(user) = get_user_by_uid(uid) {

                // Construir la ruta dinámicamente
                let service_binary_path = format!(
                    "{}/.config/pispas/{}",
                    user.home_dir().display(),
                    sharing::SERVICE_NAME_EXE
                );

                let working_directory = format!(
                    "{}/.config/pispas",
                    user.home_dir().display()
                );

                let plist_content = format!(r#"<?xml version="1.0" encoding="UTF-8"?>
        <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
        <plist version="1.0">
        <dict>
        <key>Label</key>
        <string>{}</string>
        <key>ProgramArguments</key>
        <array>
            <string>{}</string>
        </array>
        <key>RunAtLoad</key>
        <true/>
        <key>KeepAlive</key>
        <true/>
        <key>StandardOutPath</key>
        <string>/var/log/pispas/pispas-service.out.log</string>
        <key>StandardErrorPath</key>
        <string>/var/log/pispas/pispas-service.err.log</string>
        <key>WorkingDirectory</key>
        <string>{}</string>
        </dict>
        </plist>"#,
                                            sharing::SERVICE_NAME,
                                            service_binary_path,
                                            working_directory
                );

               return Ok(plist_content);
            }
        }
        Err(e) => {
            tracing::error!("Error getting first logged user: {}", e);
            return Err(anyhow::anyhow!("Failed to get first logged user"));
        }
    }
    Err(anyhow::anyhow!("Failed to create LaunchDaemon plist"))
}
// Para Linux (systemd)
#[cfg(target_os = "linux")]
pub fn register_service() -> sharing::PisPasResult<()> {
    use std::fs;
    use std::os::unix::fs::PermissionsExt;

    let service_name = sharing::SERVICE_NAME;
    let service_content = create_systemd_service()?;
    let service_path = format!("/etc/systemd/system/{}.service", service_name);

    // Escribir el archivo de servicio
    fs::write(&service_path, service_content)?;

    // Establecer permisos correctos
    let mut perms = fs::metadata(&service_path)?.permissions();
    perms.set_mode(0o644);
    fs::set_permissions(&service_path, perms)?;

    // Recargar systemd y habilitar el servicio
    std::process::Command::new("systemctl")
        .args(&["daemon-reload"])
        .output()?;

    let output = std::process::Command::new("systemctl")
        .args(&["enable", service_name])
        .output()?;

    if !output.status.success() {
        let error = String::from_utf8_lossy(&output.stderr);
        tracing::error!("Failed to enable service: {}", error);
        return Err(anyhow::anyhow!("Failed to enable service: {}", error));
    }

    tracing::info!("Service {} registered successfully", service_name);
    Ok(())
}

#[cfg(target_os = "linux")]
pub fn unregister_service() -> sharing::PisPasResult<()> {
    let service_name = sharing::SERVICE_NAME;
    let service_path = format!("/etc/systemd/system/{}.service", service_name);

    // Parar y deshabilitar el servicio
    std::process::Command::new("systemctl")
        .args(&["stop", service_name])
        .output()?;

    std::process::Command::new("systemctl")
        .args(&["disable", service_name])
        .output()?;

    // Eliminar el archivo de servicio
    if std::path::Path::new(&service_path).exists() {
        std::fs::remove_file(&service_path)?;
        tracing::info!("Service file removed: {}", service_path);
    }

    // Recargar systemd
    std::process::Command::new("systemctl")
        .args(&["daemon-reload"])
        .output()?;

    tracing::info!("Service {} unregistered successfully", service_name);
    Ok(())
}

#[cfg(target_os = "linux")]
pub fn start_service() -> sharing::PisPasResult<()> {
    let service_name = sharing::SERVICE_NAME;

    let output = std::process::Command::new("systemctl")
        .args(&["start", service_name])
        .output()?;

    if !output.status.success() {
        let error = String::from_utf8_lossy(&output.stderr);
        tracing::error!("Failed to start service: {}", error);
        return Err(anyhow::anyhow!("Failed to start service: {}", error));
    }

    tracing::info!("Service {} started successfully", service_name);
    Ok(())
}

#[cfg(target_os = "linux")]
pub fn stop_service() -> sharing::PisPasResult<()> {
    let service_name = sharing::SERVICE_NAME;

    let output = std::process::Command::new("systemctl")
        .args(&["stop", service_name])
        .output()?;

    if !output.status.success() {
        let error = String::from_utf8_lossy(&output.stderr);
        tracing::warn!("Failed to stop service (might not be running): {}", error);
    }

    tracing::info!("Service {} stopped", service_name);
    Ok(())
}

#[cfg(target_os = "linux")]
fn create_systemd_service() -> sharing::PisPasResult<String> {
    let service_binary_path = sharing::paths::bin_dir().join(sharing::SERVICE_NAME_EXE);
    let service_name = sharing::SERVICE_NAME;

    let service_content = format!(r#"[Unit]
Description={}
After=network.target

[Service]
Type=simple
ExecStart={} run
Restart=always
RestartSec=5
User=root
WorkingDirectory={}

[Install]
WantedBy=multi-user.target
"#,
                                  service_name,
                                  service_binary_path.display(),
                                  sharing::paths::bin_dir().display()
    );

    Ok(service_content)
}