Files
homelab/flake.nix
T
darmanandClaude Opus 5.5 e95726d69c feat(mars): pass-broker approval gateway for every host
A Telegram bot has a single getUpdates consumer, so a broker per host
would split approval taps between them. mars now runs the gateway: the
bot's only poller, relaying prompts and taps for terra's and titan's
brokers over the tailnet (:8097) without ever seeing an item. Each broker
authenticates with its own pass_broker_gateway_token; mars holds only the
sha256, and the prompt is labelled with the host that token belongs to.

The bot token and chat id move to mars and are dropped from the other
hosts' sops files (terra.yaml also loses its leftover LibreChat keys and
gains protonvpn_wg_private_key, which a later commit uses). Covered by
checks.pass-broker-gateway (two nodes: labels, cancel, expiry, per-host
token isolation, gateway down); the fakes are shared with checks.pass-broker.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-21 11:34:19 +02:00

700 lines
33 KiB
Nix

{
description = "Homelab NixOS configuration";
inputs = {
nixpkgs.url = "github:NixOS/nixpkgs/nixos-26.05";
nixpkgs-unstable.url = "github:NixOS/nixpkgs/nixpkgs-unstable";
disko = {
url = "github:nix-community/disko";
inputs.nixpkgs.follows = "nixpkgs";
};
sops-nix = {
url = "github:Mic92/sops-nix";
inputs.nixpkgs.follows = "nixpkgs";
};
nixos-images = {
url = "github:nix-community/nixos-images";
inputs.nixos-stable.follows = "nixpkgs";
};
nixos-anywhere = {
url = "github:nix-community/nixos-anywhere";
inputs.nixpkgs.follows = "nixpkgs";
inputs.nixos-stable.follows = "nixpkgs"; # 26.05 already IS stable
inputs.disko.follows = "disko";
inputs.nixos-images.follows = "nixos-images";
};
home-manager = {
url = "github:nix-community/home-manager/release-26.05";
inputs.nixpkgs.follows = "nixpkgs";
};
mediamanager-nix = {
url = "github:strangeglyph/mediamanager-nix";
inputs.nixpkgs.follows = "nixpkgs";
};
# Headless CouchDB<->filesystem sync for Obsidian LiveSync
# (hosts/mars/livesync-bridge.nix); not a flake/not in nixpkgs, so plain
# source pinned by flake.lock. Pin carefully — it's a small third-party
# project with open storage->couchdb bugs, so an unreviewed bump could
# silently change how notes get written back.
livesync-bridge = {
url = "github:vrtmrz/livesync-bridge";
flake = false;
};
authentik-nix.url = "github:nix-community/authentik-nix";
nix-flatpak.url = "github:gmodena/nix-flatpak";
# Own Hyprland plugin (border + title bar), public repo over https.
# `nixpkgs.follows` is required since Hyprland plugins are ABI-locked to
# the exact Hyprland build — it must share this flake's nixpkgs, not
# whatever hypr-chrome's own lock pins standalone.
hypr-chrome = {
url = "git+https://git.mgaction.town/darman/hypr-chrome.git";
inputs.nixpkgs.follows = "nixpkgs";
};
# Tome (formerly AudibleLibrary) — darman's own .NET/Photino desktop app.
# Private repo on our own gitea, fetched over ssh with darman's ambient
# key; plain source tree (`flake = false`), see pkgs/tome.nix.
#
# NOTE: the credential-less installer-iso can't fetch this, so
# `./scripts/deploy install terra localhost` fails at nixos-install
# (post-disko) while this input is present — a known tradeoff.
tome = {
url = "git+ssh://gitea@git.mgaction.town:2222/darman/TOME.git";
flake = false;
};
# Web console for luna's Honcho (hosts/mars/honcho-console.nix); own repo
# on our gitea, ships its package + NixOS module.
honcho-console = {
url = "git+ssh://gitea@git.mgaction.town:2222/darman/honcho-console.git";
inputs.nixpkgs.follows = "nixpkgs";
};
# Turtle Beach Swarm II RE (KB7/KP7); terra uses its `release` module to
# take the KB7 out of host control after a warm reboot from Windows.
turtle-beach-swarm-re = {
url = "git+ssh://gitea@git.mgaction.town:2222/darman/turtle-beach-swarm-re.git";
inputs.nixpkgs.follows = "nixpkgs";
};
# tbctl (openbeach): KB7/KP7/Kone II Air CLI + desktop GUI on terra.
# Local checkout for now (resolved path: Nix rejects the ~/Data symlink);
# upstream is git+ssh://git@github.com/darman96/openbeach.git?ref=main.
tbctl = {
url = "git+file:///mnt/hdd_01/data/Dev/repos/openbeach";
inputs.nixpkgs.follows = "nixpkgs";
};
};
outputs = { self, nixpkgs, disko, nixos-anywhere, sops-nix, nixos-images, home-manager, mediamanager-nix, authentik-nix, ... }@inputs:
let
system = "x86_64-linux";
in
{
packages.${system} = {
# Re-exported so `./scripts/deploy` can run them as `nix run .#disko` /
# `nix run .#nixos-anywhere`, at the revision flake.lock pins. See the
# nixos-anywhere input above for why that matters.
disko = disko.packages.${system}.disko;
nixos-anywhere = nixos-anywhere.packages.${system}.nixos-anywhere;
};
nixosConfigurations = {
# Real host — install on the ZimaBlade.
# disko owns the OS-disk partitioning + filesystems (see disk-config.nix).
jupiter = nixpkgs.lib.nixosSystem {
inherit system;
specialArgs = { inherit inputs; };
modules = [
disko.nixosModules.disko
sops-nix.nixosModules.sops
home-manager.nixosModules.home-manager
./hosts/jupiter/configuration.nix
];
};
# netcup VPS — public reverse proxy + tailnet node.
neptun = nixpkgs.lib.nixosSystem {
inherit system;
specialArgs = { inherit inputs; };
modules = [
disko.nixosModules.disko
sops-nix.nixosModules.sops
home-manager.nixosModules.home-manager
./hosts/neptun/configuration.nix
];
};
# terra — Ryzen 9 5900X desktop (MSI MS-7A32). Replaces CachyOS on the
# OS SSD; Hyprland desktop + tailnet node. See hosts/terra/*.
terra = nixpkgs.lib.nixosSystem {
inherit system;
specialArgs = { inherit inputs; };
modules = [
disko.nixosModules.disko
sops-nix.nixosModules.sops
home-manager.nixosModules.home-manager
inputs.nix-flatpak.nixosModules.nix-flatpak
./hosts/terra/configuration.nix
];
};
# titan — ASUS Zenbook Pro Duo UX581 laptop; same Hyprland workstation
# as terra (profiles/workstation.nix). See hosts/titan/*.
titan = nixpkgs.lib.nixosSystem {
inherit system;
specialArgs = { inherit inputs; };
modules = [
disko.nixosModules.disko
sops-nix.nixosModules.sops
home-manager.nixosModules.home-manager
inputs.nix-flatpak.nixosModules.nix-flatpak
./hosts/titan/configuration.nix
];
};
# mars — on-site x86_64 box: Hermes Agent, plus the LAN web apps luna
# hosts herself (hosts/mars/luna-sites.nix). See hosts/mars/*.
mars = nixpkgs.lib.nixosSystem {
inherit system;
specialArgs = { inherit inputs; };
modules = [
disko.nixosModules.disko
sops-nix.nixosModules.sops
home-manager.nixosModules.home-manager
./hosts/mars/configuration.nix
];
};
# mercury — Raspberry Pi 3B+ (aarch64), DNS/DHCP; SD image via:
# nix build .#nixosConfigurations.mercury.config.system.build.sdImage
# Needs binfmt/qemu for the aarch64 build on this x86 host (or a remote aarch64 builder).
mercury = nixpkgs.lib.nixosSystem {
system = "aarch64-linux";
specialArgs = { inherit inputs; };
modules = [
(nixpkgs + "/nixos/modules/installer/sd-card/sd-image-aarch64.nix")
sops-nix.nixosModules.sops
home-manager.nixosModules.home-manager
./hosts/mercury/configuration.nix
];
};
# x86_64 QEMU VM to runtime-test mercury's DNS/DHCP stack (pihole +
# unbound) before flashing the aarch64 SD. Build + run:
# nix build .#nixosConfigurations.mercury-vm.config.system.build.vm
# ./result/bin/run-mercury-vm-vm
mercury-vm = nixpkgs.lib.nixosSystem {
inherit system; # x86_64-linux, fast to build/boot with KVM
modules = [
(nixpkgs + "/nixos/modules/virtualisation/qemu-vm.nix")
home-manager.nixosModules.home-manager
./common.nix
./services/network/unbound.nix
./services/network/pihole.nix
({ lib, ... }: {
networking.hostName = "mercury-vm";
networking.nameservers = [ "1.1.1.1" "9.9.9.9" ]; # host resolver (not pihole)
users.users.darman.initialPassword = "test";
users.users.root.initialPassword = "test";
services.openssh.settings.PasswordAuthentication = lib.mkForce true;
virtualisation.graphics = false;
virtualisation.memorySize = 2048;
virtualisation.forwardPorts = [
{ from = "host"; host.port = 2223; guest.port = 22; }
{ from = "host"; host.port = 8081; guest.port = 80; }
];
system.stateVersion = "26.05";
})
];
};
# VirtualBox test image. Build the OVA with:
# nix build .#nixosConfigurations.jupiter-vbox.config.system.build.virtualBoxOVA
# NOTE: no disko here — the virtualbox-image module supplies the disk.
jupiter-vbox = nixpkgs.lib.nixosSystem {
inherit system;
specialArgs = { inherit inputs; };
modules = [
home-manager.nixosModules.home-manager
./hosts/jupiter/vm.nix
];
};
# Custom kexec installer with our SSH key baked in, for headless install
# onto a box with a read-only root (ZimaOS) where nixos-anywhere can't
# ssh-copy-id. Build the tarball:
# nix build .#nixosConfigurations.kexec.config.system.build.kexecInstallerTarball
# then scp it to the target's writable /tmp and run kexec/run (see README).
kexec = nixpkgs.lib.nixosSystem {
inherit system;
modules = [
nixos-images.nixosModules.kexec-installer
({ ... }: {
users.users.root.openssh.authorizedKeys.keys = [
"ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAILD5K6AQ0wYYHbNGzC4PyunUQsXbaD0iu1eaadLtv+Xp darman@terra"
];
})
];
};
# Bootable USB recovery installer with our SSH key + sshd + DHCP; clones
# the public homelab repo fresh at every boot to /root/homelab, so the
# same stick stays current without a rebuild. Reusable for any host's
# manual-USB install path.
# Build: nix build .#nixosConfigurations.installer-iso.config.system.build.isoImage,
# dd to USB, boot the target, ssh in, ./scripts/deploy install ...
installer-iso = nixpkgs.lib.nixosSystem {
inherit system;
modules = [
(nixpkgs + "/nixos/modules/installer/cd-dvd/installation-cd-minimal.nix")
({ pkgs, lib, ... }: {
services.openssh.enable = true;
services.openssh.settings.PermitRootLogin = "prohibit-password";
users.users.root.openssh.authorizedKeys.keys = [
"ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAILD5K6AQ0wYYHbNGzC4PyunUQsXbaD0iu1eaadLtv+Xp darman@terra"
];
networking.hostName = "homelab-installer";
console.keyMap = "de"; # matches common.nix's real hosts
environment.systemPackages = [ pkgs.git ];
# The systemd initrd (default since 26.05) has no findiso= path — only
# the legacy script stage-1 does — so this install method needs it off.
boot.initrd.systemd.enable = false;
# installation-cd-minimal ships with experimental-features unset;
# without this, both `nix run .#disko` and `nixos-install --flake`
# die with "experimental Nix feature 'nix-command' is disabled".
nix.settings.experimental-features = [ "nix-command" "flakes" ];
# Fresh clone of the public repo (no credentials baked in) so
# scripts/deploy's require_tracked() sees a real checkout; retry
# with `systemctl restart homelab-checkout` if DHCP wasn't up yet.
systemd.services.homelab-checkout = {
description = "Clone the homelab repo to /root/homelab";
after = [ "network-online.target" ];
wants = [ "network-online.target" ];
wantedBy = [ "multi-user.target" ];
path = [ pkgs.git ];
serviceConfig = {
Type = "oneshot";
RemainAfterExit = true;
};
script = ''
rm -rf /root/homelab
git clone --depth 1 https://git.mgaction.town/darman/homelab.git /root/homelab
'';
};
# Completes an unattended local_install_prepare_and_reboot() run:
# re-runs `./scripts/deploy install <config> localhost`, now genuinely
# inside the installer so it takes the disko+nixos-install branch.
# No-op if homelab.install= isn't on the kernel cmdline.
systemd.services.homelab-auto-install = {
description = "Auto-run the homelab install if homelab.install= was passed on the kernel cmdline";
after = [ "homelab-checkout.service" ];
requires = [ "homelab-checkout.service" ];
wantedBy = [ "multi-user.target" ];
serviceConfig.Type = "oneshot";
# Needs the full system PATH: scripts/deploy execs bash then shells
# out to nix/nixos-install/git/sudo/efibootmgr, none of which a
# restricted `path = [...]` PATH provides. mkForce overrides NixOS's
# default PATH derivation from `path`.
#
# HOME too: systemd sets no $HOME without User= (SetLoginEnvironment=
# defaults false), and scripts/deploy runs under `set -u`, so a
# missing $HOME aborted with a confusing "unbound variable".
environment = {
HOME = "/root";
PATH = lib.mkForce "/run/current-system/sw/bin:/run/wrappers/bin";
};
script = ''
cfg=$(grep -o 'homelab\.install=[^ ]*' /proc/cmdline | cut -d= -f2 || true)
if [ -z "$cfg" ]; then
echo "no homelab.install= on the kernel cmdline — nothing to auto-install"
exit 0
fi
# Persist this run to a file that outlives the install: the journal
# dies with the reboot and disko wipes the OS disk before a failure
# can be read back. homelab.logpart= points at the staging partition
# (survives the wipe); every step here is best-effort so logging
# itself can't break an install.
logfile=""
logpart=$(grep -o 'homelab\.logpart=[^ ]*' /proc/cmdline | cut -d= -f2 || true)
if [ -n "$logpart" ]; then
dev="/dev/disk/by-partuuid/$logpart"
logdir=""
mkdir -p /run/homelab-log
if mount -o rw "$dev" /run/homelab-log 2>/dev/null; then
logdir=/run/homelab-log
elif where=$(findmnt -fno TARGET "$dev" 2>/dev/null) && [ -n "$where" ]; then
# stage-1's findiso already has this partition mounted (how it
# reached the iso) — reuse that mount instead of a second one.
mount -o remount,rw "$where" 2>/dev/null || true
logdir="$where"
fi
if [ -n "$logdir" ]; then
# Next to the iso: findiso= is its path on this partition.
iso=$(grep -o 'findiso=[^ ]*' /proc/cmdline | cut -d= -f2 || true)
dest="$logdir/$(dirname "$iso" 2>/dev/null || echo /)"
if mkdir -p "$dest" 2>/dev/null; then
logfile="$dest/homelab-install-$cfg.log"
else
logfile="$logdir/homelab-install-$cfg.log"
fi
echo "logging this install to $logfile (on the staging disk — survives the wipe)"
else
echo "warning: could not mount PARTUUID=$logpart to log to — continuing without a persistent log" >&2
fi
fi
do_install() {
# The host key (so sops can decrypt on first boot) can't live in
# this public-repo ISO; local_install_prepare_and_reboot() drops it
# on the boot partition instead and passes that PARTUUID here — the
# copy dies with disko's wipe minutes later.
keypart=$(grep -o 'homelab\.keypart=[^ ]*' /proc/cmdline | cut -d= -f2 || true)
if [ -n "$keypart" ]; then
mkdir -p /run/homelab-key
if mount -o ro "/dev/disk/by-partuuid/$keypart" /run/homelab-key; then
src=/run/homelab-key/homelab-installer
if [ -f "$src/ssh_host_ed25519_key" ]; then
echo "picking up $cfg's host key from PARTUUID=$keypart"
install -Dm600 "$src/ssh_host_ed25519_key" \
"/root/.config/homelab/$cfg/ssh_host_ed25519_key"
install -Dm644 "$src/ssh_host_ed25519_key.pub" \
"/root/.config/homelab/$cfg/ssh_host_ed25519_key.pub"
else
echo "warning: no host key at $src — the install will refuse" >&2
fi
umount /run/homelab-key
else
echo "warning: could not mount PARTUUID=$keypart for the host key" >&2
fi
fi
# On bootloaders with no one-shot (Limine on terra), scripts/deploy
# got here via a temporary UEFI entry + BootNext (arm_efi_bootnext);
# BootNext is spent but the entry would linger pointing at a
# partition disko is about to wipe, so remove it now.
for n in $(efibootmgr 2>/dev/null \
| sed -n 's/^Boot\([0-9A-Fa-f]\{4\}\)\*\?[[:space:]]Homelab Installer[[:space:]].*/\1/p'); do
echo "removing temporary UEFI entry Boot$n"
efibootmgr -q -B -b "$n" || true
done
echo "auto-installing $cfg (homelab.install= on the kernel cmdline)"
cd /root/homelab
./scripts/deploy install "$cfg" localhost --yes
}
# tee, not exec: we need the exit status back to sync the log
# to the platter before the box possibly drops to a shell.
if [ -n "$logfile" ]; then
{ echo "=== homelab auto-install: $cfg ($(date -u 2>/dev/null || true)) ==="; do_install; } 2>&1 | tee -a "$logfile"
status=''${PIPESTATUS[0]}
else
do_install
status=$?
fi
sync 2>/dev/null || true
exit "$status"
'';
};
})
];
};
};
# VM test for `./scripts/deploy kexec-local` (nix build .#checks.x86_64-linux.kexec-local -L)
# — the one command that can't be rehearsed on real hardware since it jumps
# the machine you're on. Regression-tests kexec-run.sh's backgrounded
# `sleep 6 && kexec -e`: cleaning up the staging dir on exit would delete
# the jump binary and the box would silently stay on the old kernel.
checks.${system} = {
kexec-local =
let
pkgs = nixpkgs.legacyPackages.${system};
tarball = self.nixosConfigurations.kexec.config.system.build.kexecInstallerTarball;
sshKey = nixos-images + "/nix/kexec-installer/ssh-keys/id_ed25519";
in
pkgs.testers.runNixOSTest {
name = "deploy-kexec-local";
nodes.machine = { modulesPath, ... }: {
imports = [ (modulesPath + "/profiles/minimal.nix") ];
virtualisation.vlans = [ ];
# kexec-local refuses to run if RAM < 3x the installer image, and
# the staging dir needs ~3x the tarball on /var/tmp.
virtualisation.memorySize = 4 * 1024;
virtualisation.diskSize = 12 * 1024;
virtualisation.forwardPorts = [{ host.port = 2222; guest.port = 22; }];
services.openssh.enable = true;
users.users.root.openssh.authorizedKeys.keyFiles = [ "${sshKey}.pub" ];
# Everything the script shells out to, minus nix — the test uses the
# HOMELAB_KEXEC_* hook so no build happens inside the VM.
environment.systemPackages = with pkgs; [
bash gnutar coreutils findutils util-linux cpio gzip
];
system.extraDependencies = [ tarball pkgs.cpio pkgs.gzip ];
environment.etc."deploy".source = ./scripts/deploy;
};
testScript = /* python */ ''
import os, shutil, subprocess, tempfile, time
start_all()
machine.wait_for_unit("sshd.service")
# ssh refuses a private key that is group/world readable, and nix
# store paths are 0444 — copy it out and tighten the mode.
keydir = tempfile.mkdtemp()
key = os.path.join(keydir, "id_ed25519")
shutil.copyfile("${sshKey}", key)
os.chmod(key, 0o600)
def ssh(cmd, check=True, stdout=None):
return subprocess.run(
[ "${pkgs.openssh}/bin/ssh",
"-o", "StrictHostKeyChecking=no",
"-o", "UserKnownHostsFile=/dev/null",
"-o", "ConnectTimeout=1",
"-i", key,
"-p", "2222", "root@127.0.0.1", "--" ] + cmd,
text=True, check=check, stdout=stdout)
machine.succeed("install -Dm755 /etc/deploy /root/deploy")
# systemd-run starts units with a bare PATH lacking
# /run/current-system/sw/bin, so bash (and tar/findmnt/nohup)
# can't resolve — set it explicitly.
env = (
" --setenv=PATH=/run/wrappers/bin:/run/current-system/sw/bin"
" --setenv=HOMELAB_KEXEC_TARBALL=${tarball}/nixos-kexec-installer-${system}.tar.gz"
" --setenv=HOMELAB_KEXEC_CPIO=${pkgs.cpio}/bin/cpio"
" --setenv=HOMELAB_KEXEC_GZIP=${pkgs.gzip}/bin/gzip"
)
# Same values for the foreground (non-systemd-run) invocation below.
envsh = (
"HOMELAB_KEXEC_TARBALL=${tarball}/nixos-kexec-installer-${system}.tar.gz"
" HOMELAB_KEXEC_CPIO=${pkgs.cpio}/bin/cpio"
" HOMELAB_KEXEC_GZIP=${pkgs.gzip}/bin/gzip"
)
# Marker on a tmpfs: it must NOT survive the jump, proving we really
# booted a new kernel rather than just restarting a service.
machine.succeed("touch /run/pre-kexec-marker")
host_key_before = machine.succeed("cat /etc/ssh/ssh_host_ed25519_key.pub").strip()
while ssh(["true"], check=False).returncode != 0:
time.sleep(1)
# Refuses without --yes when stdin isn't a tty; needs the same env to
# reach the confirmation prompt, else it dies early on the nix build
# and proves nothing.
out = machine.fail(f"{envsh} /root/deploy kexec-local </dev/null 2>&1")
assert "using prebuilt kexec installer" in out, \
f"never reached the prompt, so the refusal proves nothing:\n{out}"
# systemd-run so the call returns immediately: the script stays
# alive ~60s on purpose, outliving kexec-run.sh's `sleep 6`.
machine.succeed(f"systemd-run --collect --unit=kexec-local{env} /root/deploy kexec-local --yes")
print("waiting for the jump...")
deadline = time.time() + 300
while ssh(["true"], check=False).returncode == 0:
# Surface a dead unit immediately instead of stalling until the
# deadline and blaming "never left the old kernel".
st = ssh(["systemctl", "is-active", "kexec-local"],
check=False, stdout=subprocess.PIPE).stdout or ""
if st.strip() in ("failed", "inactive"):
# NB: not `log` — the driver already binds that name to its
# AbstractLogger and the type check rejects the shadowing.
unit_log = ssh(["journalctl", "-u", "kexec-local", "--no-pager"],
check=False, stdout=subprocess.PIPE).stdout or ""
raise AssertionError(
f"kexec-local.service ended ({st.strip()}) without jumping:\n{unit_log}")
assert time.time() < deadline, "machine never left the old kernel"
time.sleep(1)
print("waiting for the installer...")
deadline = time.time() + 300
while ssh(["true"], check=False).returncode != 0:
assert time.time() < deadline, "installer never came up"
time.sleep(1)
# It really is the RAM installer, not the old system.
host = ssh(["hostname"], stdout=subprocess.PIPE).stdout.strip()
assert host == "nixos-installer", f"hostname is {host}, not nixos-installer"
assert ssh(["ls", "/run/pre-kexec-marker"], check=False).returncode != 0, \
"old /run survived — this was not a fresh kernel"
# The host key is carried across (kexec-run.sh copies /etc/ssh into
# the appended initrd), which is why `kexec` does no ssh-keygen -R.
host_key_after = ssh(
["cat", "/etc/ssh/ssh_host_ed25519_key.pub"], stdout=subprocess.PIPE
).stdout.strip()
assert host_key_before == host_key_after, \
f"host key changed: {host_key_before} != {host_key_after}"
machine.crash()
'';
};
# VM test for hosts/mars/luna-sites.nix (header of luna-sites-test.nix):
# nix build .#checks.x86_64-linux.luna-sites -L
luna-sites = import ./hosts/mars/luna-sites-test.nix {
pkgs = nixpkgs.legacyPackages.${system};
};
# VM test for services/identity/pass-broker.nix, with fake pass-cli
# and Telegram: nix build .#checks.x86_64-linux.pass-broker -L
pass-broker = import ./services/identity/pass-broker-test.nix {
pkgs = nixpkgs.legacyPackages.${system};
};
# Two-node test of the approval gateway (mars) with a broker using it:
# nix build .#checks.x86_64-linux.pass-broker-gateway -L
pass-broker-gateway = import ./services/identity/pass-broker-gateway-test.nix {
pkgs = nixpkgs.legacyPackages.${system};
};
};
# `nix develop` — hot-reload loop for dotfiles/quickshell.
#
# home/desktop/default.nix ships the shell as a store copy (`xdg.configFile`),
# which only hot-reloads its own frozen files; pointing at the working
# tree with `qs -p` restores edit-save-see without a rebuild.
#
# quickshell keys instance identity on the config path, so the
# working-tree and store-backed shells are different instances that
# would both claim every output — hence a swap, not a second instance.
# The swap starts dev first and only kills the packaged shell once dev
# is confirmed up, so a QML error leaves you on your normal bar.
#
# Every kill is scoped to one config (`qs kill` = default, `qs kill -p
# <path>` = that path) since a blanket kill would also take out
# unrelated instances like pkgs/rishot.nix.
#
# Deliberately not wired to direnv: programs.direnv is enabled for this
# user, so a `use flake` would swap the desktop shell on every `cd`
# into the checkout, including over ssh.
devShells.${system}.default =
let
pkgs = nixpkgs.legacyPackages.${system};
# Same nixpkgs terra's home.nix takes pkgs.quickshell from, so the dev
# instance is the identical build to the packaged one.
qs = "${nixpkgs.legacyPackages.${system}.quickshell}/bin/qs";
git = "${nixpkgs.legacyPackages.${system}.git}/bin/git";
grep = "${nixpkgs.legacyPackages.${system}.gnugrep}/bin/grep";
# Resolved at RUN time, not build time: the entire point is to run the
# working tree, and `self` here is only a store snapshot of it.
preamble = ''
root="$(${git} rev-parse --show-toplevel 2>/dev/null || pwd)"
cfg="$root/dotfiles/quickshell"
if [ ! -f "$cfg/shell.qml" ]; then
echo "no shell.qml under $cfg — run this from the homelab checkout" >&2
exit 1
fi
# `qs list` exits 0 whether or not it found anything, and only emits
# json when it did — so "json came back" is the liveness test.
running() { ${qs} list -p "$1" -j 2>/dev/null | grep -q '"id"'; }
prod_running() { ${qs} list -j 2>/dev/null | grep -q '"id"'; }
'';
qs-dev = pkgs.writeShellScriptBin "qs-dev" ''
set -uo pipefail
${preamble}
if [ -z "''${WAYLAND_DISPLAY:-}" ]; then
echo "qs-dev: no WAYLAND_DISPLAY — refusing to swap the desktop shell" >&2
exit 1
fi
if running "$cfg"; then
echo "qs-dev: already running from $cfg"
exit 0
fi
${qs} -d -p "$cfg"
# Confirm it came up before touching the packaged shell.
for _ in $(seq 1 50); do
running "$cfg" && break
sleep 0.1
done
if ! running "$cfg"; then
echo "qs-dev: dev shell failed to start — packaged shell left alone" >&2
echo "qs-dev: run 'qs -p $cfg' in the foreground to see the QML error" >&2
exit 1
fi
${qs} kill || true
echo "qs-dev: live on $cfg — edits there now hot-reload"
'';
# qs log -f prints everything the instance logs; WARN/ERROR are what
# mean something is actually wrong with the QML (a binding loop or
# failed binding is a WARN, easy to miss in the reload chatter).
qs-log = pkgs.writeShellScriptBin "qs-log" ''
set -uo pipefail
${preamble}
filter='WARN|ERROR'
case "''${1:-}" in
-a|--all) filter='.' ;;
esac
# -t 1: `qs log -f` otherwise replays the whole backlog on shell entry.
# It also ends when the attached instance exits, and the dev shell
# outlives individual instances (a QML error kills one, qs-dev starts
# another) — so re-attach in a loop instead of going quiet for the session.
while :; do
if running "$cfg"; then
${qs} log -p "$cfg" -t 1 -f 2>/dev/null | ${grep} --line-buffered -E "$filter" >&2
fi
sleep 1
done
'';
qs-prod = pkgs.writeShellScriptBin "qs-prod" ''
set -uo pipefail
${preamble}
running "$cfg" && ${qs} kill -p "$cfg" || true
prod_running || ${qs} -d
echo "qs-prod: back on ~/.config/quickshell"
'';
in
pkgs.mkShell {
packages = [ pkgs.quickshell qs-dev qs-prod qs-log ];
# Swap on entry, swap back on exit. Three guards:
# - interactive only ($- has i). `nix develop --command X` EXECs X,
# replacing the shell that set the trap, so the restore would
# never run and you'd be left on the dev instance. Non-interactive
# use gets the explicit `nix develop -c qs-dev` instead.
# - WAYLAND_DISPLAY, so entering the shell over ssh cannot kill the
# desktop's bar and leave nothing in its place.
# - a sentinel, so a nested `nix develop` does not swap (and then
# restore) a second time.
shellHook = ''
if [[ $- == *i* ]] && [ -n "''${WAYLAND_DISPLAY:-}" ] && [ -z "''${HOMELAB_QS_DEV:-}" ]; then
export HOMELAB_QS_DEV=1
if qs-dev; then
# Stream the dev instance's warnings and errors into this
# terminal, and take the follower down with the shell.
qs-log & HOMELAB_QS_LOG=$!
trap 'kill "$HOMELAB_QS_LOG" 2>/dev/null; qs-prod' EXIT
fi
fi
echo "homelab devshell — qs-dev (working tree) / qs-prod (packaged); exit restores"
echo "homelab devshell — quickshell WARN/ERROR stream here; qs-log -a for everything"
'';
};
};
}