setup: Complete integration asset installation slice

Integration asset installation needed adapter-neutral asset bytes, request-level
preflight, and end-to-end compatibility coverage. Use `Cow<'static, [u8]>`,
preflight once per request, test staging cleanup and facade behavior, and record
the resulting architecture and validation evidence.

Co-authored-by: SCE <sce@crocoder.dev>

Author: davidabram

cli/src/adapters/outbound/assets/embedded_integration_assets.rs

@@ -2,6 +2,7 @@
 //! adapter wrapping the existing generated embedded-asset catalog in
 //! `services::setup`.
 
+use std::borrow::Cow;
 use std::convert::Infallible;
 
 use crate::application::ports::integration_asset_catalog::IntegrationAssetCatalog;
@@ -35,7 +36,7 @@ impl IntegrationAssetCatalog for EmbeddedIntegrationAssetCatalog {
         )
         .map(|asset| IntegrationAsset {
             relative_path: asset.relative_path.to_string(),
-            bytes: asset.bytes,
+            bytes: Cow::Borrowed(asset.bytes),
         })
         .collect();
 
@@ -62,7 +63,7 @@ mod tests {
             )
             .map(|asset| IntegrationAsset {
                 relative_path: asset.relative_path.to_string(),
-                bytes: asset.bytes,
+                bytes: Cow::Borrowed(asset.bytes),
             })
             .collect();
 
@@ -87,7 +88,7 @@ mod tests {
                 )
                 .map(|asset| IntegrationAsset {
                     relative_path: asset.relative_path.to_string(),
-                    bytes: asset.bytes,
+                    bytes: Cow::Borrowed(asset.bytes),
                 })
                 .collect();
 

cli/src/adapters/outbound/filesystem/integration_installer.rs

@@ -44,6 +44,10 @@ pub(crate) struct FilesystemIntegrationInstaller;
 impl IntegrationInstaller for FilesystemIntegrationInstaller {
     type Error = anyhow::Error;
 
+    fn preflight(&self, repository_root: &Path) -> Result<()> {
+        ensure_directory_is_writable(repository_root, "setup repository root")
+    }
+
     fn install(
         &self,
         repository_root: &Path,
@@ -65,8 +69,6 @@ fn install_with_rename<F>(
 where
     F: FnMut(&Path, &Path) -> io::Result<()>,
 {
-    ensure_directory_is_writable(repository_root, "setup repository root")?;
-
     let destination_root = destination_root_for(repository_root, target);
     let staging_root = create_staging_root(repository_root, target)?;
 
@@ -147,7 +149,7 @@ fn write_assets_to_staging(staging_root: &Path, assets: &[IntegrationAsset]) ->
             )
         })?;
 
-        fs::write(&destination, asset.bytes).with_context(|| {
+        fs::write(&destination, asset.bytes.as_ref()).with_context(|| {
             format!(
                 "Failed to write staged embedded asset '{}'",
                 destination.display()
@@ -236,7 +238,7 @@ mod tests {
     fn asset(relative_path: &str, bytes: &'static [u8]) -> IntegrationAsset {
         IntegrationAsset {
             relative_path: relative_path.to_string(),
-            bytes,
+            bytes: std::borrow::Cow::Borrowed(bytes),
         }
     }
 
@@ -268,6 +270,27 @@ mod tests {
         let _ = fs::remove_dir_all(&repo);
     }
 
+    #[test]
+    fn owned_asset_bytes_reach_the_installer_unchanged() {
+        let repo = unique_temp_dir("owned-bytes");
+        let assets = vec![IntegrationAsset {
+            relative_path: "owned/asset.bin".to_string(),
+            bytes: std::borrow::Cow::Owned(vec![1, 2, 3]),
+        }];
+
+        let installed = FilesystemIntegrationInstaller
+            .install(&repo, IntegrationTarget::Claude, &assets)
+            .expect("install should succeed");
+
+        assert_eq!(
+            fs::read(installed.destination_root.join("owned/asset.bin"))
+                .expect("read installed asset"),
+            vec![1, 2, 3]
+        );
+
+        let _ = fs::remove_dir_all(&repo);
+    }
+
     #[test]
     fn install_rejects_absolute_and_parent_component_paths() {
         let repo = unique_temp_dir("invalid-path");
@@ -286,6 +309,33 @@ mod tests {
         let _ = fs::remove_dir_all(&repo);
     }
 
+    #[test]
+    fn install_cleans_up_staging_after_write_failure() {
+        let repo = unique_temp_dir("write-failure");
+        let assets = vec![
+            asset("collision", b"file"),
+            asset("collision/child.txt", b"child"),
+        ];
+
+        FilesystemIntegrationInstaller
+            .install(&repo, IntegrationTarget::Claude, &assets)
+            .expect_err("conflicting asset paths should fail during staging");
+        assert!(!InstallTargetPaths::new(&repo).claude_target_dir().exists());
+
+        let leftover_staging = fs::read_dir(&repo)
+            .expect("read repo root")
+            .filter_map(std::result::Result::ok)
+            .any(|entry| {
+                entry
+                    .file_name()
+                    .to_string_lossy()
+                    .starts_with(".sce-setup-staging-")
+            });
+        assert!(!leftover_staging, "staging directory should be cleaned up");
+
+        let _ = fs::remove_dir_all(&repo);
+    }
+
     #[test]
     fn install_replaces_an_existing_target_without_a_backup() {
         let repo = unique_temp_dir("replace-existing");

cli/src/application/ports/integration_installer.rs

@@ -22,6 +22,8 @@ pub(crate) struct InstalledIntegrationTarget {
 pub(crate) trait IntegrationInstaller {
     type Error;
 
+    fn preflight(&self, repository_root: &Path) -> Result<(), Self::Error>;
+
     fn install(
         &self,
         repository_root: &Path,

cli/src/application/use_cases/install_integration_assets.rs

@@ -43,6 +43,10 @@ impl<C: IntegrationAssetCatalog, I: IntegrationInstaller> InstallIntegrationAsse
         optional_workflows: &[String],
     ) -> Result<InstallIntegrationAssetsReport, InstallIntegrationAssetsError<C::Error, I::Error>>
     {
+        self.installer
+            .preflight(repository_root)
+            .map_err(InstallIntegrationAssetsError::Installer)?;
+
         let mut targets = Vec::new();
 
         for &target in selection.targets() {
@@ -95,28 +99,40 @@ mod tests {
 
             Ok(vec![IntegrationAsset {
                 relative_path: "file.txt".to_string(),
-                bytes: b"content",
+                bytes: std::borrow::Cow::Borrowed(b"content"),
             }])
         }
     }
 
     #[derive(Default)]
     struct FakeInstaller {
-        calls: RefCell<Vec<(PathBuf, IntegrationTarget, Vec<IntegrationAsset>)>>,
+        preflight_calls: RefCell<Vec<PathBuf>>,
+        install_calls: RefCell<Vec<(PathBuf, IntegrationTarget, Vec<IntegrationAsset>)>>,
+        preflight_error: Option<&'static str>,
     }
 
     impl IntegrationInstaller for FakeInstaller {
         type Error = &'static str;
 
+        fn preflight(&self, repository_root: &Path) -> Result<(), Self::Error> {
+            self.preflight_calls
+                .borrow_mut()
+                .push(repository_root.to_path_buf());
+
+            self.preflight_error.map_or(Ok(()), Err)
+        }
+
         fn install(
             &self,
             repository_root: &Path,
             target: IntegrationTarget,
             assets: &[IntegrationAsset],
         ) -> Result<InstalledIntegrationTarget, Self::Error> {
-            self.calls
-                .borrow_mut()
-                .push((repository_root.to_path_buf(), target, assets.to_vec()));
+            self.install_calls.borrow_mut().push((
+                repository_root.to_path_buf(),
+                target,
+                assets.to_vec(),
+            ));
 
             Ok(InstalledIntegrationTarget {
                 target,
@@ -150,7 +166,13 @@ mod tests {
         assert_eq!(catalog_calls[0].0, IntegrationTarget::Claude);
         assert_eq!(catalog_calls[0].1, optional_workflows);
 
-        let installer_calls = use_case.installer.calls.borrow();
+        let preflight_calls = use_case.installer.preflight_calls.borrow();
+        assert_eq!(
+            preflight_calls.as_slice(),
+            std::slice::from_ref(&repository_root),
+        );
+
+        let installer_calls = use_case.installer.install_calls.borrow();
         assert_eq!(installer_calls.len(), 1);
         assert_eq!(installer_calls[0].0, repository_root);
         assert_eq!(installer_calls[0].1, IntegrationTarget::Claude);
@@ -181,7 +203,13 @@ mod tests {
             ]
         );
 
-        let installer_calls = use_case.installer.calls.borrow();
+        let preflight_calls = use_case.installer.preflight_calls.borrow();
+        assert_eq!(
+            preflight_calls.as_slice(),
+            std::slice::from_ref(&repository_root),
+        );
+
+        let installer_calls = use_case.installer.install_calls.borrow();
         let installer_order: Vec<IntegrationTarget> = installer_calls
             .iter()
             .map(|(_, target, _)| *target)
@@ -221,11 +249,36 @@ mod tests {
             vec![IntegrationTarget::OpenCode, IntegrationTarget::Claude]
         );
 
-        let installer_calls = use_case.installer.calls.borrow();
+        let installer_calls = use_case.installer.install_calls.borrow();
         let installer_order: Vec<IntegrationTarget> = installer_calls
             .iter()
             .map(|(_, target, _)| *target)
             .collect();
         assert_eq!(installer_order, vec![IntegrationTarget::OpenCode]);
     }
+
+    #[test]
+    fn preflight_error_prevents_catalog_and_install_calls() {
+        let catalog = FakeCatalog::default();
+        let installer = FakeInstaller {
+            preflight_calls: RefCell::new(Vec::new()),
+            install_calls: RefCell::new(Vec::new()),
+            preflight_error: Some("preflight failed"),
+        };
+        let use_case = InstallIntegrationAssets::new(catalog, installer);
+        let repository_root = PathBuf::from("/repo");
+
+        let result = use_case.execute(&repository_root, IntegrationTargetSelection::All, &[]);
+
+        assert!(matches!(
+            result,
+            Err(InstallIntegrationAssetsError::Installer("preflight failed"))
+        ));
+        assert_eq!(
+            use_case.installer.preflight_calls.borrow().as_slice(),
+            [repository_root]
+        );
+        assert!(use_case.catalog.calls.borrow().is_empty());
+        assert!(use_case.installer.install_calls.borrow().is_empty());
+    }
 }

cli/src/domain/integration/asset.rs

@@ -1,10 +1,11 @@
 //! A single embedded integration asset to be installed into a repository.
 
+use std::borrow::Cow;
+
 /// An embedded asset destined for a repository-relative path within an
 /// integration target's install root.
 #[derive(Clone, Debug, Eq, PartialEq)]
-#[allow(dead_code)] // consumed starting with the IntegrationAssetCatalog port (T02)
 pub(crate) struct IntegrationAsset {
     pub(crate) relative_path: String,
-    pub(crate) bytes: &'static [u8],
+    pub(crate) bytes: Cow<'static, [u8]>,
 }