wrapped zsh on Darwin not loading zdot files

[karldelandsheere]

Hi! Sorry if this is a noob question but, I'm trying to setup both my NixOS and my macOS laptops with the same zsh wrapper config and while on NixOS, it loads my generated zsh-dot-dir/.zshrc, on macOS it does until I exec zsh -l.

My zsh module:

{ inputs, self, ... }:
{
  flake.wrapperModules.zsh = { config, lib, pkgs, ... }: let
    wrapped = self.packages.${pkgs.stdenv.hostPlatform.system};
  in
  {
    config = {
      # skipGlobalRC = true; # Uncomment if conflicts

      #
      zshAliases = {
        # About these dotfiles
        dots = "cd $DOTFILES";
        todo = "clear && grep -rnw $DOTFILES --exclude-dir=__deprecated -e '@todo' | grep -v 'todo ='";

        # Nix/NixOS/Darwin
        nixos-test = "sudo nixos-rebuild test --flake $DOTFILES";
        nixos-switch = "sudo nixos-rebuild switch --flake $DOTFILES";
        darwin-switch = "sudo darwin-rebuild switch --flake $DOTFILES";

        # Debug keycodes
        keycodes = "xev | grep -A2 --line-buffered '^KeyRelease' | sed -n '/keycode /s/^.*keycode \([0-9]*\).* (.*, \(.*\)).*$/\1 \2/p'";

        # Git shortcuts
        # @todo I'd like to move that to the git wrapper but I'm not sure how
        ga = "git add";
        gaa = "git add --all";
        gaacm = "git add --all && git commit -S -m";
        gb = "git branch";
        gc = "git commit -S";
        gch = "git checkout";
        gchb = "git checkout -b";
        gcl = "git clone";
        gcm = "git commit -S -m";
        gd = "git diff";
        gm = "git merge";
        gpl = "git pull";
        gplo = "git pull origin";
        gps = "git push";
        gpso = "git push origin";
        gs = "git status";

        # Tree doesn't show hidden files by default, bastard
        tree = "tree -a";
      };

      zshrc.content = /*zsh*/''
        # Completion
        autoload -U compinit && compinit
        zstyle ':completion:*' matcher-list 'm:{a-z}={A-Za-z}'
        zstyle ':completion:*' menu no

        # History
        HISTSIZE=10000
        HISTSAVE=10000
        HISTFILE="$HOME/.zsh_history"
        mkdir -p "$(dirname "$HISTFILE")"
        setopt appendhistory
        setopt sharehistory
        setopt hist_ignore_space
        setopt hist_ignore_all_dups
        setopt hist_ignore_dups
        setopt hist_save_no_dups
        setopt histfindnodups

        # Prompt integration
        eval "$(starship init zsh)"
      '';
    };
  };

  perSystem = { lib, pkgs, self', ... }:
  {
    packages.zsh = inputs.wrapper-modules.wrappers.zsh.wrap {
      inherit pkgs;
      imports = [ self.wrapperModules.zsh ];
    };
  };
}

My shell module:

{ inputs, self, ... }:
{
  flake.wrapperModules.shell = { config, lib, pkgs, ... }: let
    wrapped = self.packages.${pkgs.stdenv.hostPlatform.system};
  in
  {
    config = {
      # First things first
      programs.zsh.enable = true;

      #
      environment = {
        # All the little things that make my shell feels like $HOME
        #
        systemPackages = with pkgs; [
          # The star him-shell-f (sorry)
          wrapped.zsh

          # @todo That one is not really an essential, should I move it?
          wrapped.yt-dlp       # ../programs/yt-dlp.nix

          # Utilities
          exiftool             # EXIF metadata
          ffmpeg               # Audio/video
          wrapped.git          # ../programs/git.nix
          wrapped.helix        # ../programs/helix.nix
          jq                   # Like sed but for json (needed for persist.sh)
          scooter              # Fuzzy search & replace
          wrapped.tmux         # ../programs/tmux.nix
          tree                 # Like a recursive ls
          ueberzugpp           # Terminal image viewer
          wrapped.yazi         # ../programs/yazi.nix
          zip  unzip           # Do I really need to explain these two?

          # Remote tools
          sshfs                # Mounts remote filesystems over SSH
          sshm                 # SSH hosts manager

          # Monitoring tools
          wrapped.bottom       # ../programs/bottom.nix
          progress                   # Follow the progression of any command

          # Debugging tools
          lazyjournal          # UI for journalctl, system logs, etc.
          nix-tree             # Nix dependencies browser
          wrapped.tealdeer     # ../programs/tealdeer.nix
          xev                  # Event monitor (mostly for debugging)

          # Random nerd stuff
          cmatrix              # lol, yeah, I know
          wrapped.fastfetch    # ../programs/fastfetch.nix
          wrapped.starship     # ../programs/starship.nix
        ];

        variables = {
          DOTFILES = "${config.filesystem.dotfiles}";
          EDITOR = lib.getExe wrapped.helix;
          VISUAL = lib.getExe wrapped.helix;
        };
      };
    };
  };

  flake.modules.nixos.shell = { lib, config, pkgs, myLib, ... }: let
    wrapped = self.packages.${pkgs.stdenv.hostPlatform.system};
  in
  {
    imports = [ self.wrapperModules.shell ];

    config = {
      # Ensure everything goes smoothly on NixOS
      environment.pathsToLink = [ "/share/zsh" ];
      users.defaultUserShell = wrapped.zsh;

      # Add resources to the persist registry
      #
      features.impermanence.persist.users = myLib.impermanence.persist.users {
        files = [ ".zsh_history" ];
      };
    };
  };

  flake.modules.darwin.shell = { lib, config, pkgs, ... }: let
    wrapped = self.packages.${pkgs.stdenv.hostPlatform.system};
  in
  {
    imports = [ self.wrapperModules.shell ];
  };
}

I know there's something I'm missing but if I knew what I guess I wouldn't be missing it xD.

Thanks for any pointers or help!

[BirdeeHub]

users.defaultUserShell = wrapped.zsh;

The nixos one is setting this but the darwin one isnt

I don't know darwin that well, but I would assume that because it is working when you run it directly but not starting by default that something similar is needed there as well

---

I also can't help but notice that flake.wrapperModules.shell contains a nixos/darwin module and not a wrapper module.

You should avoid that, it is confusing. flake.wrapperModules.shell should be flake.modules.generic.shell

Also, you may benefit from using the flake-parts module for wrapper modules.

It will allow you to provide your wrapper modules to flake.wrappers and use those like submodules. So, instead of flake.wrapperModules.zsh you would have flake.wrappers.zsh

And then it will automatically create flake.wrapperModules containing the importable forms of those wrapper modules.

Meaning you could wlib.evalPackage [ self.wrapperModules.zsh { inherit pkgs; } ] to get the package too, if you want.

This will of course conflict with your flake.wrapperModules.shell which contains a nixos module, which is part of why I am cautioning against that.

The flake-parts module will also automatically create packages.*.zsh with your wrapped zsh, exported from your main flake (although you can tell it not to if you wish)

[karldelandsheere]

Hey! So, I tried the lib.hiPrio but it didn't change anything in my case.

As for the users.users.<name>.shell, I saw that but it only works for users created with nix-darwin.

The doc says:

The user's shell. This defaults to null.

When this is set to null, if the user has not been created yet, they will be created with the shell /usr/bin/false to prevent interactive login. If the user already exists, the value is considered managed by macOS and nix-darwin will not change it.

I tried anyway, because you never know, but as they say, it didn't change it for my existing user.

I'll keep looking :).

And yeah, /run/current-system/sw/bin/zsh links to the latest generation of zsh, and I see the zdot files with the correct data.

/bin/zsh being of course macOS' own zsh.

It comes after in the which -a zsh but doesn't seem to care to leave it to the new one.

Cheers!

[karldelandsheere]

So yeah, users.users.<name>.shell doesn't do anything on existing users. But environment.shells = [ wrapped.zsh ]; seems to do the trick!

(or is it because I did chsh -s /run/current-system/sw/bin/zsh? But then, it's a one time thing)

[BirdeeHub]

I would think that you would need both?

If you do create your user using nix, then users.users.<name>.shell plus environment.shells = [ wrappedzsh ]; should take care of it?

They do it a bit weird where users.users.<name>.shell contributes only passthru.shellPath from that drv, and then it looks in environment.shells for that one...

I have no idea why they do it that way, but if you do users.users.<name>.shell = "${wrappedzsh}${wrappedzsh.shellPath}"; it should use the absolute path directly instead of doing the silly passthru.shellPath thing it does itself.

That is how nixos does those too, not sure why. At least they have the defaultUserShell option which makes it easier in nixos lol

But also I think because nix did not create your user, you need to chsh? Because it is an existing user?

This is a somewhat annoying nix-darwin quirk you are teaching me about but it seems most likely that that would be how it works, i.e. that it can only set it for new users, based on what you have said and what I have read of their docs so far.

[karldelandsheere]

Yeah, that's my bet too! Maybe we can chsh in a postInstall kind of script?

[BirdeeHub]

https://birdeehub.github.io/nix-wrapper-modules/lib/core.html#installmodules

https://birdeehub.github.io/nix-wrapper-modules/md/getting-started.html#nixos-home-manager-and-friends

nix-wrapper-modules/wrapperModules/z/zsh/module.nix

Lines 212 to 229 in b1308b5

	config.install.modules.nixos =
	{ config, lib, ... }:
	let
	cfg = top.config.install.getWrapperConfig config;
	in
	{
	config = lib.mkMerge [
	(top.config.install.mkWrapperExtension "${./module.nix} zsh as defaultUserShell" {
	_file = ./module.nix;
	options.asSystemDefault = lib.mkEnableOption "zsh as defaultUserShell";
	})
	(lib.mkIf cfg.enable {
	environment.pathsToLink = [ "/share/zsh" ];
	users.defaultUserShell = lib.mkIf cfg.asSystemDefault cfg.wrapper;
	programs.zsh.enable = lib.mkIf cfg.asSystemDefault true;
	})
	];
	};

Maybe in something like this, or maybe you can just add it via runShell on mac or something? Unsure.

Regardless, if you configure your terminal via nix, then you can just pass the wrapper to that and then it hardly matters what the default shell is outside of ssh