feat: add check updates command (#577)

* feat: add check updates command

* feat: run check_update on required commands

* review: added return value to check_updates

simplified check_updates command

fix: more user-friendly error message for check_updates on Config write
failure

* refactor: check updates macro -> function

* lint: cargo fmt

* review: remove extra clap comment

* feat: check for updates in background and print on next run

feat: check for updates in background and print on next run

remove updates check from init, link and run

move functions around in main.rs

* Add check to see if the cli has been updated

* fix: CI / Tests (Windows)

* fix: match try_parse() error handling behaviour with parse()

* nit: move tests below impl

* fix: compare_semver: handle different length versions

* chore: remove big comment

---------

Co-authored-by: Jake Runzer <jakerunzer@gmail.com>

Author: alexng353

Cargo.toml

@@ -27,7 +27,10 @@ reqwest = { version = "0.12.12", default-features = false, features = [
   "rustls-tls",
   "json",
 ] }
-chrono = { version = "0.4.39", features = ["serde"], default-features = false }
+chrono = { version = "0.4.39", features = [
+  "serde",
+  "clock",
+], default-features = false }
 graphql_client = { version = "0.14.0", features = ["reqwest-rustls"] }
 paste = "1.0.15"
 tokio = { version = "1.42.0", features = ["full"] }

src/commands/check_updates.rs

@@ -0,0 +1,34 @@
+use crate::util::check_update::check_update;
+
+use super::*;
+use serde_json::json;
+
+/// Test the update check
+#[derive(Parser)]
+pub struct Args {}
+
+pub async fn command(_args: Args, json: bool) -> Result<()> {
+    let mut configs = Configs::new()?;
+
+    if json {
+        let result = configs.check_update(true).await;
+
+        let json = json!({
+            "latest_version": result.ok().flatten().as_ref(),
+            "current_version": env!("CARGO_PKG_VERSION"),
+        });
+
+        println!("{}", serde_json::to_string_pretty(&json)?);
+
+        return Ok(());
+    }
+
+    let is_latest = check_update(&mut configs, true).await?;
+    if is_latest {
+        println!(
+            "You are on the latest version of the CLI, v{}",
+            env!("CARGO_PKG_VERSION")
+        );
+    }
+    Ok(())
+}

src/commands/init.rs

@@ -15,6 +15,7 @@ pub struct Args {
 
 pub async fn command(args: Args, _json: bool) -> Result<()> {
     let mut configs = Configs::new()?;
+
     let client = GQLClient::new_authorized(&configs)?;
 
     let vars = queries::user_projects::Variables {};

src/commands/link.rs

@@ -38,6 +38,7 @@ pub struct Args {
 
 pub async fn command(args: Args, _json: bool) -> Result<()> {
     let mut configs = Configs::new()?;
+
     let client = GQLClient::new_authorized(&configs)?;
     let me = post_graphql::<queries::UserProjects, _>(
         &client,

src/commands/mod.rs

@@ -30,3 +30,5 @@ pub mod up;
 pub mod variables;
 pub mod volume;
 pub mod whoami;
+
+pub mod check_updates;

src/commands/run.rs

@@ -73,7 +73,9 @@ async fn get_service(
 }
 
 pub async fn command(args: Args, _json: bool) -> Result<()> {
+    // only needs to be mutable for the update check
     let configs = Configs::new()?;
+
     let client = GQLClient::new_authorized(&configs)?;
     let linked_project = configs.get_linked_project().await?;
 

src/config.rs

@@ -1,20 +1,23 @@
 use std::{
+    cmp::Ordering,
     collections::BTreeMap,
-    fs,
-    fs::{create_dir_all, File},
+    fs::{self, create_dir_all, File},
     io::Read,
     path::PathBuf,
 };
 
 use anyhow::{Context, Result};
+use chrono::{DateTime, Utc};
 use colored::Colorize;
 use inquire::ui::{Attributes, RenderConfig, StyleSheet, Styled};
+use is_terminal::IsTerminal;
 use serde::{Deserialize, Serialize};
 
 use crate::{
     client::{post_graphql, GQLClient},
     commands::queries,
     errors::RailwayError,
+    util::compare_semver::compare_semver,
 };
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
@@ -42,6 +45,8 @@ pub struct RailwayUser {
 pub struct RailwayConfig {
     pub projects: BTreeMap<String, LinkedProject>,
     pub user: RailwayUser,
+    pub last_update_check: Option<DateTime<Utc>>,
+    pub new_version_available: Option<String>,
 }
 
 #[derive(Debug)]
@@ -57,6 +62,13 @@ pub enum Environment {
     Dev,
 }
 
+#[derive(Deserialize)]
+struct GithubApiRelease {
+    tag_name: String,
+}
+
+const GITHUB_API_RELEASE_URL: &str = "https://api.github.com/repos/railwayapp/cli/releases/latest";
+
 pub const SSH_CONNECTION_TIMEOUT_SECS: u64 = 10;
 pub const SSH_MESSAGE_TIMEOUT_SECS: u64 = 5;
 pub const SSH_RECONNECT_DELAY_SECS: u64 = 1;
@@ -85,6 +97,8 @@ impl Configs {
                     RailwayConfig {
                         projects: BTreeMap::new(),
                         user: RailwayUser { token: None },
+                        last_update_check: None,
+                        new_version_available: None,
                     }
                 });
 
@@ -101,6 +115,8 @@ impl Configs {
             root_config: RailwayConfig {
                 projects: BTreeMap::new(),
                 user: RailwayUser { token: None },
+                last_update_check: None,
+                new_version_available: None,
             },
         })
     }
@@ -109,6 +125,8 @@ impl Configs {
         self.root_config = RailwayConfig {
             projects: BTreeMap::new(),
             user: RailwayUser { token: None },
+            last_update_check: None,
+            new_version_available: None,
         };
         Ok(())
     }
@@ -325,4 +343,36 @@ impl Configs {
 
         Ok(())
     }
+
+    pub async fn check_update(&mut self, force: bool) -> anyhow::Result<Option<String>> {
+        // outputting would break json output on CI
+        if !std::io::stdout().is_terminal() && !force {
+            return Ok(None);
+        }
+
+        if let Some(last_update_check) = self.root_config.last_update_check {
+            if Utc::now().date_naive() == last_update_check.date_naive() && !force {
+                return Ok(None);
+            }
+        }
+
+        let client = reqwest::Client::new();
+        let response = client
+            .get(GITHUB_API_RELEASE_URL)
+            .header("User-Agent", "railwayapp")
+            .send()
+            .await?;
+
+        self.root_config.last_update_check = Some(Utc::now());
+        self.write()
+            .context("Failed to save time since last update check")?;
+
+        let response = response.json::<GithubApiRelease>().await?;
+        let latest_version = response.tag_name.trim_start_matches('v');
+
+        match compare_semver(env!("CARGO_PKG_VERSION"), &latest_version) {
+            Ordering::Less => Ok(Some(latest_version.to_owned())),
+            _ => Ok(None),
+        }
+    }
 }

src/main.rs

@@ -1,8 +1,12 @@
+use std::cmp::Ordering;
+
 use anyhow::Result;
-use clap::{Parser, Subcommand};
+use clap::{error::ErrorKind, Parser, Subcommand};
 
 mod commands;
 use commands::*;
+use is_terminal::IsTerminal;
+use util::compare_semver::compare_semver;
 
 mod client;
 mod config;
@@ -59,27 +63,97 @@ commands_enum!(
     variables,
     whoami,
     volume,
-    redeploy
+    redeploy,
+    check_updates
 );
 
+fn spawn_update_task(mut configs: Configs) -> tokio::task::JoinHandle<Result<(), anyhow::Error>> {
+    tokio::spawn(async move {
+        if !std::io::stdout().is_terminal() {
+            return Ok::<(), anyhow::Error>(());
+        }
+
+        let result = configs.check_update(false).await;
+        if let Ok(Some(latest_version)) = result {
+            configs.root_config.new_version_available = Some(latest_version);
+        }
+        configs.write()?;
+        Ok::<(), anyhow::Error>(())
+    })
+}
+
+async fn handle_update_task(handle: Option<tokio::task::JoinHandle<Result<(), anyhow::Error>>>) {
+    if let Some(handle) = handle {
+        match handle.await {
+            Ok(Ok(_)) => {} // Task completed successfully
+            Ok(Err(e)) => {
+                if !std::io::stdout().is_terminal() {
+                    eprintln!("Failed to check for updates (not fatal)");
+                    eprintln!("{}", e);
+                }
+            }
+            Err(e) => {
+                eprintln!("Check Updates: Task panicked or failed to execute.");
+                eprintln!("{}", e);
+            }
+        }
+    }
+}
+
 #[tokio::main]
 async fn main() -> Result<()> {
-    let cli = Args::parse();
+    // Avoid grabbing configs multiple times, and avoid grabbing configs if we're not in a terminal
+    let mut check_updates_handle: Option<tokio::task::JoinHandle<Result<(), anyhow::Error>>> = None;
+    if std::io::stdout().is_terminal() {
+        let mut configs = Configs::new()?;
+        if let Some(new_version_available) = &configs.root_config.new_version_available {
+            match compare_semver(env!("CARGO_PKG_VERSION"), &new_version_available) {
+                Ordering::Less => {
+                    println!(
+                        "{} v{} visit {} for more info",
+                        "New version available:".green().bold(),
+                        new_version_available.yellow(),
+                        "https://docs.railway.com/guides/cli".purple(),
+                    );
+                }
+                _ => {
+                    configs.root_config.new_version_available = None;
+                    configs.write()?;
+                }
+            }
+        }
+        check_updates_handle = Some(spawn_update_task(configs));
+    }
 
-    match Commands::exec(cli).await {
-        Ok(_) => {}
+    // https://github.com/clap-rs/clap/blob/cb2352f84a7663f32a89e70f01ad24446d5fa1e2/clap_builder/src/error/mod.rs#L210-L215
+    let cli = match Args::try_parse() {
+        Ok(args) => args,
+        // Clap's source code specifically says that these errors should be
+        // printed to stdout and exit with a status of 0.
+        Err(e) if e.kind() == ErrorKind::DisplayHelp || e.kind() == ErrorKind::DisplayVersion => {
+            println!("{}", e);
+            handle_update_task(check_updates_handle).await;
+            std::process::exit(0);
+        }
         Err(e) => {
-            // If the user cancels the operation, we want to exit successfully
-            // This can happen if Ctrl+C is pressed during a prompt
-            if e.root_cause().to_string() == inquire::InquireError::OperationInterrupted.to_string()
-            {
-                return Ok(());
-            }
+            eprintln!("{}", e);
+            handle_update_task(check_updates_handle).await;
+            std::process::exit(2); // The default behavior is exit 2
+        }
+    };
 
-            eprintln!("{:?}", e);
-            std::process::exit(1);
+    let exec_result = Commands::exec(cli).await;
+
+    if let Err(e) = exec_result {
+        if e.root_cause().to_string() == inquire::InquireError::OperationInterrupted.to_string() {
+            return Ok(()); // Exit gracefully if interrupted
         }
+        eprintln!("{:?}", e);
+        handle_update_task(check_updates_handle).await;
+        std::process::exit(1);
     }
 
+    handle_update_task(check_updates_handle).await;
+
     Ok(())
 }

src/util/check_update.rs

@@ -0,0 +1,16 @@
+use colored::Colorize;
+
+pub async fn check_update(configs: &mut crate::Configs, force: bool) -> anyhow::Result<bool> {
+    let result = configs.check_update(force).await;
+    if let Ok(Some(latest_version)) = result {
+        println!(
+            "{} v{} visit {} for more info",
+            "New version available:".green().bold(),
+            latest_version.yellow(),
+            "https://docs.railway.com/guides/cli".purple(),
+        );
+        Ok(false)
+    } else {
+        Ok(true)
+    }
+}