testlint_sdk/platform/

mod.rs

/// Cross-platform process and system operations
///
/// This module provides platform-agnostic abstractions for:
/// - Process management (checking, signaling, terminating)
/// - Process information (command line, executable path)
/// - File permissions
///
/// Each operation has Unix and Windows implementations where possible,
/// with graceful degradation when platform features aren't available.
use std::process::Command;

/// Check if a process with the given PID exists
pub fn process_exists(pid: u32) -> Result<bool, String> {
    #[cfg(unix)]
    {
        let output = Command::new("ps")
            .args(["-p", &pid.to_string()])
            .output()
            .map_err(|e| format!("Failed to check process: {}", e))?;

        Ok(output.status.success())
    }

    #[cfg(windows)]
    {
        let output = Command::new("tasklist")
            .args(["/FI", &format!("PID eq {}", pid), "/NH"])
            .output()
            .map_err(|e| format!("Failed to check process: {}", e))?;

        let stdout = String::from_utf8_lossy(&output.stdout);
        Ok(stdout.contains(&pid.to_string()))
    }

    #[cfg(not(any(unix, windows)))]
    {
        Err("Process checking not supported on this platform".to_string())
    }
}

/// Get the command line of a running process
pub fn get_process_cmdline(pid: u32) -> Result<String, String> {
    #[cfg(target_os = "linux")]
    {
        let cmdline_path = format!("/proc/{}/cmdline", pid);
        std::fs::read_to_string(&cmdline_path)
            .map(|s| s.replace('\0', " "))
            .map_err(|e| format!("Failed to read process cmdline: {}", e))
    }

    #[cfg(target_os = "macos")]
    {
        let output = Command::new("ps")
            .args(["-p", &pid.to_string(), "-o", "command="])
            .output()
            .map_err(|e| format!("Failed to get process command: {}", e))?;

        Ok(String::from_utf8_lossy(&output.stdout).trim().to_string())
    }

    #[cfg(windows)]
    {
        // Use WMIC to get process command line
        let output = Command::new("wmic")
            .args([
                "process",
                "where",
                &format!("ProcessId={}", pid),
                "get",
                "CommandLine",
                "/format:list",
            ])
            .output()
            .map_err(|e| format!("Failed to get process command: {}", e))?;

        let stdout = String::from_utf8_lossy(&output.stdout);
        for line in stdout.lines() {
            if line.starts_with("CommandLine=") {
                return Ok(line.trim_start_matches("CommandLine=").to_string());
            }
        }

        Err(format!("Could not find command line for PID {}", pid))
    }

    #[cfg(not(any(target_os = "linux", target_os = "macos", windows)))]
    {
        Err("Getting process command line not supported on this platform".to_string())
    }
}

/// Get the executable name/path of a running process
pub fn get_process_name(pid: u32) -> Result<String, String> {
    #[cfg(unix)]
    {
        let output = Command::new("ps")
            .args(["-p", &pid.to_string(), "-o", "comm="])
            .output()
            .map_err(|e| format!("Failed to check process: {}", e))?;

        Ok(String::from_utf8_lossy(&output.stdout).trim().to_string())
    }

    #[cfg(windows)]
    {
        let output = Command::new("tasklist")
            .args(["/FI", &format!("PID eq {}", pid), "/NH", "/FO", "CSV"])
            .output()
            .map_err(|e| format!("Failed to get process name: {}", e))?;

        let stdout = String::from_utf8_lossy(&output.stdout);
        // CSV format: "image name","PID","Session Name","Session#","Mem Usage"
        if let Some(line) = stdout.lines().next() {
            if let Some(name) = line.split(',').next() {
                return Ok(name.trim_matches('"').to_string());
            }
        }

        Err(format!("Could not find process name for PID {}", pid))
    }

    #[cfg(not(any(unix, windows)))]
    {
        Err("Getting process name not supported on this platform".to_string())
    }
}

/// Signal a process (Unix: actual signals, Windows: graceful alternatives)
pub fn signal_process(pid: u32, signal: ProcessSignal) -> Result<(), String> {
    #[cfg(unix)]
    {
        let signal_name = match signal {
            ProcessSignal::Interrupt => "INT",
            ProcessSignal::Terminate => "TERM",
            ProcessSignal::User1 => "USR1",
            ProcessSignal::User2 => "USR2",
        };

        Command::new("kill")
            .args([&format!("-{}", signal_name), &pid.to_string()])
            .output()
            .map_err(|e| format!("Failed to signal process: {}", e))?;

        Ok(())
    }

    #[cfg(windows)]
    {
        match signal {
            ProcessSignal::Interrupt | ProcessSignal::Terminate => {
                // On Windows, we can only forcefully terminate
                // Use taskkill with /T to kill process tree
                let output = Command::new("taskkill")
                    .args(["/PID", &pid.to_string(), "/T"])
                    .output()
                    .map_err(|e| format!("Failed to terminate process: {}", e))?;

                if !output.status.success() {
                    return Err(format!(
                        "Failed to terminate process: {}",
                        String::from_utf8_lossy(&output.stderr)
                    ));
                }
                Ok(())
            }
            ProcessSignal::User1 | ProcessSignal::User2 => Err(
                "User-defined signals (SIGUSR1/SIGUSR2) are not available on Windows. \
                     Consider using a file-based trigger mechanism or named pipes instead."
                    .to_string(),
            ),
        }
    }

    #[cfg(not(any(unix, windows)))]
    {
        Err("Signaling processes not supported on this platform".to_string())
    }
}

/// Process signals (cross-platform abstraction)
#[derive(Debug, Clone, Copy)]
pub enum ProcessSignal {
    Interrupt, // SIGINT / Ctrl+C
    Terminate, // SIGTERM
    User1,     // SIGUSR1 (Unix only)
    User2,     // SIGUSR2 (Unix only)
}

/// Make a file executable (Unix only, no-op on Windows)
pub fn make_executable(path: &str) -> Result<(), String> {
    #[cfg(unix)]
    {
        Command::new("chmod")
            .args(["+x", path])
            .output()
            .map_err(|e| format!("Failed to make file executable: {}", e))?;
        Ok(())
    }

    #[cfg(windows)]
    {
        // On Windows, executability is determined by file extension (.exe, .bat, .cmd)
        // So this is a no-op
        Ok(())
    }

    #[cfg(not(any(unix, windows)))]
    {
        Ok(()) // No-op on other platforms
    }
}

/// Check if a process is of a specific type (e.g., "node", "python", "java")
pub fn is_process_type(pid: u32, process_type: &str) -> Result<bool, String> {
    let name = get_process_name(pid)?;
    let cmdline = get_process_cmdline(pid).unwrap_or_default();

    let name_lower = name.to_lowercase();
    let cmdline_lower = cmdline.to_lowercase();
    let type_lower = process_type.to_lowercase();

    Ok(name_lower.contains(&type_lower) || cmdline_lower.contains(&type_lower))
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_process_exists_current() {
        // Current process should always exist
        let pid = std::process::id();
        assert!(process_exists(pid).unwrap());
    }

    #[test]
    fn test_process_exists_invalid() {
        // PID 0 should not exist (reserved)
        // Very high PID unlikely to exist
        assert!(!process_exists(999999).unwrap_or(true));
    }

    #[test]
    fn test_get_process_name_current() {
        let pid = std::process::id();
        let name = get_process_name(pid);
        assert!(name.is_ok());
        // Should contain test runner or cargo
        let name_str = name.unwrap().to_lowercase();
        assert!(
            name_str.contains("test")
                || name_str.contains("cargo")
                || name_str.contains("testlint")
        );
    }
}