Function terminal_execute

src/apps/desktop/src/api/terminal_api.rs:672–730

(
    request: ExecuteCommandRequest,
    state: State<'_, TerminalState>,
)

#[tauri::command]
pub async fn terminal_execute(
    request: ExecuteCommandRequest,
    state: State<'_, TerminalState>,
) -> Result<ExecuteCommandResponse, String> {
    if is_remote_session(&request.session_id).await {
        if let Some(remote_manager) = get_remote_workspace_manager() {
            let terminal_manager = remote_manager
                .get_terminal_manager()
                .await
                .ok_or("Remote terminal manager not available")?;
            let session = terminal_manager
                .get_session(&request.session_id)
                .await
                .ok_or("Remote session not found")?;
            let ssh_manager = remote_manager
                .get_ssh_manager()
                .await
                .ok_or("SSH manager not available")?;
            let (stdout, stderr, exit_code) = ssh_manager
                .execute_command(&session.connection_id, &request.command)
                .await
                .map_err(|e| format!("Failed to execute remote command: {}", e))?;

            return Ok(ExecuteCommandResponse {
                command: request.command,
                command_id: format!(
                    "remote-cmd-{}",
                    std::time::SystemTime::now()
                        .duration_since(std::time::UNIX_EPOCH)
                        .unwrap_or_default()
                        .as_millis()
                ),
                output: if stderr.is_empty() {
                    stdout
                } else {
                    format!("{}\n{}", stdout, stderr)
                },
                exit_code: Some(exit_code),
                completion_reason: "completed".to_string(),
            });
        }
    }

    let api = state.get_or_init_api().await?;

    let core_request = CoreExecuteCommandRequest {
        session_id: request.session_id,
        command: request.command,
        timeout_ms: request.timeout_ms,
        prevent_history: request.prevent_history,
    };

    let result = api
        .execute_command(core_request)
        .await
        .map_err(|e| format!("Failed to execute command: {}", e))?;

    Ok(ExecuteCommandResponse::from(result))