daytona_client/

git.rs

//! Git operations within sandboxes and workspaces

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

use crate::{client::DaytonaClient, error::Result, models::git::*};

/// Manager for Git operations
pub struct GitManager<'a> {
    client: &'a DaytonaClient,
}

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

    /// Clone a repository into a sandbox
    pub async fn clone(&self, sandbox_id: &Uuid, request: GitCloneRequest) -> Result<()> {
        info!(
            "Cloning repository {} into sandbox {}",
            request.url, sandbox_id
        );

        let response = self
            .client
            .build_request(
                reqwest::Method::POST,
                &format!("/toolbox/{}/toolbox/git/clone", 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 clone repository: {}",
                error_text
            )))
        }
    }

    /// Get Git status
    pub async fn status(&self, sandbox_id: &Uuid, path: &str) -> Result<GitStatus> {
        debug!("Getting Git status for {} in sandbox {}", path, sandbox_id);

        let response = self
            .client
            .build_request(
                reqwest::Method::GET,
                &format!(
                    "/toolbox/{}/toolbox/git/status?path={}",
                    sandbox_id,
                    urlencoding::encode(path)
                ),
            )
            .send()
            .await?;

        self.client.handle_response(response).await
    }

    /// Commit changes
    pub async fn commit(&self, sandbox_id: &Uuid, request: GitCommitRequest) -> Result<String> {
        info!(
            "Committing changes in {} for sandbox {}",
            request.path, sandbox_id
        );

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

        if response.status().is_success() {
            let result: serde_json::Value = self.client.handle_response(response).await?;
            Ok(result["commit_hash"].as_str().unwrap_or("").to_string())
        } else {
            let error_text = response.text().await?;
            Err(crate::error::DaytonaError::RequestFailed(format!(
                "Failed to commit changes: {}",
                error_text
            )))
        }
    }

    /// Push changes to remote
    pub async fn push(&self, sandbox_id: &Uuid, path: &str, request: GitPushRequest) -> Result<()> {
        info!("Pushing changes from {} in sandbox {}", path, sandbox_id);

        let response = self
            .client
            .build_request(
                reqwest::Method::POST,
                &format!(
                    "/toolbox/{}/toolbox/git/push?path={}",
                    sandbox_id,
                    urlencoding::encode(path)
                ),
            )
            .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 push changes: {}",
                error_text
            )))
        }
    }

    /// Pull changes from remote
    pub async fn pull(&self, sandbox_id: &Uuid, path: &str, request: GitPullRequest) -> Result<()> {
        info!("Pulling changes to {} in sandbox {}", path, sandbox_id);

        let response = self
            .client
            .build_request(
                reqwest::Method::POST,
                &format!(
                    "/toolbox/{}/toolbox/git/pull?path={}",
                    sandbox_id,
                    urlencoding::encode(path)
                ),
            )
            .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 pull changes: {}",
                error_text
            )))
        }
    }

    /// Get Git history (log)
    pub async fn history(&self, sandbox_id: &Uuid, path: &str) -> Result<Vec<GitCommitInfo>> {
        debug!("Getting Git history for {} in sandbox {}", path, sandbox_id);

        let url = format!(
            "/toolbox/{}/toolbox/git/history?path={}",
            sandbox_id,
            urlencoding::encode(path)
        );

        let response = self
            .client
            .build_request(reqwest::Method::GET, &url)
            .send()
            .await?;

        self.client.handle_response(response).await
    }

    /// Get Git log (alias for history)
    pub async fn log(&self, sandbox_id: &Uuid, path: &str) -> Result<Vec<GitCommitInfo>> {
        self.history(sandbox_id, path).await
    }

    /// List branches
    pub async fn list_branches(&self, sandbox_id: &Uuid, path: &str) -> Result<Vec<String>> {
        debug!(
            "Listing Git branches for {} in sandbox {}",
            path, sandbox_id
        );

        let response = self
            .client
            .build_request(
                reqwest::Method::GET,
                &format!(
                    "/toolbox/{}/toolbox/git/branches?path={}",
                    sandbox_id,
                    urlencoding::encode(path)
                ),
            )
            .send()
            .await?;

        let result: ListBranchResponse = self.client.handle_response(response).await?;
        Ok(result.branches)
    }

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

        let body = serde_json::json!({
            "path": path,
            "name": branch_name
        });

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

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

    /// Switch branch
    pub async fn switch_branch(
        &self,
        sandbox_id: &Uuid,
        path: &str,
        branch_name: &str,
    ) -> Result<()> {
        info!(
            "Switching to branch {} in {} for sandbox {}",
            branch_name, path, sandbox_id
        );

        let body = serde_json::json!({
            "path": path,
            "branch": branch_name
        });

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

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

    /// Delete branch
    pub async fn delete_branch(
        &self,
        sandbox_id: &Uuid,
        path: &str,
        branch_name: &str,
    ) -> Result<()> {
        info!(
            "Deleting branch {} in {} for sandbox {}",
            branch_name, path, sandbox_id
        );

        let body = serde_json::json!({
            "path": path,
            "name": branch_name
        });

        let response = self
            .client
            .build_request(
                reqwest::Method::DELETE,
                &format!("/toolbox/{}/toolbox/git/branches", sandbox_id),
            )
            .json(&body)
            .send()
            .await?;

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

    /// Stage files
    pub async fn stage(&self, sandbox_id: &Uuid, path: &str, files: Vec<String>) -> Result<()> {
        info!(
            "Staging {} files in {} for sandbox {}",
            files.len(),
            path,
            sandbox_id
        );

        let body = serde_json::json!({
            "path": path,
            "files": files
        });

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

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

impl DaytonaClient {
    /// Get Git manager
    pub fn git(&self) -> GitManager<'_> {
        GitManager::new(self)
    }
}