daytona_client/

process.rs

//! Process execution within sandboxes

use base64::{Engine, engine::general_purpose::STANDARD};
use tracing::{debug, info};
use uuid::Uuid;

use crate::{
    client::DaytonaClient,
    error::Result,
    models::{
        CreateSessionRequest, ExecuteRequest, ExecuteResponse, Language, Session, SessionCommand,
        SessionExecuteRequest, SessionExecuteResponse,
    },
};

/// Process executor for running commands and code in sandboxes
pub struct ProcessExecutor<'a> {
    client: &'a DaytonaClient,
}

impl<'a> ProcessExecutor<'a> {
    /// Create a new process executor
    pub fn new(client: &'a DaytonaClient) -> Self {
        Self { client }
    }

    /// Execute a raw command in a sandbox
    pub async fn execute_command(
        &self,
        sandbox_id: &Uuid,
        command: &str,
    ) -> Result<ExecuteResponse> {
        info!("Executing command in sandbox {}: {}", sandbox_id, command);

        let request = ExecuteRequest {
            command: command.to_string(),
            cwd: None,
            timeout: Some(self.client.config.timeout_seconds),
        };

        let response = self
            .client
            .build_request(
                reqwest::Method::POST,
                &format!("/toolbox/{}/toolbox/process/execute", sandbox_id),
            )
            .json(&request)
            .send()
            .await?;

        self.client.handle_response(response).await
    }

    /// Execute with custom options
    pub async fn execute_with_options(
        &self,
        sandbox_id: &Uuid,
        request: ExecuteRequest,
    ) -> Result<ExecuteResponse> {
        info!("Executing command with options in sandbox {}", sandbox_id);

        let response = self
            .client
            .build_request(
                reqwest::Method::POST,
                &format!("/toolbox/{}/toolbox/process/execute", sandbox_id),
            )
            .json(&request)
            .send()
            .await?;

        self.client.handle_response(response).await
    }

    /// Execute code in a specific language
    pub async fn execute_code(
        &self,
        sandbox_id: &Uuid,
        language: Language,
        code: &str,
    ) -> Result<ExecuteResponse> {
        info!("Executing {:?} code in sandbox {}", language, sandbox_id);
        debug!("Code:\n{}", code);

        // First, write the code to a temporary file
        let file_ext = match language {
            Language::Python => "py",
            Language::Javascript => "js",
            Language::Typescript => "ts",
            Language::Rust => "rs",
            Language::Go => "go",
            Language::Java => "java",
            Language::Ruby => "rb",
            Language::Php => "php",
            Language::Shell => "sh",
        };

        let filename = format!("/tmp/code_{}.{}", Uuid::new_v4(), file_ext);

        // Upload the code file
        let files = crate::files::FileManager::new(self.client);
        files.upload(sandbox_id, &filename, code.as_bytes()).await?;

        // Execute the file
        let command = match language {
            Language::Python => format!("python {}", filename),
            Language::Javascript => format!("node {}", filename),
            Language::Typescript => format!("ts-node {}", filename),
            Language::Rust => format!("rustc {} -o /tmp/rust_out && /tmp/rust_out", filename),
            Language::Go => format!("go run {}", filename),
            Language::Java => {
                let class_name = filename.strip_suffix(".java").unwrap_or(&filename);
                format!("javac {} && java {}", filename, class_name)
            }
            Language::Ruby => format!("ruby {}", filename),
            Language::Php => format!("php {}", filename),
            Language::Shell => format!("bash {}", filename),
        };

        self.execute_command(sandbox_id, &command).await
    }

    /// Execute code using stdin (for simpler cases)
    pub async fn execute_code_stdin(
        &self,
        sandbox_id: &Uuid,
        language: Language,
        code: &str,
    ) -> Result<ExecuteResponse> {
        // Base64 encode the code to avoid shell escaping issues
        let encoded_code = STANDARD.encode(code.as_bytes());

        let command = match language {
            Language::Python => format!("echo {} | base64 -d | python", encoded_code),
            Language::Javascript => format!("echo {} | base64 -d | node", encoded_code),
            Language::Shell => format!("echo {} | base64 -d | bash", encoded_code),
            _ => {
                // For languages that don't easily support stdin, fall back to file method
                return self.execute_code(sandbox_id, language, code).await;
            }
        };

        self.execute_command(sandbox_id, &command).await
    }

    /// Run a shell script
    pub async fn run_script(&self, sandbox_id: &Uuid, script: &str) -> Result<ExecuteResponse> {
        self.execute_code(sandbox_id, Language::Shell, script).await
    }

    /// Install packages in the sandbox
    pub async fn install_packages(
        &self,
        sandbox_id: &Uuid,
        language: Language,
        packages: Vec<String>,
    ) -> Result<ExecuteResponse> {
        let command = match language {
            Language::Python => format!("pip install {}", packages.join(" ")),
            Language::Javascript => format!("npm install {}", packages.join(" ")),
            Language::Ruby => format!("gem install {}", packages.join(" ")),
            Language::Php => format!("composer require {}", packages.join(" ")),
            Language::Go => format!("go get {}", packages.join(" ")),
            Language::Rust => format!("cargo add {}", packages.join(" ")),
            _ => {
                return Err(crate::error::DaytonaError::InvalidParameters(format!(
                    "Package installation not supported for {:?}",
                    language
                )));
            }
        };

        self.execute_command(sandbox_id, &command).await
    }

    /// Create a new session for persistent command execution
    pub async fn create_session(&self, sandbox_id: &Uuid, session_id: &str) -> Result<()> {
        info!(
            "Creating new session {} in sandbox {}",
            session_id, sandbox_id
        );

        let request = CreateSessionRequest {
            session_id: session_id.to_string(),
        };

        let response = self
            .client
            .build_request(
                reqwest::Method::POST,
                &format!("/toolbox/{}/toolbox/process/session", sandbox_id),
            )
            .json(&request)
            .send()
            .await?;

        if response.status().is_success() {
            Ok(())
        } else {
            let error_text = response.text().await?;
            Err(crate::error::DaytonaError::RequestFailed(format!(
                "Failed to create session: {}",
                error_text
            )))
        }
    }

    /// Delete a session
    pub async fn delete_session(&self, sandbox_id: &Uuid, session_id: &str) -> Result<()> {
        info!("Deleting session {} in sandbox {}", session_id, sandbox_id);

        let response = self
            .client
            .build_request(
                reqwest::Method::DELETE,
                &format!(
                    "/toolbox/{}/toolbox/process/session/{}",
                    sandbox_id, session_id
                ),
            )
            .send()
            .await?;

        if response.status().is_success() {
            Ok(())
        } else {
            let error_text = response.text().await?;
            Err(crate::error::DaytonaError::RequestFailed(format!(
                "Failed to delete session: {}",
                error_text
            )))
        }
    }

    /// Get session information
    pub async fn get_session(&self, sandbox_id: &Uuid, session_id: &str) -> Result<Session> {
        debug!("Getting session {} in sandbox {}", session_id, sandbox_id);

        let response = self
            .client
            .build_request(
                reqwest::Method::GET,
                &format!(
                    "/toolbox/{}/toolbox/process/session/{}",
                    sandbox_id, session_id
                ),
            )
            .send()
            .await?;

        self.client.handle_response(response).await
    }

    /// List all sessions
    pub async fn list_sessions(&self, sandbox_id: &Uuid) -> Result<Vec<Session>> {
        debug!("Listing sessions in sandbox {}", sandbox_id);

        let response = self
            .client
            .build_request(
                reqwest::Method::GET,
                &format!("/toolbox/{}/toolbox/process/session", sandbox_id),
            )
            .send()
            .await?;

        self.client.handle_response(response).await
    }

    /// Execute a command in a session
    pub async fn execute_session_command(
        &self,
        sandbox_id: &Uuid,
        session_id: &str,
        request: SessionExecuteRequest,
    ) -> Result<SessionExecuteResponse> {
        info!(
            "Executing command '{}' in session {} in sandbox {}",
            request.command, session_id, sandbox_id
        );

        let response = self
            .client
            .build_request(
                reqwest::Method::POST,
                &format!(
                    "/toolbox/{}/toolbox/process/session/{}/exec",
                    sandbox_id, session_id
                ),
            )
            .json(&request)
            .send()
            .await?;

        self.client.handle_response(response).await
    }

    /// Get session command result
    pub async fn get_session_command(
        &self,
        sandbox_id: &Uuid,
        session_id: &str,
        command_id: &str,
    ) -> Result<SessionCommand> {
        debug!(
            "Getting command {} from session {} in sandbox {}",
            command_id, session_id, sandbox_id
        );

        let response = self
            .client
            .build_request(
                reqwest::Method::GET,
                &format!(
                    "/toolbox/{}/toolbox/process/session/{}/command/{}",
                    sandbox_id, session_id, command_id
                ),
            )
            .send()
            .await?;

        self.client.handle_response(response).await
    }

    /// Get session command logs
    pub async fn get_session_command_logs(
        &self,
        sandbox_id: &Uuid,
        session_id: &str,
        command_id: &str,
    ) -> Result<String> {
        debug!(
            "Getting logs for command {} from session {} in sandbox {}",
            command_id, session_id, sandbox_id
        );

        let response = self
            .client
            .build_request(
                reqwest::Method::GET,
                &format!(
                    "/toolbox/{}/toolbox/process/session/{}/command/{}/logs",
                    sandbox_id, session_id, command_id
                ),
            )
            .send()
            .await?;

        if response.status().is_success() {
            Ok(response.text().await?)
        } else {
            let error_text = response.text().await?;
            Err(crate::error::DaytonaError::RequestFailed(format!(
                "Failed to get command logs: {}",
                error_text
            )))
        }
    }

    /// Get project directory
    pub async fn get_project_dir(&self, sandbox_id: &Uuid) -> Result<String> {
        debug!("Getting project directory for sandbox {}", sandbox_id);

        let response = self
            .client
            .build_request(
                reqwest::Method::GET,
                &format!("/toolbox/{}/toolbox/project-dir", sandbox_id),
            )
            .send()
            .await?;

        if response.status().is_success() {
            Ok(response.text().await?.trim().to_string())
        } else {
            let error_text = response.text().await?;
            Err(crate::error::DaytonaError::RequestFailed(format!(
                "Failed to get project directory: {}",
                error_text
            )))
        }
    }
}

impl DaytonaClient {
    /// Get process executor
    pub fn process(&self) -> ProcessExecutor<'_> {
        ProcessExecutor::new(self)
    }
}