What causes "this launcher does not support repository clones" in Hmbown/CodeWhale?

Use a launcher implementation that actually supports clones (the real sandbox launcher for your platform).

this launcher does not support repository clones

Error message

this launcher does not support repository clones

What it means

This is the default SandboxLauncher trait implementation for clone_repository: a launcher that has not overridden the method reports that it cannot clone repositories into a sandbox. It exists so trait implementors only implement the operations they support; calling the unimplemented one fails loudly instead of silently doing nothing.

Solutions

Use a launcher implementation that actually supports clones (the real sandbox launcher for your platform).
Check which launcher is wired into the dispatch path and why the default trait impl is being hit.
If clones are not supported in this environment, dispatch without the clone step or pre-populate the workspace instead.
Surface a clear 'sandbox clones unavailable here' message instead of retrying the same call.

Example fix

// before
launcher.clone_repository(&receipt, &url, path)?; // default impl -> bail
// after
if launcher_supports_clones(&launcher) {
    launcher.clone_repository(&receipt, &url, path)?;
} else {
    bail!("sandbox clones unavailable in this environment");
}

Defensive patterns

Strategy: try-catch

Validate before calling

// capability probe before use
fn launcher_supports_clones(l: &dyn SandboxLauncher) -> bool {
    // attempt is the contract; detect via a cheap probe or launcher metadata
    l.capabilities().contains(Capability::Clone)
}

Try / catch

match launcher.clone_repository(&receipt, url, path) {
    Err(e) if e.to_string().contains("does not support repository clones") => {
        eprintln!("this launcher cannot clone; use a sandbox-capable launcher");
    }
    other => { /* ... */ }
}

Prevention

Select the launcher based on required capabilities before dispatch.
In restricted environments, plan flows that do not need in-sandbox clones.
Keep stub launchers out of production dispatch paths.
Add an integration test asserting the production launcher implements clone_repository.

When it happens

Trigger: Calling clone_repository with a receipt produced by a launcher that did not override clone_repository — i.e. any dispatch flow that requests a sandbox clone against a minimal/no-op launcher.

Common situations: Running cloud dispatch in an environment or build where the real sandbox launcher is stubbed out; wiring a test/fallback launcher into the dispatch pipeline; a platform where sandboxing is unavailable so the default impl is used.

Related errors

AI-assisted analysis of Hmbown/CodeWhale@73e0f67d83 (2026-09-22). Data as JSON: /api/errors/324426c1cc789b83. Report an issue: GitHub.

Appendix: source

Thrown at crates/tui/src/cloud_dispatch.rs:1182

        .filter(|value| !value.is_empty())
        .unwrap_or_else(|| DEFAULT_DAYTONA_API.to_string())
}

/// Launch seam. Tests inject a recorder; production uses [`LiveDaytonaLauncher`].
///
/// The methods after `create_sandbox` default to "unsupported" so partial
/// fixtures keep compiling; the real runner (and the recording tests) drive
/// the full protocol.
pub trait DaytonaLauncher {
    /// Create the sandbox and return its id plus the (validated) toolbox URL.
    fn create_sandbox(&self, job: &CloudJob) -> Result<SandboxReceipt>;
    /// Block until the sandbox accepts toolbox calls (bounded poll).
    fn wait_ready(&self, _receipt: &SandboxReceipt) -> Result<()> {
        Ok(())
    }
    /// Clone the target forge repository inside the sandbox.
    fn clone_repository(&self, _receipt: &SandboxReceipt, _url: &str, _path: &str) -> Result<()> {
        bail!("this launcher does not support repository clones")
    }
    /// Run one harness command inside the sandbox and return bounded stdout.
    fn run_harness(&self, _receipt: &SandboxReceipt, _command: &HarnessCommand) -> Result<String> {
        bail!("this launcher does not support harness execution")
    }
    /// Collect the agent's work product from the sandbox.
    fn collect_patch(&self, _receipt: &SandboxReceipt) -> Result<PatchReceipt> {
        bail!("this launcher does not support patch collection")
    }
    /// Tear the sandbox down. Called on cancel, failure, and completion.
    fn teardown(&self, _receipt: &SandboxReceipt) -> Result<()> {
        bail!("this launcher does not support teardown")
    }
    /// List Codewhale-dispatch sandboxes with their job labels. Used by the
    /// reconciler (startup sweep and cancel); not part of the run protocol.
    fn list_job_sandboxes(&self) -> Result<Vec<LabeledSandbox>> {
        bail!("this launcher does not support sandbox listing")
    }

View on GitHub (pinned to 73e0f67d83)