nix-inspect

The application uses a config.json file to manage bookmarks for different Nix configurations. This file is stored in the local project configuration directory.

Config Structure

The configuration is a JSON object containing a list of bookmarks. Each bookmark includes a display name and a path (represented as a BrowserPath).

{
  "bookmarks": [
    {
      "display": "hostname-config",
      "path": "/etc/nixos/nixos-config.nix"
    }
  ]
}

Automatic Configuration Generation

If no configuration file exists, nix-inspect will automatically generate one based on your system's hostname and current user. It creates bookmarks for:

1. The hostname-based NixOS configuration: .nixosConfigurations.<hostname>
2. The user-specific Home Manager configuration: .nixosConfigurations.<hostname>.config.home-manager.users.<user>

{
  "bookmarks": [
    {
      "display": "my-machine",
      "path": ".nixosConfigurations.my-machine"
    }
  ]
}

The nix-inspect CLI allows you to inspect Nix configurations by providing either a specific Nix expression or a filesystem path. The tool automatically determines whether to treat a path as a Flake or a standard Nix configuration.

CLI Arguments

Resolution Logic

1. If --expr is provided: The tool uses the provided string directly as the Nix expression.
2. If --path is provided:
   • If the path is a file ending in flake.nix (or contains a flake.nix), it is treated as a Flake using builtins.getFlake "<path>".
   • Otherwise, it is treated as a standard Nix configuration using an import statement.
3. If no arguments are provided:
   • It first checks /etc/nixos/flake.nix.
   • If not found, it searches for the nixos-config entry in your NIX_PATH environment variable.
   • It falls back to treating the directory found in NIX_PATH (or the current directory) as a standard Nix configuration.

# Inspect a specific path
nix-inspect --path /path/to/my/config

# Inspect a specific flake
nix-inspect --path /path/to/flake-dir

# Inspect a raw Nix expression
nix-inspect --expr "{ options = {}; config = {}; }"

The WorkerHost struct manages the lifecycle of a Nix worker process. It uses a background thread to communicate with a worker binary via stdin and stdout.

To use it, call WorkerHost::new(expr) with a Nix expression. This returns a host containing two channels:

1. tx: A kanal::Sender<BrowserPath> used to send new paths (expressions) to the worker for inspection.
2. rx: A kanal::Receiver<(BrowserPath, PathData)> used to receive the results of those inspections.

When a path is sent via tx, the receiver will first emit a PathData::Loading state for that path, followed by either the parsed NixValue or a PathData::Error if the inspection fails.

// Example conceptual usage
let host = WorkerHost::new("builtins.attrset".to_string());

// Send a path to inspect
host.tx.send(some_browser_path).unwrap();

// Receive the result
if let Ok((path, data)) = host.rx.recv() {
    match data {
        PathData::Loading => println!("Loading..."),
        PathData::Error(e) => eprintln!("Error: {}", e),
        _ => println!("Received data for {:?}", path),
    }
}

The NixValue enum represents the serialized data types returned by the Nix worker. When consuming the worker's output, values are tagged with a type field and the actual data is contained within a data field. The following mapping is used for serialization:

{
  "type": "4",
  "data": "example string"
}