Preserve legacy flat cache during install backup

Author: moradology

Cargo.lock

@@ -4,7 +4,7 @@ members = ["crates/*"]
 exclude = ["support/m80-close-range"]
 
 [workspace.package]
-version = "0.2.21"
+version = "0.2.22"
 edition = "2021"
 license = "Apache-2.0 OR MIT"
 repository = "https://github.com/moradology/m80"

Cargo.toml

@@ -447,7 +447,7 @@ impl FlatPathBackup {
                 }
             }
             Ok(metadata) if metadata.is_dir() => {
-                hardlink_copy_tree(&path, backup)?;
+                backup_directory_tree(&path, backup)?;
                 FlatPathState::Directory {
                     backup: backup.to_path_buf(),
                 }
@@ -496,6 +496,79 @@ impl FlatPathBackup {
     }
 }
 
+fn backup_directory_tree(source: &Path, destination: &Path) -> Result<(), FcError> {
+    let parent = destination_parent(destination)?;
+    fs::create_dir_all(parent).map_err(|source_err| FcError::PathIo {
+        path: parent.to_path_buf(),
+        source: source_err,
+    })?;
+    let tmp = sibling_tmp_path(destination, "backup-tree");
+    remove_path_if_exists(&tmp)?;
+    copy_backup_tree_contents(source, &tmp)?;
+    if let Err(err) = replace_path_with_prepared_tree(&tmp, destination) {
+        let _ = remove_path_if_exists(&tmp);
+        return Err(err);
+    }
+    Ok(())
+}
+
+fn copy_backup_tree_contents(source: &Path, destination: &Path) -> Result<(), FcError> {
+    fs::create_dir(destination).map_err(|source_err| FcError::PathIo {
+        path: destination.to_path_buf(),
+        source: source_err,
+    })?;
+    fs::set_permissions(destination, fs::Permissions::from_mode(0o755)).map_err(|source_err| {
+        FcError::PathIo {
+            path: destination.to_path_buf(),
+            source: source_err,
+        }
+    })?;
+    for entry in fs::read_dir(source).map_err(|source_err| FcError::PathIo {
+        path: source.to_path_buf(),
+        source: source_err,
+    })? {
+        let entry = entry.map_err(|source_err| FcError::PathIo {
+            path: source.to_path_buf(),
+            source: source_err,
+        })?;
+        let source_path = entry.path();
+        let destination_path = destination.join(entry.file_name());
+        let metadata =
+            fs::symlink_metadata(&source_path).map_err(|source_err| FcError::PathIo {
+                path: source_path.clone(),
+                source: source_err,
+            })?;
+        if metadata.file_type().is_symlink() {
+            let target = fs::read_link(&source_path).map_err(|source_err| FcError::PathIo {
+                path: source_path.clone(),
+                source: source_err,
+            })?;
+            symlink(&target, &destination_path).map_err(|source_err| FcError::PathIo {
+                path: destination_path,
+                source: source_err,
+            })?;
+        } else if metadata.is_dir() {
+            copy_backup_tree_contents(&source_path, &destination_path)?;
+        } else if metadata.is_file() {
+            fs::hard_link(&source_path, &destination_path).map_err(|source_err| {
+                FcError::PathIo {
+                    path: destination_path,
+                    source: source_err,
+                }
+            })?;
+        } else {
+            return Err(FcError::Config(ConfigError::InvalidValue {
+                field: "install.flat_projection",
+                reason: format!(
+                    "flat projection backup contains unsupported file type: {}",
+                    source_path.display()
+                ),
+            }));
+        }
+    }
+    Ok(())
+}
+
 fn flat_managed_paths(install_root: &Path) -> Vec<PathBuf> {
     let bin_dir = install_root.join("bin");
     let artifact_dir = install_root.join("artifacts");
@@ -519,7 +592,7 @@ mod tests {
     use std::fs;
     use std::os::unix::fs::MetadataExt;
 
-    use super::hardlink_copy_tree;
+    use super::{backup_directory_tree, hardlink_copy_tree};
 
     #[test]
     fn hardlink_copy_tree_replaces_stale_destination_entries() {
@@ -549,6 +622,31 @@ mod tests {
         );
     }
 
+    #[test]
+    fn backup_directory_tree_preserves_legacy_symlinks_without_following() {
+        let temp = tempfile::tempdir().unwrap();
+        let source = temp.path().join("source");
+        let destination = temp.path().join("backup");
+        fs::create_dir_all(&source).unwrap();
+        fs::write(source.join("manifest.json"), b"manifest").unwrap();
+        std::os::unix::fs::symlink(
+            "../versions/v0.2.20/artifacts/release-proof-cache",
+            source.join("release-proof-cache"),
+        )
+        .unwrap();
+
+        backup_directory_tree(&source, &destination).unwrap();
+
+        assert_same_inode(
+            &source.join("manifest.json"),
+            &destination.join("manifest.json"),
+        );
+        assert_eq!(
+            fs::read_link(destination.join("release-proof-cache")).unwrap(),
+            std::path::PathBuf::from("../versions/v0.2.20/artifacts/release-proof-cache")
+        );
+    }
+
     fn assert_same_inode(left: &std::path::Path, right: &std::path::Path) {
         let left = fs::metadata(left).unwrap();
         let right = fs::metadata(right).unwrap();

crates/m80-cli/src/cmds/install/layout/flat_projection.rs

@@ -28,16 +28,16 @@ fn current_latest_version_cutover_names_real_repair_tag() {
             .expect("read installer layout fixture");
 
     assert!(
-        cargo_toml.contains("version = \"0.2.21\""),
+        cargo_toml.contains("version = \"0.2.22\""),
         "workspace package version must match the current repair tag"
     );
     assert!(
-        runbook.contains("workspace package version `0.2.21`")
-            && runbook.contains("expected release tag is `v0.2.21`"),
+        runbook.contains("workspace package version `0.2.22`")
+            && runbook.contains("expected release tag is `v0.2.22`"),
         "release runbook must document the real current repair version"
     );
     assert!(
-        behavior.contains("matching stable tag is `v0.2.21`")
+        behavior.contains("matching stable tag is `v0.2.22`")
             && behavior.contains("`v0.2.7` installer handoff"),
         "behavior doc must name the repaired tag and the superseded latest state"
     );

crates/m80-cli/tests/release/current_latest_version_cutover.rs

@@ -38,19 +38,22 @@ keeps the installer fix, restores the lockfile, and retries only transient
 stale-latest observations before declaring the public-access receipt failed.
 `v0.2.21` carries the flat `/opt/m80/bin` and `/opt/m80/artifacts` hardlink
 projection so preflight and clients use stable paths while the versioned
-install record remains available for rollback.
+install record remains available for rollback. `v0.2.22` fixes the legacy
+flat proof-cache bridge case found on vulcan, where an old nested symlink under
+`/opt/m80/artifacts/release-proof-cache/` made the `v0.2.21` rollback backup
+reject the install before activation.
 
-The current repair source therefore uses workspace package version `0.2.21`.
-The matching stable tag is `v0.2.21`; tags at or before the existing public
-latest `v0.2.20` are intentionally rejected as old-release backfill candidates
+The current repair source therefore uses workspace package version `0.2.22`.
+The matching stable tag is `v0.2.22`; tags at or before the existing public
+latest `v0.2.21` are intentionally rejected as old-release backfill candidates
 by `scripts/current_latest_repair_preflight.py`.
 
 The release runbook documents this as the real source-state expectation rather
 than a fixture-only value. Dev builds still render as `<package-version>-dev`,
-so an unreleased local build now reports `0.2.21-dev` and remains barred from
+so an unreleased local build now reports `0.2.22-dev` and remains barred from
 using mutable `releases/latest` implicitly.
 
-Fixture and release-script coverage uses `v0.2.21` as the packageable release
+Fixture and release-script coverage uses `v0.2.22` as the packageable release
 tag. Rust installer-layout fixtures derive their release tag from
 `CARGO_PKG_VERSION`, so the bundled layout tests also follow the same cutover.
 Tests may still use other tags only when they are explicitly testing mismatch,