release(v1.7.7-alpha): clean OTA test bump on top of robust apply

Pure version bump. No code changes. First release shipped with the
reinforced apply_update (timestamped staging + all-mv) and frontend
with 95% progress cap — this OTA should walk through cleanly from
.116/.198/.253 without any sideload intervention.

Artefacts:
  archipelago                                      e3f1740d…006025  40373392
  archipelago-frontend-1.7.7-alpha.tar.gz          4fb79664…0172e9  76984615 (reused)

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

core/Cargo.lock

@@ -80,7 +80,7 @@ checksum = "a23eb6b1614318a8071c9b2521f36b424b2c83db5eb3a0fead4a6c0809af6e61"
 
 [[package]]
 name = "archipelago"
-version = "1.7.3-alpha"
+version = "1.7.7-alpha"
 dependencies = [
  "anyhow",
  "archipelago-container",

core/archipelago/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "archipelago"
-version = "1.7.3-alpha"
+version = "1.7.7-alpha"
 edition = "2021"
 description = "Archipelago Bitcoin Node OS - Native backend"
 authors = ["Archipelago Team"]

core/archipelago/src/api/rpc/update.rs

@@ -6,12 +6,18 @@ impl RpcHandler {
     /// Check for available system updates.
     /// Tries git-based check first (if repo exists), falls back to manifest-based.
     pub(super) async fn handle_update_check(&self) -> Result<serde_json::Value> {
-        // Try git-based check first (preferred for beta nodes)
+        // Manifest override: when ARCHIPELAGO_UPDATE_URL is explicitly set,
+        // the operator wants OTA via manifest — typically a dev box where
+        // ~/archy/.git exists but isn't the intended update surface.
+        // Without this short-circuit the dev box always advertises "Pull
+        // & Rebuild" and can never exercise the manifest OTA path.
+        let manifest_override = std::env::var("ARCHIPELAGO_UPDATE_URL").is_ok();
+
         let repo_dir = std::path::PathBuf::from(
             std::env::var("HOME").unwrap_or_else(|_| "/home/archipelago".to_string()),
         )
         .join("archy");
-        if repo_dir.join(".git").exists() {
+        if !manifest_override && repo_dir.join(".git").exists() {
             if let Ok(git_status) = self.git_check_update(&repo_dir).await {
                 return Ok(git_status);
             }

core/archipelago/src/update.rs

@@ -305,42 +305,90 @@ pub async fn apply_update(data_dir: &Path) -> Result<()> {
                 info!(name = %name, "Backend binary applied");
             }
             _ if name.contains("frontend") && name.ends_with(".tar.gz") => {
-                let web_ui_dir = Path::new("/opt/archipelago/web-ui");
-                // Back up current frontend. /opt/archipelago is root-owned;
-                // the backup goes under our data_dir where we can write.
-                let frontend_backup = backup_dir.join("web-ui-backup.tar.gz");
-                if web_ui_dir.exists() {
-                    let status = tokio::process::Command::new("sudo")
-                        .args([
-                            "tar",
-                            "-czf",
-                            &frontend_backup.to_string_lossy(),
-                            "-C",
-                            "/opt/archipelago",
-                            "web-ui",
-                        ])
-                        .status()
-                        .await
-                        .context("Failed to backup frontend")?;
-                    if status.success() {
-                        info!("Frontend backed up");
-                    }
+                // Tarball contents are the *inside* of web-ui/ (root entries
+                // `./test-aiui.html`, `./assets/`, ...). Extract into a
+                // uniquely-named staging dir, then mv into place. No `rm
+                // -rf` pre-cleanup — that's what hit transient EROFS on
+                // .198 and aborted the apply mid-flight.
+                let ts = chrono::Utc::now().timestamp_millis();
+                let staging_new = format!("/opt/archipelago/web-ui.new.{}", ts);
+                let staging_old = format!("/opt/archipelago/web-ui.old.{}", ts);
+                let web_ui = "/opt/archipelago/web-ui";
+                let backup_path = "/opt/archipelago/web-ui.bak";
+
+                let mk = tokio::process::Command::new("sudo")
+                    .args(["mkdir", "-p", &staging_new])
+                    .status()
+                    .await
+                    .context("Failed to create frontend staging dir")?;
+                if !mk.success() {
+                    anyhow::bail!("mkdir {} failed", staging_new);
                 }
-                // Extract new frontend into /opt/archipelago (root-owned dir).
-                let status = tokio::process::Command::new("sudo")
-                    .args(["tar", "-xzf", &src.to_string_lossy(), "-C", "/opt/archipelago"])
+                let extract = tokio::process::Command::new("sudo")
+                    .args(["tar", "-xzf", &src.to_string_lossy(), "-C", &staging_new])
                     .status()
                     .await
                     .with_context(|| format!("Failed to extract {}", name))?;
-                if !status.success() {
+                if !extract.success() {
+                    // Best-effort cleanup of the partial extraction.
+                    let _ = tokio::process::Command::new("sudo")
+                        .args(["rm", "-rf", &staging_new])
+                        .status()
+                        .await;
                     anyhow::bail!("tar extraction failed for {}", name);
                 }
-                // nginx serves this tree; keep ownership consistent with
-                // what first-boot + the ISO layout expect.
                 let _ = tokio::process::Command::new("sudo")
-                    .args(["chown", "-R", "archipelago:archipelago", "/opt/archipelago/web-ui"])
+                    .args(["chown", "-R", "archipelago:archipelago", &staging_new])
                     .status()
                     .await;
+
+                // Swap: mv current web-ui aside, then mv new into place.
+                if Path::new(web_ui).exists() {
+                    let mv_old = tokio::process::Command::new("sudo")
+                        .args(["mv", web_ui, &staging_old])
+                        .status()
+                        .await
+                        .context("Failed to rotate old web-ui")?;
+                    if !mv_old.success() {
+                        anyhow::bail!("failed to move old web-ui aside");
+                    }
+                }
+                let mv_new = tokio::process::Command::new("sudo")
+                    .args(["mv", &staging_new, web_ui])
+                    .status()
+                    .await
+                    .context("Failed to swap new web-ui into place")?;
+                if !mv_new.success() {
+                    // Roll back the rename so nginx keeps serving.
+                    if Path::new(&staging_old).exists() {
+                        let _ = tokio::process::Command::new("sudo")
+                            .args(["mv", &staging_old, web_ui])
+                            .status()
+                            .await;
+                    }
+                    anyhow::bail!("failed to move new web-ui into place");
+                }
+
+                // Rotate previous rollback aside (best-effort) and install
+                // this apply's old copy as the new rollback.
+                if Path::new(&staging_old).exists() {
+                    if Path::new(backup_path).exists() {
+                        // Tag the previous backup with its own ts so it
+                        // doesn't collide; best-effort cleanup.
+                        let _ = tokio::process::Command::new("sudo")
+                            .args([
+                                "mv",
+                                backup_path,
+                                &format!("{}.{}", backup_path, ts),
+                            ])
+                            .status()
+                            .await;
+                    }
+                    let _ = tokio::process::Command::new("sudo")
+                        .args(["mv", &staging_old, backup_path])
+                        .status()
+                        .await;
+                }
                 info!(name = %name, "Frontend archive extracted to /opt/archipelago/web-ui");
             }
             _ => {

neode-ui/src/views/SystemUpdate.vue

@@ -345,10 +345,12 @@ async function downloadUpdate() {
   downloadPercent.value = 0
   statusMessage.value = ''
 
-  // Simulate incremental progress while waiting for the RPC
+  // Simulate incremental progress while waiting for the RPC. Capped at
+  // 95% so the bar never shows >100% before the real completion jumps it
+  // to 100 — previously the random increment could overshoot.
   const progressInterval = setInterval(() => {
-    if (downloadPercent.value < 90) {
-      downloadPercent.value += Math.random() * 15
+    if (downloadPercent.value < 95) {
+      downloadPercent.value = Math.min(95, downloadPercent.value + Math.random() * 3)
     }
   }, 500)