Method exec

core/src/workspace/local.rs:479–533

(&self, request: CommandRequest)

#[async_trait]
impl WorkspaceCommandRunner for LocalWorkspaceBackend {
    async fn exec(&self, request: CommandRequest) -> Result<CommandOutput> {
        #[cfg(windows)]
        if let Some(output) =
            crate::tools::builtin::bash::maybe_execute_simple_windows_http_command(&request.command)
                .await
        {
            let exit_code = output
                .metadata
                .as_ref()
                .and_then(|m| m.get("exit_code"))
                .and_then(|v| v.as_i64())
                .map(|v| v as i32)
                .unwrap_or(if output.success { 0 } else { -1 });
            return Ok(CommandOutput {
                output: output.content,
                exit_code,
                timed_out: false,
            });
        }

        let timeout_secs = request.timeout_ms / 1000;
        let mut child = crate::tools::builtin::bash::spawn_shell(
            &request.command,
            &self.root,
            request.env.as_deref(),
        )
        .map_err(|e| anyhow!("Failed to spawn shell: {}", e))?;

        let (output, timed_out) = crate::tools::process::read_process_output(
            &mut child,
            timeout_secs,
            request.output_observer.as_deref(),
        )
        .await;

        if timed_out {
            return Ok(CommandOutput {
                output,
                exit_code: -1,
                timed_out: true,
            });
        }

        let status = child
            .wait()
            .await
            .map_err(|e| anyhow!("Failed to wait for shell: {}", e))?;
        let exit_code = status.code().unwrap_or(-1);

        Ok(CommandOutput {
            output,
            exit_code,
            timed_out: false,
        })
    }
}

impl LocalWorkspaceBackend {