feat: nudge desktop app when a newer release is available

- Query the latest GitHub release on the control panel and show a themed banner with a Download button when the running build is behind
- Add `update.rs` module with `newer_release()` async check and blocking wrapper `newer_release_blocking()` that works without an install receipt, supporting the macOS app bundle that ships out-of-band
- Implement pure semver comparison seam `newer_than()` to parse and compare version strings, tolerating missing "v" prefix and ignoring parse failures to prevent false nags
- Integrate update check into `stitch-setup` app with `check_for_update()` that spawns a one-shot worker thread and requests repaints on success
- Add `update_banner()` UI component to display available version with Download button that opens the releases page
- Add `open_url()` helper for cross-platform URL opening (macOS, Windows, Linux)
- Add `semver` 1.0 dependency for semantic versioning comparison
- Bump version to 0.1.65

Author: bnolens

.textile-monorepo-source

@@ -1 +1 @@
-a576c31d949378f7729b83b21c2f4876ecf39b97
+9f3f83fc3e22a8257e44f6e9d9df417b96ff5e92

.textile-stitch-release-version

@@ -1 +1 @@
-0.1.64
+0.1.65

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "stitch-bot"
-version = "0.1.64"
+version = "0.1.65"
 edition = "2021"
 description = "Stitch — Textile filler-network operator bot; signs UniswapX limit orders and closes settlement auctions."
 license = "AGPL-3.0-or-later"
@@ -36,6 +36,7 @@ alloy-rlp = "0.3"
 k256 = { version = "0.13", features = ["ecdsa"] }
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
+semver = "1"
 toml = "0.8"
 anyhow = "1"
 thiserror = "1"

Cargo.toml

@@ -42,6 +42,11 @@ pub struct StitchApp {
     pub logs: Arc<Mutex<VecDeque<String>>>,
     /// Textile mark shown in the header (loaded once at startup).
     pub icon: Option<egui::TextureHandle>,
+    /// Newer release version if the background check found one. Shared with the
+    /// worker thread that queries GitHub, hence the Arc/Mutex.
+    pub available_update: Arc<Mutex<Option<String>>>,
+    /// Guards the one-shot update check so it's spawned once, not every frame.
+    update_check_started: bool,
     child: Option<Child>,
 }
 
@@ -85,10 +90,30 @@ impl StitchApp {
             action_note: None,
             logs: Arc::new(Mutex::new(VecDeque::new())),
             icon,
+            available_update: Arc::new(Mutex::new(None)),
+            update_check_started: false,
             child: None,
         }
     }
 
+    /// Kick off a one-shot, best-effort "is a newer release out?" check on a
+    /// worker thread. Safe to call every frame: it only spawns once. On success
+    /// it stores the version and requests a repaint so the nudge appears.
+    pub fn check_for_update(&mut self, ctx: &egui::Context) {
+        if self.update_check_started {
+            return;
+        }
+        self.update_check_started = true;
+        let slot = self.available_update.clone();
+        let ctx = ctx.clone();
+        std::thread::spawn(move || {
+            if let Some(version) = stitch_bot::update::newer_release_blocking() {
+                *slot.lock().unwrap() = Some(version);
+                ctx.request_repaint();
+            }
+        });
+    }
+
     pub fn push_log(logs: &Arc<Mutex<VecDeque<String>>>, line: String) {
         let mut buf = logs.lock().unwrap();
         if buf.len() >= MAX_LOG_LINES {

src/bin/stitch-setup/app.rs

@@ -14,6 +14,8 @@ pub fn show(app: &mut StitchApp, ui: &mut egui::Ui) {
     let p = Palette::current(&ctx);
     let running = app.status != Status::Stopped;
 
+    app.check_for_update(&ctx);
+
     egui::Panel::top("header")
         .frame(panel_frame(&p, 14, 12))
         .show(ui, |ui| {
@@ -43,6 +45,14 @@ pub fn show(app: &mut StitchApp, ui: &mut egui::Ui) {
             });
         });
 
+    if let Some(latest) = app.available_update.lock().unwrap().clone() {
+        egui::Panel::top("update-nudge")
+            .frame(panel_frame(&p, 0, 12))
+            .show(ui, |ui| {
+                update_banner(ui, &p, &latest);
+            });
+    }
+
     egui::Panel::top("controls")
         .frame(panel_frame(&p, 12, 12))
         .show(ui, |ui| {
@@ -192,6 +202,31 @@ fn status_style(p: &Palette, status: Status) -> (egui::Color32, egui::Color32, &
     }
 }
 
+/// A warning-tinted strip that tells the operator a newer release is out and
+/// sends them to the download page. The macOS app ships out-of-band, so a
+/// download (not an in-place self-update) is the honest action for everyone.
+fn update_banner(ui: &mut egui::Ui, p: &Palette, latest: &str) {
+    egui::Frame::new()
+        .fill(p.warning_bg)
+        .corner_radius(egui::CornerRadius::same(10))
+        .inner_margin(Margin::symmetric(13, 10))
+        .show(ui, |ui| {
+            ui.set_min_width(ui.available_width());
+            ui.horizontal(|ui| {
+                ui.label(
+                    RichText::new(format!("Stitch v{latest} is available."))
+                        .color(p.warning)
+                        .strong(),
+                );
+                ui.with_layout(Layout::right_to_left(Align::Center), |ui| {
+                    if theme::tinted_button(ui, p.accent, "Download").clicked() {
+                        open_url(stitch_bot::update::RELEASES_PAGE);
+                    }
+                });
+            });
+        });
+}
+
 fn open_folder(dir: &std::path::Path) {
     #[cfg(target_os = "macos")]
     let _ = std::process::Command::new("open").arg(dir).spawn();
@@ -200,3 +235,12 @@ fn open_folder(dir: &std::path::Path) {
     #[cfg(all(unix, not(target_os = "macos")))]
     let _ = std::process::Command::new("xdg-open").arg(dir).spawn();
 }
+
+fn open_url(url: &str) {
+    #[cfg(target_os = "macos")]
+    let _ = std::process::Command::new("open").arg(url).spawn();
+    #[cfg(target_os = "windows")]
+    let _ = std::process::Command::new("explorer").arg(url).spawn();
+    #[cfg(all(unix, not(target_os = "macos")))]
+    let _ = std::process::Command::new("xdg-open").arg(url).spawn();
+}

src/bin/stitch-setup/panel.rs

@@ -49,3 +49,89 @@ pub async fn warn_if_outdated() {
         );
     }
 }
+
+/// Public repo the release binaries (both `stitch` and `stitch-setup`) are cut
+/// from. The two ship from one crate version, so a single check covers both.
+const RELEASE_REPO: &str = "textile-protocol/textile-stitch";
+
+/// The releases page to send operators to when a self-update isn't possible
+/// (notably the macOS `Stitch.app`, which ships out-of-band with no updater
+/// receipt, so it's re-downloaded rather than patched in place).
+pub const RELEASES_PAGE: &str =
+    "https://github.com/textile-protocol/textile-stitch/releases/latest";
+
+#[derive(serde::Deserialize)]
+struct GhRelease {
+    tag_name: String,
+}
+
+/// Best-effort "is a newer release published?" check that does NOT need an
+/// install receipt, so it works for the macOS app bundle too. Returns the newer
+/// version string, or None when already current / offline / anything odd.
+pub async fn newer_release() -> Option<String> {
+    let url = format!("https://api.github.com/repos/{RELEASE_REPO}/releases/latest");
+    let client = reqwest::Client::builder()
+        .user_agent(concat!("stitch/", env!("CARGO_PKG_VERSION")))
+        .build()
+        .ok()?;
+    let release: GhRelease = client
+        .get(url)
+        .send()
+        .await
+        .ok()?
+        .error_for_status()
+        .ok()?
+        .json()
+        .await
+        .ok()?;
+    newer_than(env!("CARGO_PKG_VERSION"), &release.tag_name)
+}
+
+/// Blocking wrapper so the synchronous GUI can run the check on a worker thread
+/// without threading a runtime through its own code.
+pub fn newer_release_blocking() -> Option<String> {
+    tokio::runtime::Builder::new_current_thread()
+        .enable_all()
+        .build()
+        .ok()?
+        .block_on(newer_release())
+}
+
+/// The pure comparison seam: return the normalized latest version when
+/// `latest_tag` (e.g. "v0.2.0") parses to a semver strictly greater than
+/// `current`. Any parse failure yields None, so a garbled tag can't nag.
+fn newer_than(current: &str, latest_tag: &str) -> Option<String> {
+    let latest = semver::Version::parse(latest_tag.strip_prefix('v').unwrap_or(latest_tag)).ok()?;
+    let current = semver::Version::parse(current).ok()?;
+    (latest > current).then(|| latest.to_string())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::newer_than;
+
+    #[test]
+    fn flags_a_newer_tag() {
+        assert_eq!(newer_than("0.1.0", "v0.2.0").as_deref(), Some("0.2.0"));
+    }
+
+    #[test]
+    fn tolerates_a_missing_v_prefix() {
+        assert_eq!(newer_than("0.1.0", "0.2.0").as_deref(), Some("0.2.0"));
+    }
+
+    #[test]
+    fn ignores_the_same_version() {
+        assert!(newer_than("0.1.0", "v0.1.0").is_none());
+    }
+
+    #[test]
+    fn ignores_an_older_tag() {
+        assert!(newer_than("0.2.0", "v0.1.0").is_none());
+    }
+
+    #[test]
+    fn ignores_a_garbage_tag() {
+        assert!(newer_than("0.1.0", "nightly").is_none());
+    }
+}