Add auto-update system for release builds

- New src/update.rs module: checks GitHub Releases API for updates,
  downloads platform-specific binaries, atomic install with symlink swap
- Only release builds (JCODE_RELEASE_BUILD=1) auto-update; dev builds
  keep existing git-based update check
- build.rs forwards JCODE_RELEASE_BUILD env var at compile time
- release.yml sets JCODE_RELEASE_BUILD=1 for CI-built binaries
- Version comparison (semver) determines if update is newer
- Supports .tar.gz asset extraction
- Rollback support via previous binary tracking
- jcode update command works for both release and dev builds

Author: 1jehuang

.github/workflows/release.yml

@@ -45,6 +45,8 @@ jobs:
 
       - name: Build release binary
         run: cargo build --release --target ${{ matrix.target }}
+        env:
+          JCODE_RELEASE_BUILD: "1"
 
       - name: Package binary
         run: |

Cargo.toml

@@ -95,6 +95,10 @@ mail-parser = "0.9"
 # PDF parsing
 pdf-extract = "0.8"
 
+# Archive extraction (for auto-update)
+flate2 = "1"
+tar = "0.4"
+
 # Mermaid diagram rendering (stable v0.2.0 tag)
 mermaid-rs-renderer = { git = "ssh://git@github.com/1jehuang/mermaid-rs-renderer.git", tag = "v0.2.0" }
 

build.rs

@@ -87,9 +87,15 @@ fn main() {
     println!("cargo:rustc-env=JCODE_GIT_TAG={}", git_tag);
     println!("cargo:rustc-env=JCODE_CHANGELOG={}", changelog);
 
+    // Forward JCODE_RELEASE_BUILD env var if set (CI sets this for release binaries)
+    if std::env::var("JCODE_RELEASE_BUILD").is_ok() {
+        println!("cargo:rustc-env=JCODE_RELEASE_BUILD=1");
+    }
+
     // Re-run if git HEAD changes
     println!("cargo:rerun-if-changed=.git/HEAD");
     println!("cargo:rerun-if-changed=.git/index");
+    println!("cargo:rerun-if-env-changed=JCODE_RELEASE_BUILD");
 }
 
 /// Get and increment the build number stored in ~/.jcode/build_number

src/lib.rs

@@ -35,5 +35,6 @@ pub mod telegram;
 pub mod todo;
 pub mod tool;
 pub mod tui;
+pub mod update;
 pub mod usage;
 pub mod util;

src/main.rs

@@ -38,6 +38,7 @@ mod telegram;
 mod todo;
 mod tool;
 mod tui;
+mod update;
 mod usage;
 mod util;
 
@@ -481,26 +482,63 @@ async fn main() -> Result<()> {
     let auto_update = args.auto_update;
 
     if check_updates {
-        // Spawn update check in background to avoid blocking startup
-        std::thread::spawn(move || {
-            if let Some(update_available) = check_for_updates() {
-                if update_available {
-                    if auto_update {
-                        eprintln!("Update available - auto-updating...");
-                        if let Err(e) = run_auto_update() {
+        if update::is_release_build() {
+            // Release build: check GitHub Releases for newer version
+            std::thread::spawn(move || {
+                match update::check_and_maybe_update(auto_update) {
+                    update::UpdateCheckResult::UpdateAvailable {
+                        current,
+                        latest,
+                        ..
+                    } => {
+                        eprintln!(
+                            "\n📦 Update available: {} → {}. Run `jcode update` to install.\n",
+                            current, latest
+                        );
+                    }
+                    update::UpdateCheckResult::UpdateInstalled { version, path } => {
+                        eprintln!(
+                            "✅ Updated to {}. Restarting from {}...",
+                            version,
+                            path.display()
+                        );
+                        // Exec into the new binary
+                        use std::os::unix::process::CommandExt;
+                        let args: Vec<String> = std::env::args().skip(1).collect();
+                        let err = ProcessCommand::new(&path)
+                            .args(&args)
+                            .arg("--no-update")
+                            .exec();
+                        eprintln!("Failed to exec new binary: {}", err);
+                    }
+                    update::UpdateCheckResult::Error(e) => {
+                        logging::info(&format!("Update check failed: {}", e));
+                    }
+                    update::UpdateCheckResult::NoUpdate => {}
+                }
+            });
+        } else {
+            // Dev build: check git remote for updates
+            std::thread::spawn(move || {
+                if let Some(update_available) = check_for_updates() {
+                    if update_available {
+                        if auto_update {
+                            eprintln!("Update available - auto-updating...");
+                            if let Err(e) = run_auto_update() {
+                                eprintln!(
+                                    "Auto-update failed: {}. Continuing with current version.",
+                                    e
+                                );
+                            }
+                        } else {
                             eprintln!(
-                                "Auto-update failed: {}. Continuing with current version.",
-                                e
+                                "\n📦 Update available! Run `jcode update` or `/reload` to update.\n"
                             );
                         }
-                    } else {
-                        eprintln!(
-                            "\n📦 Update available! Run `jcode update` or `/reload` to update.\n"
-                        );
                     }
                 }
-            }
-        });
+            });
+        }
     }
 
     if let Err(e) = run_main(args).await {
@@ -2375,12 +2413,34 @@ fn run_auto_update() -> Result<()> {
 
 /// Run the update process (manual)
 fn run_update() -> Result<()> {
+    if update::is_release_build() {
+        eprintln!("Checking GitHub for latest release...");
+        match update::check_for_update_blocking() {
+            Ok(Some(release)) => {
+                eprintln!(
+                    "Downloading {} → {}...",
+                    env!("JCODE_VERSION"),
+                    release.tag_name
+                );
+                let path = update::download_and_install_blocking(&release)?;
+                eprintln!("✅ Updated to {} at {}", release.tag_name, path.display());
+                eprintln!("Restart jcode to use the new version.");
+            }
+            Ok(None) => {
+                eprintln!("Already up to date ({})", env!("JCODE_VERSION"));
+            }
+            Err(e) => {
+                anyhow::bail!("Update check failed: {}", e);
+            }
+        }
+        return Ok(());
+    }
+
     let repo_dir =
         get_repo_dir().ok_or_else(|| anyhow::anyhow!("Could not find jcode repository"))?;
 
     eprintln!("Updating jcode from {}...", repo_dir.display());
 
-    // Git pull
     eprintln!("Pulling latest changes...");
     let pull = ProcessCommand::new("git")
         .args(["pull"])
@@ -2391,7 +2451,6 @@ fn run_update() -> Result<()> {
         anyhow::bail!("git pull failed");
     }
 
-    // Cargo build --release
     eprintln!("Building...");
     let build = ProcessCommand::new("cargo")
         .args(["build", "--release"])
@@ -2406,7 +2465,6 @@ fn run_update() -> Result<()> {
         eprintln!("Warning: install failed: {}", e);
     }
 
-    // Get new version hash
     let hash = ProcessCommand::new("git")
         .args(["rev-parse", "--short", "HEAD"])
         .current_dir(&repo_dir)