use std::path::PathBuf; use warpui::{App, EntityId, SingletonEntity}; use crate::ai::execution_profiles::profiles::AIExecutionProfilesModel;use crate::ai::execution_profiles::{AIExecutionProfile, ActionPermission, ExecutionProfileId}; #[derive(Debug)]pub struct ExecutionProfileSnapshot {    pub name: String,    pub apply_code_diffs_always_allow: bool,    pub read_files_always_allow: bool,    pub execute_commands_always_ask: bool,    pub base_model: Option<String>,    pub command_allowlist: Vec<String>,    pub directory_allowlist: Vec<PathBuf>,    pub web_search_enabled: bool,} fn snapshot(profile: &AIExecutionProfile) -> ExecutionProfileSnapshot {    ExecutionProfileSnapshot {        name: profile.name.clone(),        apply_code_diffs_always_allow: profile.apply_code_diffs == ActionPermission::AlwaysAllow,        read_files_always_allow: profile.read_files == ActionPermission::AlwaysAllow,        execute_commands_always_ask: profile.execute_commands == ActionPermission::AlwaysAsk,        base_model: profile.base_model.as_ref().map(ToString::to_string),        command_allowlist: profile            .command_allowlist            .iter()            .map(ToString::to_string)            .collect(),        directory_allowlist: profile.directory_allowlist.clone(),        web_search_enabled: profile.web_search_enabled,    }} pub fn default_execution_profile(app: &App) -> ExecutionProfileSnapshot {    app.read(|ctx| {        snapshot(            AIExecutionProfilesModel::as_ref(ctx)                .default_profile(ctx)                .data(),        )    })} pub fn execution_profile(app: &App, profile_id: &str) -> Option<ExecutionProfileSnapshot> {    let profile_id = ExecutionProfileId::parse(profile_id)?;    app.read(|ctx| {        AIExecutionProfilesModel::as_ref(ctx)            .get_profile_by_id(&profile_id, ctx)            .map(|profile| snapshot(profile.data()))    })} pub fn has_multiple_execution_profiles(app: &App) -> bool {    app.read(|ctx| AIExecutionProfilesModel::as_ref(ctx).has_multiple_profiles())} pub fn create_and_select_execution_profile(    app: &mut App,    terminal_view_id: EntityId,    name: &str,    readable_directory: PathBuf,) -> String {    AIExecutionProfilesModel::handle(app)        .update(app, |profiles, ctx| {            let profile_id = profiles                .create_profile(ctx)                .expect("settings-backed profile should be created");            profiles.set_profile_name(&profile_id, name, ctx);            profiles.set_read_files(&profile_id, &ActionPermission::AlwaysAllow, ctx);            profiles.add_to_directory_allowlist(&profile_id, &readable_directory, ctx);            profiles.set_active_profile(terminal_view_id, profile_id.clone(), ctx);            profile_id        })        .to_string()} pub fn active_execution_profile_id(app: &App, terminal_view_id: EntityId) -> String {    app.read(|ctx| {        AIExecutionProfilesModel::as_ref(ctx)            .active_profile(Some(terminal_view_id), ctx)            .id()            .to_string()    })}