Function remote_open_workspace

src/apps/desktop/src/api/ssh_api.rs:396–449

(
    state: State<'_, AppState>,
    connection_id: String,
    remote_path: String,
)

#[tauri::command]
pub async fn remote_open_workspace(
    state: State<'_, AppState>,
    connection_id: String,
    remote_path: String,
) -> Result<(), String> {
    let remote_path =
        bitfun_core::service::remote_ssh::normalize_remote_workspace_path(&remote_path);
    let manager = state.get_ssh_manager_async().await?;

    // Verify connection exists
    if !manager.is_connected(&connection_id).await {
        return Err("Not connected to remote server".to_string());
    }

    // Verify remote path exists
    let remote_fs = state.get_remote_file_service_async().await?;
    let exists = remote_fs
        .exists(&connection_id, &remote_path)
        .await
        .map_err(|e| e.to_string())?;

    if !exists {
        return Err(format!("Remote path does not exist: {}", remote_path));
    }

    // Get connection info for workspace
    let connections = manager.get_saved_connections().await;
    let conn = connections.iter().find(|c| c.id == connection_id);

    let ssh_host = manager
        .get_connection_config(&connection_id)
        .await
        .map(|c| c.host)
        .unwrap_or_default();

    let workspace = crate::api::RemoteWorkspace {
        connection_id: connection_id.clone(),
        connection_name: conn.map(|c| c.name.clone()).unwrap_or_default(),
        remote_path: remote_path.clone(),
        ssh_host,
    };

    state
        .set_remote_workspace(workspace)
        .await
        .map_err(|e| e.to_string())?;

    log::info!(
        "Opened remote workspace: {} on connection {}",
        remote_path,
        connection_id
    );
    Ok(())
}

#[tauri::command]
pub async fn remote_close_workspace(state: State<'_, AppState>) -> Result<(), String> {