fix(rust): backdate extracted CLI mtime to stop build.rs self-invalidation (#1776)

* fix(rust): backdate extracted CLI mtime to stop self-invalidation

When `bundled-cli` is off, `build.rs` watches the extracted CLI binary via
`cargo:rerun-if-changed` so a deleted cache binary forces a re-extract. On a
cold cache the same build script *creates* that binary mid-build, after the
download — so its mtime ends up newer than cargo's build-script `output`
reference (stamped when the script was spawned). The next identical `cargo`
invocation then sees the watched file as "changed", reruns build.rs, recompiles
the SDK crate, and relinks every downstream crate (observed ~9 min of wasted CI
on a second cargo invocation in the same job).

Backdate the staged binary's mtime to the Unix epoch before the atomic rename
(rename preserves mtime), so it lands unambiguously older than any real build
reference and a no-change rebuild stays a true no-op. Best-effort: on error we
emit a `cargo:warning` and continue, reverting to the prior redundant-rebuild
behaviour rather than breaking the build. The deleted-file recovery contract is
untouched — a missing file still can't be stat'd, so cargo still reruns.

Embed mode (`bundled-cli` on) is unaffected: it emits no `rerun-if-changed` on
any build-created file.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

* refactor(rust): write staging binary through a single file handle

Address review: open the staging file once and perform the write, permission-set, and mtime-backdate on one handle instead of reopening it for each step. Write and chmod failures stay fatal; the epoch backdate stays best-effort (warn and continue). Behavior is otherwise unchanged: the extracted binary still lands epoch-dated so a no-change rebuild is a true no-op.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

---------

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: redsun82

rust/build.rs

@@ -1,4 +1,4 @@
-use std::io::Read;
+use std::io::{Read, Write};
 use std::path::{Path, PathBuf};
 use std::time::Duration;
 
@@ -359,22 +359,55 @@ fn extract_to_cache(archive: &[u8], install_dir: &Path, platform: Platform) -> P
         std::process::id(),
     ));
 
-    if let Err(e) = std::fs::write(&staging_path, &bytes) {
-        let _ = std::fs::remove_file(&staging_path);
-        panic!(
-            "failed to write staging file {}: {e}",
-            staging_path.display()
-        );
-    }
-
-    #[cfg(unix)]
     {
-        use std::os::unix::fs::PermissionsExt;
-        if let Err(e) =
-            std::fs::set_permissions(&staging_path, std::fs::Permissions::from_mode(0o755))
-        {
+        let mut f = std::fs::File::create(&staging_path).unwrap_or_else(|e| {
             let _ = std::fs::remove_file(&staging_path);
-            panic!("failed to chmod {}: {e}", staging_path.display());
+            panic!(
+                "failed to create staging file {}: {e}",
+                staging_path.display()
+            );
+        });
+
+        if let Err(e) = f.write_all(&bytes) {
+            let _ = std::fs::remove_file(&staging_path);
+            panic!(
+                "failed to write staging file {}: {e}",
+                staging_path.display()
+            );
+        }
+
+        #[cfg(unix)]
+        {
+            use std::os::unix::fs::PermissionsExt;
+            if let Err(e) = f.set_permissions(std::fs::Permissions::from_mode(0o755)) {
+                let _ = std::fs::remove_file(&staging_path);
+                panic!("failed to chmod {}: {e}", staging_path.display());
+            }
+        }
+
+        // Backdate the staged binary to the Unix epoch before it lands. We emit
+        // `cargo:rerun-if-changed` on `final_path` (see caller) so a *deleted*
+        // cache binary forces a re-extract — but cargo stamps the build-script
+        // `output` reference when the script is spawned, seconds before this
+        // freshly-downloaded binary is written. A current mtime would therefore
+        // be *newer* than that reference, so the next identical `cargo`
+        // invocation would see the watched file as "changed" and pointlessly
+        // rerun build.rs + recompile the crate + relink every downstream crate.
+        // Pinning to the epoch keeps the file unambiguously older than any real
+        // build reference; `rename` preserves mtime (same inode), so it lands
+        // already-backdated and a no-change rebuild stays a true no-op. The
+        // deleted-file recovery contract is untouched: a missing file can't be
+        // stat'd, so cargo still treats it as stale and reruns regardless.
+        //
+        // Best-effort: a filesystem that refuses the epoch (e.g. FAT's 1980 floor
+        // clamps it — still older than any real reference) or rejects the call
+        // just reverts to the pre-fix redundant-rebuild behaviour, never a broken
+        // build.
+        if let Err(e) = f.set_modified(std::time::SystemTime::UNIX_EPOCH) {
+            println!(
+                "cargo:warning=Could not backdate {} (a redundant rebuild may occur): {e}",
+                staging_path.display()
+            );
         }
     }