sha256 update

flake.lock

@@ -18,11 +18,11 @@
     },
     "flake-file": {
       "locked": {
-        "lastModified": 1774666175,
-        "narHash": "sha256-WaZxvtOvVNikiNTen2Emhds2RvzFCWIb7KU9C0eWrNA=",
+        "lastModified": 1776202746,
+        "narHash": "sha256-RZVtJefKKy3Z2UvKWSbtRF3cUxt/2fHga2adN6MZQ1U=",
         "owner": "vic",
         "repo": "flake-file",
-        "rev": "953d01f3ae5ba50869c5e1248062198f73e971bf",
+        "rev": "7d16dfaeb912d5efdff0d0eda2aabc0c934168dd",
         "type": "github"
       },
       "original": {
@@ -38,11 +38,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1772408722,
-        "narHash": "sha256-rHuJtdcOjK7rAHpHphUb1iCvgkU3GpfvicLMwwnfMT0=",
+        "lastModified": 1775087534,
+        "narHash": "sha256-91qqW8lhL7TLwgQWijoGBbiD4t7/q75KTi8NxjVmSmA=",
         "owner": "hercules-ci",
         "repo": "flake-parts",
-        "rev": "f20dc5d9b8027381c474144ecabc9034d6a839a3",
+        "rev": "3107b77cd68437b9a76194f0f7f9c55f2329ca5b",
         "type": "github"
       },
       "original": {
@@ -95,11 +95,11 @@
         "nixpkgs": "nixpkgs"
       },
       "locked": {
-        "lastModified": 1774738535,
-        "narHash": "sha256-2jfBEZUC67IlnxO5KItFCAd7Oc+1TvyV/jQlR+2ykGQ=",
+        "lastModified": 1776562531,
+        "narHash": "sha256-Lh5Ns9DI67E+lSMOCGK0S+mFPy0mz0yOGiJTUXiR9JI=",
         "owner": "nix-community",
         "repo": "home-manager",
-        "rev": "769e07ef8f4cf7b1ec3b96ef015abec9bc6b1e2a",
+        "rev": "5b56ad02dc643808b8af6d5f3ff179e2ce9593f4",
         "type": "github"
       },
       "original": {
@@ -184,11 +184,11 @@
     "nixos-hardware": {
       "flake": false,
       "locked": {
-        "lastModified": 1774777275,
-        "narHash": "sha256-qogBiYFq8hZusDPeeKRqzelBAhZvREc7Cl+qlewGUCg=",
+        "lastModified": 1775490113,
+        "narHash": "sha256-2ZBhDNZZwYkRmefK5XLOusCJHnoeKkoN95hoSGgMxWM=",
         "owner": "NixOS",
         "repo": "nixos-hardware",
-        "rev": "b8f81636927f1af0cca812d22c876bad0a883ccd",
+        "rev": "c775c2772ba56e906cbeb4e0b2db19079ef11ff7",
         "type": "github"
       },
       "original": {
@@ -199,11 +199,11 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1774106199,
-        "narHash": "sha256-US5Tda2sKmjrg2lNHQL3jRQ6p96cgfWh3J1QBliQ8Ws=",
+        "lastModified": 1775423009,
+        "narHash": "sha256-vPKLpjhIVWdDrfiUM8atW6YkIggCEKdSAlJPzzhkQlw=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "6c9a78c09ff4d6c21d0319114873508a6ec01655",
+        "rev": "68d8aa3d661f0e6bd5862291b5bb263b2a6595c9",
         "type": "github"
       },
       "original": {
@@ -215,33 +215,17 @@
     },
     "nixpkgs_2": {
       "locked": {
-        "lastModified": 1774701658,
-        "narHash": "sha256-5QVei2IIfVO3GqMkiiXlrZtaniOkXyMWnqbTVkItrco=",
-        "rev": "b63fe7f000adcfa269967eeff72c64cafecbbebe",
+        "lastModified": 1776329215,
+        "narHash": "sha256-mBqzkn7oJti2hqeO8iTbDxKw+1ifxpP53feQ0CEXies=",
+        "rev": "b86751bc4085f48661017fa226dee99fab6c651b",
         "type": "tarball",
-        "url": "https://releases.nixos.org/nixpkgs/nixpkgs-26.05pre971056.b63fe7f000ad/nixexprs.tar.xz"
+        "url": "https://releases.nixos.org/nixpkgs/nixpkgs-26.05pre981196.b86751bc4085/nixexprs.tar.xz"
       },
       "original": {
         "type": "tarball",
         "url": "https://channels.nixos.org/nixpkgs-unstable/nixexprs.tar.xz"
       }
     },
-    "nixpkgs_3": {
-      "locked": {
-        "lastModified": 1774610258,
-        "narHash": "sha256-HaThtroVD9wRdx7KQk0B75JmFcXlMUoEdDFNOMOlsOs=",
-        "owner": "NixOS",
-        "repo": "nixpkgs",
-        "rev": "832efc09b4caf6b4569fbf9dc01bec3082a00611",
-        "type": "github"
-      },
-      "original": {
-        "owner": "NixOS",
-        "ref": "nixpkgs-unstable",
-        "repo": "nixpkgs",
-        "type": "github"
-      }
-    },
     "nvf": {
       "inputs": {
         "flake-compat": "flake-compat",
@@ -254,11 +238,11 @@
         "systems": "systems_2"
       },
       "locked": {
-        "lastModified": 1774736237,
-        "narHash": "sha256-uQ+Was7QP9Bupr0XZyZXOAD32Ox8z2mJnevT2FmDwS8=",
+        "lastModified": 1776608870,
+        "narHash": "sha256-lBKrueFu15TdmtMF6GsiSVCifwdrUBYFoa3+zZjYTFM=",
         "owner": "notashelf",
         "repo": "nvf",
-        "rev": "a0636d5c977743851c91d3c2e74bfac90be48835",
+        "rev": "d9ba7f0a9ed6c016dc9e526cc606d1a2f7898cd4",
         "type": "github"
       },
       "original": {
@@ -281,7 +265,8 @@
         ],
         "nvf": "nvf",
         "sops-nix": "sops-nix",
-        "wrapper-modules": "wrapper-modules"
+        "wrapper-modules": "wrapper-modules",
+        "wrappers": "wrappers"
       }
     },
     "sops-nix": {
@@ -291,11 +276,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1774760784,
-        "narHash": "sha256-D+tgywBHldTc0klWCIC49+6Zlp57Y4GGwxP1CqfxZrY=",
+        "lastModified": 1776119890,
+        "narHash": "sha256-Zm6bxLNnEOYuS/SzrAGsYuXSwk3cbkRQZY0fJnk8a5M=",
         "owner": "Mic92",
         "repo": "sops-nix",
-        "rev": "8adb84861fe70e131d44e1e33c426a51e2e0bfa5",
+        "rev": "d4971dd58c6627bfee52a1ad4237637c0a2fb0cd",
         "type": "github"
       },
       "original": {
@@ -336,14 +321,16 @@
     },
     "wrapper-modules": {
       "inputs": {
-        "nixpkgs": "nixpkgs_3"
+        "nixpkgs": [
+          "nixpkgs"
+        ]
       },
       "locked": {
-        "lastModified": 1774767209,
-        "narHash": "sha256-bJxBN+ebX3yZj+KT/c+LeA4xIpoNghG233szgRFAWOc=",
+        "lastModified": 1776464146,
+        "narHash": "sha256-XwLFfJDz71vIF7BAhnbLhrzQjmDC2uXdo7N0oHUrYzA=",
         "owner": "BirdeeHub",
         "repo": "nix-wrapper-modules",
-        "rev": "70795f6eb74a69d736e41ee837cd7e1a6d46c0aa",
+        "rev": "75febede14a0845f4ef429da692a0698bf433600",
         "type": "github"
       },
       "original": {
@@ -351,6 +338,26 @@
         "repo": "nix-wrapper-modules",
         "type": "github"
       }
+    },
+    "wrappers": {
+      "inputs": {
+        "nixpkgs": [
+          "nixpkgs"
+        ]
+      },
+      "locked": {
+        "lastModified": 1776505856,
+        "narHash": "sha256-VbnOijrn4EdYYJwiNQFxQNXECKBa60U66UPxUQAGkBE=",
+        "owner": "lassulus",
+        "repo": "wrappers",
+        "rev": "738d4bf81cbf306f6917c540a5b798110e3cf1e8",
+        "type": "github"
+      },
+      "original": {
+        "owner": "lassulus",
+        "repo": "wrappers",
+        "type": "github"
+      }
     }
   },
   "root": "root",

flake.nix

@@ -29,6 +29,13 @@
       url = "github:Mic92/sops-nix";
       inputs.nixpkgs.follows = "nixpkgs";
     };
-    wrapper-modules.url = "github:BirdeeHub/nix-wrapper-modules";
+    wrapper-modules = {
+      url = "github:BirdeeHub/nix-wrapper-modules";
+      inputs.nixpkgs.follows = "nixpkgs";
+    };
+    wrappers = {
+      url = "github:lassulus/wrappers";
+      inputs.nixpkgs.follows = "nixpkgs";
+    };
   };
 }

modules/features/desktop.nix

@@ -10,7 +10,6 @@
     home.packages = with pkgs; [
       mangohud
       sublime4
-      proton-vpn
     ];
   };
 }

modules/features/forgejo.nix

@@ -0,0 +1,147 @@
+{ self, inputs, ... }: {
+  flake.modules.nixos.forgejo = {config, pkgs, lib, ... }:
+    let
+      cfg = config.forgejo;
+      needsPrivilegedPort = cfg.port < 1024;
+    in
+    {
+      options.forgejo = {
+        enable = lib.mkEnableOption "Enable Forgejo backed with PostgreSQL";
+        root_url = lib.mkOption {
+          type = lib.types.str;
+        };
+
+        port = lib.mkOption {
+          type = lib.types.port;
+          default = 3000;
+          description = "TCP port for the Forgejo web interface.";
+        };
+
+        openFirewall = lib.mkOption {
+          type = lib.types.bool;
+          default = true;
+          description = "Open the Forgejo web interface port in the firewall.";
+        };
+
+        https = lib.mkEnableOption "Open the Forgejo web interface port in the firewall.";
+      };
+
+      config = lib.mkIf cfg.enable {
+        networking.firewall.allowedTCPPorts = lib.optionals cfg.openFirewall [ cfg.port ];
+
+        systemd.services.forgejo.serviceConfig = lib.mkIf needsPrivilegedPort {
+          AmbientCapabilities = [ "CAP_NET_BIND_SERVICE" ];
+          CapabilityBoundingSet = [ "CAP_NET_BIND_SERVICE" ];
+          PrivateUsers = lib.mkForce false;
+        };
+
+        sops.secrets = {
+          "forgejo/secret_key".owner = config.services.forgejo.user;
+          "forgejo/internal_token".owner = config.services.forgejo.user;
+          "forgejo/jwt_secret".owner = config.services.forgejo.user;
+          "forgejo/lfs_jwt_secret".owner = config.services.forgejo.user;
+        };
+
+        services = {
+          forgejo = {
+            enable = true;
+            lfs.enable = true;
+            database.type = "postgres";
+            settings = {
+              DEFAULT = {
+                RUN_MODE = "dev";
+              };
+              server = lib.mkMerge [
+                {
+                  HTTP_PORT = cfg.port;
+                  DISABLE_SSH = true;
+                  ROOT_URL = cfg.root_url;
+                }
+                (lib.mkIf cfg.https {
+                  PROTOCOL = "https";
+                  COOKIE_SECURE = true;
+                  KEY_FILE = config.mtls.keyFile;
+                  CERT_FILE = config.mtls.certFile;
+                })
+              ];
+              oauth2_client = {
+                ENABLE_AUTO_REGISTRATION = true;
+                USERNAME = "nickname";
+                UPDATE_AVATAR = true;
+                ACCOUNT_LINKING = "login";
+                REGISTER_EMAIL_CONFIRM = false;
+              };
+              repository = {
+                ENABLE_PUSH_CREATE_USER = true;
+              };
+              ui.SHOW_USER_EMAIL = false;
+              markup = {
+                ENABLED = true;
+              };
+            };
+
+            secrets = {
+              security = {
+                SECRET_KEY = lib.mkForce config.sops.secrets."forgejo/secret_key".path;
+                INTERNAL_TOKEN = lib.mkForce config.sops.secrets."forgejo/internal_token".path;
+              };
+              oauth2.JWT_SECRET = lib.mkForce config.sops.secrets."forgejo/jwt_secret".path;
+              server.LFS_JWT_SECRET = lib.mkForce config.sops.secrets."forgejo/lfs_jwt_secret".path;
+            };
+            dump = {
+              enable = true;
+              type = "tar";
+              interval = "*-*-* 00/12:00:00";
+            };
+          };
+
+          postgresql = {
+            enable = true;
+            enableTCPIP = false;
+          };
+        };
+
+        # https://forgejo.org/docs/latest/admin/command-line/#dump
+        systemd.services.forgejo-dump.serviceConfig.ExecStart = lib.mkForce ''
+          ${lib.getExe config.services.forgejo.package} dump --verbose \
+          --type ${config.services.forgejo.dump.type} \
+          --database postgres \
+          --work-path ${config.services.forgejo.dump.backupDir}
+        '';
+
+        environment.systemPackages =
+          let
+            systemctl = lib.getExe' pkgs.systemd "systemctl";
+            clean-forgejo = (pkgs.writeShellScriptBin "clean-forgejo" ''
+              set -euo pipefail
+              sudo ${systemctl} stop forgejo.service
+              ${lib.getExe' pkgs.coreutils "echo"} "Stopped Forgejo"
+              sudo ${lib.getExe' pkgs.coreutils "rm"} -rf ${config.services.forgejo.stateDir}
+              ${lib.getExe' pkgs.coreutils "echo"} "Removed ${config.services.forgejo.stateDir}"
+            '');
+            clean-postgres = (pkgs.writeShellScriptBin "clean-postgres" ''
+              set -euo pipefail
+              sudo ${systemctl} stop postgresql.service
+              ${lib.getExe' pkgs.coreutils "echo"} "Stopped PostgreSQL"
+              sudo ${lib.getExe' pkgs.coreutils "rm"} -rf ${config.services.postgresql.dataDir}
+              ${lib.getExe' pkgs.coreutils "echo"} "Removed ${config.services.postgresql.dataDir}"
+            '');
+          in [
+            clean-forgejo
+            clean-postgres
+            (pkgs.writeShellScriptBin "clean-all" ''
+              set -euo pipefail
+              GREEN_CHECK="\e[32m✔\e[0m"
+              YELLOW_BANG="\e[33m!\e[0m"
+              ${lib.getExe' pkgs.coreutils "echo"} -n -e "$YELLOW_BANG Remove everything related to Forgejo and the PostgreSQL database behind it?"
+              read -p " (y/n) " -n 1 -r
+              if [[ $REPLY =~ ^[Yy]$ ]]; then
+                ${lib.getExe clean-forgejo}
+                ${lib.getExe clean-postgres}
+                ${lib.getExe' pkgs.coreutils "echo"} -e "$GREEN_CHECK Removed everything related to forgejo"
+              fi
+            '')
+          ];
+      };
+    };
+}

modules/features/greetd.nix

@@ -1,6 +1,6 @@
 # https://github.com/glabrie/dotfiles/blob/main/modules/system/settings/greetd.nix
 { inputs, ... }: {
-  flake.module.nixos.greetd = { pkgs, lib, ... }: {
+  flake.modules.nixos.greetd = { pkgs, lib, ... }: {
     services.greetd = {
       enable = true;
       settings = {

modules/features/mtls.nix

@@ -1,7 +1,7 @@
 { self, inputs, lib, ... }:
 let
-  # Options that will be in common between
-  opts = {
+  # Options that will be in common between the nixos module and the home-manager module.
+  mkOpts = config: let cfg = config.mtls; in {
     enable = lib.mkEnableOption "Enable mTLS";
     subject = lib.mkOption {
       description = "The Common Name, DNS Name, or IP address that will be set as the Subject Common Name for the certificate. If no Subject Alternative Names (SANs) are configured (via the --san flag) then the subject will be set as the only SAN.";
@@ -11,20 +11,25 @@ let
       description = "String path to the directory where the certs will be stored";
       type = lib.types.str;
     };
-    keyFilename = lib.mkOption {
-      description = "String filename for the private key";
+    caFile = lib.mkOption {
+      description = "String path for the root CA file";
       type = lib.types.str;
-      default = "key.pem";
+      default = "${cfg.certDir}/root_ca.crt";
     };
-    certFilename = lib.mkOption {
-      description = "String filename for the public certificate";
+    keyFile = lib.mkOption {
+      description = "String path for the private key";
       type = lib.types.str;
-      default = "cert.pem";
+      default = "${cfg.certDir}/key.pem";
     };
-    bundleFilename = lib.mkOption {
-      description = "String filename for the mTLS key bundle";
+    certFile = lib.mkOption {
+      description = "String path for the public cert";
       type = lib.types.str;
-      default = "mtls.pem";
+      default = "${cfg.certDir}/cert.pem";
+    };
+    bundleFile = lib.mkOption {
+      description = "String path for the mTLS key bundle";
+      type = lib.types.str;
+      default = "${cfg.certDir}/mtls.pem";
     };
     san = lib.mkOption {
       description = "List of SAN to give the mTLS cert";
@@ -37,13 +42,13 @@ let
     };
     lifetime = lib.mkOption {
       type = lib.types.str;
-      default = "6h";
+      default = "24h";
     };
     renew = {
       enable = lib.mkOption {
         description = "Enable automatic mTLS certificate renewal using a systemd timer.";
         type = lib.types.bool;
-        default = true;
+        default = cfg.enable;
       };
       onCalendar = lib.mkOption {
         description = "systemd OnCalendar schedule for mTLS certificate renewal checks.";
@@ -61,9 +66,9 @@ let
         default = "root";
       };
       group = lib.mkOption {
-        description = "Group to run the mTLS renewal service as. Defaults to the configured renewal user when null.";
+        description = "Group to run the mTLS renewal service as. Defaults to the configured renewal user.";
         type = lib.types.nullOr lib.types.str;
-        default = null;
+        default = "mtls";
       };
       reloadUnits = lib.mkOption {
         description = "systemd units to try-reload-or-restart after a successful certificate renewal.";
@@ -83,165 +88,31 @@ let
     subject,
     provisioner,
     san,
-    tlsCert,
-    tlsKey,
-    mtlsBundle,
+    certFile,
+    keyFile,
+    bundleFile,
     lifetime,
+    user,
+    group,
   }:
   let
-    stepCmd = lib.getExe pkgs.step-cli;
     sanArgs = lib.concatMapStringsSep " " (s: "--san \"${s}\"") san;
   in
-    pkgs.writeShellScriptBin "mtls-generate" ''
+    pkgs.writeShellApplication {
+      name = "mtls-generate";
+      runtimeInputs = with pkgs; [ coreutils step-cli ];
+      text = ''
         set -euo pipefail
-      ${stepCmd} ca certificate \
-        ${subject} ${tlsCert} ${tlsKey} \
-        --not-before=-5m --not-after=${lifetime} \
+        step ca certificate ${subject} ${certFile} ${keyFile} \
           --provisioner ${provisioner} \
+          --not-before=-5m --not-after=${lifetime} \
           ${sanArgs} \
           "$@"
-      cat ${tlsCert} ${tlsKey} > ${mtlsBundle}
+        (umask 077; cat ${certFile} ${keyFile} > ${bundleFile})
+        chown ${user}:${group} ${certFile} ${keyFile} ${bundleFile}
+        chmod 640 ${certFile} ${keyFile} ${bundleFile}
+        printf '\033[32m✔\033[0m \033[1mmTLS Bundle:\033[0m %s\n' ${lib.escapeShellArg bundleFile}
       '';
-  
-  mkMtlsCheckScript = { pkgs, mtlsBundle }: pkgs.writeShellScriptBin "mtls-check" ''
-    ${lib.getExe pkgs.openssl} x509 \
-    -noout -subject -issuer \
-    -ext subjectAltName,extendedKeyUsage \
-    -enddate -in ${mtlsBundle}
-  '';
-
-  mkMtlsRenewScript = {
-    pkgs,
-    tlsCert,
-    tlsKey,
-    mtlsBundle,
-    reloadUnits ? [ ],
-    postCommands ? [ ],
-    systemctlArgs ? [ ],
-  }:
-  let
-    echoCmd = lib.getExe' pkgs.coreutils "echo";
-    systemctl = lib.getExe' pkgs.systemd "systemctl";
-    escapedArgs = lib.escapeShellArgs systemctlArgs;
-    systemctlCommand = "${systemctl} ${escapedArgs}";
-    renewReloadScript = lib.concatMapStringsSep "\n" (unit: ''
-      if ${systemctlCommand} --quiet is-active "${unit}"; then
-        ${systemctlCommand} try-reload-or-restart "${unit}"
-      fi
-    '') reloadUnits;
-    renewPostCommands = lib.concatStringsSep "\n" postCommands;
-  in
-    pkgs.writeShellScriptBin "mtls-renew" ''
-      set -euo pipefail
-
-      if ${lib.getExe pkgs.step-cli} certificate needs-renewal "${tlsCert}"; then
-        ${echoCmd} "Renewing mTLS certificate"
-      else
-        ${echoCmd} "Skipping renew"
-        exit "$?"
-      fi
-
-      ${lib.getExe pkgs.step-cli} ca renew --force "${tlsCert}" "${tlsKey}"
-
-      umask 077
-      ${lib.getExe' pkgs.coreutils "cat"} "${tlsCert}" "${tlsKey}" > "${mtlsBundle}"
-
-      ${echoCmd} "Reloading units:"
-      ${renewReloadScript}
-
-      ${echoCmd} "Post commands:"
-      ${renewPostCommands}
-    '';
-
-  mkNixosMtlsRenewService = {
-    pkgs,
-    tlsCert,
-    tlsKey,
-    mtlsBundle,
-    reloadUnits ? [ ],
-    postCommands ? [ ],
-    user ? "root",
-    group ? null,
-  }:
-  let
-    serviceGroup = if group == null then user else group;
-    renewScript = mkMtlsRenewScript {
-      inherit pkgs tlsCert tlsKey mtlsBundle reloadUnits postCommands;
-    };
-  in
-  {
-    description = "Renew the mTLS certificate when Smallstep marks it ready";
-    wantedBy = [ ];
-    after = [ "network-online.target" ];
-    wants = [ "network-online.target" ];
-    serviceConfig = {
-      Type = "oneshot";
-      User = user;
-      Group = serviceGroup;
-      ExecStart = lib.getExe renewScript;
-    };
-  };
-
-  mkNixosMtlsRenewTimer = {
-    onCalendar,
-    randomizedDelaySec,
-    unit ? "mtls-renew.service",
-  }: {
-    description = "Periodic Smallstep renewal for the mTLS certificate";
-    wantedBy = [ "timers.target" ];
-    timerConfig = {
-      Persistent = true;
-      OnCalendar = onCalendar;
-      AccuracySec = "1us";
-      RandomizedDelaySec = randomizedDelaySec;
-      Unit = unit;
-    };
-  };
-
-  mkHomeManagerMtlsRenewService = {
-    pkgs,
-    tlsCert,
-    tlsKey,
-    mtlsBundle,
-    reloadUnits ? [ ],
-    postCommands ? [ ],
-  }:
-  let
-    renewScript = mkMtlsRenewScript {
-      inherit pkgs tlsCert tlsKey mtlsBundle reloadUnits postCommands;
-      systemctlArgs = [ "--user" ];
-    };
-  in
-  {
-    Unit = {
-      Description = "Renew the mTLS certificate when Smallstep marks it ready";
-      After = [ "network-online.target" ];
-      Wants = [ "network-online.target" ];
-    };
-    Service = {
-      Type = "oneshot";
-      ExecStart = lib.getExe renewScript;
-    };
-  };
-
-  mkHomeManagerMtlsRenewTimer = {
-    onCalendar,
-    randomizedDelaySec,
-    unit ? "mtls-renew.service",
-  }: {
-    Unit = {
-      Description = "Periodic Smallstep renewal for the mTLS certificate";
-    };
-    Timer = {
-      Persistent = true;
-      OnCalendar = onCalendar;
-      AccuracySec = "1us";
-      RandomizedDelaySec = randomizedDelaySec;
-      Unit = unit;
-    };
-    Install = {
-      WantedBy = [ "timers.target" ];
-    };
     };
 
 in
@@ -249,56 +120,92 @@ in
   flake.modules.nixos.mtls = { config, lib, pkgs, ... }:
     let
       cfg = config.mtls;
-      tlsKey = "${cfg.certDir}/${cfg.keyFilename}";
-      tlsCert = "${cfg.certDir}/${cfg.certFilename}";
-      mtlsBundle = "${cfg.certDir}/${cfg.bundleFilename}";
-      sanArgs = lib.concatMapStringsSep " " (san: "--san \"${san}\"") cfg.san;
+      mtlsRenewWrapper = inputs.self.wrappers.mtlsRenew.apply {
+        inherit pkgs;
+        inherit (cfg) certDir keyFile certFile bundleFile;
+        inherit (cfg.renew) user group reloadUnits postCommands;
+        systemd = {
+          description = "Renew the mTLS certificate when Smallstep marks it ready";
+          after = [ "network-online.target" ];
+          wants = [ "network-online.target" ];
+          serviceConfig = {
+            Type = "oneshot";
+            User = cfg.renew.user;
+            Group = cfg.renew.group;
+          };
+        } // lib.optionalAttrs cfg.renew.enable {
+          startAt = cfg.renew.onCalendar;
+        };
+      };
     in
     {
-      options.mtls = opts // {
+      options.mtls = (mkOpts config) // {
         certDir = lib.mkOption {
           description = "String path to where the mtls certs will be stored.";
           type = lib.types.str;
-          default = "/etc/step/certs";
+          default = "/etc/step-ca/certs";
+        };
+        certReaders = lib.mkOption {
+          description = "";
+          type = lib.types.listOf lib.types.str;
+          default = [ ];
         };
       };
 
       config = lib.mkIf cfg.enable {
+        users.groups.certReaders = {
+          name = cfg.renew.group;
+          members = cfg.certReaders;
+        };
+
         environment.systemPackages = with pkgs; lib.optionals cfg.enable [
-          step-cli
+          # step-cli
           (mkMtlsGenerateScript {
-            inherit (cfg) subject provisioner san lifetime;
-            inherit pkgs tlsCert tlsKey mtlsBundle;
+            inherit pkgs;
+            inherit (cfg) subject provisioner san certFile keyFile bundleFile lifetime;
+            inherit (cfg.renew) user group;
           })
-          (mkMtlsCheckScript { inherit pkgs mtlsBundle; })
-          (mkMtlsRenewScript { inherit pkgs tlsCert tlsKey mtlsBundle; })
+          (inputs.self.wrappers.mtlsCheck.apply {
+            inherit pkgs;
+            inherit (cfg) bundleFile;
+          }).wrapper
+          mtlsRenewWrapper.wrapper
         ];
 
         systemd.tmpfiles.rules = [
-          "d ${cfg.certDir} 0750 ${cfg.renew.user} ${if cfg.renew.group == null then cfg.renew.user else cfg.renew.group} -"
+          "d ${cfg.certDir} 0750 ${cfg.renew.user} ${cfg.renew.group} -"
         ];
 
-        systemd.services.mtls-renew = lib.mkIf cfg.renew.enable (mkNixosMtlsRenewService {
-          inherit pkgs tlsCert tlsKey mtlsBundle;
-          inherit (cfg.renew) reloadUnits postCommands user group;
-        });
+        systemd.packages = lib.mkIf cfg.renew.enable [
+          mtlsRenewWrapper.outputs.systemd-system
+        ];
 
-        systemd.timers.mtls-renew = lib.mkIf cfg.renew.enable (mkNixosMtlsRenewTimer {
-          inherit (cfg.renew) onCalendar randomizedDelaySec;
-        });
+        systemd.timers.mtls-renew = lib.mkIf cfg.renew.enable {
+          wantedBy = [ "timers.target" ];
+          timerConfig = {
+            Persistent = true;
+            AccuracySec = "1us";
+            RandomizedDelaySec = cfg.renew.randomizedDelaySec;
+          };
+        };
       };
     };
 
   flake.modules.homeManager.mtls = { config, lib, pkgs, ... }:
     let
       cfg = config.mtls;
-      tlsKey = "${cfg.certDir}/${cfg.keyFilename}";
-      tlsCert = "${cfg.certDir}/${cfg.certFilename}";
-      mtlsBundle = "${cfg.certDir}/${cfg.bundleFilename}";
-      sanArgs = lib.concatMapStringsSep " " (san: "--san \"${san}\"") cfg.san;
+      mtlsRenewWrapper = inputs.self.wrappers.mtlsRenew.apply {
+        inherit pkgs;
+        inherit (cfg) certDir keyFile certFile bundleFile;
+        inherit (cfg.renew) reloadUnits postCommands;
+        systemctlArgs = [ "--user" ];
+        systemd = lib.optionalAttrs cfg.renew.enable {
+          startAt = cfg.renew.onCalendar;
+        };
+      };
     in
     {
-      options.mtls = opts // {
+      options.mtls = (mkOpts config) // {
         certDir = lib.mkOption {
           description = "String path to where the mtls certs will be stored.";
           type = lib.types.str;
@@ -308,27 +215,228 @@ in
 
       config = {
         home.packages = with pkgs; lib.optionals cfg.enable [
-          step-cli
+          # step-cli
           (mkMtlsGenerateScript {
+            inherit pkgs;
+            inherit (cfg) keyFile certFile bundleFile;
             inherit (cfg) subject provisioner san lifetime;
-            inherit pkgs tlsCert tlsKey mtlsBundle;
+            inherit (cfg.renew) user group;
           })
-          (mkMtlsCheckScript { inherit pkgs mtlsBundle; })
-          (mkMtlsRenewScript { inherit pkgs tlsCert tlsKey mtlsBundle; })
+          (inputs.self.wrappers.mtlsCheck.apply {
+            inherit pkgs;
+            inherit (cfg) bundleFile;
+          }).wrapper
         ];
 
         systemd.user.tmpfiles.rules = lib.mkIf cfg.enable [
-          "d ${cfg.certDir} 0700 - - -"
+          "d ${cfg.certDir} 0700 - - -" # Ensure the cert directory exists and is writable by the user
         ];
 
-        systemd.user.services.mtls-renew = lib.mkIf cfg.renew.enable (mkHomeManagerMtlsRenewService {
-          inherit pkgs tlsCert tlsKey mtlsBundle;
-          inherit (cfg.renew) reloadUnits postCommands;
+        # Create the systemd service files for the user.
+        xdg.dataFile = lib.mkIf cfg.renew.enable {
+          "systemd/user/mtls-renew.service".source =
+            "${mtlsRenewWrapper.outputs.systemd-user}/systemd/user/mtls-renew.service";
+          "systemd/user/mtls-renew.timer".source =
+            "${mtlsRenewWrapper.outputs.systemd-user}/systemd/user/mtls-renew.timer";
+          "systemd/user/mtls-renew.timer.d/override.conf".text = ''
+            [Timer]
+            Persistent=true
+            AccuracySec=1us
+            RandomizedDelaySec=${cfg.renew.randomizedDelaySec}
+          '';
+        };
+
+        # Ensure the timer gets started
+        home.activation.mtlsRenewTimer = lib.hm.dag.entryAfter [ "writeBoundary" ] ''
+          if [ -n "$XDG_RUNTIME_DIR" ] && [ -S "$XDG_RUNTIME_DIR/systemd/private" ]; then
+            if [ "${lib.boolToString (cfg.enable && cfg.renew.enable)}" = "true" ]; then
+              run ${pkgs.systemd}/bin/systemctl --user daemon-reload
+              run ${pkgs.systemd}/bin/systemctl --user enable --now mtls-renew.timer
+            else
+              run ${pkgs.systemd}/bin/systemctl --user disable --now mtls-renew.timer || true
+              run ${pkgs.systemd}/bin/systemctl --user daemon-reload || true
+            fi
+          fi
+        '';
+      };
+    };
+
+  flake.wrappers = {
+    mtlsCheck = inputs.wrappers.lib.wrapModule ({ config, lib, wlib, ... }: {
+      options = {
+        bundleFile = lib.mkOption {
+          description = "String path for the mTLS key bundle";
+          type = lib.types.str;
+        };
+      };
+
+      config = {
+        binName = "mtls-check";
+        # This pattern is necessary to wrap packages like openssl that provide more than one binary
+        package = config.pkgs.symlinkJoin {
+          name = "openssl";
+          paths = [ config.pkgs.openssl.bin config.pkgs.openssl.man ];
+          meta.mainProgram = "openssl";
+        };
+        args = [
+          "x509"
+          "-noout"
+          "-in" config.bundleFile
+          "-subject"
+          "-issuer"
+          "-ext" "subjectAltName,extendedKeyUsage"
+          "-enddate"
+        ];
+      };
     });
 
-        systemd.user.timers.mtls-renew = lib.mkIf cfg.renew.enable (mkHomeManagerMtlsRenewTimer {
-          inherit (cfg.renew) onCalendar randomizedDelaySec;
+    mtlsNeedsRenewal = inputs.wrappers.lib.wrapModule ({ config, lib, wlib, ... }: {
+      options = {
+        certFile = lib.mkOption {
+          description = "String path for the public cert";
+          type = lib.types.str;
+        };
+      };
+
+      config = {
+        binName = "mtls-needs-renewal";
+        package = config.pkgs.step-cli;
+        preHook = ''
+          echo "Checking renewal status..."
+        '';
+        args = [ "certificate" "needs-renewal" "${config.certFile}" ];
+      };
+    });
+
+    mtlsRenew = inputs.wrappers.lib.wrapModule ({ config, lib, wlib, ... }: {
+      imports = [ wlib.modules.systemd ];
+
+      options = {
+        certDir = lib.mkOption {
+          description = "String path to the directory where the certs will be stored";
+          type = lib.types.str;
+        };
+        keyFile = lib.mkOption {
+          description = "String path for the private key";
+          type = lib.types.str;
+          default = "${config.certDir}/key.pem";
+        };
+        certFile = lib.mkOption {
+          description = "String path for the public cert";
+          type = lib.types.str;
+          default = "${config.certDir}/cert.pem";
+        };
+        bundleFile = lib.mkOption {
+          description = "String path for the mTLS key bundle";
+          type = lib.types.str;
+          default = "${config.certDir}/mtls.pem";
+        };
+        user = lib.mkOption {
+          description = "User that should own the renewed certificate files.";
+          type = lib.types.nullOr lib.types.str;
+          default = null;
+        };
+        group = lib.mkOption {
+          description = "Group that should own the renewed certificate files.";
+          type = lib.types.nullOr lib.types.str;
+          default = null;
+        };
+        reloadUnits = lib.mkOption {
+          description = "systemd units to try-reload-or-restart after a successful renewal.";
+          type = lib.types.listOf lib.types.str;
+          default = [ ];
+        };
+        postCommands = lib.mkOption {
+          description = "Shell commands to run after a successful renewal.";
+          type = lib.types.listOf lib.types.lines;
+          default = [ ];
+        };
+        systemctlArgs = lib.mkOption {
+          description = "Additional arguments to pass to systemctl when reloading units.";
+          type = lib.types.listOf lib.types.str;
+          default = [ ];
+        };
+      };
+
+      config = {
+        binName = "mtls-renew";
+        package = let
+          systemctlCmd = "systemctl ${lib.escapeShellArgs config.systemctlArgs}";
+
+          hasReloadUnits = config.reloadUnits != [ ];
+          renewReloadScript = lib.concatMapStringsSep "\n" (unit: ''
+            if ${systemctlCmd} --quiet is-active "${unit}"; then
+              ${systemctlCmd} try-reload-or-restart "${unit}"
+            fi
+          '') config.reloadUnits;
+
+          hasPostCommands = config.postCommands != [ ];
+          renewPostCommands = lib.concatStringsSep "\n" config.postCommands;
+
+          hasOwnership = config.user != null && config.group != null;
+        in
+          config.pkgs.writeShellApplication {
+            name = "mtls-renew";
+            runtimeInputs = with config.pkgs; [ coreutils step-cli systemd ];
+            text = ''
+            set -euo pipefail
+
+            YELLOW_BANG="\e[33m!\e[0m"
+
+            force=0
+            while [[ $# -gt 0 ]]; do
+            case $1 in
+              --force)
+              force=1
+              shift
+              ;;
+              *)
+              echo -e "$YELLOW_BANG Warning: ignoring unrecognized argument '$1'"
+              exit 1
+              ;;
+            esac
+            done
+
+            if [[ $force -eq 0 ]] && ! step certificate needs-renewal "${config.certFile}"; then
+              echo "Skipping renew"
+              exit 0
+            fi
+
+            echo "Renewing mTLS certificate"
+            step ca renew --force "${config.certFile}" "${config.keyFile}"
+            (umask 077; cat "${config.certFile}" "${config.keyFile}" > "${config.bundleFile}")
+
+            ${lib.optionalString hasOwnership ''
+              chown ${config.user}:${config.group} ${config.certFile} ${config.keyFile} ${config.bundleFile}
+              chmod 640 ${config.certFile} ${config.keyFile} ${config.bundleFile}
+            ''}
+
+            ${lib.optionalString hasReloadUnits ''
+              echo "Reloading units: ${lib.concatStringsSep ", " config.reloadUnits}"
+              ${renewReloadScript}
+            ''}
+
+            ${lib.optionalString hasPostCommands ''
+              echo "Running post commands"
+              ${renewPostCommands}
+            ''}
+            '';
+          };
+        extraPackages = [
+          config.pkgs.step-cli
+        ];
+        systemd = {
+          description = "Automatic mTLS renewal service";
+          documentation = [
+            "https://smallstep.com/docs/step-ca/certificate-authority-server-production"
+          ];
+          startLimitIntervalSec = 0;
+          after = [ "network-online.target" ];
+          wants = [ "network-online.target" ];
+          serviceConfig.Type = lib.mkDefault "oneshot";
+          # serviceConfig.ExecCondition = "";
+        };
+      };
     });
   };
-    };
 }

modules/features/restic.nix

@@ -19,6 +19,11 @@
           type = lib.types.str;
           default = "john-ubuntu";
         };
+        repoUrl = lib.mkOption {
+          description = "URL to the REST endpoint";
+          type = lib.types.str;
+          default = "rest:https://soteria.john-stream.com/${cfg.repoName}";
+        };
         passwordFile = lib.mkOption {
           description = "String path to the restic password file";
           type = lib.types.str;
@@ -44,29 +49,24 @@
         };
       };
 
-      config = let
-        resticRepository = "rest:https://soteria.john-stream.com/${cfg.repoName}";
-        caCert = "${config.mtls.certDir}/root_ca.crt";
-        mtlsBundle = "${config.mtls.certDir}/${config.mtls.bundleFilename}";
-      in
-      {
+      config = {
         home.sessionVariables = {
-          RESTIC_REPOSITORY = resticRepository;
+          RESTIC_REPOSITORY = cfg.repoUrl;
           RESTIC_PASSWORD_FILE = cfg.passwordFile;
-          RESTIC_CACERT = caCert;
-          RESTIC_TLS_CLIENT_CERT = mtlsBundle;
+          RESTIC_CACERT = config.mtls.caFile;
+          RESTIC_TLS_CLIENT_CERT = config.mtls.bundleFile;
         };
         
         # This is necessary because the restic service in home manager doesn't otherwise expose these options.
         systemd.user.services."restic-backups-${cfg.repoName}".Service.Environment = [
-          "RESTIC_CACERT=${caCert}"
-          "RESTIC_TLS_CLIENT_CERT=${mtlsBundle}"
+          "RESTIC_CACERT=${config.mtls.caFile}"
+          "RESTIC_TLS_CLIENT_CERT=${config.mtls.bundleFile}"
         ];
 
         services.restic = {
           enable = true;
           backups.${cfg.repoName} = {
-            repository = resticRepository;
+            repository = cfg.repoUrl;
             passwordFile = cfg.passwordFile;
             paths = cfg.paths;
             timerConfig = {

modules/features/shell-tools.nix

@@ -1,40 +1,63 @@
 # This module provides all the shell options
-{ inputs, lib, ... }:
-{
+{ self, inputs, ... }: {
   flake.modules.homeManager.shell-tools = { config, pkgs, ... }: {
-    options.shell.program = lib.mkOption {
-      type = lib.types.enum [ "bash" "zsh" ];
-      default = "zsh";
-      description = "Which interactive shell configuration to enable.";
-    };
-
     imports = with inputs.self.modules.homeManager; [
-      bash
+      # bash
       zsh
-
-      # Tools
-      eza
       files
     ];
 
-    config = {
-      home.shell.enableShellIntegration = true;
-      programs.zsh.enable  = lib.mkForce (config.shell.program == "zsh");
     home.packages = with pkgs; [
-        wget
-        curl
-        busybox
-        gnugrep
-        dig
       btop
       uv
       xclip
-        jq
-        ripgrep
-        (writeShellScriptBin "ds" ''
-          ${lib.getExe pkgs.gdu} -x -I /snap /
-        '')
+      inputs.self.packages.${pkgs.stdenv.hostPlatform.system}.shell-tools
     ];
+
+    home.shell.enableShellIntegration = true;
+  };
+
+  perSystem = { system, pkgs, self', ... }: {
+    packages.shell-tools = inputs.wrappers.lib.wrapPackage { 
+      inherit pkgs;
+      # binName = "show-tools";
+      package = (pkgs.symlinkJoin {
+        name = "show-tools";
+        meta.mainProgram = "show-tools";
+        paths = with pkgs; [
+          nh
+          ripgrep
+          fd
+          jq
+          wget
+          curl
+          dig
+          self'.packages.gdu
+          self'.packages.my-eza
+          hostname
+          iproute2
+          direnv
+          (writeShellApplication {
+            name = "show-tools";
+            text = ''
+              IFS=':' read -r -a path_dirs <<< "''${PATH:-}"
+
+              for dir in "''${path_dirs[@]}"; do
+                [[ "$dir" == */bin ]] || continue
+                [[ -d "$dir" ]] || continue
+
+                printf '%s\n' "$dir"/*
+              done
+            '';
+          })
+        ];
+      });
+    };
+
+    packages.gdu = inputs.wrappers.lib.wrapPackage {
+      inherit pkgs;
+      package = pkgs.gdu;
+      args = [ "-x" "--si" "--collapse-path" "--mouse" "$@" ];
     };
   };
 }

modules/features/ssh-certs.nix

@@ -0,0 +1,100 @@
+{ self, inputs, ... }:
+let
+  mkPrincipalArgs = principals:
+    builtins.concatLists (map (principal: [ "--principal" principal ]) principals);
+in
+{
+  perSystem = { system, self', pkgs, lib, ... }: {
+    packages.ssh-certs = inputs.wrappers.lib.wrapPackage {
+      inherit pkgs;
+      package = (pkgs.symlinkJoin {
+        name = "ssh-certs";
+        meta.mainProgram = "sign-ssh-user-cert";
+        paths = [
+          (inputs.self.wrappers.signUserWrapper.apply {
+            inherit pkgs;
+            provisioner = "admin";
+            overwrite = true;
+            validUsers = [ "john" "root" "appdaemon" ];
+          }).wrapper
+
+          (inputs.self.wrappers.signHostWrapper.apply {
+            inherit pkgs;
+            provisioner = "admin";
+            overwrite = true;
+            # extraPrincipals = [ "home-pc" ];
+          }).wrapper
+        ];
+      });
+    };
+  };
+
+  flake.wrappers.signHostWrapper = inputs.wrappers.lib.wrapModule ({config, lib, wlib, ... }: {
+    options = {
+      provisioner = lib.mkOption {
+        type = lib.types.nullOr lib.types.str;
+        default = "admin";
+      };
+      extraPrincipals = lib.mkOption {
+        type = lib.types.listOf lib.types.str;
+        default = [ ];
+      };
+      overwrite = lib.mkEnableOption "Overwrite existing cert file?";
+    };
+
+    config = {
+      binName = "sign-ssh-host-cert";
+      package = config.pkgs.step-cli;
+      extraPackages = with config.pkgs; [ hostname iproute2 systemd ];
+      preHook = ''
+        HOSTNAME=$(hostname -s)
+        IP_ADDRESS=$(ip -4 -o addr show scope global | while read -r _ _ _ addr _; do
+          case "$addr" in
+            192.168.1.*/*)
+              printf '%s\n' "''${addr%%/*}"
+              break
+              ;;
+          esac
+        done)
+        echo "Signing SSH host cert for $HOSTNAME at $IP_ADDRESS"
+      '';
+      args =
+        [
+          "ssh" "certificate"
+          "--host" "--sign"
+          "--principal" "$HOSTNAME"
+          "--principal" "$IP_ADDRESS"
+        ]
+        ++ lib.optionals (config.provisioner != null) [ "--provisioner" "${config.provisioner}" ]
+        ++ lib.optionals config.overwrite [ "-f" ]
+        ++ mkPrincipalArgs config.extraPrincipals;
+      postHook = ''
+        systemctl reload-or-restart sshd
+      '';
+    };
+  });
+
+  flake.wrappers.signUserWrapper = inputs.wrappers.lib.wrapModule ({config, lib, wlib, ... }: {
+    options = {
+      provisioner = lib.mkOption {
+        type = lib.types.nullOr lib.types.str;
+        default = "admin";
+      };
+      validUsers = lib.mkOption {
+        description = "A list of the user names that this cert will be valid for";
+        type = lib.types.listOf lib.types.str;
+        default = [ ];
+      };
+      overwrite = lib.mkEnableOption "Overwrite existing cert file?";
+    };
+
+    config = {
+      binName = "sign-ssh-user-cert";
+      package = config.pkgs.step-cli;
+      args = [ "ssh" "certificate" "--sign" ]
+        ++ lib.optionals (config.provisioner != null) [ "--provisioner" "${config.provisioner}" ]
+        ++ lib.optionals config.overwrite [ "-f" ]
+        ++ mkPrincipalArgs config.validUsers;
+    };
+  });
+}

modules/features/step-client.nix

@@ -0,0 +1,51 @@
+{ self, inputs, ... }: {
+  flake.modules.homeManager.step-client = { config, pkgs, lib, ... }: {
+    home.file.".step/config/defaults.json".text = builtins.toJSON {
+      ca-url = "https://janus.john-stream.com/";
+      fingerprint = "2036c44f7b5901566ff7611ea6c927291ecc6d2dd00779c0eead70ec77fa10d6";
+      root = ../hosts/janus/root_ca.crt;
+    };
+    home.packages = [
+      inputs.self.packages.${pkgs.stdenv.hostPlatform.system}.step-bootstrap
+    ];
+    # sops.secrets."step-ca-defaults" = {
+    #   sopsFile = ../hosts/janus/defaults.json;
+    #   format = "json";
+    #   key = ""; # This causes it to decode the whole file
+    #   path = "${config.home.homeDirectory}/defaults.json";
+    #   mode = "0400";
+    # };
+  };
+
+  perSystem = { system, pkgs, lib, ... }: {
+    packages.step-bootstrap = (inputs.self.wrappers.stepBootstrap.apply {
+      inherit pkgs;
+      ca-url = "https://janus.john-stream.com";
+      fingerprint = "2036c44f7b5901566ff7611ea6c927291ecc6d2dd00779c0eead70ec77fa10d6";
+      install = true;
+    }).wrapper;
+  };
+
+  flake.wrappers.stepBootstrap = inputs.wrappers.lib.wrapModule ({config, lib, wlib, ... }: {
+    options = {
+      ca-url = lib.mkOption {
+        type = lib.types.str;
+      };
+      fingerprint = lib.mkOption {
+        type = lib.types.str;
+      };
+      install = lib.mkEnableOption "Install the cert to the system trust store";
+    };
+
+    config = {
+      binName = "step-bootstrap";
+      package = config.pkgs.step-cli;
+      args = [
+        "ca" "bootstrap"
+        "--ca-url" config.ca-url
+        "--fingerprint" config.fingerprint
+      ]
+      ++ lib.optional config.install "--install";
+    };
+  });
+}

modules/hosts/janus/default.nix

@@ -4,13 +4,57 @@ let
   hostname = "janus";
 in
 {
+  flake.modules.nixos.janus-ca =
+    { config, lib, ... }:
+    let
+      cfg = config.janus-ca;
+      johnHome = lib.attrByPath [ "users" "users" username "home" ] "/home/${username}" config;
+      johnGroup = lib.attrByPath [ "users" "users" username "group" ] username config;
+      cfgInEtc = lib.hasPrefix "/etc/" cfg.certDir;
+      certDirEtcPath =
+        if cfgInEtc then
+          lib.removePrefix "/etc/" cfg.certDir
+        else
+          cfg.certDir;
+      certRootEtcPath = "${certDirEtcPath}/root_ca.crt";
+      mkStepRules = home: user: group: [
+        "d ${home}/.step 0700 ${user} ${group} -"
+        "d ${home}/.step/config 0700 ${user} ${group} -"
+        "d ${home}/.step/certs 0700 ${user} ${group} -"
+        "L+ ${home}/.step/config/defaults.json - - - - /etc/step-ca/defaults.json"
+        "L+ ${home}/.step/certs/root_ca.crt - - - - ${cfg.certDir}/root_ca.crt"
+      ];
+    in
+    {
+      options.janus-ca = {
+        certDir = lib.mkOption {
+          description = "String path to where the mtls certs will be stored.";
+          type = lib.types.str;
+          default = "/etc/step-ca/certs";
+        };
+      };
+
+      config = {
+        environment.etc = lib.mkIf cfgInEtc {
+          "step-ca/defaults.json".text = builtins.toJSON {
+            ca-url = "https://janus.john-stream.com/";
+            fingerprint = builtins.readFile ./fingerprint;
+            root = "/etc/${certRootEtcPath}";
+          };
+          "${certRootEtcPath}".source = ./root_ca.crt;
+        };
+        systemd.tmpfiles.rules =
+          mkStepRules johnHome username johnGroup
+          ++ mkStepRules "/root" "root" "root";
+      };
+    };
+
   flake.modules.homeManager.janus-ca = { config, ... }: {
     home.file.".step/config/defaults.json".text = builtins.toJSON {
-      "ca-url" = "https://janus.john-stream.com/";
-      fingerprint = "2036c44f7b5901566ff7611ea6c927291ecc6d2dd00779c0eead70ec77fa10d6";
-      root = "${config.home.homeDirectory}/.step/certs/root_ca.crt";
+      ca-url = "https://janus.john-stream.com/";
+      fingerprint = builtins.readFile ./fingerprint;
+      root = ./root_ca.crt;
     };
-    home.file.".step/certs/root_ca.crt".source = ./root_ca.crt;
   };
 
   flake.nixosConfigurations."${hostname}" = inputs.nixpkgs.lib.nixosSystem {
@@ -18,6 +62,7 @@ in
       nixos.lxc
       nixos.mysops
       nixos.step-ssh-host
+      nixos.janus-ca
       inputs.home-manager.nixosModules.home-manager
       nixos."${username}"
       nixos.docker
@@ -40,8 +85,6 @@ in
         home-manager.users."${username}" = {
           imports = with inputs.self.modules.homeManager; [
             mysops
-            step-ssh-user
-            janus-ca
           ];
           shell.program = "zsh";
           docker.enable = true;

modules/hosts/janus/fingerprint

@@ -0,0 +1 @@
+2036c44f7b5901566ff7611ea6c927291ecc6d2dd00779c0eead70ec77fa10d6

modules/hosts/john-p14s/configuration.nix

@@ -5,6 +5,7 @@
       hostname = "john-p14s";
       homeDirectory = config.home-manager.users.john.home.homeDirectory;
       flakeDir = "${homeDirectory}/Documents/dendritic";
+      selfPkgs = inputs.self.packages.${pkgs.stdenv.hostPlatform.system};
     in
     {
       imports = [
@@ -35,11 +36,10 @@
       # List packages installed in system profile. To search, run:
       # $ nix search wget
       environment.systemPackages = with pkgs; [
-        wget
-        cacert
-        busybox
-        dig
         samba
+        selfPkgs.my-neovim
+        selfPkgs.wg-platform
+        selfPkgs.jsl-zsh
       ];
 
       security.pam.services.swaylock = {};
@@ -84,6 +84,11 @@
         };
       };
 
+      fonts.packages = with pkgs; [
+        nerd-fonts.hack
+        nerd-fonts.sauce-code-pro
+      ];
+
       services.libinput.enable = true; # Enable touchpad support (enabled default in most desktopManager).
       services.fprintd.enable = true; # Enables fingerprint sensor
 
@@ -106,7 +111,6 @@
       home-manager.users.root = {
         imports = with inputs.self.modules.homeManager; [
           rebuild
-          janus-ca
         ];
         home.stateVersion = "25.11";
       };
@@ -115,7 +119,6 @@
         desktop
         mysops
         rebuild
-        janus-ca
         {
           my-vscode.enable = true;
           mysops.hostSecretFile = "${flakeDir}/modules/hosts/john-p14s/secrets.yaml";
@@ -124,7 +127,16 @@
           home.packages = with pkgs; [
             bash
             discord
+            proton-vpn
+            joplin-desktop
           ];
+          ssh.certificates.enable = true;
+          ssh.matchSets = {
+            appdaemon = true;
+            homelab = true;
+            dev = true;
+            certs = true;
+          };
         }
       ];
       sops.defaultSopsFile = ./secrets.yaml;

modules/hosts/john-p14s/default.nix

@@ -12,6 +12,7 @@
       "${inputs.nixos-hardware}/lenovo/thinkpad/p14s/amd/gen4"
     ] ++ (with self.modules.nixos; [
       p14sConfiguration
+      janus-ca
       rebuild
       sudo
       john

modules/hosts/john-pc/default.nix

@@ -1,41 +1,33 @@
-{ self, inputs, ... }:
+{ withSystem, self, inputs, ... }:
 let
   username = "john";
   hostname = "john-pc-ubuntu";
 
-  testHost = "soteria";
-  testTarget = "fded:fb16:653e:25da:be24:11ff:fea0:753f"; # test-nix
   # testTarget = "fded:fb16:653e:25da:be24:11ff:fe89:1cc3"; # soteria
+  # testTarget = "fded:fb16:653e:25da:be24:11ff:fea0:753f"; # test-nix
+  testHost = "soteria"; # which host to test build
+  testTarget = "test-nix";
 
 in
 {
   flake.modules.homeManager."${hostname}" = { config, pkgs, lib, ... }:
   let
-    flakeDir = "${config.xdg.configHome}/home-manager/jsl-dendritic";
-    certDir = "${config.mtls.certDir}";
-    mtlsBundle = "${certDir}/${config.mtls.bundleFilename}";
+    selfPkgs = inputs.self.packages.${pkgs.stdenv.hostPlatform.system};
     resticPasswordFile = "${config.xdg.configHome}/restic/password.txt";
-
-    testPushCmd = (pkgs.writeShellScriptBin "test-push" ''
-      ${lib.getExe' pkgs.coreutils "mkdir"} -p /var/tmp/nix-build
-      ${lib.getExe' pkgs.coreutils "chmod"} 1777 /var/tmp/nix-build
-      ${lib.getExe pkgs.nixos-rebuild} switch \
-        --flake ${flakeDir}#${testHost} \
-        --target-host root@${testTarget}
-    '');
+    flakeDir = "${config.xdg.configHome}/home-manager/jsl-dendritic";
   in
   {
     imports = with inputs.self.modules.homeManager; [
       rebuild
       john
-      mysops
-      janus-ca
-      step-ssh-user
       mtls
       restic
       docker
       desktop
-      # neovim
+      step-client
+      mysops
+      # myPackage
+      # myStepClient
     ];
     # TODO: make this more restrictive, rather than allowing all unfree packages
     nixpkgs.config.allowUnfree = true;
@@ -46,21 +38,22 @@ in
     home.username = "${username}";
     home.homeDirectory = "/home/${username}";
     home.packages = with pkgs; [
-      nixos-rebuild
-      testPushCmd
-      inputs.self.packages.${pkgs.stdenv.hostPlatform.system}.my-neovim
+      selfPkgs.jsl-zsh
+      selfPkgs.my-neovim
+      selfPkgs.ssh-certs
+      # selfPkgs.step-bootstrap
+      # selfPkgs.wg-platform
+      # self'.packages.myWrappedPackage
+      (inputs.self.wrappers.test-push.apply {
+        inherit pkgs flakeDir;
+        host = testHost;
+        target = testTarget;
+      }).wrapper
     ];
 
-    shell.program = "zsh";
-  
     homeManagerFlakeDir = flakeDir;
     docker.enable = true;
 
-    step-ssh-user = {
-      enable = true;
-      principals = ["root" "${username}" "appdaemon"];
-      provisioner = "admin";
-    };
     ssh = {
       certificates.enable = true;
       knownHosts = [
@@ -71,6 +64,7 @@ in
         appdaemon = true;
         homelab = true;
         dev = true;
+        tailscale = true;
       };
     };
 
@@ -110,10 +104,13 @@ in
     };
   };
 
-  flake.homeConfigurations."${hostname}" = inputs.home-manager.lib.homeManagerConfiguration {
-    pkgs = import inputs.nixpkgs { system = "x86_64-linux"; };
-    modules = with inputs.self.modules; [
-      homeManager."${hostname}"
-    ];
-  };
+  flake.homeConfigurations."john@john-pc-ubuntu" = withSystem "x86_64-linux" (ctx@{ system, inputs', ... }:
+    inputs.home-manager.lib.homeManagerConfiguration {
+      # pkgs = import inputs.nixpkgs {
+      #   inherit system;
+      #   overlays = [ inputs.self.overlays.default ];
+      # };
+      pkgs = inputs'.nixpkgs.legacyPackages;
+      modules = [ inputs.self.modules.homeManager."${hostname}" ];
+  });
 }

modules/hosts/john-pc/dev.nix

@@ -0,0 +1,33 @@
+{ self, inputs, ... }: {
+  flake.wrappers.test-push = inputs.wrappers.lib.wrapModule ({config, lib, wlib, ... }: {
+    options = {
+      flakeDir = lib.mkOption {
+        type = lib.types.str;
+      };
+      host = lib.mkOption {
+        type = lib.types.str;
+      };
+      target = lib.mkOption {
+        type = lib.types.str;
+      };
+      sshUser = lib.mkOption {
+        type = lib.types.str;
+        default = "root";
+      };
+      elevationStrategy = lib.mkOption {
+        type = lib.types.str;
+        default = "none";
+      };
+    };
+
+    config = {
+      binName = "test-push";
+      package = config.pkgs.nh;
+      args = [
+        "os" "switch" "${config.flakeDir}#${config.host}"
+        "--target-host" "${config.sshUser}@${config.target}"
+        "--elevation-strategy" "${config.elevationStrategy}"
+      ]; 
+    };
+  });
+}

modules/hosts/soteria/secrets.yaml

@@ -1,5 +1,14 @@
 janus:
     admin_jwk: ENC[AES256_GCM,data:2XcN5X77wTQ+OUXa4C9xAErGvrwJKseHjCcgoj6jt+c=,iv:9x+M1wM0dYND1JYkJjM4N8pSOok2OF+P9vmm9NCumTI=,tag:dTCfh+KB1iRJBVoNsGqvuw==,type:str]
+forgejo:
+    #ENC[AES256_GCM,data:/wtm0uXbiWFoGNWtlTzVuNxBR7CPm2FMB98t3AxSj5V5rltLvzF9BjgWoJCiX3ltzmU=,iv:xaZXbUIGJHxPrLRQzEQI7hgRgc0y061jIhoE3zlcMaA=,tag:fQGheCIdBKm6wE+vtj7g6A==,type:comment]
+    secret_key: ENC[AES256_GCM,data:/jcyeDcsryLqu9Q3VnNaENb71/Tl5JUr0zDzxt8L5UCtnJ/YHA6MKItrQ9ZHFv1XROtnSfZl9D5kKomeM8EVqA==,iv:HxMKAMVQ08gkq6SWENj0/d8i9PhcgPCp5eqbztj9bSg=,tag:nO2dFWT/vfgGc/9JIDZrGw==,type:str]
+    #ENC[AES256_GCM,data:TADqVsZwXpH/zfrXNclavH8Sv++jX081UjK/Mkys5x52gU5fU0ikk478EmwzeergsHpmxxon,iv:v9HsIsud+eiko7F0u622MBrTVDsIxlpqru0Viifvqow=,tag:FLgNTW0EcGhHT6iI9I6Bsg==,type:comment]
+    internal_token: ENC[AES256_GCM,data:7eZM+misgHZz1p6HH9VzCAPIIFjp2vT0kyc9B1KllE+x2URyrgs5IR9SZ+T5vNdMdnlNzF25pUhKzjbak8tVN554rYWp06SczzqhLyaoHKs8iGBohMqfJkoZxxIVSB7g7GC+/SAsb719,iv:XbBXqXh/PqjEcAj0qsajR7Ij56KGT/9Spdp5T549p9I=,tag:o4ONucOkIE2VJ6VjOlPb6w==,type:str]
+    #ENC[AES256_GCM,data:ZqwgnKjaolJtjcy287fnDOkb/oSLnBpfWfsTeVPwbIE8YLRSoPP4gbCnHJBLq+TJNNI=,iv:zTvw4ZS6C1ifUwOijNLuTfUQ3JM+5gj1X2f/s8MwWXc=,tag:Y1yKlL+jIRHVBulGlSErog==,type:comment]
+    jwt_secret: ENC[AES256_GCM,data:e59MlATOorsTIQjtTUKfX5Yo3CVsbbfuKczp1gh1m2D1kkZK3ORFztYpjg==,iv:JH3PVUmXToiThEKDkDJ8MGVMAPlIEgPSWhru+9WgNjk=,tag:FfDpaCPejpw6kGDkxJwDWw==,type:str]
+    lfs_jwt_secret: ENC[AES256_GCM,data:xi9PEKFUGRyc3YOg3JM3KrrENi9xsbeBjiz4R16SK5WDafoGFLazN6KRJQ==,iv:1IhPyQDwA8tZ22pfZJiU8TRTCLCHC/HAnKdmSGDfvcM=,tag:rLdREVSKBm67rt8ayN16Vw==,type:str]
+restic_password: ENC[AES256_GCM,data:u7QOZXJkxVG4J75K5nphb2uJGdz6jbWuVSsKKu+41fshp7cVoRijtr/Cs02LjVse,iv:bt1W2FeBTG6ypBFYzMPXPIkYTSn0uHURY2ui6MRgYY8=,tag:DObAMws/zQcM+UKUe9EECA==,type:str]
 sops:
     age:
         - recipient: age1ykcs39e62pz3xu6cedg8ea685kv5d5qsrhgkndygzm8rx30xd5ys5t3qxt
@@ -29,7 +38,7 @@ sops:
             Yjd0MUcxcExvWVpCOUR3MkdZdGQyWUkKnru0Y2A98+0Mps7EtVK7ct3vPqIGveUt
             E5fzpcKvdefzObrx7BPTwJ19t2fZg/dSi7HKwx3vmKZSzyQaqJOzsg==
             -----END AGE ENCRYPTED FILE-----
-    lastmodified: "2026-03-29T22:44:20Z"
-    mac: ENC[AES256_GCM,data:f2QVZsCNZJIxnsWsBXVyD6JFSmsMktZqCXQWAJcLfSaojEld9CMu1rJjDyCbG3GPJStrMS20WZbtQvx7H6gosnkxXL401L8SwIoy/gNNEIx0qVLUneoEsuvjSTIiiUG7B2Y9lBKQ/kO/iKrJMURSke0wWWC1Ng5mUePfZ94FVTg=,iv:xOFeak0pjBt4iTFr9vt4cuA9WzFD/ipVThgulNOp100=,tag:YPLXK4RmQLa+ADl6DohmBQ==,type:str]
+    lastmodified: "2026-04-04T23:18:43Z"
+    mac: ENC[AES256_GCM,data:qBgeli5lHb4pyA8nAADBuRBAaq8VbAIsFI37OZtgnbnoHW2crxo3YC+EknaIYnZpZ48kwVhQS5lGRjI6JsWWhTH3+LVAhTmS2Qj/pZTD/JDLK6XJGXS4U9nB7m9aGYyW8gFCy9/DfoJWGsS//+ZmUikKPfd5kMZgh1zGoYCIGug=,iv:h+2fA+bO2SMCNrEslP36x3BPRaIy25cU/DNX8CYSC6A=,tag:RvVyUZ4ONRaKaqGiT31eUQ==,type:str]
     unencrypted_suffix: _unencrypted
-    version: 3.12.1
+    version: 3.12.2

modules/hosts/soteria/soteria.nix

@@ -1,4 +1,4 @@
-{ inputs, lib, ... }:
+{ withSystem, self, inputs, lib, ... }:
 let
   username = "john";
   hostname = "soteria";
@@ -11,11 +11,15 @@ in
       nixos.mysops
       nixos.step-ssh-host
       nixos.login-text
-      # nixos.mtls
+      nixos.docker
+      nixos.mtls
+      nixos.janus-ca
+      nixos.forgejo
       # nixos.restic-server
       # nixos.restic-envoy
-      {
+      ({ config, pkgs, ... }: {
         networking.hostName = hostname;
+        time.timeZone = "America/Chicago";
 
         # Removes password for sudo
         security.sudo-rs.extraRules = lib.mkAfter [
@@ -29,61 +33,88 @@ in
             ];
           }
         ];
-        # nix.settings.build-dir = "/var/tmp/nix-build";
-        # systemd.tmpfiles.rules = [
-        #   "d /var/tmp/nix-build 1777 root root -"
-        # ];
-        step-ssh-host = {
-          hostname = hostname;
+
+        users.users."${username}".extraGroups = [ "mtls" ];
+        mtls = {
+          enable = true;
+          certDir = config.janus-ca.certDir;
+          subject = hostname;
+          san = [
+            "${hostname}.john-stream.com"
+            # "192.168.1.142"
+            "forgejo.john-stream.com"
+            "192.168.1.244"
+          ];
+          lifetime = "12h";
+          renew.onCalendar = "*:3/15";
+          renew.reloadUnits = [ "forgejo.service" "restic-rest-server.service" ];
+          certReaders = [ config.services.forgejo.user "restic" ];
         };
+        forgejo = {
+          enable = true;
+          root_url = "https://forgejo.john-stream.com";
+          https = true;
+          port = 443;
+        };
+
+        networking.firewall.allowedTCPPorts = [ 8000 ];
+        services.restic.server = {
+          enable = true;
+          privateRepos = true;
+          listenAddress = "0.0.0.0:8000";
+          extraFlags = [
+            "--no-auth"
+            "--tls"
+            "--tls-cert=${config.mtls.certFile}"
+            "--tls-key=${config.mtls.keyFile}"
+          ];
+        };
+
+        loginText.extraServiceStatus = {
+          Docker = "docker";
+          "mTLS Renewal" = "mtls-renew.timer";
+          Forgejo = "forgejo.service";
+          "Forgejo Backup" = "forgejo-dump.timer";
+          "Restic REST Server" = "restic-rest-server.service";
+        };
+
+        step-ssh-host.hostname = hostname;
+
         # This provides the secrets at install time
         sops.defaultSopsFile = ./secrets.yaml;
 
-        home-manager.users."${username}" = {
-          imports = with inputs.self.modules; [
-            homeManager."${hostname}"
+        programs.zsh.enable = true;
+
+        home-manager.users."${username}".imports = [ inputs.self.modules.homeManager.soteria ];
+
+        environment.systemPackages = [
+          inputs.self.packages.${pkgs.stdenv.hostPlatform.system}.my-neovim
+          inputs.self.packages.${pkgs.stdenv.hostPlatform.system}.jsl-zsh
         ];
-        };
-      }
+      })
     ];
   };
 
-  flake.modules.homeManager."${hostname}" = { config, pkgs, lib, ... }: {
-    imports = with inputs.self.modules; [
-      homeManager.rebuild
-      homeManager.mysops
-      homeManager.janus-ca
-      homeManager.mtls
-      homeManager.docker
-    ];
-
+  flake.modules.homeManager.soteria = { config, pkgs, lib, ... }: {
+    imports = [
+      inputs.self.modules.homeManager.rebuild
+      inputs.self.modules.homeManager.mysops
+      ({ config, pkgs, lib, ... }: {
         homeManagerFlakeDir = "${config.xdg.configHome}/home-manager";
-    shell.program = "zsh";
         docker.enable = true;
 
         # This will provide the edit-secrets script targeting this file
         mysops.hostSecretFile = "${config.homeManagerFlakeDir}/modules/hosts/soteria/secrets.yaml";
-
-    mtls = {
-      enable = true;
-      subject = hostname;
-      san = [
-        "${hostname}.john-stream.com"
-        "192.168.1.142"
+      })
     ];
-      lifetime = "1h";
-      renew.onCalendar = "*:3/15";
-      renew.postCommands = [
-        "${lib.getExe pkgs.docker} restart envoy"
-      ];
-    };
   };
 
-  flake.homeConfigurations."${hostname}" = inputs.home-manager.lib.homeManagerConfiguration {
-    pkgs = import inputs.nixpkgs { system = "x86_64-linux"; };
-    modules = with inputs.self.modules; [
-      homeManager."${username}"
-      homeManager."${hostname}"
+  flake.homeConfigurations.soteria = withSystem "x86_64-linux" (ctx@{ config, inputs', ...}:
+    inputs.home-manager.lib.homeManagerConfiguration {
+      pkgs = inputs'.nixpkgs.legacyPackages;
+      modules = [
+        inputs.self.modules.homeManager."${username}"
+        inputs.self.modules.homeManager.soteria
       ];
-  };
+  });
 }

modules/nix-tools/rebuild.nix

@@ -6,11 +6,21 @@
       flakeDir = config.rebuild.flakeDir;
       echoCmd = lib.getExe' pkgs.coreutils "echo";
       hostnameCmd = "$(${lib.getExe pkgs.hostname} -s)";
-      nfs = (pkgs.writeShellScriptBin "nfs" ''
-        HOSTNAME=${hostnameCmd}
-        ${echoCmd} "Switching to the $HOSTNAME nixos profile"
-        sudo ${lib.getExe pkgs.nixos-rebuild} switch --impure --flake ${flakeDir}#$HOSTNAME
-      '');
+
+      nfs = with pkgs; writeShellApplication {
+        name = "nfs";
+        runtimeInputs = [ coreutils hostname nh ];
+        text = ''
+          HOSTNAME=$(hostname -s)
+          echo "Switching to the $HOSTNAME nixos profile"
+          nh os switch "$@" "${flakeDir}#$HOSTNAME"
+        '';
+      };
+      nfsu = with pkgs; writeShellApplication {
+        name = "nfsu";
+        runtimeInputs = [ nfs pkgs.git ];
+        text = ''nfs --refresh "$@"'';
+      };
     in
     {
       options.rebuild = {
@@ -22,29 +32,38 @@
       };
 
       config = {
-        environment.systemPackages = with pkgs; [
-          nfs
-          (writeShellScriptBin "nfsu" ''
-            ${lib.getExe nix} flake update --impure --flake ${flakeDir}
-            ${lib.getExe git} -C ${flakeDir} add ${flakeDir}/flake.lock > /dev/null 2>&1
-            ${lib.getExe nfs}
-          '')
-        ];
+        environment.systemPackages = with pkgs; [ nfs nfsu ];
       };
     };
 
   flake.modules.homeManager.rebuild =
     { config, pkgs, lib, ... }:
     let
-      nixBin = lib.getExe pkgs.nix;
       flakeDir = config.homeManagerFlakeDir;
-      echoCmd = lib.getExe' pkgs.coreutils "echo";
-      hostnameCmd = "$(${lib.getExe pkgs.hostname} -s)";
-      nhms = (pkgs.writeShellScriptBin "nhms" ''
-        HOSTNAME=${hostnameCmd}
-        ${echoCmd} "Switching to the $HOSTNAME home-manager profile"
-        ${lib.getExe pkgs.home-manager} switch --impure --flake ${flakeDir}#$HOSTNAME
-      '');
+
+      flake-parts-check = with pkgs; writeShellApplication {
+        name = "flake-parts-check";
+        runtimeInputs = [ nix ];
+        text = ''
+          cd ${flakeDir}
+          nix run "${flakeDir}#write-flake"
+          nix flake check
+        '';
+      };
+
+      test-build = with pkgs; writeShellApplication {
+        name = "test-build";
+        runtimeInputs = [ coreutils nix hostname ];
+        text = ''
+          if [ -z "$1" ]; then
+            HOSTNAME=$(hostname -s)
+          else
+            HOSTNAME="$1"
+          fi
+          echo "Testing the evaulation of the nixos config for $HOSTNAME"
+          nix eval "${flakeDir}#nixosConfigurations.$HOSTNAME.config.system.build.toplevel.drvPath"
+        '';
+      };
     in
     {
       options = {
@@ -53,41 +72,77 @@
           type = lib.types.str;
           default = "${config.xdg.configHome}/home-manager";
         };
-        buildHostname = lib.mkOption {
-          description = "Hostname for the NixOS configuration to use.";
-          type = lib.types.str;
-          default = hostnameCmd;
-        };
       };
 
       config = {
         home.activation.printFlakeDir = lib.hm.dag.entryAfter ["writeBoundary"] ''
-          run ${echoCmd} "Home Manager flake directory: ${flakeDir}"
+          run echo "Home Manager flake directory: ${flakeDir}"
         '';
 
         home.packages = with pkgs; [
           home-manager
-          (writeShellScriptBin "flake-parts-check" ''
-            cd ${flakeDir}
-            ${nixBin} run "${flakeDir}#write-flake"
-            ${nixBin} flake check
-          '')
-          nhms
-          (writeShellScriptBin "nhmu" ''
-            ${nixBin} flake update --flake ${flakeDir}
-            ${lib.getExe nhms}
-          '')
-
-          (writeShellScriptBin "test-build" ''
-            if [ -z "$1" ]; then
-              HOSTNAME=${hostnameCmd}
-            else
-              HOSTNAME="$1"
-            fi
-            ${echoCmd} "Testing the evaulation of the nixos config for $HOSTNAME"
-            ${lib.getExe nix} eval ${flakeDir}#nixosConfigurations.$HOSTNAME.config.system.build.toplevel.drvPath
-          '')
+          (symlinkJoin {
+            name = "build-tools";
+            paths = [
+              flake-parts-check
+              test-build
+              (inputs.self.wrappers.home-switch.apply {
+                inherit pkgs flakeDir;
+              }).wrapper
+              (inputs.self.wrappers.home-switch.apply {
+                binName = lib.mkForce "nhmu";
+                inherit pkgs flakeDir;
+                extraOptions = [ "--update" ];
+              }).wrapper
+              (inputs.wrappers.lib.wrapPackage {
+                binName = "cleanup";
+                inherit pkgs;
+                package = nh;
+                args = [ "clean" "user" "--keep-since" "3days" ];
+              })
+            ];
+          })
         ];
       };
     };
+
+  flake.wrappers.home-switch = inputs.wrappers.lib.wrapModule ({config, lib, wlib, ... }: {
+    options = {
+      flakeDir = lib.mkOption {
+        type = lib.types.str;
+      };
+      user = lib.mkOption {
+        type = lib.types.str;
+        default = "$(whoami)";
+      };
+      hostname = lib.mkOption {
+        type = lib.types.str;
+        default = "$(hostname -s)";
+      };
+      configuration = lib.mkOption {
+        type = lib.types.str;
+        default = "${config.user}@${config.hostname}";
+      };
+      extraOptions = lib.mkOption {
+        type = lib.types.listOf lib.types.str;
+        default = [ ];
+      };
+    };
+
+    config = {
+      binName = "nhms";
+      extraPackages = with config.pkgs; [ coreutils hostname nh ];
+      preHook = ''
+        CONFIG=${config.configuration}
+        echo "Switching to $CONFIG"
+      '';
+      package = config.pkgs.nh;
+      args = [
+        "home" "switch"
+        "--configuration" "${config.configuration}"
+        "$@"
+        "${config.flakeDir}"
+      ] ++ config.extraOptions;
+    };
+  });
 }

modules/nix-tools/user.nix

@@ -14,19 +14,26 @@
         inputs.home-manager.nixosModules.home-manager
       ];
 
+      environment.shells = [
+        "${lib.getExe pkgs.zsh}"
+        "${lib.getExe inputs.self.packages.${pkgs.stdenv.hostPlatform.system}.jsl-zsh}"
+      ];
+
+      users.groups."${username}" = {};
+
       users.users."${username}" = {
         isNormalUser = true;
+        group = username;
         home = "/home/${username}";
-        shell = lib.mkIf config.programs.zsh.enable pkgs.zsh;
-        extraGroups = [
-          "input"
-          "networkmanager"
-        ] ++ lib.optionals isAdmin [
-          "docker"
-          "wheel"
-        ];
+        shell = pkgs.zsh;
+        extraGroups = [ "input" "networkmanager" ]
+          ++ lib.optional isAdmin "wheel"
+          ++ lib.optional config.virtualisation.docker.enable "docker"
+          ++ lib.optional (isAdmin && config.services.forgejo.enable) config.services.forgejo.group
+          ++ lib.optional (isAdmin && config.services.postgresql.enable) "postgres";
       };
 
+      programs.zsh.enable = true;
 
       security.sudo-rs.enable = lib.mkIf isAdmin true;
 
@@ -36,7 +43,9 @@
         imports = [ self.modules.homeManager."${username}" ];
         home.username = "${username}";
         home.homeDirectory = "/home/${username}";
-        # home.packages = homePackages;
+        home.packages = with pkgs; [
+          # fzf zoxide starship
+        ];
       };
     };
   };

modules/nix-tools/wrappers.nix

@@ -0,0 +1,21 @@
+{ self, inputs, ... }: {
+  config.flake-file.inputs = {
+    wrapper-modules = {
+      url = "github:BirdeeHub/nix-wrapper-modules";
+      inputs.nixpkgs.follows = "nixpkgs";
+    };
+    wrappers = {
+      url = "github:lassulus/wrappers";
+      inputs.nixpkgs.follows = "nixpkgs";
+    };
+  };
+
+  options = {
+    # This is what allows wrappers to be defined in flake.wrappers.<wrapper-name> throughout different flake-parts modules
+    flake = inputs.flake-parts.lib.mkSubmoduleOptions {
+      wrappers = inputs.nixpkgs.lib.mkOption {
+        default = {};
+      };
+    };
+  };
+}

modules/nixos/login-text.nix

@@ -1,5 +1,18 @@
 { inputs, ... }: {
-  flake.modules.nixos.login-text = { config, ... }: {
+  flake.modules.nixos.login-text = { config, lib, ... }:
+    let
+      defaultServiceStatus = {
+        SSH = "sshd.socket";
+        "SSH Cert Renewal" = "step-ssh-host-renew.timer";
+      };
+    in {
+    options.loginText.extraServiceStatus = lib.mkOption {
+      type = lib.types.attrsOf lib.types.str;
+      default = { };
+      description = "Additional rust-motd service status entries keyed by display name.";
+    };
+
+    config = {
       programs.rust-motd = {
         enable = true;
         refreshInterval = "*:0/5";
@@ -21,12 +34,10 @@
             root = 3;
           };
 
-        service_status = {
-          Docker = "docker";
-          SSH = "sshd.socket";
-          "SSH Cert Renewal" = "step-ssh-host-renew.timer";
-          "mTLS Renewal" = "mtls-renew.timer";
-        };
+          service_status = lib.mkMerge [
+            defaultServiceStatus
+            config.loginText.extraServiceStatus
+          ];
 
           # This calculation is wrong for LXCs
           # uptime = {
@@ -43,4 +54,5 @@
         };
       };
     };
+  };
 }

modules/programs/bash.nix

@@ -1,10 +1,9 @@
 {
   flake.modules.homeManager.bash = { pkgs, lib, config, ... }:
   {
-    programs.bash = lib.mkIf (config.shell.program == "bash") {
+    programs.bash = {
       enable = true;
       enableCompletion = true;
-      package = pkgs.bash;
     };
   };
 }

modules/programs/eza.nix

@@ -1,14 +1,32 @@
-{ inputs, pkgs, lib, ... }:
+{ self, inputs, ... }:
 {
-  flake.modules.homeManager.eza = { pkgs, lib, ... }: {
+  flake.modules.homeManager.eza = { config, pkgs, lib, ... }: {
     programs.eza = {
       enable = true;
-      package = pkgs.eza;
       enableBashIntegration = true;
       enableZshIntegration = true;
+      package = inputs.self.packages.${pkgs.stdenv.hostPlatform.system}.my-eza;
     };
-    home.shellAliases = {
-      ls = "${lib.getExe pkgs.eza} -lgos type --no-time --follow-symlinks";
+  };
+
+  perSystem = { system, pkgs, ... }: {
+    packages.my-eza = inputs.wrappers.lib.wrapPackage {
+      inherit pkgs;
+      package = pkgs.eza;
+      args = [
+        "--all"
+        "--long"
+        "--group-directories-first"
+        "--icons=auto"
+        "--color=auto"
+        "--sort=type"
+        "--dereference"
+        "--octal-permissions"
+        "--smart-group"
+        "--no-time"
+        "--git"
+        "$@"
+      ];
     };
   };
 }

modules/programs/files.nix

@@ -1,15 +1,18 @@
 {
-  flake.modules.homeManager.files = { pkgs, ... }:
+  flake.modules.homeManager.files = { pkgs, lib, ... }:
   {
-    programs.lf.enable = true;
-    programs.lf.cmdKeybindings = {
+    programs.lf = {
+      enable = true;
+      cmdKeybindings = {
         "D" = "delete";
       };
-
-    home.packages = with pkgs; [
-      gdu
-      lf
-      # TODO: find a CLI file editor that's not insane
-    ];
+      settings = {
+        preview = true;
+        hidden = true;
+        drawbox = true;
+        icons = true;
+        ignorecase = true;
+      };
+    };
   };
 }

modules/programs/ghostty.nix

@@ -8,6 +8,17 @@
   };
 
   flake.modules.homeManager.ghostty = { config, pkgs, lib, ... }:
+  let
+    ghosttyPackage = pkgs.symlinkJoin {
+      name = "ghostty-x11";
+      paths = [ (config.lib.nixGL.wrap pkgs.ghostty) ];
+      nativeBuildInputs = [ pkgs.makeWrapper ];
+      meta.mainProgram = "ghostty";
+      postBuild = ''
+        wrapProgram $out/bin/ghostty --set GDK_BACKEND x11
+      '';
+    };
+  in
   {
     home.sessionVariables = {
       TERMINAL = "ghostty";
@@ -22,7 +33,7 @@
     programs.ghostty = {
       enable = true;
       enableZshIntegration = true;
-      package = config.lib.nixGL.wrap pkgs.ghostty;
+      package = ghosttyPackage;
       settings = {
         command = "TERM=xterm-256color ${lib.getExe pkgs.zsh}";
         font-size = 12;
@@ -32,6 +43,7 @@
         shell-integration = "zsh";
         shell-integration-features = [ "no-title" "sudo" ];
         gtk-single-instance = true;
+        mouse-scroll-multiplier = 0.375;
 
         window-position-x = 25;
         window-position-y = 25;
@@ -60,13 +72,12 @@
     # https://github.com/ghostty-org/ghostty/discussions/3763#discussioncomment-11699970
     xdg.desktopEntries."com.mitchellh.ghostty" =
     let
-      ghosttyCmd = "nixGLMesa ${lib.getExe pkgs.ghostty}";
+      ghosttyCmd = lib.getExe ghosttyPackage;
     in
     {
       name = "Ghostty";
       type = "Application";
       comment = "A terminal emulator";
-      # exec = "nixGLMesa ghostty";
       exec = ghosttyCmd;
       icon = "com.mitchellh.ghostty";
       terminal = false;
@@ -85,7 +96,6 @@
         new-window = {
           name = "New Window";
           exec = ghosttyCmd;
-          # exec = "nixGLMesa ghostty";
         };
       };
     };

modules/programs/neovim.nix

@@ -6,25 +6,153 @@
     };
   };
 
-  perSystem = { system, pkgs, ... }: {
-    packages.my-neovim = (inputs.nvf.lib.neovimConfiguration {
+  perSystem = { system, pkgs, config, ... }: {
+    packages.my-neovim = ((inputs.nvf.lib.neovimConfiguration {
       inherit pkgs;
       modules = [
         {
+          # https://nvf.notashelf.dev/search.html
           config.vim = {
+            options = {
+              number = true;
+              relativenumber = true;
+              expandtab = true;
+              shiftwidth = 4;
+              tabstop = 4;
+              softtabstop = 4;
+
+              wrap = true;
+              linebreak = true;
+            };
+
+            syntaxHighlighting = true;
+
             # Enable custom theming options
             theme.enable = true;
+            theme.name = "catppuccin";
+            theme.style = "mocha";
+
+            git.enable = true;
+            # git.neogit.enable = true;
+
+            # https://github.com/akinsho/toggleterm.nvim
+            terminal.toggleterm.enable = true;
+            terminal.toggleterm.lazygit.enable = true;
+            terminal.toggleterm.lazygit.direction = "float";
+            terminal.toggleterm.lazygit.mappings.open = "<C-g>";
+
+
+            utility.nix-develop.enable = true;
+
+            utility.oil-nvim.enable = true;
+            utility.oil-nvim.gitStatus.enable = true;
+
+            filetree.neo-tree = {
+              enable = true;
+            };
+
+            # lazy = {
+            #   enable = true;
+            # };
+
+            # globals = {
+            #   SimpylFold_docstring_preview = 1;
+            #   SimpylFold_fold_blank = 0;
+            # };
+
+            # extraPlugins = with pkgs.vimPlugins; {
+            #   SimpylFold.package = SimpylFold;
+            # };
+
+            telescope = {
+              enable = true;
+              extensions  = [
+                {
+                  name = "fzf";
+                  packages = [pkgs.vimPlugins.telescope-fzf-native-nvim];
+                  setup = {fzf = {fuzzy = true;};};
+                }
+              ];
+            };
 
             # Enable Treesitter
-            treesitter.enable = true;
+            treesitter = {
+              enable = true;
+              grammars = with pkgs.vimPlugins.nvim-treesitter-parsers; [ python ];
+            };
 
-            # Other options will go here. Refer to the config
-            # reference in Appendix B of the nvf manual.
-            # ...
+            lsp.enable = true;
+
+            languages = {
+              enableTreesitter = true;
+              enableFormat = true;
+
+              markdown = {
+                enable = true;
+                extensions = {
+                  # render-markdown-nvim.enable = true;
+                  markview-nvim.enable = true;
+                };
+              };
+
+              bash.enable = true;
+              css.enable = true;
+              yaml.enable = true;
+              toml.enable = true;
+
+              nix = {
+                enable = true;
+              };
+
+              python = {
+                enable = true;
+                dap.enable = true;
+                format.type = [ "ruff" ];
+              };
+            };
+
+            keymaps = [
+              {
+                desc = "Edit key mappings";
+                key = "<leader>ekm";
+                mode = [ "n" ];
+                silent = false;
+                action = "<cmd>:edit +/keymaps /home/john/.config/home-manager/jsl-dendritic/modules/programs/neovim.nix<CR>";
+              }
+              {
+                desc = "Home Manager Switch";
+                key = "<leader>nhms";
+                mode = [ "n" ];
+                silent = false;
+                action = "<cmd>:TermExec cmd='clear && nhms && exit' name='Nix Home Manager Switch' direction=float<CR>";
+              }
+              {
+                desc = "Key Maps [Telescope]";
+                key = "<leader>fkm";
+                mode = "n";
+                silent = false;
+                action = "<cmd>:Telescope keymaps<CR>";
+              }
+              {
+                desc = "Toggle Filesystem Tree [NeoTree]";
+                key = "<C-b>";
+                mode = [ "n" "v" "t" ];
+                silent = false;
+                action = "<cmd>:Neotree toggle filesystem left action=show<CR>";
+              }
+              {
+                key = "<C-`>";
+                mode = ["n" "v" "t"];
+                silent = false;
+                action = "<cmd>:ToggleTerm<CR>";
+              } 
+            ];
           };
         }
       ];
-    })
-    .neovim;
+    }).neovim).overrideAttrs (old: {
+      pname = "my-neovim";
+      version = "custom";
+    });
   };
 }

modules/programs/niri.nix

@@ -1,9 +1,4 @@
 { self, inputs, ... }: {
-  flake-file.inputs = {
-    wrapper-modules.url = "github:BirdeeHub/nix-wrapper-modules";
-    # wrapper-modules.inputs.nixpkgs.follows = "nixpkgs";
-  };
-
   flake.modules.nixos.niri = { pkgs, lib, ... }: {
     programs.niri = {
       enable = true;

modules/programs/sops.nix

@@ -1,4 +1,4 @@
-{ inputs, ... }:
+{ self, inputs, ... }:
 let
   inputs' = inputs;  # save a reference before it's shadowed
 in
@@ -14,18 +14,10 @@ in
     imports = [ inputs.sops-nix.nixosModules.sops ];
   };
 
-  # Define the homeModules that are used by flake-parts
-  # https://flake.parts/options/home-manager.html#opt-flake.modules.homeManager
-  flake.modules.homeManager.mysops = { inputs, config, pkgs, lib, ... }:
+  flake.modules.homeManager.mysops =
+    { config, pkgs, lib, ... }:
     let
       cfg = config.mysops;
-    sopsBin = lib.getExe pkgs.sops;
-    sopsConfigPath = ../../.sops.yaml;
-    sopsSecretsPath = ../../keys/secrets.yaml;
-
-    editScript = lib.optional (cfg.hostSecretFile != null) (pkgs.writeShellScriptBin  "edit-secrets" ''
-      ${sopsBin} --config ${sopsConfigPath} ${cfg.hostSecretFile}
-    '');
     in
     {
       imports = [
@@ -34,11 +26,6 @@ in
       ];
 
       options.mysops = {
-      ageKeyFile = lib.mkOption {
-        description = "Default location for the age key";
-        type = lib.types.str;
-        default = "${config.xdg.configHome}/sops/age/keys.txt";
-      };
         hostSecretFile = lib.mkOption {
           description = "Path to the secrets file for this host. Used to create the edit-secrets script";
           type = lib.types.nullOr lib.types.str;
@@ -48,50 +35,63 @@ in
 
       config =
         let
-      echo = lib.getExe' pkgs.coreutils "echo";
-      dirname = lib.getExe' pkgs.coreutils "dirname";
-      mkdir = lib.getExe' pkgs.coreutils "mkdir";
-      show-age-key = (pkgs.writeShellScriptBin "show-age-key" ''
-        ${lib.getExe' pkgs.age "age-keygen"} -y ${cfg.ageKeyFile}
-      '');
+          my-sops = (inputs.self.wrappers.mySops.apply {
+            inherit pkgs;
+            sshKey = config.ssh.identityFile;
+          }).wrapper;
         in
         {
-      home.packages = with pkgs; [
-        eza
-        age
-        sops # This is necessary to make the sops binary available
-        ssh-to-age
-        (writeShellScriptBin "gen-age-key" ''
-          set -eu
-
-          if [ ! -f "${config.ssh.identityFile}" ]; then
-            ${echo} "SSH identity file not found: ${config.ssh.identityFile}" >&2
-            exit 1
-          fi
-
-          if [ -e "${cfg.ageKeyFile}" ]; then
-            ${echo} "Refusing to overwrite existing age key file: ${cfg.ageKeyFile}" >&2
-            exit 1
-          fi
-
-          ${mkdir} -p "$(${dirname} "${cfg.ageKeyFile}")"
-          ${lib.getExe pkgs.ssh-to-age} -i ${config.ssh.identityFile} -private-key > ${cfg.ageKeyFile}
-          ${echo} -n "Created ${cfg.ageKeyFile}: "
-          ${echo} $(${lib.getExe show-age-key})
-        '')
-        show-age-key
-        (writeShellScriptBin "ls-secrets" "${lib.getExe pkgs.eza} -alT --follow-symlinks ~/.config/sops-nix/secrets")
-      ] ++ editScript;
-
-      home.shellAliases.sops = "${sopsBin} --config ${sopsConfigPath}";
-
           # Option definitions for the sops home-manager module:
           # https://github.com/Mic92/sops-nix/blob/master/modules/home-manager/sops.nix
           sops = {
-        defaultSopsFile = sopsSecretsPath;
+            defaultSopsFile = ../../keys/secrets.yaml;
             defaultSopsFormat = "yaml";
             age.sshKeyPaths = [ "${config.ssh.identityFile}" ];
           };
+
+          home.packages = with pkgs; [
+            my-sops
+            (inputs.wrappers.lib.wrapPackage {
+              binName = "ls-secrets";
+              inherit pkgs;
+              package = inputs.self.packages.${pkgs.stdenv.hostPlatform.system}.my-eza;
+              args = [
+                "-T" "--follow-symlinks"
+                "${config.xdg.configHome}/sops-nix/secrets"
+              ];
+            })
+            
+          ]
+          ++ lib.optional (cfg.hostSecretFile != null) (inputs.wrappers.lib.wrapPackage {
+            binName = "edit-secrets";
+            inherit pkgs;
+            package = my-sops;
+            args = [ cfg.hostSecretFile ];
+          });
         };
     };
+
+  flake.wrappers.mySops = inputs.wrappers.lib.wrapModule ({config, lib, wlib, ... }: {
+    options = {
+      sshKey = lib.mkOption {
+        type = lib.types.str;
+        description = "String path to the SSH key to use for creating an AGE key at runtime";
+      };
+    };
+
+    config = {
+      # binName = "my-sops";
+      package = config.pkgs.sops;
+      extraPackages = with config.pkgs; [ coreutils ssh-to-age ];
+      preHook = ''
+        AGE_KEY=$(umask 077; mktemp)
+        ssh-to-age -private-key -i ${config.sshKey} > "$AGE_KEY"
+      '';
+      flags."--config" = "${../../.sops.yaml}";
+      postHook = ''
+        rm "$AGE_KEY"
+        echo "Removed $AGE_KEY"
+      '';
+    };
+  });
 }

modules/programs/starship.nix

@@ -0,0 +1,54 @@
+{ self, inputs, ... }: {
+  perSystem = { system, pkgs, lib, ... }: {
+    packages.starship = (inputs.wrappers.wrapperModules.starship.apply {
+      inherit pkgs;
+      settings = lib.recursiveUpdate (lib.importTOML (pkgs.fetchurl {
+          url = https://starship.rs/presets/toml/catppuccin-powerline.toml;
+          sha256 = "1jzbbzm3nwdlldq43aj3csp0ps23fsa6x2225z85l0s9qbj4cdy2";
+        })) {
+          palette = "catppuccin_mocha";
+          add_newline = true;
+          line_break.disabled = false;
+          git_status.diverged = "⇕⇡\${ahead_count}⇣\${behind_count}";
+          cmd_duration.format = "󰔛 $duration";
+          cmd_duration.show_notifications = false;
+          hostname = {
+            disabled = false;
+            ssh_symbol = "🌐";
+            format = "[$ssh_symbol$hostname]($style)";
+            style = "bg:red fg:crust";
+          };
+          os.symbols.NixOS = " ";
+          format = lib.replaceStrings ["\n"] [""] ''
+            [](red)
+            $os
+            $username
+            $hostname
+            [](bg:peach fg:red)
+            $directory
+            [](bg:yellow fg:peach)
+            $git_branch
+            $git_status
+            [](fg:yellow bg:green)
+            $c
+            $rust
+            $golang
+            $nodejs
+            $php
+            $java
+            $kotlin
+            $haskell
+            $python
+            [](fg:green bg:sapphire)
+            $conda
+            [](fg:sapphire bg:lavender)
+            $time
+            [ ](fg:lavender)
+            $cmd_duration
+            $line_break
+            $character
+          '';
+        };
+    }).wrapper;
+  };
+}

modules/programs/step-client.nix

@@ -1,37 +0,0 @@
-{ self, inputs, ... }: {
-  #
-  # Home Manager Module
-  #
-  flake.modules.homeManager.step-ssh-user = { config, pkgs, lib, ... }:
-  let
-    cfg = config.step-ssh-user;
-    firstPrincipal = lib.head cfg.principals;
-    principalArgs = lib.concatMapStringsSep " "
-      (principal: "--principal \"${principal}\"") cfg.principals;
-  in
-  {
-    options.step-ssh-user = {
-      enable = lib.mkEnableOption "opionated step client config for SSH certs";
-      provisioner = lib.mkOption {
-        type = lib.types.str;
-        default = "admin";
-      };
-      principals = lib.mkOption {
-        type = lib.types.listOf lib.types.str;
-      };
-    };
-    config = lib.mkIf cfg.enable {
-      sops.secrets."janus/admin_jwk".mode = "0400";
-      home.packages = with pkgs; [
-        (writeShellScriptBin "sign-ssh-cert" ''
-          ${lib.getExe pkgs.step-cli} ssh certificate \
-          --sign \
-          ${principalArgs} \
-          --provisioner "${cfg.provisioner}" \
-          --provisioner-password-file "${config.sops.secrets."janus/admin_jwk".path}" \
-          "${firstPrincipal}" "${config.ssh.identityFile}.pub"
-        '')
-      ];
-    };
-  };
-}

modules/programs/wireguard.nix

@@ -2,39 +2,13 @@
   flake.modules.nixos.wireguard = { config, pkgs, lib, ... }:
   let
     wgInterface = "platform";
-    systemctl = lib.getExe' pkgs.systemd "systemctl";
-    journalctl = lib.getExe' pkgs.systemd "journalctl";
-
-    mkConnect = interface:
-      let
-        serviceName = "wg-quick-${interface}";
-        service = "${serviceName}.service";
-      in
-      pkgs.writeShellScriptBin "wg-connect-${interface}" ''
-        ${systemctl} start ${service}
-        start_time=$(${systemctl} show -p ActiveEnterTimestamp ${serviceName} | cut -d= -f2)
-        ${journalctl} -u ${service} --since "$start_time" --no-pager
-      '';
-    mkDisconnect = interface:
-      let
-        serviceName = "wg-quick-${interface}";
-        service = "${serviceName}.service";
-      in
-      pkgs.writeShellScriptBin "wg-disconnect-${interface}" ''
-        STOPTIME=$(${lib.getExe' pkgs.coreutils "date"} '+%Y-%m-%d %H:%M:%S')
-        ${systemctl} stop ${service}
-        start_time=$(${systemctl} show -p ActiveEnterTimestamp ${serviceName} | cut -d= -f2)
-        ${journalctl} -u ${service} --since "$STOPTIME" --no-pager
-      '';
   in
   {
     imports = [ inputs.sops-nix.nixosModules.sops ];
 
     environment.systemPackages = with pkgs; [
-      wireguard-tools
-      wg-netmanager
-      (mkConnect "platform")
-      (mkDisconnect "platform")
+      wireguard-tools # https://github.com/WireGuard/wireguard-tools
+      # wg-netmanager # https://github.com/gin66/wg_netmanager
     ];
 
     sops.secrets.wireguard_private_key = { };
@@ -56,4 +30,39 @@
       };
     };
   };
+
+  perSystem = { system, pkgs, lib, ... }:
+  let
+    connect = pkgs.writeShellApplication {
+      name = "wg-platform-connect";
+      text = ''
+        sudo systemctl start wg-quick-platform.service
+        START_TIME=$(sudo systemctl show -p ActiveEnterTimestamp wg-quick-platform | cut -d= -f2)
+        journalctl -u wg-quick-platform --since "$START_TIME" --no-pager
+      '';
+    };
+
+    disconnect = pkgs.writeShellApplication {
+      name = "wg-platform-disconnect";
+      text = ''
+        STOP_TIME=$(date '+%Y-%m-%d %H:%M:%S')
+        systemctl stop wg-quick-platform.service
+        journalctl -u wg-quick-platform.service --since "$STOP_TIME" --no-pager
+      '';
+    };
+  in
+  {
+    packages.wg-platform = inputs.wrappers.lib.wrapPackage {
+      inherit pkgs;
+      runtimeInputs = with pkgs; [ coreutils systemd wireguard-tools ];
+      package = pkgs.symlinkJoin {
+        name = "wg-platform";
+        meta.mainProgram = "wg-platform-connect";
+        paths = [
+          connect
+          disconnect
+        ];
+      };
+    };
+  };
 }

modules/programs/zed-editor.nix

@@ -0,0 +1,33 @@
+{ self, inputs, ... }:
+let
+  packageName = "zed-editor";
+
+  zedWrapper = inputs.wrappers.lib.wrapModule ({ config, lib, wlib, ... }: { 
+    options = { 
+      text-to-say = lib.mkOption {
+        type = lib.types.str;
+        description = "Text for the ascii cow to say.";
+      };
+    };
+
+    config = {
+      binName = "my-pkg"; 
+      package = config.pkgs.cowsay; 
+      args = [ config.text-to-say ]; 
+    };
+  });
+in
+{
+  perSystem = { system, pkgs, lib, ... }: {
+    packages."${packageName}" = (zedWrapper.apply { 
+      inherit pkgs; 
+      text-to-say = "Hello from wrapped module!"; 
+    }).wrapper;
+  };
+
+  flake.modules.homeManager."${packageName}" = { config, pkgs, lib, ... }: { 
+    home.packages = [
+      inputs.self.packages.${pkgs.stdenv.hostPlatform.system}."${packageName}" 
+    ];
+  };
+}

modules/programs/zsh.nix

@@ -1,6 +1,25 @@
-{ inputs, ... }:
+{ self, inputs, ... }:
 let
   username = "john";
+  historySize = 10000;
+  homeEndKeyBindings = ''
+    # Normalize common Home/End escape sequences across terminal emulators.
+    bindkey "^[[H" beginning-of-line
+    bindkey "^[[F" end-of-line
+    bindkey "^[[1~" beginning-of-line
+    bindkey "^[[4~" end-of-line
+    bindkey "^[[7~" beginning-of-line
+    bindkey "^[[8~" end-of-line
+    bindkey "^[OH" beginning-of-line
+    bindkey "^[OF" end-of-line
+    bindkey "^[[3~" delete-char
+
+    # Normalize common Ctrl+Arrow sequences for word-wise movement.
+    bindkey "^[[1;5D" backward-word
+    bindkey "^[[1;5C" forward-word
+    bindkey "^[[5D" backward-word
+    bindkey "^[[5C" forward-word
+  '';
 in
 {
   flake.modules = {
@@ -16,11 +35,14 @@ in
     homeManager.zsh = { pkgs, config, ... }: {
       programs.zsh = {
         enable = true;
-        package = pkgs.zsh;
+        package = inputs.self.packages.${pkgs.stdenv.hostPlatform.system}.jsl-zsh;
         enableCompletion = true;
         autosuggestion.enable = true;
         # syntaxHighlighting.enable = true;
-        initContent = "HOST=$(hostname -s)";
+        initContent = ''
+          HOST=$(hostname -s)
+          ${homeEndKeyBindings}
+        '';
         dotDir = "${config.xdg.configHome}/zsh";
         history = {
           append = true;
@@ -31,8 +53,8 @@ in
             "eza"
             "clear"
           ];
-          save = 1000;
-          size = 1000;
+          save = historySize;
+          size = historySize;
           share = true;
         };
         oh-my-zsh = {
@@ -51,4 +73,71 @@ in
     };
   };
 
+  perSystem = { config, self', pkgs, lib, ... }: {
+    packages.jsl-zsh =
+      let
+        ignorePatterns = [
+          "ls" "eza" "history" "clear"
+        ];
+        aliasStr = lib.concatStringsSep "\n" (
+          lib.mapAttrsToList (k: v: "alias -- ${lib.escapeShellArg k}=${lib.escapeShellArg v}") {
+            ls = "eza";
+            ll = "eza -l";
+            la = "eza -a";
+            lt = "eza --tree";
+            lla = "eza -la";
+            ds = "gdu -i /snap /";
+            ld = "lazydocker";
+          });
+      in
+      (inputs.wrappers.wrapperModules.zsh.apply {
+        inherit pkgs;
+        binName = "jsl-zsh";
+        env = {
+          LANG = "en_US.UTF-8";
+          COLORTERM = "truecolor";
+        };
+        settings = {
+          completion = {
+            enable = true;
+            extraCompletions = true;
+            caseInsensitive = true;
+            fuzzySearch = true;
+          };
+          autoSuggestions = {
+            enable = true;
+            strategy = [ "history" "completion" ];
+          };
+          history = {
+            append = true;
+            expanded = true;
+            share = true;
+            ignoreAllDups = true;
+            ignoreSpace = true;
+          };
+          integrations = {
+            fzf.enable = true;
+            starship = {
+              enable = true;
+              package = self'.packages.starship;
+            };
+            zoxide.enable = true;
+          };
+        };
+        extraRC = ''
+          ${homeEndKeyBindings}
+
+          HISTFILE=$HOME/.config/zsh/.zsh_history
+          SAVEHIST=${toString historySize}
+          HISTORY_IGNORE=${lib.escapeShellArg "(${lib.concatStringsSep "|" ignorePatterns})"}
+
+          HOSTNAME=$(hostname -s)
+          ${aliasStr}
+        '';
+        extraPackages = with pkgs; [
+          lazydocker
+          self'.packages.shell-tools
+        ];
+      }).wrapper;
+  };
 }

modules/services/ssh.nix

@@ -102,6 +102,7 @@ in
         certs = mkEnableOption "Enable Janus and Soteria SSH targets";
         homelab = mkEnableOption "Enable various Homelab targets";
         dev = mkEnableOption "Enable development targets";
+        tailscale = mkEnableOption "Enable tailscale targets";
       };
     };
 
@@ -127,6 +128,10 @@ in
 
         matchBlocks = lib.mkMerge [
           {
+            "john-pc-ubuntu" = {
+              hostname = "192.168.1.85";
+            };
+
             "*" = lib.mkMerge [
               {
                 user = "john";
@@ -171,6 +176,10 @@ in
             "docs" = {
               hostname = "192.168.1.110";
               user = "root";
+              extraOptions = {
+                RequestTTY = "force";
+                RemoteCommand = "~/.nix-profile/bin/jsl-zsh";
+              };
             };
             "gitea" = {
               hostname = "192.168.1.104";
@@ -189,6 +198,20 @@ in
             "test-nix" = {
               hostname = "fded:fb16:653e:25da:be24:11ff:fea0:753f";
               user = "john";
+              extraOptions = {
+                RequestTTY = "auto";
+                # RemoteCommand = "/run/current-system/sw/bin/jsl-zsh";
+              };
+            };
+          })
+          (lib.mkIf cfg.matchSets.tailscale {
+            "jdl-docker" = {
+              hostname = "jdl-docker.tailcf205.ts.net";
+              user = "john";
+              extraOptions = {
+                RequestTTY = "auto";
+                # RemoteCommand = "~/.nix-profile/bin/jsl-zsh";
+              };
             };
           })
         ];

modules/services/step-ca/ssh-host.nix

@@ -33,7 +33,7 @@
       networking.nameservers = [ "192.168.1.150" ];
       networking.dhcpcd.extraConfig = "nohook resolv.conf";
       environment.systemPackages = with pkgs; [
-        step-cli
+        # step-cli
         (writeShellScriptBin "ssh-host-cert-renew" ''
           ${lib.getExe pkgs.step-cli} ssh certificate \
           --host --sign \
@@ -51,7 +51,7 @@
         wantedBy = [ ];
         after = [ "network-online.target" ];
         wants = [ "network-online.target" ];
-        path = [ pkgs.step-cli pkgs.openssh pkgs.coreutils pkgs.systemd ];
+        path = with pkgs; [ coreutils systemd step-cli openssh  ];
         serviceConfig = {
           Type = "oneshot";
           User = "root";

modules/services/step-ca/step-ca.nix

@@ -17,6 +17,9 @@ in
         crt = "";
       };
     };
-    environment.systemPackages = with pkgs; [ step-ca step-cli ];
+    environment.systemPackages = with pkgs; [
+      step-ca
+      step-cli
+    ];
   };
 }

modules/users/john.nix

@@ -1,6 +1,10 @@
 { self, inputs, lib, ... }:
 let
   username = "john";
+  baseUserModules = self.factory.user {
+    username = username;
+    isAdmin = true;
+  };
 in
 {
   flake.meta.users."${username}" = {
@@ -8,23 +12,17 @@ in
     name = "John Lancaster";
     inherit username;
     key = "";
-    keygrip = [
-    ];
+    keygrip = [ ];
     authorizedKeys = [
       # "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIIAUa4dcg1TWc4pW++uodyhX4eOqrX/QYIxFWtEP7HFJ john@john-pc-ubuntu"
       "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIMOkGLo4N/L3RYvaIZ1FmePlxa1HK0fMciZxKtRhN58F root@janus"
     ];
   };
 
-  flake.modules = lib.mkMerge [
-    (self.factory.user {
-      username = username;
-      isAdmin = true;
-    })
-    {
-      nixos."${username}" = {
+  flake.modules = {
+    nixos."${username}" = { ... }: {
       imports = [
-          inputs.home-manager.nixosModules.home-manager
+        baseUserModules.nixos."${username}"
       ];
       users.users."${username}" = {
         openssh.authorizedKeys.keys = inputs.self.meta.users."${username}".authorizedKeys;
@@ -32,17 +30,20 @@ in
     };
 
     # This module will be imported by the user factory
-      homeManager."${username}" = with inputs.self.meta.users."${username}"; {
+    homeManager."${username}" = { pkgs, ... }:
+      with inputs.self.meta.users."${username}"; {
         home.stateVersion = "25.11";
+        imports = [
+          inputs.self.modules.homeManager.shell-tools
+          inputs.self.modules.homeManager.ssh
+          inputs.self.modules.homeManager.git
+        ];
+        # home.packages = [
+        #   inputs.self.packages.${pkgs.stdenv.hostPlatform.system}.shell-tools
+        # ];
         xdg.enable = true;
         programs.git.settings.user.name = name;
         programs.git.settings.user.email = email;
-        imports = with inputs.self.modules.homeManager; [
-          ssh
-          shell-tools
-          git
-        ];
       };
-    }
-  ];
+  };
 }