daytona_client/

files.rs

//! File operations within sandboxes

use tracing::{debug, info};
use uuid::Uuid;

use crate::{
    client::DaytonaClient,
    error::{DaytonaError, Result},
    models::{FileInfo, FindResult},
};

/// File manager for sandbox file operations
pub struct FileManager<'a> {
    client: &'a DaytonaClient,
}

impl<'a> FileManager<'a> {
    /// Create a new file manager
    pub fn new(client: &'a DaytonaClient) -> Self {
        Self { client }
    }

    /// Upload a file to the sandbox
    pub async fn upload(&self, sandbox_id: &Uuid, path: &str, content: &[u8]) -> Result<()> {
        info!("Uploading file to sandbox {}: {}", sandbox_id, path);

        // Create multipart form for file upload using bulk-upload endpoint
        // The API expects files[0].path and files[0].file fields
        let form = reqwest::multipart::Form::new()
            .text("files[0].path", path.to_string())
            .part(
                "files[0].file",
                reqwest::multipart::Part::bytes(content.to_vec())
                    .file_name(path.to_string())
                    .mime_str("application/octet-stream")?,
            );

        let response = self
            .client
            .build_multipart_request(
                reqwest::Method::POST,
                &format!("/toolbox/{}/toolbox/files/bulk-upload", sandbox_id),
            )
            .multipart(form)
            .send()
            .await?;

        if response.status().is_success() {
            debug!("File uploaded successfully: {}", path);
            Ok(())
        } else {
            let error_text = response.text().await?;
            Err(DaytonaError::FileError(format!(
                "Failed to upload file: {}",
                error_text
            )))
        }
    }

    /// Upload text content as a file
    pub async fn upload_text(&self, sandbox_id: &Uuid, path: &str, content: &str) -> Result<()> {
        self.upload(sandbox_id, path, content.as_bytes()).await
    }

    /// Download a file from the sandbox
    pub async fn download(&self, sandbox_id: &Uuid, path: &str) -> Result<Vec<u8>> {
        info!("Downloading file from sandbox {}: {}", sandbox_id, path);

        let response = self
            .client
            .build_request(
                reqwest::Method::GET,
                &format!("/toolbox/{}/toolbox/files/download", sandbox_id),
            )
            .query(&[("path", path)])
            .send()
            .await?;

        if response.status().is_success() {
            let content = response.bytes().await?.to_vec();
            debug!(
                "File downloaded successfully: {} ({} bytes)",
                path,
                content.len()
            );
            Ok(content)
        } else {
            let error_text = response.text().await?;
            Err(DaytonaError::FileError(format!(
                "Failed to download file: {}",
                error_text
            )))
        }
    }

    /// Download a text file from the sandbox
    pub async fn download_text(&self, sandbox_id: &Uuid, path: &str) -> Result<String> {
        let bytes = self.download(sandbox_id, path).await?;
        String::from_utf8(bytes)
            .map_err(|e| DaytonaError::FileError(format!("Invalid UTF-8 in file: {}", e)))
    }

    /// Delete a file from the sandbox
    pub async fn delete(&self, sandbox_id: &Uuid, path: &str) -> Result<()> {
        info!("Deleting file from sandbox {}: {}", sandbox_id, path);

        let response = self
            .client
            .build_request(
                reqwest::Method::DELETE,
                &format!("/toolbox/{}/toolbox/files", sandbox_id),
            )
            .query(&[("path", path)])
            .send()
            .await?;

        if response.status().is_success() {
            debug!("File deleted successfully: {}", path);
            Ok(())
        } else {
            let error_text = response.text().await?;
            Err(DaytonaError::FileError(format!(
                "Failed to delete file: {}",
                error_text
            )))
        }
    }

    /// List files in a directory
    pub async fn list(&self, sandbox_id: &Uuid, path: &str) -> Result<Vec<FileInfo>> {
        info!("Listing files in sandbox {}: {}", sandbox_id, path);

        let response = self
            .client
            .build_request(
                reqwest::Method::GET,
                &format!("/toolbox/{}/toolbox/files", sandbox_id),
            )
            .query(&[("path", path)])
            .send()
            .await?;

        self.client.handle_response(response).await
    }

    /// Get file information
    pub async fn get_file_info(&self, sandbox_id: &Uuid, path: &str) -> Result<FileInfo> {
        debug!("Getting file info in sandbox {}: {}", sandbox_id, path);

        let response = self
            .client
            .build_request(
                reqwest::Method::GET,
                &format!("/toolbox/{}/toolbox/files/info", sandbox_id),
            )
            .query(&[("path", path)])
            .send()
            .await?;

        self.client.handle_response(response).await
    }

    /// Check if a file exists
    pub async fn exists(&self, sandbox_id: &Uuid, path: &str) -> Result<bool> {
        self.get_file_info(sandbox_id, path)
            .await
            .map(|_| true)
            .or_else(|e| match e {
                DaytonaError::RequestFailed(msg) if msg.contains("404") => Ok(false),
                _ => Err(e),
            })
    }

    /// Create a directory
    pub async fn create_directory(&self, sandbox_id: &Uuid, path: &str) -> Result<()> {
        info!("Creating directory in sandbox {}: {}", sandbox_id, path);

        let response = self
            .client
            .build_request(
                reqwest::Method::POST,
                &format!("/toolbox/{}/toolbox/files/folder", sandbox_id),
            )
            .query(&[("path", path), ("mode", "755")])
            .send()
            .await?;

        if response.status().is_success() {
            debug!("Directory created successfully: {}", path);
            Ok(())
        } else {
            let error_text = response.text().await?;
            Err(DaytonaError::FileError(format!(
                "Failed to create directory: {}",
                error_text
            )))
        }
    }

    /// Copy a file within the sandbox
    pub async fn copy(&self, sandbox_id: &Uuid, source: &str, destination: &str) -> Result<()> {
        info!(
            "Copying file in sandbox {}: {} -> {}",
            sandbox_id, source, destination
        );

        let process = crate::process::ProcessExecutor::new(self.client);
        let result = process
            .execute_command(sandbox_id, &format!("cp {} {}", source, destination))
            .await?;

        if result.exit_code == 0 {
            Ok(())
        } else {
            Err(DaytonaError::FileError(format!(
                "Failed to copy file: {}",
                result.result
            )))
        }
    }

    /// Move/rename a file within the sandbox
    pub async fn rename(&self, sandbox_id: &Uuid, source: &str, destination: &str) -> Result<()> {
        info!(
            "Moving file in sandbox {}: {} -> {}",
            sandbox_id, source, destination
        );

        let response = self
            .client
            .build_request(
                reqwest::Method::POST,
                &format!("/toolbox/{}/toolbox/files/move", sandbox_id),
            )
            .query(&[("source", source), ("destination", destination)])
            .send()
            .await?;

        if response.status().is_success() {
            debug!("File moved successfully: {} -> {}", source, destination);
            Ok(())
        } else {
            let error_text = response.text().await?;
            Err(DaytonaError::FileError(format!(
                "Failed to move file: {}",
                error_text
            )))
        }
    }

    /// Find text in files
    pub async fn find_in_files(
        &self,
        sandbox_id: &Uuid,
        pattern: &str,
        path: &str,
    ) -> Result<Vec<FindResult>> {
        info!(
            "Finding '{}' in files at {} in sandbox {}",
            pattern, path, sandbox_id
        );

        let response = self
            .client
            .build_request(
                reqwest::Method::GET,
                &format!("/toolbox/{}/toolbox/files/find", sandbox_id),
            )
            .query(&[("path", path), ("pattern", pattern)])
            .send()
            .await?;

        if response.status().is_success() {
            // The API returns Match objects, convert to FindResult
            let matches: Vec<crate::models::Match> = self.client.handle_response(response).await?;

            Ok(matches
                .into_iter()
                .map(|m| FindResult {
                    file: m.file,
                    line_number: m.line_number as usize,
                    content: m.content,
                })
                .collect())
        } else {
            let error_text = response.text().await?;
            Err(DaytonaError::FileError(format!(
                "Failed to find in files: {}",
                error_text
            )))
        }
    }

    /// Replace text in files
    pub async fn replace_in_files(
        &self,
        sandbox_id: &Uuid,
        find: &str,
        replace: &str,
        files: &[String],
    ) -> Result<Vec<String>> {
        info!(
            "Replacing '{}' with '{}' in {} files in sandbox {}",
            find,
            replace,
            files.len(),
            sandbox_id
        );

        // Build the request body
        let request_body = serde_json::json!({
            "files": files,
            "pattern": find,
            "newValue": replace
        });

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

        if response.status().is_success() {
            // The API returns ReplaceResult objects
            let results: Vec<crate::models::ReplaceResult> =
                self.client.handle_response(response).await?;

            Ok(results
                .into_iter()
                .filter_map(|r| {
                    if r.success.unwrap_or(false) {
                        r.file
                    } else {
                        None
                    }
                })
                .collect())
        } else {
            let error_text = response.text().await?;
            Err(DaytonaError::FileError(format!(
                "Failed to replace in files: {}",
                error_text
            )))
        }
    }

    /// Search for files by name pattern
    pub async fn search_files(
        &self,
        sandbox_id: &Uuid,
        pattern: &str,
        path: &str,
    ) -> Result<Vec<String>> {
        info!(
            "Searching for files matching '{}' in {} in sandbox {}",
            pattern, path, sandbox_id
        );

        let response = self
            .client
            .build_request(
                reqwest::Method::GET,
                &format!("/toolbox/{}/toolbox/files/search", sandbox_id),
            )
            .query(&[("path", path), ("pattern", pattern)])
            .send()
            .await?;

        if response.status().is_success() {
            let result: crate::models::SearchFilesResponse =
                self.client.handle_response(response).await?;
            Ok(result.files)
        } else {
            let error_text = response.text().await?;
            Err(DaytonaError::FileError(format!(
                "Failed to search files: {}",
                error_text
            )))
        }
    }

    /// Set file permissions
    pub async fn set_file_permissions(
        &self,
        sandbox_id: &Uuid,
        path: &str,
        mode: &str,
        owner: Option<&str>,
        group: Option<&str>,
    ) -> Result<()> {
        info!(
            "Setting permissions {} for {} in sandbox {}",
            mode, path, sandbox_id
        );

        let mut query_params = vec![("path", path), ("mode", mode)];

        if let Some(owner_val) = owner {
            query_params.push(("owner", owner_val));
        }
        if let Some(group_val) = group {
            query_params.push(("group", group_val));
        }

        let response = self
            .client
            .build_request(
                reqwest::Method::POST,
                &format!("/toolbox/{}/toolbox/files/permissions", sandbox_id),
            )
            .query(&query_params)
            .send()
            .await?;

        if response.status().is_success() {
            debug!("File permissions set successfully for: {}", path);
            Ok(())
        } else {
            let error_text = response.text().await?;
            Err(DaytonaError::FileError(format!(
                "Failed to set file permissions: {}",
                error_text
            )))
        }
    }
}

impl DaytonaClient {
    /// Get file manager
    pub fn files(&self) -> FileManager<'_> {
        FileManager::new(self)
    }
}