openrunner-rs 1.0.0

//! Core execution functions for running OpenScript code.

use crate::error::{Error, Result};
use crate::types::{ExecResult, IoOptions, ScriptOptions, SpawnResult};
use std::io::Write;
use std::path::PathBuf;
use std::process::Stdio;
use std::time::Instant;
use tempfile::NamedTempFile;
use tokio::process::{Child, Command};
use tokio::time::timeout;

/// Run an OpenScript from a string and wait for completion.
///
/// This function creates a temporary file with the script content and executes it
/// using the OpenScript interpreter, waiting for completion and capturing the output.
///
/// # Arguments
///
/// * `script` - The OpenScript code to execute
/// * `options` - Configuration options for script execution
///
/// # Returns
///
/// Returns an `ExecResult` containing the exit code, stdout, stderr, and execution duration.
///
/// # Examples
///
/// ```rust
/// use openrunner_rs::{run, ScriptOptions};
/// use std::time::Duration;
///
/// # #[tokio::main]
/// # async fn main() -> openrunner_rs::Result<()> {
/// let options = ScriptOptions::new()
///     .openscript_path("/bin/sh")
///     .timeout(Duration::from_secs(30));
/// let result = run("echo 'Hello, World!'", options).await?;
/// println!("Output: {}", result.stdout);
/// # Ok(())
/// # }
/// ```
pub async fn run(script: &str, options: ScriptOptions) -> Result<ExecResult> {
    let start_time = Instant::now();
    
    // Validate script is not empty
    if script.trim().is_empty() {
        return Err(Error::command_failed("Script content cannot be empty"));
    }

    // Create temporary file for the script
    let mut temp_file = NamedTempFile::new()
        .map_err(|e| Error::script_write_error(e))?;
    
    temp_file.write_all(script.as_bytes())
        .map_err(|e| Error::script_write_error(e))?;
    
    temp_file.flush()
        .map_err(|e| Error::script_write_error(e))?;

    let script_path = temp_file.path().to_path_buf();
    
    // Validate working directory if specified
    if let Some(ref wd) = options.working_directory {
        if !wd.exists() {
            return Err(Error::invalid_working_directory(
                wd.to_string_lossy(),
                std::io::Error::new(std::io::ErrorKind::NotFound, "Directory does not exist")
            ));
        }
        if !wd.is_dir() {
            return Err(Error::invalid_working_directory(
                wd.to_string_lossy(),
                std::io::Error::new(std::io::ErrorKind::InvalidInput, "Path is not a directory")
            ));
        }
    }

    let timeout_duration = options.timeout;
    let child = spawn_command(&script_path, &options)
        .await?;

    // Handle timeout if specified
    let output = if let Some(timeout_duration) = timeout_duration {
        match timeout(timeout_duration, child.wait_with_output()).await {
            Ok(result) => result.map_err(|e| Error::process_wait_error(e))?,
            Err(_) => {
                // Note: child is consumed by wait_with_output(), so we can't kill it here
                // The timeout mechanism in tokio will handle process cleanup
                return Ok(ExecResult {
                    exit_code: -1,
                    stdout: String::new(),
                    stderr: format!("Process timed out after {:?}", timeout_duration),
                    duration: start_time.elapsed(),
                    timed_out: true,
                });
            }
        }
    } else {
        child.wait_with_output().await
            .map_err(|e| Error::process_wait_error(e))?
    };

    let duration = start_time.elapsed();
    let exit_code = output.status.code().unwrap_or(-1);
    
    let stdout = String::from_utf8_lossy(&output.stdout).to_string();
    let stderr = String::from_utf8_lossy(&output.stderr).to_string();

    Ok(ExecResult {
        exit_code,
        stdout,
        stderr,
        duration,
        timed_out: false,
    })
}

/// Run an OpenScript file and wait for completion.
///
/// This function executes a script file using the OpenScript interpreter,
/// waiting for completion and capturing the output.
///
/// # Arguments
///
/// * `path` - Path to the script file to execute
/// * `options` - Configuration options for script execution
///
/// # Returns
///
/// Returns an `ExecResult` containing the exit code, stdout, stderr, and execution duration.
///
/// # Examples
///
/// ```rust
/// use openrunner_rs::{run_file, ScriptOptions};
/// use std::path::PathBuf;
/// use std::io::Write;
///
/// # #[tokio::main]
/// # async fn main() -> openrunner_rs::Result<()> {
/// # let mut temp_file = tempfile::NamedTempFile::new().unwrap();
/// # writeln!(temp_file, "echo 'Hello from file!'").unwrap();
/// # let script_path = temp_file.path().to_path_buf();
/// let options = ScriptOptions::new().openscript_path("/bin/sh");
/// let result = run_file(&script_path, options).await?;
/// println!("Exit code: {}", result.exit_code);
/// # Ok(())
/// # }
/// ```
pub async fn run_file(path: &PathBuf, options: ScriptOptions) -> Result<ExecResult> {
    // Validate the script file exists and is readable
    if !path.exists() {
        return Err(Error::script_read_error(
            path.to_string_lossy(),
            std::io::Error::new(std::io::ErrorKind::NotFound, "Script file does not exist")
        ));
    }
    
    if !path.is_file() {
        return Err(Error::invalid_script_path(
            path.to_string_lossy(),
            "Path is not a file"
        ));
    }

    // Check if file is readable
    match std::fs::metadata(path) {
        Ok(metadata) => {
            if metadata.len() == 0 {
                return Err(Error::invalid_script_path(
                    path.to_string_lossy(),
                    "Script file is empty"
                ));
            }
        }
        Err(e) => {
            return Err(Error::script_read_error(path.to_string_lossy(), e));
        }
    }

    let start_time = Instant::now();
    let timeout_duration = options.timeout;
    let child = spawn_command(path, &options).await?;

    // Handle timeout if specified
    let output = if let Some(timeout_duration) = timeout_duration {
        match timeout(timeout_duration, child.wait_with_output()).await {
            Ok(result) => result.map_err(|e| Error::process_wait_error(e))?,
            Err(_) => {
                // Note: child is consumed by wait_with_output(), so we can't kill it here
                // The timeout mechanism in tokio will handle process cleanup
                return Ok(ExecResult {
                    exit_code: -1,
                    stdout: String::new(),
                    stderr: format!("Process timed out after {:?}", timeout_duration),
                    duration: start_time.elapsed(),
                    timed_out: true,
                });
            }
        }
    } else {
        child.wait_with_output().await
            .map_err(|e| Error::process_wait_error(e))?
    };

    let duration = start_time.elapsed();
    let exit_code = output.status.code().unwrap_or(-1);
    
    let stdout = String::from_utf8_lossy(&output.stdout).to_string();
    let stderr = String::from_utf8_lossy(&output.stderr).to_string();

    Ok(ExecResult {
        exit_code,
        stdout,
        stderr,
        duration,
        timed_out: false,
    })
}

/// Spawn an OpenScript process from a string without waiting for completion.
///
/// This function creates a temporary file with the script content and spawns
/// the OpenScript process, returning a `Child` handle for further interaction.
///
/// The returned `SpawnResult` contains the `Child` and a handle to the temporary
/// file, ensuring it is not deleted until the `SpawnResult` is dropped.
///
/// # Arguments
///
/// * `script` - The OpenScript code to execute
/// * `options` - Configuration options for script execution
///
/// # Returns
///
/// Returns a `SpawnResult` that can be used to interact with the running process.
///
/// # Examples
///
/// ```rust
/// use openrunner_rs::{spawn, ScriptOptions};
///
/// # #[tokio::main]
/// # async fn main() -> openrunner_rs::Result<()> {
/// let options = ScriptOptions::new().openscript_path("/bin/sh");
/// let spawn_result = spawn("echo 'Background task'", options).await?;
/// let output = spawn_result.child.wait_with_output().await?;
/// println!("Output: {}", String::from_utf8_lossy(&output.stdout));
/// # Ok(())
/// # }
/// ```
pub async fn spawn(script: &str, options: ScriptOptions) -> Result<SpawnResult> {
    // Validate script is not empty
    if script.trim().is_empty() {
        return Err(Error::command_failed("Script content cannot be empty"));
    }

    // Create temporary file for the script
    let mut temp_file = NamedTempFile::new()
        .map_err(|e| Error::script_write_error(e))?;
    
    temp_file.write_all(script.as_bytes())
        .map_err(|e| Error::script_write_error(e))?;
    
    temp_file.flush()
        .map_err(|e| Error::script_write_error(e))?;

    let script_path = temp_file.path().to_path_buf();
    let child = spawn_command(&script_path, &options).await?;

    Ok(SpawnResult {
        child,
        _temp_file: Some(temp_file),
    })
}

/// Spawn an OpenScript process from a file without waiting for completion.
///
/// This function spawns a script file using the OpenScript interpreter and returns
/// a `Child` handle for further interaction.
///
/// # Arguments
///
/// * `path` - Path to the script file to execute
/// * `options` - Configuration options for script execution
///
/// # Returns
///
/// Returns a `Child` process handle.
pub async fn spawn_file(path: &PathBuf, options: ScriptOptions) -> Result<Child> {
    // Validate the script file exists and is readable
    if !path.exists() {
        return Err(Error::script_read_error(
            path.to_string_lossy(),
            std::io::Error::new(std::io::ErrorKind::NotFound, "Script file does not exist")
        ));
    }
    
    if !path.is_file() {
        return Err(Error::invalid_script_path(
            path.to_string_lossy(),
            "Path is not a file"
        ));
    }

    spawn_command(path, &options).await
}

async fn spawn_command(path: &PathBuf, options: &ScriptOptions) -> Result<Child> {
    let openscript_path = options
        .openscript_path
        .as_ref()
        .cloned()
        .unwrap_or_else(|| PathBuf::from("openscript"));

    // Validate openscript executable exists if it's an absolute path
    if openscript_path.is_absolute() && !openscript_path.exists() {
        return Err(Error::OpenScriptNotFound);
    }

    let mut cmd = Command::new(&openscript_path);

    cmd.arg(path);
    cmd.args(&options.args);

    // Validate and set working directory
    if let Some(ref cwd) = options.working_directory {
        if !cwd.exists() {
            return Err(Error::invalid_working_directory(
                cwd.to_string_lossy(),
                std::io::Error::new(std::io::ErrorKind::NotFound, "Directory does not exist")
            ));
        }
        cmd.current_dir(cwd);
    }

    if options.clear_env {
        cmd.env_clear();
    }
    
    // Validate environment variables
    for (key, value) in &options.env_vars {
        if key.contains('\0') || value.contains('\0') {
            return Err(Error::invalid_environment_variable(
                key, 
                "Environment variable contains null bytes"
            ));
        }
        cmd.env(key, value);
    }

    cmd.stdin(convert_io(options.stdin));
    cmd.stdout(convert_io(options.stdout));
    cmd.stderr(convert_io(options.stderr));

    let child = cmd.spawn().map_err(|e| {
        match e.kind() {
            std::io::ErrorKind::NotFound => Error::OpenScriptNotFound,
            std::io::ErrorKind::PermissionDenied => Error::PermissionDenied,
            _ => Error::process_spawn_error(e),
        }
    })?;

    Ok(child)
}

fn convert_io(io_option: IoOptions) -> Stdio {
    match io_option {
        IoOptions::Inherit => Stdio::inherit(),
        IoOptions::Pipe => Stdio::piped(),
        IoOptions::Null => Stdio::null(),
    }
}

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

    #[tokio::test]
    async fn test_run_success() {
        let options = ScriptOptions::new().openscript_path("/bin/sh");
        let result = run("echo 'test'", options).await.unwrap();
        assert_eq!(result.exit_code, 0);
        assert!(result.stdout.contains("test"));
    }

    #[tokio::test]
    async fn test_run_empty_script() {
        let options = ScriptOptions::new().openscript_path("/bin/sh");
        let result = run("", options).await;
        assert!(result.is_err());
        assert!(matches!(result.unwrap_err(), Error::CommandFailed { .. }));
    }

    #[tokio::test]
    async fn test_run_with_timeout() {
        let options = ScriptOptions::new()
            .openscript_path("/bin/sh")
            .timeout(Duration::from_millis(100));
        let result = run("sleep 1", options).await.unwrap();
        assert!(result.timed_out);
    }

    #[tokio::test]
    async fn test_spawn_and_wait() -> crate::Result<()> {
        let options = ScriptOptions::new().openscript_path("/bin/sh");
        let spawn_result = spawn("echo 'spawned'", options).await?;
        let output = spawn_result.child.wait_with_output().await?;
        let stdout = String::from_utf8_lossy(&output.stdout);
        assert!(stdout.contains("spawned"));
        Ok(())
    }

    #[tokio::test]
    async fn test_invalid_working_directory() {
        let options = ScriptOptions::new()
            .openscript_path("/bin/sh")
            .working_directory("/nonexistent/directory");
        let result = run("echo 'test'", options).await;
        assert!(result.is_err());
        assert!(matches!(result.unwrap_err(), Error::InvalidWorkingDirectory { .. }));
    }

    #[tokio::test]
    async fn test_invalid_script_file() {
        let options = ScriptOptions::new().openscript_path("/bin/sh");
        let non_existent_path = PathBuf::from("/nonexistent/script.sh");
        let result = run_file(&non_existent_path, options).await;
        assert!(result.is_err());
        assert!(matches!(result.unwrap_err(), Error::ScriptReadError { .. }));
    }

    #[tokio::test]
    async fn test_error_retryability() {
        let timeout_error = Error::timeout(Duration::from_secs(5));
        assert!(timeout_error.is_retryable());

        let not_found_error = Error::OpenScriptNotFound;
        assert!(!not_found_error.is_retryable());
    }

    #[tokio::test]
    async fn test_user_friendly_messages() {
        let error = Error::OpenScriptNotFound;
        let message = error.user_message();
        assert!(message.contains("install OpenScript"));
    }
}