Daytona Integration

#[async_trait]
impl Sandbox for DaytonaSandbox {
    fn name(&self) -> &str {
        "daytona"
    }

    fn working_dir(&self) -> &str {
        &self.working_dir
    }

    async fn exec(&self, command: &str, args: &[&str]) -> Result<ExecOutput> {
        // Daytona's execute_command does NOT use a shell,
        // so we wrap in `sh -c '...'` to support shell operators (&&, |, etc.)
        let inner = if args.is_empty() {
            format!("cd {} && {}", self.working_dir, command)
        } else {
            let args_str = args.iter().map(|a| shell_escape(a)).collect::<Vec<_>>().join(" ");
            format!("cd {} && {} {}", self.working_dir, command, args_str)
        };
        let full_cmd = format!("sh -c {}", shell_escape(&inner));

        let result = self.client
            .process()
            .execute_command(&self.sandbox_id, &full_cmd)
            .await?;

        Ok(ExecOutput {
            stdout: result.result.clone(),
            stderr: String::new(),  // Daytona combines output into result
            exit_code: result.exit_code,
        })
    }

    async fn read_file(&self, path: &str) -> Result<Vec<u8>> {
        let full_path = if path.starts_with('/') {
            path.to_string()
        } else {
            format!("{}/{}", self.working_dir, path)
        };
        self.client.files().download(&self.sandbox_id, &full_path).await
    }

    async fn write_file(&self, path: &str, content: &[u8]) -> Result<()> {
        let full_path = if path.starts_with('/') {
            path.to_string()
        } else {
            format!("{}/{}", self.working_dir, path)
        };
        self.client.files().upload(&self.sandbox_id, &full_path, content).await
    }

    async fn destroy(&self) -> Result<()> {
        self.client.sandboxes().delete(&self.sandbox_id).await
    }
}

use magpie_core::sandbox::pool::{WarmPool, WarmPoolConfig, RepoPoolConfig};

let pool_config = WarmPoolConfig {
    pool_size: 3,  // 3 sandboxes per repo
    refresh_interval_secs: 300,  // refresh every 5 minutes
    daytona: daytona_config.clone(),
    repos: vec![
        RepoPoolConfig {
            repo_name: "api-service".to_string(),
            repo_full_name: "myorg/api-service".to_string(),
            snapshot_name: "myorg-api-service-snapshot".to_string(),
            sandbox_class: "large".to_string(),  // override default class
            base_branch: "main".to_string(),
            build_check_cmd: Some("cargo check --all-features".to_string()),
            volume_id: Some("vol-abc123".to_string()),
            volume_mount_path: Some("/workspace/api-service/target".to_string()),
            env_vars: HashMap::new(),
        },
    ],
};

let pool = Arc::new(WarmPool::new(pool_config));
pool.provision().await?;
pool.start_refresh_loop().await;

let pooled: Option<Box<dyn Sandbox>> = if let Some(ref pool) = config.pool {
    match pool.acquire(&full_name).await {
        Some(ws) => {
            info!(org, repo = %repo_name, "acquired warm pooled sandbox");
            Some(Box::new(crate::sandbox::pooled::PooledSandbox::new(
                ws,
                Arc::clone(pool),
                config.base_branch.clone(),
            )))
        }
        None => {
            info!(org, repo = %repo_name, "no idle pooled sandbox — falling back to cold clone");
            None
        }
    }
} else {
    None
};

if let Some(sandbox) = pooled {
    sandbox
} else if let Some(ref daytona_cfg) = config.daytona {
    // Cold creation from snapshot or clone...
}

impl Sandbox for PooledSandbox {
    async fn destroy(&self) -> Result<()> {
        // Release back to pool instead of destroying
        self.pool.release(&self.workspace, &self.base_branch).await?;
        Ok(())
    }
}

pub async fn release(&self, workspace: &Arc<Workspace>, base_branch: &str) -> Result<()> {
    // Reset git state but preserve build artifacts
    let reset_cmd = format!(
        "cd {} && git checkout {} && git clean -fd -e target/ -e node_modules/ -e .next/ && git reset --hard origin/{}",
        workspace.working_dir, base_branch, base_branch
    );
    workspace.sandbox.exec_shell(&reset_cmd).await?;

    workspace.set_status(WorkspaceStatus::Idle);
    Ok(())
}

pub async fn start_refresh_loop(&self) {
    let workspaces = Arc::clone(&self.workspaces);
    let shutdown = Arc::clone(&self.shutdown);
    let interval = Duration::from_secs(self.config.refresh_interval_secs);

    let handle = tokio::spawn(async move {
        loop {
            tokio::select! {
                _ = tokio::time::sleep(interval) => {},
                _ = shutdown.notified() => return,
            }

            let lock = workspaces.lock().await;
            let idle: Vec<Arc<Workspace>> = lock
                .iter()
                .filter(|ws| ws.status() == WorkspaceStatus::Idle)
                .cloned()
                .collect();
            drop(lock);

            for ws in idle {
                // git fetch + reset
                let fetch_cmd = format!(
                    "cd {} && git fetch origin {} && git reset --hard origin/{}",
                    ws.working_dir, base_branch, base_branch
                );
                ws.sandbox.exec_shell(&fetch_cmd).await?;

                // Optional build check
                if let Some(ref cmd) = build_cmd {
                    let full_cmd = format!("cd {} && {}", ws.working_dir, cmd);
                    ws.sandbox.exec_shell(&full_cmd).await?;
                }
            }
        }
    });
}

FROM ubuntu:22.04

# Install base dependencies
RUN apt-get update && apt-get install -y \
    git curl build-essential pkg-config libssl-dev \
    && rm -rf /var/lib/apt/lists/*

# Install Rust
RUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
ENV PATH="/root/.cargo/bin:${PATH}"

# Install GitHub CLI
RUN curl -fsSL https://cli.github.com/packages/githubcli-archive-keyring.gpg \
    | dd of=/usr/share/keyrings/githubcli-archive-keyring.gpg \
    && chmod go+r /usr/share/keyrings/githubcli-archive-keyring.gpg \
    && echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/githubcli-archive-keyring.gpg] https://cli.github.com/packages stable main" \
    | tee /etc/apt/sources.list.d/github-cli.list > /dev/null \
    && apt-get update && apt-get install -y gh

# Install Claude CLI
RUN curl -fsSL https://download.claudeai.dev/install.sh | bash

# Pre-clone repo (optional)
WORKDIR /workspace
RUN git clone https://github.com/myorg/api-service.git

# Pre-fetch dependencies (optional)
WORKDIR /workspace/api-service
RUN cargo fetch

use magpie_core::sandbox::snapshots::ensure_snapshot;

let snapshot_name = ensure_snapshot(&daytona_config, "api-service-snapshot").await?;

let env: HashMap<String, String> = std::env::var("DAYTONA_ENV")
    .unwrap_or_default()
    .split(',')
    .filter_map(|pair| {
        let (k, v) = pair.split_once('=')?;
        Some((k.trim().to_string(), v.trim().to_string()))
    })
    .collect();