Confirm dangerous downloads

crates/ely_app/src/shell/downloads.rs

@@ -0,0 +1,216 @@
+use ely_domain::DownloadId;
+use gpui::Context;
+
+use crate::services::{
+    download_checksums::DownloadChecksumCalculator, download_files::DownloadFileAction,
+};
+
+use super::{ElyShell, ShellState};
+
+#[derive(Clone, Debug)]
+pub(super) struct PendingDownloadFileAction {
+    download_id: DownloadId,
+    file_name: String,
+    action: DownloadFileAction,
+}
+
+impl PendingDownloadFileAction {
+    fn new(download_id: DownloadId, file_name: String, action: DownloadFileAction) -> Self {
+        Self { download_id, file_name, action }
+    }
+
+    pub(super) fn file_name(&self) -> &str {
+        &self.file_name
+    }
+
+    pub(super) fn action_label(&self) -> &'static str {
+        self.action.label()
+    }
+}
+
+impl ElyShell {
+    pub(super) fn pause_download(&mut self, download_id: &DownloadId, cx: &mut Context<Self>) {
+        if let ShellState::Ready(core) = &mut self.state
+            && core.pause_download(download_id).is_ok()
+        {
+            cx.notify();
+        }
+    }
+
+    pub(super) fn resume_download(&mut self, download_id: &DownloadId, cx: &mut Context<Self>) {
+        if let ShellState::Ready(core) = &mut self.state
+            && core.resume_download(download_id).is_ok()
+        {
+            cx.notify();
+        }
+    }
+
+    pub(super) fn cancel_download(&mut self, download_id: &DownloadId, cx: &mut Context<Self>) {
+        if let ShellState::Ready(core) = &mut self.state
+            && core.cancel_download(download_id).is_ok()
+        {
+            cx.notify();
+        }
+    }
+
+    pub(super) fn retry_download(&mut self, download_id: &DownloadId, cx: &mut Context<Self>) {
+        if let ShellState::Ready(core) = &mut self.state
+            && core.retry_download(download_id).is_ok()
+        {
+            cx.notify();
+        }
+    }
+
+    pub(super) fn request_clear_active_profile_downloads(&mut self, cx: &mut Context<Self>) {
+        self.download_clear_confirmation = true;
+        cx.notify();
+    }
+
+    pub(super) fn cancel_clear_active_profile_downloads(&mut self, cx: &mut Context<Self>) {
+        self.download_clear_confirmation = false;
+        cx.notify();
+    }
+
+    pub(super) fn clear_active_profile_downloads(&mut self, cx: &mut Context<Self>) {
+        if let ShellState::Ready(core) = &mut self.state {
+            core.clear_downloads_for_active_profile();
+        }
+        self.download_clear_confirmation = false;
+        self.download_action_error = None;
+        cx.notify();
+    }
+
+    pub(super) fn calculate_download_checksum(
+        &mut self,
+        download_id: &DownloadId,
+        cx: &mut Context<Self>,
+    ) {
+        let result = match &mut self.state {
+            ShellState::Ready(core) => core
+                .download_target_file_path(download_id)
+                .map_err(|error| error.to_string())
+                .and_then(|path| {
+                    DownloadChecksumCalculator::sha256(&path).map_err(|error| error.to_string())
+                })
+                .and_then(|checksum| {
+                    core.record_download_checksum(download_id, checksum)
+                        .map_err(|error| error.to_string())
+                }),
+            ShellState::StartupError(message) => Err(message.clone()),
+        };
+
+        self.download_action_error = result.err();
+        cx.notify();
+    }
+
+    pub(super) fn open_download_file(&mut self, download_id: &DownloadId, cx: &mut Context<Self>) {
+        self.run_download_file_action(download_id, DownloadFileAction::Open, cx);
+    }
+
+    pub(super) fn reveal_download_file(
+        &mut self,
+        download_id: &DownloadId,
+        cx: &mut Context<Self>,
+    ) {
+        self.run_download_file_action(download_id, DownloadFileAction::Reveal, cx);
+    }
+
+    pub(super) fn confirm_download_security_prompt(&mut self, cx: &mut Context<Self>) {
+        let Some(pending_action) = self.download_security_confirmation.take() else {
+            cx.notify();
+            return;
+        };
+
+        let result = match &mut self.state {
+            ShellState::Ready(core) => core
+                .confirm_download_security_prompt(&pending_action.download_id)
+                .map_err(|error| error.to_string()),
+            ShellState::StartupError(message) => Err(message.clone()),
+        };
+
+        if let Err(message) = result {
+            self.download_action_error = Some(message);
+            cx.notify();
+            return;
+        }
+
+        self.execute_download_file_action(&pending_action.download_id, pending_action.action, cx);
+    }
+
+    pub(super) fn cancel_download_security_prompt(&mut self, cx: &mut Context<Self>) {
+        self.download_security_confirmation = None;
+        cx.notify();
+    }
+
+    fn run_download_file_action(
+        &mut self,
+        download_id: &DownloadId,
+        action: DownloadFileAction,
+        cx: &mut Context<Self>,
+    ) {
+        match self.queue_security_confirmation(download_id, action) {
+            Ok(true) => {
+                self.download_action_error = None;
+                cx.notify();
+                return;
+            }
+            Ok(false) => {}
+            Err(message) => {
+                self.download_action_error = Some(message);
+                cx.notify();
+                return;
+            }
+        }
+
+        self.execute_download_file_action(download_id, action, cx);
+    }
+
+    fn queue_security_confirmation(
+        &mut self,
+        download_id: &DownloadId,
+        action: DownloadFileAction,
+    ) -> Result<bool, String> {
+        let core = match &self.state {
+            ShellState::Ready(core) => core,
+            ShellState::StartupError(message) => return Err(message.clone()),
+        };
+
+        if !core
+            .download_requires_security_confirmation(download_id)
+            .map_err(|error| error.to_string())?
+        {
+            return Ok(false);
+        }
+
+        let file_name = core
+            .snapshot()
+            .map_err(|error| error.to_string())?
+            .download_entries
+            .into_iter()
+            .find(|entry| entry.id() == download_id)
+            .map(|entry| entry.file_name().to_string())
+            .ok_or_else(|| format!("download not found: {download_id}"))?;
+
+        self.download_security_confirmation =
+            Some(PendingDownloadFileAction::new(download_id.clone(), file_name, action));
+        Ok(true)
+    }
+
+    fn execute_download_file_action(
+        &mut self,
+        download_id: &DownloadId,
+        action: DownloadFileAction,
+        cx: &mut Context<Self>,
+    ) {
+        let result = match &self.state {
+            ShellState::Ready(core) => core
+                .download_target_file_path(download_id)
+                .map_err(|error| error.to_string())
+                .and_then(|path| action.run(&path).map_err(|error| error.to_string())),
+            ShellState::StartupError(message) => Err(message.clone()),
+        };
+
+        self.download_action_error = result.err();
+        cx.notify();
+    }
+}