unbreak darwin(?)

Author: NotAShelf

src/darwin.rs

@@ -1,11 +1,13 @@
-use color_eyre::eyre::bail;
-use color_eyre::Result;
-use tracing::{debug, info, warn};
+use color_eyre::eyre::{bail, Context};
+use tracing::{debug, warn};
 
 use crate::commands::Command;
+use crate::installable::Installable;
 use crate::interface::{DarwinArgs, DarwinRebuildArgs, DarwinReplArgs, DarwinSubcommand};
 use crate::update::update;
+use crate::util::get_hostname;
 use crate::util::platform;
+use crate::Result;
 
 const SYSTEM_PROFILE: &str = "/nix/var/nix/profiles/system";
 const CURRENT_PROFILE: &str = "/run/current-system";
@@ -35,69 +37,70 @@ impl DarwinRebuildArgs {
     fn rebuild(self, variant: DarwinRebuildVariant) -> Result<()> {
         use DarwinRebuildVariant::{Build, Switch};
 
-        // Check if we're running as root
+        // Check if running as root
         platform::check_not_root(false)?;
 
         if self.update_args.update {
             update(&self.common.installable, self.update_args.update_input)?;
         }
 
-        // Get the hostname
-        let (hostname, _) = platform::get_target_hostname(self.hostname, false)?;
+        let hostname = self.hostname.ok_or(()).or_else(|()| get_hostname())?;
 
-        // Create output path
+        // Create temporary output path
         let out_path = platform::create_output_path(self.common.out_link, "nh-darwin")?;
         debug!(?out_path);
 
-        // Use NH_DARWIN_FLAKE if available, otherwise use the provided installable
+        // Resolve the installable from env var or from the provided argument
         let installable =
             platform::resolve_env_installable("NH_DARWIN_FLAKE", self.common.installable.clone());
 
-        // Build the configuration
-        let _target_profile = platform::handle_rebuild_workflow(
+        // Build the darwin configuration with proper attribute path handling
+        let target_profile = platform::handle_rebuild_workflow(
             installable,
             "darwinConfigurations",
             &["toplevel"],
             Some(hostname),
             out_path.as_ref(),
             &self.extra_args,
-            None, // No builder
+            None, // Darwin doesn't use remote builders
             "Building Darwin configuration",
             self.common.no_nom,
-            "",    // No specialisation path for Darwin
-            false, // No specialisation
-            None,  // No specialisation
+            "", // Darwin doesn't use specialisations like NixOS
+            false,
+            None,
             CURRENT_PROFILE,
-            false, // Don't skip comparison
+            false,
         )?;
 
-        if self.common.ask && !self.common.dry && !matches!(variant, Build) {
-            info!("Apply the config?");
-            let confirmation = dialoguer::Confirm::new().default(false).interact()?;
-
-            if !confirmation {
-                bail!("User rejected the new config");
-            }
+        // Allow users to confirm before applying changes
+        if !platform::confirm_action(
+            self.common.ask && !matches!(variant, Build),
+            self.common.dry,
+        )? {
+            return Ok(());
         }
 
-        if matches!(variant, Switch) && !self.common.dry {
+        if matches!(variant, Switch) {
             Command::new("nix")
                 .args(["build", "--no-link", "--profile", SYSTEM_PROFILE])
-                .arg(out_path.get_path())
+                .arg(&target_profile)
                 .elevate(true)
                 .dry(self.common.dry)
                 .run()?;
 
-            let darwin_rebuild = out_path.get_path().join("sw/bin/darwin-rebuild");
-            let activate_user = out_path.get_path().join("activate-user");
+            let darwin_rebuild = target_profile.join("sw/bin/darwin-rebuild");
+            let activate_user = target_profile.join("activate-user");
 
-            // Determine if we need to elevate privileges
-            let needs_elevation = !activate_user.try_exists().unwrap_or(false)
+            // Darwin activation may or may not need root privileges
+            // This checks if we need elevation based on the activation-user script
+            let needs_elevation = !activate_user
+                .try_exists()
+                .context("Failed to check if activate-user file exists")?
                 || std::fs::read_to_string(&activate_user)
-                    .unwrap_or_default()
+                    .context("Failed to read activate-user file")?
                     .contains("# nix-darwin: deprecated");
 
-            // Create and run the activation command with or without elevation
+            // Actually activate the configuration using darwin-rebuild
             Command::new(darwin_rebuild)
                 .arg("activate")
                 .message("Activating configuration")
@@ -108,30 +111,26 @@ impl DarwinRebuildArgs {
 
         // Make sure out_path is not accidentally dropped
         // https://docs.rs/tempfile/3.12.0/tempfile/index.html#early-drop-pitfall
-        drop(out_path);
 
         Ok(())
     }
 }
 
 impl DarwinReplArgs {
     fn run(self) -> Result<()> {
-        // Use NH_DARWIN_FLAKE if available, otherwise use the provided installable
-        let installable = platform::resolve_env_installable("NH_DARWIN_FLAKE", self.installable);
+        if let Installable::Store { .. } = self.installable {
+            bail!("Nix doesn't support nix store installables.");
+        }
 
-        // Get hostname for the configuration
-        let hostname = match self.hostname {
-            Some(h) => h,
-            None => crate::util::get_hostname()?,
-        };
+        let hostname = self.hostname.ok_or(()).or_else(|()| get_hostname())?;
 
-        // Start an interactive Nix REPL with the darwin configuration
+        // Open an interactive REPL session for exploring darwin configurations
         platform::run_repl(
-            installable,
+            platform::resolve_env_installable("NH_DARWIN_FLAKE", self.installable),
             "darwinConfigurations",
-            &[], // No extra path needed
+            &[], // REPL doesn't need additional path elements
             Some(hostname),
-            &[], // No extra arguments
+            &[], // No extra REPL args
         )
     }
 }

src/util/platform.rs

@@ -354,6 +354,61 @@ pub fn handle_rebuild_workflow(
     current_profile: &str,
     skip_compare: bool,
 ) -> Result<PathBuf> {
+    // Darwin configurations have a different structure that requires special handling
+    if config_type == "darwinConfigurations" {
+        // First construct the proper attribute path for darwin configs
+        let mut processed_installable = installable;
+        if let Installable::Flake {
+            ref mut attribute, ..
+        } = processed_installable
+        {
+            // Only set the attribute path if user hasn't already specified one
+            if attribute.is_empty() {
+                attribute.push(String::from(config_type));
+                if let Some(name) = config_name {
+                    attribute.push(name);
+                }
+            }
+        }
+
+        // Next, add config.system.build.<attr> to the path to access the derivation
+        let mut toplevel_attr = processed_installable;
+        if let Installable::Flake {
+            ref mut attribute, ..
+        } = toplevel_attr
+        {
+            // All darwin configurations expose their outputs under system.build
+            let toplevel_path = ["config", "system", "build"];
+            attribute.extend(toplevel_path.iter().map(|s| s.to_string()));
+
+            // Add the final component (usually "toplevel")
+            if !extra_path.is_empty() {
+                attribute.push(extra_path[0].to_string());
+            }
+        }
+
+        // Build the configuration
+        build_configuration(
+            toplevel_attr,
+            out_path,
+            extra_args,
+            builder,
+            message,
+            no_nom,
+        )?;
+
+        // Darwin doesn't use the specialisation mechanism like NixOS
+        let target_profile = out_path.get_path().to_owned();
+
+        // Run the diff to show changes
+        if !skip_compare {
+            compare_configurations(current_profile, &target_profile, false, "Comparing changes")?;
+        }
+
+        return Ok(target_profile);
+    }
+
+    // NixOS and Home Manager follow a different pattern
     // Configure the installable with platform-specific attributes
     let configured_installable = extend_installable_for_platform(
         installable,
@@ -378,7 +433,7 @@ pub fn handle_rebuild_workflow(
         no_nom,
     )?;
 
-    // Process any specialisations
+    // Process any specialisations (NixOS/Home-Manager specific feature)
     let target_specialisation =
         process_specialisation(no_specialisation, specialisation, specialisation_path)?;