nixos-config/flake.nix

{
  description = "System config";

  inputs = {
    nixpkgs.url = "github:nixos/nixpkgs/nixos-unstable";

    home-manager = {
      url = "github:nix-community/home-manager";
      inputs.nixpkgs.follows = "nixpkgs";
    };

    flake-utils.url = "github:numtide/flake-utils";

    flake-parts.url = "github:hercules-ci/flake-parts";

    nixos-hardware.url = "github:NixOS/nixos-hardware";

    pre-commit-hooks = {
      url = "github:cachix/git-hooks.nix";
      inputs = {
        nixpkgs.follows = "nixpkgs";
      };
    };

    treefmt-nix = {
      url = "github:numtide/treefmt-nix";
      inputs.nixpkgs.follows = "nixpkgs";
    };

    naersk = {
      url = "github:nix-community/naersk";
      inputs.nixpkgs.follows = "nixpkgs";
    };

    rust-overlay = {
      url = "github:oxalica/rust-overlay";
      inputs = {
        nixpkgs.follows = "nixpkgs";
      };
    };

    microvm = {
      url = "github:astro/microvm.nix";
      inputs = {
        nixpkgs.follows = "nixpkgs";
        flake-utils.follows = "flake-utils";
      };
    };

    sops = {
      url = "github:Mic92/sops-nix";
      inputs.nixpkgs.follows = "nixpkgs";
    };

    emacs-overlay = {
      url = "github:nix-community/emacs-overlay/ed670c7246dd4bfd24e50939eb5d9bcaa95e638b";
      inputs = {
        nixpkgs.follows = "nixpkgs";
      };
    };

    nil = {
      url = "github:oxalica/nil";
      inputs = {
        nixpkgs.follows = "nixpkgs";
        flake-utils.follows = "flake-utils";
        rust-overlay.follows = "rust-overlay";
      };
    };

    disko = {
      url = "github:nix-community/disko";
      inputs.nixpkgs.follows = "nixpkgs";
    };

    eww = {
      url = "github:elkowar/eww";
      inputs = {
        nixpkgs.follows = "nixpkgs";
        rust-overlay.follows = "rust-overlay";
      };
    };

    anyrun = {
      url = "github:anyrun-org/anyrun";
      inputs.nixpkgs.follows = "nixpkgs";
    };

    colmena = {
      url = "github:zhaofengli/colmena";
      inputs.nixpkgs.follows = "nixpkgs";
    };

    nixos-facter-modules.url = "github:numtide/nixos-facter-modules";

    comin = {
      url = "github:nlewo/comin";
      inputs.nixpkgs.follows = "nixpkgs";
    };

    caddy-nix = {
      url = "github:vincentbernat/caddy-nix";
    };

    ghostty = {
      url = "git+https://git.datarift.nl/erwin/ghostty.git?ref=main";
    };

    caddy-with-plugins = {
      url = "github:eboskma/caddy-with-plugins";
      inputs = {
        nixpkgs.follows = "nixpkgs";
        flake-parts.follows = "flake-parts";
        treefmt-nix.follows = "treefmt-nix";
      };
    };

    ha-now-playing = {
      url = "git+https://git.datarift.nl/erwin/ha-now-playing.git?ref=main";
      inputs = {
        nixpkgs.follows = "nixpkgs";
        flake-utils.follows = "flake-utils";
        rust-overlay.follows = "rust-overlay";
        pre-commit-hooks.follows = "pre-commit-hooks";
        treefmt-nix.follows = "treefmt-nix";
      };
    };

    pamedia = {
      url = "git+https://git.datarift.nl/erwin/pamedia-rs.git?ref=main";
      inputs = {
        nixpkgs.follows = "nixpkgs";
        flake-parts.follows = "flake-parts";
        rust-overlay.follows = "rust-overlay";
      };
    };
  };

  outputs =
    {
      self,
      sops,
      flake-parts,
      ...
    }@inputs:
    with inputs;
    let
      machines = import ./machines inputs;
    in
    flake-parts.lib.mkFlake { inherit inputs; } {

      systems = [
        "x86_64-linux"
        "aarch64-linux"
      ];

      imports = [
        inputs.pre-commit-hooks.flakeModule
        inputs.treefmt-nix.flakeModule
      ];

      flake = {
        lib = import ./lib inputs;

        overlays.default = import ./overlays;

        nixosModules = builtins.listToAttrs (
          map (x: {
            name = x;
            value = import (./modules + "/${x}");
          }) (builtins.attrNames (builtins.readDir ./modules))
        );

        nixosConfigurations = builtins.listToAttrs (
          map (machine: {
            name = machine;
            value = self.lib.defSystem (machines.${machine}.system or "x86_64-linux") {
              imports = [ machines.${machine}.config ];
            } (machines.${machine}.deploy or null);
          }) (builtins.attrNames machines)
        );

        colmenaHive = inputs.colmena.lib.makeHive self.outputs.colmena;

        colmena =
          {
            meta = {
              nixpkgs = import nixpkgs { system = "x86_64-linux"; };

              specialArgs = {
                inherit nixpkgs;
              };
            };
          }
          // builtins.listToAttrs (
            map (machine: {
              name = machine;
              value = {
                deployment = {
                  targetHost = machines.${machine}.deploy.host;
                  targetUser = "root"; # machines.${machine}.deploy.sshUser;
                  # targetUser = machines.${machine}.deploy.sshUser;
                  tags = machines.${machine}.deploy.tags or [ ];
                };
                imports = self.lib.systemModules (machines.${machine}.system or "x86_64-linux"
                ) machines.${machine}.config;
              };
            }) (builtins.filter (machine: machines.${machine} ? deploy) (builtins.attrNames machines))
          );
      };

      perSystem =
        {
          inputs',
          pkgs,
          config,
          system,
          ...
        }:
        {

          _module.args.pkgs = import inputs.nixpkgs {
            inherit system;
            overlays = [ self.overlays.default ];
          };

          pre-commit = {
            settings = {
              hooks = {
                nixfmt-rfc-style.enable = true;
                deadnix.enable = true;
                black.enable = true;
                shellcheck = {
                  enable = true;
                  types_or = [ "executable" ];
                };
                shfmt.enable = true;
              };
            };
          };

          treefmt = {
            projectRootFile = "flake.lock";

            programs = {
              black.enable = true;
              deadnix.enable = true;
              nixfmt = {
                enable = true;
                package = pkgs.nixfmt-rfc-style;
              };
              shellcheck.enable = true;
              shfmt = {
                enable = true;
                indent_size = 0;
              };
            };
          };

          packages = {
            dnspyre = pkgs.callPackage ./pkgs/dnspyre { };
            git-repo-go = pkgs.git-repo-go;
            hassbridge = pkgs.callPackage ./pkgs/hassbridge { };
            mapshot = pkgs.mapshot;
            pds = pkgs.pds;
            pdsadmin = pkgs.pdsadmin;
            peakperf = pkgs.callPackage ./pkgs/peakperf { };
            tinyows = pkgs.callPackage ./pkgs/tinyows { };
            tsui = pkgs.callPackage ./pkgs/tsui { };
          };

          devShells.default =
            with pkgs;
            mkShell {
              name = "dotfiles";
              packages = [
                age
                config.packages.git-repo-go
                fontpreview
                inputs'.colmena.packages.colmena
                just
                libxkbcommon
                lswt
                multimarkdown
                nix-diff
                nix-init
                nix-output-monitor
                nix-prefetch
                nix-prefetch-docker
                nix-prefetch-github
                nix-prefetch-scripts
                nix-tree
                nix-update
                nixfmt-rfc-style
                nodejs
                nodePackages.typescript-language-server
                nodePackages.yaml-language-server
                nodePackages.prettier
                openssl
                pciutils
                pkgs.sops
                python3Packages.websocket-client
                ssh-to-age
                taplo
                # vscode-langservers-extracted
                yj

                inputs'.disko.packages.disko
              ];

              shellHook = ''
                ${config.pre-commit.installationScript}
              '';
            };

          devShells.install =
            with pkgs;
            mkShell {
              name = "install";
              packages = [ inputs'.disko.packages.disko ];
            };
        };
    };
}