Bskiser/fix linux update (#540)

* fix: Linux updating from the CLI

* fix: Notify user on sigint during Linux update

Author: brandonskiser

crates/fig_install/src/lib.rs

@@ -91,7 +91,7 @@ pub enum Error {
     SystemNotOnChannel,
     #[error("manifest not found")]
     ManifestNotFound,
-    #[error("update in progress")]
+    #[error("Update in progress")]
     UpdateInProgress,
     #[error("could not convert path to cstring")]
     Nul(#[from] std::ffi::NulError),

crates/fig_ipc/src/local.rs

@@ -123,7 +123,7 @@ pub async fn prompt_accessibility_command() -> Result<()> {
 
 pub async fn update_command(force: bool) -> Result<Option<CommandResponse>> {
     let command = command::Command::Update(UpdateCommand { force });
-    send_recv_command_to_socket(command).await
+    send_recv_command_to_socket_with_timeout(command, std::time::Duration::from_secs(120)).await
 }
 
 pub async fn restart_command() -> Result<()> {
@@ -155,7 +155,11 @@ pub async fn devtools_command(window: devtools_command::Window) -> Result<()> {
 pub trait LocalIpc: SendRecvMessage {
     async fn send_hook(&mut self, hook: local::Hook) -> Result<()>;
     async fn send_command(&mut self, command: local::command::Command, response: bool) -> Result<()>;
-    async fn send_recv_command(&mut self, command: local::command::Command) -> Result<Option<local::CommandResponse>>;
+    async fn send_recv_command(
+        &mut self,
+        command: local::command::Command,
+        timeout: Duration,
+    ) -> Result<Option<local::CommandResponse>>;
 }
 
 #[async_trait]
@@ -183,10 +187,15 @@ where
         Ok(self.send_message(message).await?)
     }
 
-    /// Send a command to and recv a response from the desktop app
-    async fn send_recv_command(&mut self, command: local::command::Command) -> Result<Option<local::CommandResponse>> {
+    /// Send a command to and recv a response from the desktop app, with a configurable timeout on
+    /// the response
+    async fn send_recv_command(
+        &mut self,
+        command: local::command::Command,
+        timeout: Duration,
+    ) -> Result<Option<local::CommandResponse>> {
         self.send_command(command, true).await?;
-        Ok(tokio::time::timeout(Duration::from_secs(2), self.recv_message())
+        Ok(tokio::time::timeout(timeout, self.recv_message())
             .await
             .or(Err(Error::Timeout))??)
     }
@@ -206,7 +215,14 @@ pub async fn send_command_to_socket(command: local::command::Command) -> Result<
 }
 
 pub async fn send_recv_command_to_socket(command: local::command::Command) -> Result<Option<local::CommandResponse>> {
+    send_recv_command_to_socket_with_timeout(command, Duration::from_secs(2)).await
+}
+
+pub async fn send_recv_command_to_socket_with_timeout(
+    command: local::command::Command,
+    timeout: Duration,
+) -> Result<Option<local::CommandResponse>> {
     let path = directories::desktop_socket_path()?;
     let mut conn = BufferedUnixStream::connect_timeout(&path, Duration::from_secs(3)).await?;
-    conn.send_recv_command(command).await
+    conn.send_recv_command(command, timeout).await
 }

crates/q_cli/src/cli/update.rs

@@ -1,3 +1,4 @@
+use std::io::stdout;
 use std::process::ExitCode;
 
 use anstream::println;
@@ -38,6 +39,10 @@ use tracing::{
 };
 
 use crate::util::dialoguer_theme;
+use crate::util::spinner::{
+    Spinner,
+    SpinnerComponent,
+};
 
 #[derive(Debug, PartialEq, Args)]
 pub struct UpdateArgs {
@@ -130,19 +135,36 @@ async fn try_linux_update() -> Result<ExitCode> {
                     .interact_opt()?;
 
                 if should_continue == Some(0) {
-                    println!("Updating {PRODUCT_NAME}...");
-                    match update_command(true).await {
+                    let mut spinner = Spinner::new(vec![
+                        SpinnerComponent::Spinner,
+                        SpinnerComponent::Text(format!(" Updating {PRODUCT_NAME}, please wait...")),
+                    ]);
+                    tokio::spawn(async {
+                        tokio::signal::ctrl_c().await.unwrap();
+                        println!(
+                            "\nThe app is still updating. You can view the progress by running {}",
+                            format!("{CLI_BINARY_NAME} debug logs").bold()
+                        );
+                        crossterm::execute!(stdout(), crossterm::cursor::Show).unwrap();
+                        #[allow(clippy::exit)]
+                        std::process::exit(0);
+                    });
+
+                    let update_cmd_result = update_command(true).await;
+                    println!("");
+                    match update_cmd_result {
                         Ok(Some(CommandResponse {
                             response: Some(Response::Success(_)),
                             ..
                         })) => {
-                            println!("Update complete");
+                            spinner.stop_with_message("Update complete".into());
                             Ok(ExitCode::SUCCESS)
                         },
                         Ok(Some(CommandResponse {
                             response: Some(Response::Error(ErrorResponse { message, .. })),
                             ..
                         })) => {
+                            spinner.stop();
                             let message = message.unwrap_or("An unknown error occurred attempting to update".into());
                             eyre::bail!(
                                 "{message}\n\nFailed to update. If this is unexpected, try running {} and then try again.\n",
@@ -152,14 +174,25 @@ async fn try_linux_update() -> Result<ExitCode> {
                         Ok(_) => {
                             // This case shouldn't happen, we expect a response from the desktop
                             // app.
-                            println!("Update complete");
+                            spinner.stop_with_message("Update complete".into());
                             Ok(ExitCode::SUCCESS)
                         },
                         Err(err) => {
-                            eyre::bail!(
-                                "{err}\n\nFailed to update. If this is unexpected, try running {} and then try again.\n",
-                                format!("{CLI_BINARY_NAME} doctor").bold()
-                            )
+                            spinner.stop();
+                            match err {
+                                fig_ipc::Error::Timeout => {
+                                    eyre::bail!(
+                                        "Timed out while waiting for the app to update. Updating may still be in progress - you can view app logs by running {}",
+                                        format!("{CLI_BINARY_NAME} debug logs").bold()
+                                    )
+                                },
+                                err => {
+                                    eyre::bail!(
+                                        "{err}\n\nFailed to update. If this is unexpected, try running {} and then try again.\n",
+                                        format!("{CLI_BINARY_NAME} doctor").bold()
+                                    )
+                                },
+                            }
                         },
                     }
                 } else {