Merge pull request #1838 from cachix/cli-options

Add --option CLI flag for overriding configuration options

Author: domenkozar

CLAUDE.md

@@ -12,7 +12,7 @@
 ## Code Style Guidelines
 - **Imports**: Group by category (std lib first, then external crates, then internal)
 - **Naming**: Use `snake_case` for functions/variables, `CamelCase` for types/traits
-- **Error Handling**: Use `thiserror` crate with custom error types and `?` operator
+- **Error Handling**: Use `thiserror` crate with custom error types, `bail!` (instead of `panic~`) and `?` operator
 - **Types**: Prefer strong typing with descriptive names and appropriate generics
 - **Formatting**: Follow standard rustfmt rules, use pre-commit hooks
 - **Documentation**: Document public APIs with rustdoc comments

devenv-tasks/src/lib.rs

@@ -1045,7 +1045,10 @@ mod test {
         if let Err(Error::CycleDetected(task)) = result {
             assert_eq!(task, "myapp:task_2".to_string());
         } else {
-            panic!("Expected Error::CycleDetected, got {:?}", result);
+            return Err(Error::TaskNotFound(format!(
+                "Expected Error::CycleDetected, got {:?}",
+                result
+            )));
         }
         Ok(())
     }

devenv/src/cli.rs

@@ -144,6 +144,15 @@ pub struct GlobalOptions {
         help = "Override inputs in devenv.yaml."
     )]
     pub override_input: Vec<String>,
+
+    #[arg(
+        long,
+        global = true,
+        num_args = 2,
+        value_delimiter = ' ',
+        help = "Override configuration options with typed values, e.g. --option languages.rust.version:string beta"
+    )]
+    pub option: Vec<String>,
 }
 
 impl Default for GlobalOptions {
@@ -165,6 +174,7 @@ impl Default for GlobalOptions {
             nix_debugger: false,
             nix_option: vec![],
             override_input: vec![],
+            option: vec![],
         }
     }
 }

devenv/src/cnix.rs

@@ -159,7 +159,7 @@ impl Nix {
         let now_ns = get_now_with_nanoseconds();
         let target = format!("{}-shell", now_ns);
         if let Ok(resolved_gc_root) = fs::canonicalize(gc_root) {
-            symlink_force(&resolved_gc_root, &self.devenv_home_gc.join(target));
+            symlink_force(&resolved_gc_root, &self.devenv_home_gc.join(target))?;
         } else {
             warn!(
                 "Failed to resolve the GC root path to the Nix store: {}. Try running devenv again with --refresh-eval-cache.",
@@ -185,7 +185,7 @@ impl Nix {
         let link_path = self
             .devenv_dot_gc
             .join(format!("{}-{}", name, get_now_with_nanoseconds()));
-        symlink_force(path, &link_path);
+        symlink_force(path, &link_path)?;
         Ok(())
     }
 
@@ -387,8 +387,9 @@ impl Nix {
             cached_cmd.watch_path(self.devenv_root.join("devenv.yaml"));
             cached_cmd.watch_path(self.devenv_root.join("devenv.lock"));
             cached_cmd.watch_path(self.devenv_dotfile.join("flake.json"));
+            cached_cmd.watch_path(self.devenv_dotfile.join("cli-options.nix"));
 
-            // Ignore anything in .devenv.
+            // Ignore anything in .devenv except for the specifically watched files above.
             cached_cmd.unwatch_path(&self.devenv_dotfile);
 
             if self.global_options.refresh_eval_cache || options.refresh_cached_output {
@@ -859,7 +860,7 @@ impl Nix {
     }
 }
 
-fn symlink_force(link_path: &Path, target: &Path) {
+fn symlink_force(link_path: &Path, target: &Path) -> Result<()> {
     let _lock = dotlock::Dotlock::create(target.with_extension("lock")).unwrap();
 
     debug!(
@@ -869,16 +870,20 @@ fn symlink_force(link_path: &Path, target: &Path) {
     );
 
     if target.exists() {
-        fs::remove_file(target).unwrap_or_else(|_| panic!("Failed to remove {}", target.display()));
+        fs::remove_file(target)
+            .map_err(|e| miette::miette!("Failed to remove {}: {}", target.display(), e))?;
     }
 
-    symlink(link_path, target).unwrap_or_else(|_| {
-        panic!(
-            "Failed to create symlink: {} -> {}",
+    symlink(link_path, target).map_err(|e| {
+        miette::miette!(
+            "Failed to create symlink: {} -> {}: {}",
             link_path.display(),
-            target.display()
+            target.display(),
+            e
         )
-    });
+    })?;
+
+    Ok(())
 }
 
 fn get_now_with_nanoseconds() -> String {

devenv/src/devenv.rs

@@ -160,7 +160,7 @@ impl Devenv {
 
             let path = PROJECT_DIR
                 .get_file(filename)
-                .unwrap_or_else(|| panic!("missing {} in the executable", filename));
+                .ok_or_else(|| miette::miette!("missing {} in the executable", filename))?;
 
             // write path.contents to target/filename
             let target_path = target.join(filename);
@@ -862,8 +862,9 @@ impl Devenv {
             "});
         }
 
-        fs::create_dir_all(&self.devenv_dot_gc)
-            .unwrap_or_else(|_| panic!("Failed to create {}", self.devenv_dot_gc.display()));
+        fs::create_dir_all(&self.devenv_dot_gc).map_err(|e| {
+            miette::miette!("Failed to create {}: {}", self.devenv_dot_gc.display(), e)
+        })?;
 
         // Initialise any Nix state
         self.nix.assemble().await?;
@@ -897,8 +898,55 @@ impl Devenv {
         )
         .expect("Failed to write imports.txt");
 
-        fs::create_dir_all(&self.devenv_runtime)
-            .unwrap_or_else(|_| panic!("Failed to create {}", self.devenv_runtime.display()));
+        fs::create_dir_all(&self.devenv_runtime).map_err(|e| {
+            miette::miette!("Failed to create {}: {}", self.devenv_runtime.display(), e)
+        })?;
+
+        // Create cli-options.nix if there are CLI options
+        if !self.global_options.option.is_empty() {
+            let mut cli_options = String::from("{\n");
+
+            const SUPPORTED_TYPES: &[&str] = &["string", "int", "float", "bool", "path"];
+
+            for chunk in self.global_options.option.chunks_exact(2) {
+                // Parse the path and type from the first value
+                let key_parts: Vec<&str> = chunk[0].split(':').collect();
+                if key_parts.len() < 2 {
+                    miette::bail!("Invalid option format: '{}'. Must include type, e.g. 'languages.rust.version:string'. Supported types: {}", 
+                           chunk[0], SUPPORTED_TYPES.join(", "));
+                }
+
+                let path = key_parts[0];
+                let type_name = key_parts[1];
+
+                // Format value based on type
+                let value = match type_name {
+                    "string" => format!("\"{}\"", &chunk[1]),
+                    "int" => chunk[1].clone(),
+                    "float" => chunk[1].clone(),
+                    "bool" => chunk[1].clone(), // true/false will work directly in Nix
+                    "path" => format!("./{}", &chunk[1]), // relative path
+                    _ => miette::bail!(
+                        "Unsupported type: '{}'. Supported types: {}",
+                        type_name,
+                        SUPPORTED_TYPES.join(", ")
+                    ),
+                };
+
+                cli_options.push_str(&format!("  {} = {};\n", path, value));
+            }
+
+            cli_options.push_str("}\n");
+
+            fs::write(self.devenv_dotfile.join("cli-options.nix"), cli_options)
+                .expect("Failed to write cli-options.nix");
+        } else {
+            // Remove the file if it exists but there are no CLI options
+            let cli_options_path = self.devenv_dotfile.join("cli-options.nix");
+            if cli_options_path.exists() {
+                fs::remove_file(&cli_options_path).expect("Failed to remove cli-options.nix");
+            }
+        }
 
         // create flake.devenv.nix
         let vars = indoc::formatdoc!(

devenv/src/flake.tmpl.nix

@@ -91,6 +91,7 @@
               ./devenv.nix
               (devenv.devenv or { })
               (if builtins.pathExists ./devenv.local.nix then ./devenv.local.nix else { })
+              (if builtins.pathExists (devenv_dotfile + "/cli-options.nix") then import (devenv_dotfile + "/cli-options.nix") else { })
             ];
           };
           config = project.config;

docs/basics.md

@@ -36,22 +36,16 @@ jq-1.6
 hello
 ```
 
-
-
-
-See [Nix language tutorial](https://nix.dev/tutorials/first-steps/nix-language) for a 1-2 hour deep dive 
+See [Nix language tutorial](https://nix.dev/tutorials/first-steps/nix-language) for a 1-2 hour deep dive
 that will allow you to read any Nix file.
 
-!!! note
-
-    We're running [a fundraiser to improve the developer experience around error messages](https://opencollective.com/nix-errors-enhancement), with the goal of lowering the barrier to learning Nix.
 
 ## Environment Summary
 
 If you'd like to print the summary of the current environment:
 
 ```shell-session
-$ devenv info 
+$ devenv info
 ...
 
 # env
@@ -68,3 +62,23 @@ $ devenv info
 # processes
 
 ```
+
+## CLI Options Overrides
+
+!!! info "New in 1.6"
+
+You can override configuration options temporarily using the `--option` flag:
+
+```shell-session
+$ devenv shell --option env.GREET:string Hello --option languages.rust.enable:bool true
+```
+
+The option requires you to specify the inferred Nix type:
+
+- `:string` for string values
+- `:int` for integer values
+- `:float` for floating-point values
+- `:bool` for boolean values (true/false)
+- `:path` for file paths (interpreted as relative paths)
+
+This is useful for temporarily changing the configuration without modifying your `devenv.nix` file, such as when testing different configurations or creating option matrices.

tests/cli-options/.test.sh

@@ -0,0 +1,60 @@
+#!/usr/bin/env bash
+set -eu -o pipefail
+
+# Test CLI options feature
+cd "$(dirname "$0")"
+
+# Test basic string and bool types
+OUTPUT=$(devenv --option languages.rust.channel:string beta --option services.redis.enable:bool true info)
+
+# Check for expected RUST_VERSION
+echo "$OUTPUT" | grep -E "RUST_VERSION:.*beta" || {
+  echo "ERROR: Expected CLI option override for RUST_VERSION to be 'beta'"
+  echo $OUTPUT
+  exit 1
+}
+
+# Check for expected REDIS_ENABLED
+echo "$OUTPUT" | grep -E "REDIS_ENABLED:.*1" || {
+  echo "ERROR: Expected CLI option override for REDIS_ENABLED to be '1'"
+  echo $OUTPUT
+  exit 1
+}
+
+# Test int type
+OUTPUT=$(devenv --option env.TEST_INT:int 42 info)
+echo "$OUTPUT" | grep -E "TEST_INT:.*42" || {
+  echo "ERROR: Expected CLI option override for TEST_INT to be '42'"
+  echo $OUTPUT
+  exit 1
+}
+
+# Test float type
+OUTPUT=$(devenv --option env.TEST_FLOAT:float 3.14 info)
+echo "$OUTPUT" | grep -E "TEST_FLOAT:.*3.14" || {
+  echo "ERROR: Expected CLI option override for TEST_FLOAT to be '3.14'"
+  echo $OUTPUT
+  exit 1
+}
+
+# Test path type
+OUTPUT=$(devenv --option env.TEST_PATH:path somepath info)
+echo "$OUTPUT" | grep -E "TEST_PATH:.*/somepath" || {
+  echo "ERROR: Expected CLI option override for TEST_PATH to include 'somepath'"
+  echo $OUTPUT
+  exit 1
+}
+
+# Test invalid type (should fail)
+if devenv --option languages.rust.version:invalid value info &> /dev/null; then
+  echo "ERROR: Expected CLI option with invalid type to fail"
+  echo $OUTPUT
+  exit 1
+fi
+
+# Test missing type (should fail)
+if devenv --option languages.rust.version value info &> /dev/null; then
+  echo "ERROR: Expected CLI option without type specification to fail"
+  echo $OUTPUT
+  exit 1
+fi

tests/cli-options/devenv.nix

@@ -0,0 +1,11 @@
+{ pkgs, lib, config, ... }:
+
+{
+  languages.rust.enable = true;
+  languages.rust.channel = lib.mkDefault "stable";
+
+  env = {
+    RUST_VERSION = config.languages.rust.channel;
+    REDIS_ENABLED = builtins.toString config.services.redis.enable;
+  };
+}

tests/cli-options/devenv.yaml

@@ -0,0 +1,6 @@
+inputs:
+  fenix:
+    url: github:nix-community/fenix
+    inputs:
+      nixpkgs:
+        follows: nixpkgs