WIP: mootube: init at 2022-08-28

.sops.yaml

@@ -3,7 +3,6 @@ keys:
   - &user_lappy_colin age1j2pqnl8j0krdzk6npe93s4nnqrzwx978qrc0u570gzlamqpnje9sc8le2g
   - &user_servo_colin age1z8fauff34cdecr6sjkre260luzxcca05kpcwvhx988d306tpcejsp63znu
   - &user_moby_colin age1zsrsvd7j6l62fjxpfd2qnhqlk8wk4p8r0dtxpe4sdgnh2474095qdu7xj9
-  - &host_crappy age1hl50ufuxnqy0jnk8fqeu4tclh4vte2xn2d59pxff0gun20vsmv5sp78chj
   - &host_desko age1vnw7lnfpdpjn62l3u5nyv5xt2c965k96p98kc43mcnyzpetrts9q54mc9v
   - &host_lappy age1w7mectcjku6x3sd8plm8wkn2qfrhv9n6zhzlf329e2r2uycgke8qkf9dyn
   - &host_servo age1tzlyex2z6t88tg9h82943e39shxhmqeyr7ywhlwpdjmyqsndv3qq27x0rf
@@ -16,7 +15,6 @@ creation_rules:
       - *user_lappy_colin
       - *user_servo_colin
       - *user_moby_colin
-      - *host_crappy
       - *host_desko
       - *host_lappy
       - *host_servo

README.md

@@ -1,9 +1,3 @@
-![hello](doc/hello.gif)
-
-# .❄️≡We|_c0m3 7o m`/ f14k≡❄️.
-
-(er, it's not a flake anymore. welcome to my nix files.)
-
 ## What's Here
 
 this is the top-level repo from which i configure/deploy all my NixOS machines:
@@ -12,60 +6,66 @@ this is the top-level repo from which i configure/deploy all my NixOS machines:
 - server
 - mobile phone (Pinephone)
 
-everything outside of [hosts/](./hosts/) and [secrets/](./secrets/) is intended for export, to be importable for use by 3rd parties.
+everything outside of <./hosts/> and <./secrets/> is intended for export, to be importable for use by 3rd parties.
 the only hard dependency for my exported pkgs/modules should be [nixpkgs][nixpkgs].
-building [hosts/](./hosts/) will require [sops][sops].
+building <./hosts/> will require [sops][sops].
 
 you might specifically be interested in these files (elaborated further in #key-points-of-interest):
-- [my packages](./pkgs/by-name)
+- [`sxmo-utils`](./pkgs/additional/sxmo-utils/default.nix)
+  - [example SXMO deployment](./hosts/modules/gui/sxmo/default.nix)
 - [my implementation of impermanence](./modules/persist/default.nix)
 - my way of deploying dotfiles/configuring programs per-user:
-  - [modules/fs/](./modules/fs/default.nix)
-  - [modules/programs/](./modules/programs/default.nix)
-  - [modules/users/](./modules/users/default.nix)
-
-if you find anything here genuinely useful, message me so that i can work to upstream it!
+  - <./modules/fs/default.nix>
+  - <./modules/programs.nix>
+  - <./modules/users.nix>
 
 [nixpkgs]: https://github.com/NixOS/nixpkgs
 [sops]: https://github.com/Mic92/sops-nix
 [uninsane-org]: https://uninsane.org
 
-
 ## Using This Repo In Your Own Config
 
-follow the instructions [here][NUR] to access my packages through the Nix User Repositories.
+this should be a pretty "standard" flake. just reference it, and import either
+- `nixosModules.sane` (for the modules)
+- `overlays.pkgs` (for the packages)
+
+or follow the instructions [here][NUR] to use it via the Nix User Repositories.
 
 [NUR]: https://nur.nix-community.org/
 
-
 ## Layout
 - `doc/`
-  - instructions for tasks i find myself doing semi-occasionally in this repo.
+    - instructions for tasks i find myself doing semi-occasionally in this repo.
 - `hosts/`
-  - configs which aren't factored with external use in mind.
-  - that is, if you were to add this repo to a flake.nix for your own use,
-    you won't likely be depending on anything in this directory.
+    - the bulk of config which isn't factored with external use in mind.
+    - that is, if you were to add this repo to a flake.nix for your own use,
+      you won't likely be depending on anything in this directory.
 - `integrations/`
-  - code intended for consumption by external tools (e.g. the Nix User Repos).
+    - code intended for consumption by external tools (e.g. the Nix User Repos)
 - `modules/`
-  - config which is gated behind `enable` flags, in similar style to nixpkgs' `nixos/` directory.
-  - if you depend on this repo for anything besides packages, it's most likely for something in this directory.
+    - config which is gated behind `enable` flags, in similar style to nixpkgs'
+      `nixos/` directory.
+    - if you depend on this repo, it's most likely for something in this directory.
+- `nixpatches/`
+    - literally, diffs i apply atop upstream nixpkgs before performing further eval.
 - `overlays/`
-  - predominantly a list of `callPackage` directives.
+    - exposed via the `overlays` output in `flake.nix`.
+    - predominantly a list of `callPackage` directives.
 - `pkgs/`
-  - derivations for things not yet packaged in nixpkgs.
-  - derivations for things from nixpkgs which i need to `override` for some reason.
-  - inline code for wholly custom packages (e.g. `pkgs/by-name/sane-scripts/` for CLI tools
-    that are highly specific to my setup).
+    - derivations for things not yet packaged in nixpkgs.
+    - derivations for things from nixpkgs which i need to `override` for some reason.
+    - inline code for wholly custom packages (e.g. `pkgs/additional/sane-scripts/` for CLI tools
+      that are highly specific to my setup).
 - `scripts/`
-  - scripts which aren't reachable on a deployed system, but may aid manual deployments.
+    - scripts which aren't reachable on a deployed system, but may aid manual deployments
 - `secrets/`
-  - encrypted keys, API tokens, anything which one or more of my machines needs
-    read access to but shouldn't be world-readable.
-  - not much to see here.
+    - encrypted keys, API tokens, anything which one or more of my machines needs
+      read access to but shouldn't be world-readable.
+    - not much to see here
 - `templates/`
-  - used to instantiate short-lived environments.
-  - used to auto-fill the boiler-plate portions of new packages.
+    - exposed via the `templates` output in `flake.nix`.
+    - used to instantiate short-lived environments.
+    - used to auto-fill the boiler-plate portions of new packages.
 
 
 ## Key Points of Interest
@@ -73,49 +73,47 @@ follow the instructions [here][NUR] to access my packages through the Nix User R
 i.e. you might find value in using these in your own config:
 
 - `modules/fs/`
-  - use this to statically define leafs and nodes anywhere in the filesystem,
-    not just inside `/nix/store`.
-  - e.g. specify that `/var/www` should be:
-    - owned by a specific user/group
-    - set to a specific mode
-    - symlinked to some other path
-    - populated with some statically-defined data
-    - populated according to some script
-    - created as a dependency of some service (e.g. `nginx`)
-  - this is akin to using [Home Manager's][home-manager] file API -- the part which lets you
-    statically define `~/.config` files -- just with a different philosophy.
-    namely, it avoids any custom activation scripts by leveraging `systemd-tmpfiles`.
+    - use this to statically define leafs and nodes anywhere in the filesystem,
+      not just inside `/nix/store`.
+    - e.g. specify that `/var/www` should be:
+        - owned by a specific user/group
+        - set to a specific mode
+        - symlinked to some other path
+        - populated with some statically-defined data
+        - populated according to some script
+        - created as a dependency of some service (e.g. `nginx`)
+    - values defined here are applied neither at evaluation time _nor_ at activation time.
+        - rather, they become systemd services.
+        - systemd manages dependencies
+        - e.g. link `/var/www -> /mnt/my-drive/www` only _after_ `/mnt/my-drive/www` appears)
+    - this is akin to using [Home Manager's][home-manager] file API -- the part which lets you
+      statically define `~/.config` files -- just with a different philosophy.
 - `modules/persist/`
-  - my implementation of impermanence, built atop the above `fs` module, with a few notable features:
-    - no custom activation scripts or services (uses `systemd-tmpfiles` and `.mount` units)
-    - "persist" cache directories -- to free up RAM -- but auto-wipe them on mount
-      and encrypt them to ephemeral keys so they're unreadable post shutdown/unmount.
-    - persist to encrypted storage which is unlocked at login time.
-- `modules/programs/`
-  - like nixpkgs' `programs` options, but allows both system-wide or per-user deployment.
-  - allows `fs` and `persist` config values to be gated behind program deployment:
-    - e.g. `/home/<user>/.mozilla/firefox` is persisted only for users who
-      `sane.programs.firefox.enableFor.user."<user>" = true;`
-  - allows aggressive sandboxing any program:
-    - `sane.programs.firefox.sandbox.enable = true;  # wraps the program so that it isolates itself into a new namespace when invoked`
-    - `sane.programs.firefox.sandbox.whitelistWayland = true;  # allow it to render a wayland window`
-    - `sane.programs.firefox.sandbox.extraHomePaths = [ "Downloads" ];  # allow it read/write access to ~/Downloads`
-    - integrated with `fs` and `persist` modules so that programs' config files and persisted data stores are linked into the sandbox w/o any extra involvement.
-- `modules/users/`
-  - convenience layer atop the above modules so that you can just write
-    `fs.".config/git"` instead of `fs."/home/colin/.config/git"`
-  - simplified `systemd.services` API
+    - my alternative to the Impermanence module.
+    - this builds atop `modules/fs/` to achieve things stock impermanence can't:
+        - persist things to encrypted storage which is unlocked at login time (pam_mount).
+        - "persist" cache directories -- to free up RAM -- but auto-wipe them on mount
+          and encrypt them to ephemeral keys so they're unreadable post shutdown/unmount.
+- `modules/programs.nix`
+    - like nixpkgs' `programs` options, but allows both system-wide or per-user deployment.
+    - allows `fs` and `persist` config values to be gated behind program deployment:
+        - e.g. `/home/<user>/.mozilla/firefox` is persisted only for users who
+          `sane.programs.firefox.enableFor.user."<user>" = true;`
+- `modules/users.nix`
+    - convenience layer atop the above modules so that you can just write
+      `fs.".config/git"` instead of `fs."/home/colin/.config/git"`
+
+some things in here could easily find broader use. if you would find benefit in
+them being factored out of my config, message me and we could work to make that happen.
 
 [home-manager]: https://github.com/nix-community/home-manager
 
-
 ## Mirrors
 
 this repo exists in a few known locations:
 - primary: <https://git.uninsane.org/colin/nix-files>
 - mirror: <https://github.com/nix-community/nur-combined/tree/master/repos/colinsane>
 
-
 ## Contact
 
 if you want to contact me for questions, or collaborate to split something useful into a shared repo, etc,

TODO.md

@@ -1,168 +1,133 @@
 ## BUGS
-- alacritty Ctrl+N frequently fails to `cd` to the previous directory
-- bunpen dbus sandboxing can't be *nested* (likely a problem in xdg-dbus-proxy)
-- dissent has a memory leak (3G+ after 24hr)
-  - set a max memory use in the systemd service, to force it to restart as it leaks?
-- `rmDbusServices` may break sandboxing
-  - e.g. if the package ships a systemd unit which references $out, then make-sandboxed won't properly update that unit.
-  - `rmDbusServicesInPlace` is not affected
-- mpv: audiocast has mpv sending its output to the builtin speakers unless manually changed
-- syshud (volume overlay): when casting with `blast`, syshud doesn't react to volume changes
-- dissent: if i launch it without net connectivity, it gets stuck at the login, and never tries again
-- newsflash on moby can't play videos
-  - "open in browser" works though -- in mpv
-- gnome-maps can't use geoclue *and* openstreetmap at the same time
-  - get gnome-maps to speak xdg-desktop-portal, and this will be fixed
-- epiphany can't save cookies
-  - see under "preferences", cookies are disabled
-  - prevents logging into websites (OpenStreetMap)
-  - works when sandbox is disabled
-- rsync to ssh target fails because of restrictive sandboxing
-- `/mnt/.servo_ftp` retries every 10s, endlessly, rather than doing a linear backoff
-  - repro by `systemctl stop sftpgo` on servo, then watching `mnt-.servo_ftp.{mount,timer}` on desko
+- ringer (i.e. dino incoming call) doesn't prevent moby from sleeping
+- Fractal opens links with non-preferred web browser
+- `nix` operations from lappy hang when `desko` is unreachable
+  - could at least direct the cache to `http://desko-hn:5001`
+- waybar isn't visible on moby until after `swaymsg reload`
 
 ## REFACTORING:
-- fold hosts/modules/ into toplevel modules/
-- add import checks to my Python nix-shell scripts
-- consolidate ~/dev and ~/ref
-  - ~/dev becomes a link to ~/ref/cat/mine
+
 - fold hosts/common/home/ssh.nix -> hosts/common/users/colin.nix
-- don't hardcode IP addresses so much in servo
 
 ### sops/secrets
-- user secrets could just use `gocryptfs`, like with ~/private?
-  - can gocryptfs support nested filesystems, each with different perms (for desko, moby, etc)?
+- attach secrets to the thing they're used by (sane.programs)
+- rework secrets to leverage `sane.fs`
+- remove sops activation script as it's covered by my systemd sane.fs impl
+
+### roles
+- allow any host to take the role of `uninsane.org`
+  - will make it easier to test new services?
 
 ### upstreaming
-- upstream blueprint-compiler cross fixes -> nixpkgs
-- upstream cargo cross fixes -> nixpkgs
-- upstream `gps-share` package -> nixpkgs
+- split out a sxmo module usable by NUR consumers
+- bump nodejs version in lemmy-ui
+- add updateScripts to all my packages in nixpkgs
+- fix lightdm-mobile-greeter for newer libhandy
+- port zecwallet-lite to a from-source build
+- REVIEW/integrate jellyfin dataDir config: <https://github.com/NixOS/nixpkgs/pull/233617>
 
 #### upstreaming to non-nixpkgs repos
-- gnome-calls: retry net connection when DNS is down
 - gtk: build schemas even on cross compilation: <https://github.com/NixOS/nixpkgs/pull/247844>
-- linux: upstream PinePhonePro device trees
-- nwg-panel: configurable media controls
-- nwg-panel / playerctl hang fix (i think nwg-panel is what should be patched here)
+- sxmo: add new app entries
 
 
 ## IMPROVEMENTS:
-- sane-deadlines: show day of the week for upcoming items
-- curlftpfs: replace with something better
-  - safer (rust? actively maintained? sandboxable?)
-  - handles spaces/symbols in filenames
-  - has better multi-stream perf (e.g. `sane-sync-music` should be able to copy N items in parallel)
-- firefox: open *all* links (http, https, ...) with system handler
-  - removes the need for open-in-mpv, firefox-xdg-open, etc.
-  - matrix room links *just work*.
-  - `network.protocol-handler.external.https = true` in about:config *seems* to do this,
-    but breaks some webpages (e.g. Pleroma)
-- associate http(s)://*.pdf with my pdf handler
-  - can't do that because lots of applications don't handle URIs
-  - could workaround using a wrapper that downloads the file and then passes it to the program
-- geary: replace with envelope
-  - likely requires updating envelope to a more recent version (for multi-accounting), and therefore updating libadwaita...
-
 ### security/resilience
-- enable `snapper` btrfs snapshots (`services.snapper`)
-- /mnt/desko/home, etc, shouldn't include secrets (~/private)
-  - 95% of its use is for remote media access and stuff which isn't in VCS (~/records)
-- harden systemd services:
-  - servo: `coturn.service`
-  - servo: `postgresql.service`
-  - servo: `postfix.service`
-  - servo: `prosody.service`
-  - servo: `slskd.service`
-  - desko: `usbmuxd.service`
-  - servo: `backup-torrents.service`
-  - servo: `dedupe-media.service`
-  - remove SGID /run/wrappers/bin/sendmail, and just add senders to `postdrop` group
-- port all sane.programs to be sandboxed
-  - sandbox `nix`
-  - enforce that all `environment.packages` has a sandbox profile (or explicitly opts out)
-  - enforce granular dbus sandboxing (bunpen-dbus-*)
-- make gnome-keyring-daemon less monolithic
-  - no reason every application with _a_ secret needs to see _all_ secrets
-  - check out oo7-daemon?
-  - also unix-pass based provider: <https://github.com/mdellweg/pass_secret_service>
-- make dconf stuff less monolithic
-  - i.e. per-app dconf profiles for those which need it. possible static config.
-  - flatpak/spectrum has some stuff to proxy dconf per-app
+- validate duplicity backups!
+- encrypt more ~ dirs (~/archives, ~/records, ..?)
+  - best to do this after i know for sure i have good backups
+- have `sane.programs` be wrapped such that they run in a cgroup?
+  - at least, only give them access to the portion of the fs they *need*.
+  - Android takes approach of giving each app its own user: could hack that in here.
+  - **systemd-run** takes a command and runs it in a temporary scope (cgroup)
+    - presumably uses the same options as systemd services
+    - see e.g. <https://github.com/NixOS/nixpkgs/issues/113903#issuecomment-857296349>
+  - flatpak does this, somehow
+  - apparmor?  SElinux?  (desktop) "portals"?
+  - see Spectrum OS; Alyssa Ross; etc
+  - bubblewrap-based sandboxing: <https://github.com/nixpak/nixpak>
+- canaries for important services
+  - e.g. daily email checks; daily backup checks
+  - integrate `nix check` into Gitea actions?
+
+### faster/better deployments
+- remove audacity's dependency on webkitgtk (via wxwidgets)
 
 ### user experience
-- setup a real calendar system, for recurring events
-- rofi: sort items case-insensitively
-- rofi: enable mouse mode?
-- mpv: add media looping controls (e.g. loop song, loop playlist)
-- mpv: add/implement an extension to search youtube
-  - apparently `yt-dlp` does searching!
-- replace starship prompt with something more efficient
-  - watch `forkstat`: it does way too much
-- cleanup nwg-panel so that it's not invoking swaync every second
-  - nwg-panel: doesn't know that virtual-desktop 10/TV exists
 - install apps:
   - display QR codes for WiFi endpoints: <https://linuxphoneapps.org/apps/noappid.wisperwind.wifi2qr/>
   - shopping list (not in nixpkgs): <https://linuxphoneapps.org/apps/ro.hume.cosmin.shoppinglist/>
   - offline Wikipedia (or, add to `wike`)
+  - offline docs viewer (gtk): <https://github.com/workbenchdev/Biblioteca>
   - some type of games manager/launcher
     - Gnome Highscore (retro games)?: <https://gitlab.gnome.org/World/highscore>
+  - better maps for mobile (Osmin (QtQuick)? Pure Maps (Qt/Kirigami)? Gnome Maps is improved in 45)
   - note-taking app: <https://linuxphoneapps.org/categories/note-taking/>
-    - Folio is nice, uses standard markdown, though it only supports flat repos
   - OSK overlay specifically for mobile gaming
     - i.e. mock joysticks, for use with SuperTux and SuperTuxKart
-  - game: Hedgewars
 - install mobile-friendly games:
   - Shattered Pixel Dungeon (nixpkgs `shattered-pixel-dungeon`; doesn't cross-compile b/c openjdk/libIDL) <https://github.com/ebolalex/shattered-pixel-dungeon>
   - UnCiv (Civ V clone; nixpkgs `unciv`; doesn't cross-compile):  <https://github.com/yairm210/UnCiv>
   - Simon Tatham's Puzzle Collection (not in nixpkgs) <https://git.tartarus.org/?p=simon/puzzles.git>
   - Shootin Stars  (Godot; not in nixpkgs) <https://gitlab.com/greenbeast/shootin-stars>
-  - numberlink (generic name for Flow Free). not packaged in Nix
-  - Neverball (https://neverball.org/screenshots.php). nix: as `neverball`
-  - blurble (https://linuxphoneapps.org/games/app.drey.blurble/). nix: not as of 2024-02-05
-  - Trivia Quiz (https://linuxphoneapps.org/games/io.github.nokse22.trivia-quiz/)
-- sane-sync-music: remove empty dirs
-- soulseek: install a CLI app usable over ssh
 
 #### moby
-- moby: port battery support to something upstreamable
-- moby: install transito/mobroute public transit app: <https://sr.ht/~mil/mobroute/> <https://git.sr.ht/~mil/transito>
-  - see: <https://github.com/NixOS/nixpkgs/pull/335613>
-- moby: consider honeybee instead of gnome-calls for calling? <https://git.sr.ht/~anjan/honeybee>
-  - uses XMPP, so more NAT/WoWLAN-friendly
 - fix cpuidle (gets better power consumption): <https://xnux.eu/log/077.html>
-- fix cpupower for better power/perf
-  - `journalctl -u cpupower --boot` (problem is present on lappy, at least)
-- use dynamic DRAM clocking to reduce power by 0.5W: <https://xnux.eu/log/083.html>
-  - coreboot implements DRAM training for rk3399: <https://gitlab.com/vicencb/kevinboot/-/blob/master/cb/sdram.c>
-- moby: tune keyboard layout
-- SwayNC/nwg-panel: add option to change audio output
-- Newsflash: sync OPML on start, same way i do with gpodder
-- better podcasting client?
-- hardware upgrade (OnePlus)?
+- SwayNC:
+  - don't show MPRIS if no players detected
+    - this is a problem of playerctld, i guess
+    - also, the album icon when "Not playing" doesn't follow the size we give in the config
+      - that means mpris always takes up excessive space on moby
+  - add option to change audio output
+  - fix colors (red alert) to match overall theme
+- moby: tune GPS
+  - run only geoclue, and not gpsd, to save power?
+  - tune QGPS setting in eg25-control, for less jitter?
+  - direct mepo to prefer gpsd, with fallback to geoclue, for better accuracy?
+  - configure geoclue to do some smoothing?
+  - manually do smoothing, as some layer between mepo and geoclue/gpsd?
+- moby: show battery state on ssh login
+- moby: improve gPodder launch time
+- sxmo: port to swaybar like i use on desktop
+  - users in #sxmo claim it's way better perf
+- sxmo: fix youtube scripts (package youtube-cli)
+- moby: theme GTK apps (i.e. non-adwaita styles)
+  - combine multiple icon themes to get one which has the full icon set?
+  - get adwaita-icon-theme to ship everything even when cross-compiled?
+  - especially, make the menubar collapsible
+  - try Gradience tool specifically for theming adwaita? <https://linuxphoneapps.org/apps/com.github.gradienceteam.gradience/>
+- phog: remove the gnome-shell runtime dependency to save hella closure size
 
 #### non-moby
 - RSS: integrate a paywall bypass
   - e.g. self-hosted [ladder](https://github.com/everywall/ladder) (like 12ft.io)
-- RSS: have podcasts get downloaded straight into ~/Videos/...
-  - and strip the ads out using Whisper transcription + asking a LLM where the ad breaks are
-- neovim: integrate ollama
-- neovim: better docsets (e.g. c++, glib)
-- firefox: persist history
+- neovim: set up language server (lsp; rnix-lsp; nvim-lspconfig)
+- Helix: make copy-to-system clipboard be the default
+- firefox/librewolf: persist history
   - just not cookies or tabs
+- package Nix/NixOS docs for Zeal
+  - install [doc-browser](https://github.com/qwfy/doc-browser)
+  - this supports both dash (zeal) *and* the datasets from <https://devdocs.io> (which includes nix!)
+  - install [devhelp](https://wiki.gnome.org/Apps/Devhelp)  (gnome)
 - have xdg-open parse `<repo:...> URIs (or adjust them so that it _can_ parse)
 - sane-bt-search: show details like 5.1 vs stereo, h264 vs h265
   - maybe just color these "keywords" in all search results?
-- transmission: apply `sane-tag-media` path fix in `torrent-done` script
-  - many .mkv files do appear to be tagged: i'd just need to add support in my own tooling
-  - more aggressively cleanup non-media files after DL (ripper logos, info txts)
 - uninsane.org: make URLs relative to allow local use (and as offline homepage)
 - email: fix so that local mail doesn't go to junk
   - git sendmail flow adds the DKIM signatures, but gets delivered locally w/o having the sig checked, so goes into Junk
   - could change junk filter from "no DKIM success" to explicit "DKIM failed"
-  - add an auto-reply address (e.g. `reply-test@uninsane.org`) which reflects all incoming mail; use this (or a friend running this) for liveness checks
+
+### perf
+- add `pkgs.impure-cached.<foo>` package set to build things with ccache enabled
+  - every package here can be auto-generated, and marked with some env var so that it doesn't pollute the pure package set
+  - would be super handy for package prototyping!
+- get moby to build without binfmt emulation (i.e. make all emulation explicit)
+  - then i can distribute builds across servo + desko, and also allow servo to pull packages from desko w/o worrying about purity
+
 
 ## NEW FEATURES:
-- migrate Kodi box to nix
 - migrate MAME cabinet to nix
   - boot it from PXE from servo?
+- deploy to new server, and use it as a remote builder
 - enable IPv6
+- package lemonade lemmy app: <https://linuxphoneapps.org/apps/ml.mdwalters.lemonade/>

default.nix

@@ -1,5 +1,9 @@
-{ ... }@args:
-let
-  sane-nix-files = import ./pkgs/by-name/sane-nix-files/package.nix { };
-in
-  import "${sane-nix-files}/impure.nix" args
+# limited, non-flake interface to this repo.
+# this file exposes the same view into `pkgs` which the flake would see when evaluated.
+#
+# the primary purpose of this file is so i can run `updateScript`s which expect
+# the root to be `default.nix`
+{ pkgs ? import <nixpkgs> {} }:
+pkgs.appendOverlays [
+  (import ./overlays/all.nix)
+]

doc/adding-a-host.md

@@ -1,25 +0,0 @@
-to add a host:
-- create the new nix targets
-  - hosts/by-name/HOST
-  - let the toplevel (flake.nix) know about HOST
-- build and flash an image
-- optionally expand the rootfs
-  - `cfdisk /dev/sda2` -> resize partition
-  - `mount /dev/sda2 boot`
-  - `btrfs filesystem resize max root`
-- setup required persistent directories
-  - `mkdir -p root/persist/private`
-  - `gocryptfs -init root/persist/private`
-  - then boot the device, and for every dangling symlink in ~/.local/share, ~/.cache, do `mkdir -p` on it
-- setup host ssh
-  - `mkdir -p root/persist/plaintext/etc/ssh/host_keys`
-  - boot the machine and let it create its own ssh keys
-  - add the pubkey to `hosts/common/hosts.nix`
-- setup user ssh
-  - `ssh-keygen`. don't enter any password; it's stored in a password-encrypted fs.
-  - add the pubkey to `hosts/common/hosts.nix`
-- allow the new host to view secrets
-  - instructions in hosts/common/secrets.nix
-  - run `ssh-to-age` on user/host pubkeys
-  - add age key to .sops.yaml
-  - update encrypted secrets: `sops updatekeys path/to/secret.yaml`

doc/recovery.md

@@ -1,12 +0,0 @@
-## deploying to SD card
-- build a toplevel config: `nix build '.#hostSystems.moby'`
-- mount a system:
-  - `mkdir -p root/{nix,boot}`
-  - `mount /dev/sdX1 root/boot`
-  - `mount /dev/sdX2 root/nix`
-- copy the config:
-  - `sudo nix copy --no-check-sigs --to root/ $(readlink result)`
-    - nix will copy stuff to `root/nix/store`
-- install the boot files:
-  - `sudo /nix/store/sbwpwngjlgw4f736ay9hgi69pj3fdwk5-extlinux-conf-builder.sh -d ./root/boot -t 5 -c $(readlink ./result)`
-    - extlinux-conf-builder can be found in `/run/current-system/bin/switch-to-configuration`

flake.lock

@@ -0,0 +1,138 @@
+{
+  "nodes": {
+    "flake-utils": {
+      "inputs": {
+        "systems": "systems"
+      },
+      "locked": {
+        "lastModified": 1694529238,
+        "narHash": "sha256-zsNZZGTGnMOf9YpHKJqMSsa0dXbfmxeoJ7xHlrt+xmY=",
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "rev": "ff7b65b44d01cf9ba6a71320833626af21126384",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "type": "github"
+      }
+    },
+    "mobile-nixos": {
+      "flake": false,
+      "locked": {
+        "lastModified": 1694749521,
+        "narHash": "sha256-MiVokKlpcJmfoGuWAMeW1En7gZ5hk0rCQArYm6P9XCc=",
+        "owner": "nixos",
+        "repo": "mobile-nixos",
+        "rev": "d25d3b87e7f300d8066e31d792337d9cd7ecd23b",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nixos",
+        "ref": "d25d3b87e7f300d8066e31d792337d9cd7ecd23b",
+        "repo": "mobile-nixos",
+        "type": "github"
+      }
+    },
+    "nixpkgs-stable": {
+      "locked": {
+        "lastModified": 1700905716,
+        "narHash": "sha256-w1vHn2MbGfdC+CrP3xLZ3scsI06N0iQLU7eTHIVEFGw=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "dfb95385d21475da10b63da74ae96d89ab352431",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "release-23.05",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "nixpkgs-unpatched": {
+      "locked": {
+        "lastModified": 1701180790,
+        "narHash": "sha256-kYWcHsk2A1VUpiOvSo7Pq175WnSVeltspTGM2q+Cr3U=",
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "rev": "c9702bf40b036c0f1d3d5b0aaf3eee2bf920124c",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nixos",
+        "ref": "master",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "mobile-nixos": "mobile-nixos",
+        "nixpkgs-unpatched": "nixpkgs-unpatched",
+        "sops-nix": "sops-nix",
+        "uninsane-dot-org": "uninsane-dot-org"
+      }
+    },
+    "sops-nix": {
+      "inputs": {
+        "nixpkgs": [
+          "nixpkgs-unpatched"
+        ],
+        "nixpkgs-stable": "nixpkgs-stable"
+      },
+      "locked": {
+        "lastModified": 1701127353,
+        "narHash": "sha256-qVNX0wOl0b7+I35aRu78xUphOyELh+mtUp1KBx89K1Q=",
+        "owner": "Mic92",
+        "repo": "sops-nix",
+        "rev": "b1edbf5c0464b4cced90a3ba6f999e671f0af631",
+        "type": "github"
+      },
+      "original": {
+        "owner": "Mic92",
+        "repo": "sops-nix",
+        "type": "github"
+      }
+    },
+    "systems": {
+      "locked": {
+        "lastModified": 1681028828,
+        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
+        "owner": "nix-systems",
+        "repo": "default",
+        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-systems",
+        "repo": "default",
+        "type": "github"
+      }
+    },
+    "uninsane-dot-org": {
+      "inputs": {
+        "flake-utils": "flake-utils",
+        "nixpkgs": [
+          "nixpkgs-unpatched"
+        ]
+      },
+      "locked": {
+        "lastModified": 1699515935,
+        "narHash": "sha256-cJIuVrYorhIzG5pRFZb+ZtaKhTFD92ThC42SaxvSe/E=",
+        "ref": "refs/heads/master",
+        "rev": "8a4273489d945f21d7e0ca6aac952460c7d4c391",
+        "revCount": 216,
+        "type": "git",
+        "url": "https://git.uninsane.org/colin/uninsane"
+      },
+      "original": {
+        "type": "git",
+        "url": "https://git.uninsane.org/colin/uninsane"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}

flake.nix

@@ -0,0 +1,508 @@
+# FLAKE FEEDBACK:
+# - if flake inputs are meant to be human-readable, a human should be able to easily track them down given the URL.
+#   - this is not the case with registry URLs, like `nixpkgs/nixos-22.11`.
+#   - this is marginally the case with schemes like `github:nixos/nixpkgs`.
+#   - given the *existing* `git+https://` scheme, i propose expressing github URLs similarly:
+#     - `github+https://github.com/nixos/nixpkgs/tree/nixos-22.11`
+#     - this would allow for the same optimizations as today's `github:nixos/nixpkgs`, but without obscuring the source.
+#       a code reader could view the source being referenced simply by clicking the https:// portion of that URI.
+# - need some way to apply local patches to inputs.
+#
+#
+# DEVELOPMENT DOCS:
+# - Flake docs: <https://nixos.wiki/wiki/Flakes>
+# - Flake RFC: <https://github.com/tweag/rfcs/blob/flakes/rfcs/0049-flakes.md>
+#   - Discussion: <https://github.com/NixOS/rfcs/pull/49>
+# - <https://serokell.io/blog/practical-nix-flakes>
+#
+#
+# COMMON OPERATIONS:
+# - update a specific flake input:
+#   - `nix flake lock --update-input nixpkgs`
+
+{
+  # XXX: use the `github:` scheme instead of the more readable git+https: because it's *way* more efficient
+  # preferably, i would rewrite the human-readable https URLs to nix-specific github: URLs with a helper,
+  # but `inputs` is required to be a strict attrset: not an expression.
+  inputs = {
+    # branch workflow:
+    # - daily:
+    #   - nixos-unstable cut from master after enough packages have been built in caches.
+    # - every 6 hours:
+    #   - master auto-merged into staging.
+    #   - staging-next auto-merged into staging.
+    # - manually, approximately once per month:
+    #   - staging-next is cut from staging.
+    #   - staging-next merged into master.
+    #
+    # which branch to source from?
+    # - nixos-unstable: for everyday development; it provides good caching
+    # - master: temporarily if i'm otherwise cherry-picking lots of already-applied patches
+    # - staging-next: if testing stuff that's been PR'd into staging, i.e. base library updates.
+    # - staging: maybe if no staging-next -> master PR has been cut yet?
+    #
+    # <https://github.com/nixos/nixpkgs/tree/nixos-unstable>
+    # nixpkgs-unpatched.url = "github:nixos/nixpkgs?ref=nixos-unstable";
+    nixpkgs-unpatched.url = "github:nixos/nixpkgs?ref=master";
+    # nixpkgs-unpatched.url = "github:nixos/nixpkgs?ref=staging-next";
+    # nixpkgs-unpatched.url = "github:nixos/nixpkgs?ref=staging";
+
+    mobile-nixos = {
+      # <https://github.com/nixos/mobile-nixos>
+      # only used for building disk images, not relevant after deployment
+      # TODO: replace with something else. commit `0f3ac0bef1aea70254a3bae35e3cc2561623f4c1`
+      # replaces the imageBuilder with a "new implementation from celun" and wildly breaks my use.
+      # pinning to d25d3b... is equivalent to holding at 2023-09-15
+      url = "github:nixos/mobile-nixos?ref=d25d3b87e7f300d8066e31d792337d9cd7ecd23b";
+      flake = false;
+    };
+    sops-nix = {
+      # <https://github.com/Mic92/sops-nix>
+      # used to distribute secrets to my hosts
+      url = "github:Mic92/sops-nix";
+      # inputs.nixpkgs.follows = "nixpkgs";
+      inputs.nixpkgs.follows = "nixpkgs-unpatched";
+    };
+    uninsane-dot-org = {
+      # provides the package to deploy <https://uninsane.org>, used only when building the servo host
+      url = "git+https://git.uninsane.org/colin/uninsane";
+      # inputs.nixpkgs.follows = "nixpkgs";
+      inputs.nixpkgs.follows = "nixpkgs-unpatched";
+    };
+  };
+
+  outputs = {
+    self,
+    nixpkgs-unpatched,
+    mobile-nixos,
+    sops-nix,
+    uninsane-dot-org,
+    ...
+  }@inputs:
+    let
+      inherit (builtins) attrNames elem listToAttrs map mapAttrs;
+      # redefine some nixpkgs `lib` functions to avoid the infinite recursion
+      # of if we tried to use patched `nixpkgs.lib` as part of the patching process.
+      mapAttrs' = f: set:
+        listToAttrs (map (attr: f attr set.${attr}) (attrNames set));
+      optionalAttrs = cond: attrs: if cond then attrs else {};
+      # mapAttrs but without the `name` argument
+      mapAttrValues = f: mapAttrs (_: f);
+
+      # rather than apply our nixpkgs patches as a flake input, do that here instead.
+      # this (temporarily?) resolves the bad UX wherein a subflake residing in the same git
+      # repo as the main flake causes the main flake to have an unstable hash.
+      nixpkgs = (import ./nixpatches/flake.nix).outputs {
+        self = nixpkgs;
+        nixpkgs = nixpkgs-unpatched;
+      } // {
+        # provide values that nixpkgs ordinarily sources from the flake.lock file,
+        # inaccessible to it here because of the import-from-derivation.
+        # rev and shortRev seem to not always exist (e.g. if the working tree is dirty),
+        # so those are made conditional.
+        #
+        # these values impact the name of a produced nixos system. having date/rev in the
+        # `readlink /run/current-system` store path helps debuggability.
+        inherit (self) lastModifiedDate lastModified;
+      } // optionalAttrs (self ? rev) {
+        inherit (self) rev;
+      } // optionalAttrs (self ? shortRev) {
+        inherit (self) shortRev;
+      };
+
+      nixpkgsCompiledBy = system: nixpkgs.legacyPackages."${system}";
+
+      evalHost = { name, local, target, light ? false }: nixpkgs.lib.nixosSystem {
+        system = target;
+        modules = [
+          {
+            nixpkgs = (if (local != null) then {
+              buildPlatform = local;
+            } else {}) // {
+              # TODO: does the earlier `system` arg to nixosSystem make its way here?
+              hostPlatform.system = target;
+            };
+            # nixpkgs.buildPlatform = local;  # set by instantiate.nix instead
+            # nixpkgs.config.replaceStdenv = { pkgs }: pkgs.ccacheStdenv;
+          }
+          (optionalAttrs light {
+            sane.enableSlowPrograms = false;
+          })
+          (import ./hosts/instantiate.nix { hostName = name; })
+          self.nixosModules.default
+          self.nixosModules.passthru
+          {
+            nixpkgs.overlays = [
+              self.overlays.passthru
+              self.overlays.sane-all
+            ];
+          }
+        ];
+      };
+    in {
+      nixosConfigurations =
+        let
+          hosts = {
+            servo       = { name = "servo";  local = "x86_64-linux"; target = "x86_64-linux";  };
+            desko       = { name = "desko";  local = "x86_64-linux"; target = "x86_64-linux";  };
+            desko-light = { name = "desko";  local = "x86_64-linux"; target = "x86_64-linux";  light = true; };
+            lappy       = { name = "lappy";  local = "x86_64-linux"; target = "x86_64-linux";  };
+            lappy-light = { name = "lappy";  local = "x86_64-linux"; target = "x86_64-linux";  light = true; };
+            moby        = { name = "moby";   local = "x86_64-linux"; target = "aarch64-linux"; };
+            moby-light  = { name = "moby";   local = "x86_64-linux"; target = "aarch64-linux"; light = true; };
+            rescue      = { name = "rescue"; local = "x86_64-linux"; target = "x86_64-linux";  };
+          };
+          # cross-compiled builds: instead of emulating the host, build using a cross-compiler.
+          # - these are faster to *build* than the emulated variants (useful when tweaking packages),
+          # - but fewer of their packages can be found in upstream caches.
+          cross = mapAttrValues evalHost hosts;
+          emulated = mapAttrValues
+            (args: evalHost (args // { local = null; }))
+            hosts;
+          prefixAttrs = prefix: attrs: mapAttrs'
+            (name: value: {
+              name = prefix + name;
+              inherit value;
+            })
+            attrs;
+        in
+          (prefixAttrs "cross-" cross) //
+          (prefixAttrs "emulated-" emulated) // {
+            # prefer native builds for these machines:
+            inherit (emulated) servo desko desko-light lappy lappy-light rescue;
+            # prefer cross-compiled builds for these machines:
+            inherit (cross) moby moby-light;
+          };
+
+      # unofficial output
+      # this produces a EFI-bootable .img file (GPT with a /boot partition and a system (/ or /nix) partition).
+      # after building this:
+      #   - flash it to a bootable medium (SD card, flash drive, HDD)
+      #   - resize the root partition (use cfdisk)
+      #   - mount the part
+      #      - chown root:nixbld <part>/nix/store
+      #      - chown root:root -R <part>/nix/store/*
+      #      - chown root:root -R <part>/persist  # if using impermanence
+      #      - populate any important things (persist/, home/colin/.ssh, etc)
+      #   - boot
+      #   - if fs wasn't resized automatically, then `sudo btrfs filesystem resize max /`
+      #   - checkout this flake into /etc/nixos AND UPDATE THE FS UUIDS.
+      #   - `nixos-rebuild --flake './#<host>' switch`
+      imgs = mapAttrValues (host: host.config.system.build.img) self.nixosConfigurations;
+
+      # unofficial output
+      hostConfigs = mapAttrValues (host: host.config) self.nixosConfigurations;
+      hostPkgs = mapAttrValues (host: host.config.system.build.pkgs) self.nixosConfigurations;
+      hostPrograms = mapAttrValues (host: mapAttrValues (p: p.package) host.config.sane.programs) self.nixosConfigurations;
+
+      overlays = {
+        # N.B.: `nix flake check` requires every overlay to take `final: prev:` at defn site,
+        #   hence the weird redundancy.
+        default = final: prev: self.overlays.pkgs final prev;
+        sane-all = final: prev: import ./overlays/all.nix final prev;
+        disable-flakey-tests = final: prev: import ./overlays/disable-flakey-tests.nix final prev;
+        pkgs = final: prev: import ./overlays/pkgs.nix final prev;
+        pins = final: prev: import ./overlays/pins.nix final prev;
+        preferences = final: prev: import ./overlays/preferences.nix final prev;
+        optimizations = final: prev: import ./overlays/optimizations.nix final prev;
+        passthru = final: prev:
+          let
+            mobile = (import "${mobile-nixos}/overlay/overlay.nix");
+            uninsane = uninsane-dot-org.overlay;
+          in
+            (mobile final prev)
+            // (uninsane final prev)
+          ;
+      };
+
+      nixosModules = rec {
+        default = sane;
+        sane = import ./modules;
+        passthru = { ... }: {
+          imports = [
+            sops-nix.nixosModules.sops
+          ];
+        };
+      };
+
+      # this includes both our native packages and all the nixpkgs packages.
+      legacyPackages =
+        let
+          allPkgsFor = sys: (nixpkgsCompiledBy sys).appendOverlays [
+            self.overlays.passthru self.overlays.pkgs
+          ];
+        in {
+          x86_64-linux = allPkgsFor "x86_64-linux";
+          aarch64-linux = allPkgsFor "aarch64-linux";
+        };
+
+      # extract only our own packages from the full set.
+      # because of `nix flake check`, we flatten the package set and only surface x86_64-linux packages.
+      packages = mapAttrs
+        (system: allPkgs:
+          allPkgs.lib.filterAttrs (name: pkg:
+            # keep only packages which will pass `nix flake check`, i.e. keep only:
+            # - derivations (not package sets)
+            # - packages that build for the given platform
+            (! elem name [ "feeds" "pythonPackagesExtensions" ])
+            && (allPkgs.lib.meta.availableOn allPkgs.stdenv.hostPlatform pkg)
+          )
+          (
+            # expose sane packages and chosen inputs (uninsane.org)
+            (import ./pkgs { pkgs = allPkgs; }) // {
+              inherit (allPkgs) uninsane-dot-org;
+            }
+          )
+        )
+        # self.legacyPackages;
+        { inherit (self.legacyPackages) x86_64-linux; }
+      ;
+
+      apps."x86_64-linux" =
+        let
+          pkgs = self.legacyPackages."x86_64-linux";
+          sanePkgs = import ./pkgs { inherit pkgs; };
+          deployScript = host: addr: action: pkgs.writeShellScript "deploy-${host}" ''
+            nix build '.#nixosConfigurations.${host}.config.system.build.toplevel' --out-link ./result-${host} $@
+            sudo nix sign-paths -r -k /run/secrets/nix_serve_privkey $(readlink ./result-${host})
+
+            # XXX: this triggers another config eval & (potentially) build.
+            # if the config changed between these invocations, the above signatures might not apply to the deployed config.
+            # let the user handle that edge case by re-running this whole command
+            nixos-rebuild --flake '.#${host}' ${action} --target-host colin@${addr} --use-remote-sudo $@
+          '';
+          deployApp = host: addr: action: {
+            type = "app";
+            program = ''${deployScript host addr action}'';
+          };
+
+          # pkg updating.
+          # a cleaner alternative lives here: <https://discourse.nixos.org/t/how-can-i-run-the-updatescript-of-personal-packages/25274/2>
+          # mkUpdater :: [ String ] -> { type = "app"; program = path; }
+          mkUpdater = attrPath: {
+            type = "app";
+            program = let
+              pkg = pkgs.lib.getAttrFromPath attrPath sanePkgs;
+              strAttrPath = pkgs.lib.concatStringsSep "." attrPath;
+              commandArgv = pkg.updateScript.command or pkg.updateScript;
+              command = pkgs.lib.escapeShellArgs commandArgv;
+            in builtins.toString (pkgs.writeShellScript "update-${strAttrPath}" ''
+              export UPDATE_NIX_NAME=${pkg.name}
+              export UPDATE_NIX_PNAME=${pkg.pname}
+              export UPDATE_NIX_OLD_VERSION=${pkg.version}
+              export UPDATE_NIX_ATTR_PATH=${strAttrPath}
+              ${command}
+            '');
+          };
+          mkUpdatersNoAliases = opts: basePath: pkgs.lib.concatMapAttrs
+            (name: pkg:
+              if pkg.recurseForDerivations or false then {
+                "${name}" = mkUpdaters opts (basePath ++ [ name ]);
+              } else if pkg.updateScript or null != null then {
+                "${name}" = mkUpdater (basePath ++ [ name ]);
+              } else {}
+            )
+            (pkgs.lib.getAttrFromPath basePath sanePkgs);
+          mkUpdaters = { ignore ? [], flakePrefix ? [] }@opts: basePath:
+            let
+              updaters = mkUpdatersNoAliases opts basePath;
+              invokeUpdater = name: pkg:
+                let
+                  fullPath = basePath ++ [ name ];
+                  doUpdateByDefault = !builtins.elem fullPath ignore;
+
+                  # in case `name` has a `.` in it, we have to quote it
+                  escapedPath = builtins.map (p: ''"${p}"'') fullPath;
+                  updatePath = builtins.concatStringsSep "." (flakePrefix ++ escapedPath);
+                in pkgs.lib.optionalString doUpdateByDefault (
+                  pkgs.lib.escapeShellArgs [
+                    "nix" "run" ".#${updatePath}"
+                  ]
+                );
+            in {
+              type = "app";
+              # top-level app just invokes the updater of everything one layer below it
+              program = builtins.toString (pkgs.writeShellScript
+                (builtins.concatStringsSep "-" (flakePrefix ++ basePath))
+                (builtins.concatStringsSep
+                  "\n"
+                  (pkgs.lib.mapAttrsToList invokeUpdater updaters)
+                )
+              );
+            } // updaters;
+        in {
+          help = {
+            type = "app";
+            program = let
+              helpMsg = builtins.toFile "nixos-config-help-message" ''
+                commands:
+                - `nix run '.#help'`
+                  - show this message
+                - `nix run '.#update.pkgs'`
+                  - updates every package
+                - `nix run '.#update.feeds'`
+                  - updates metadata for all feeds
+                - `nix run '.#init-feed' <url>`
+                - `nix run '.#deploy.{desko,lappy,moby,servo}[-light][.test]' [nixos-rebuild args ...]`
+                - `nix run '.#check'`
+                  - make sure all systems build; NUR evaluates
+
+                specific build targets of interest:
+                - `nix build '.#imgs.rescue'`
+              '';
+            in builtins.toString (pkgs.writeShellScript "nixos-config-help" ''
+              cat ${helpMsg}
+              echo ""
+              echo "complete flake structure:"
+              nix flake show --option allow-import-from-derivation true
+            '');
+          };
+          # wrangle some names to get package updaters which refer back into the flake, but also conditionally ignore certain paths (e.g. sane.feeds).
+          # TODO: better design
+          update = rec {
+            _impl.pkgs.sane = mkUpdaters { flakePrefix = [ "update" "_impl" "pkgs" ]; ignore = [ [ "sane" "feeds" ] ]; } [ "sane" ];
+            pkgs = _impl.pkgs.sane;
+            _impl.feeds.sane.feeds = mkUpdaters { flakePrefix = [ "update" "_impl" "feeds" ]; } [ "sane" "feeds" ];
+            feeds = _impl.feeds.sane.feeds;
+          };
+
+          init-feed = {
+            type = "app";
+            program = "${pkgs.feeds.init-feed}";
+          };
+
+          deploy = {
+            lappy       = deployApp "lappy"       "lappy" "switch";
+            lappy-light = deployApp "lappy-light" "lappy" "switch";
+            moby        = deployApp "moby"        "moby"  "switch";
+            moby-light  = deployApp "moby-light"  "moby"  "switch";
+            moby-test   = deployApp "moby"        "moby"  "test";
+            servo       = deployApp "servo"       "servo" "switch";
+          };
+
+          sync-moby = {
+            # copy music from the current device to moby
+            # TODO: should i actually sync from /mnt/servo-media/Music instead of the local drive?
+            type = "app";
+            program = builtins.toString (pkgs.writeShellScript "sync-to-moby" ''
+              sudo mount /mnt/moby-home
+              ${pkgs.sane-scripts.sync-music}/bin/sane-sync-music ~/Music /mnt/moby-home/Music
+            '');
+          };
+
+          sync-lappy = {
+            # copy music from servo to lappy
+            # can run this from any device that has ssh access to lappy
+            type = "app";
+            program = builtins.toString (pkgs.writeShellScript "sync-to-lappy" ''
+              sudo mount /mnt/lappy-home
+              ${pkgs.sane-scripts.sync-music}/bin/sane-sync-music /mnt/servo-media/Music /mnt/lappy-home/Music
+            '');
+          };
+
+          check = {
+            type = "app";
+            program = builtins.toString (pkgs.writeShellScript "check-all" ''
+              nix run '.#check.nur'
+              RC0=$?
+              nix run '.#check.host-configs'
+              RC1=$?
+              nix run '.#check.rescue'
+              RC2=$?
+              echo "nur: $RC0"
+              echo "host-configs: $RC1"
+              echo "rescue: $RC2"
+              exit $(($RC0 | $RC1 | $RC2))
+            '');
+          };
+
+          check.nur = {
+            # `nix run '.#check-nur'`
+            # validates that my repo can be included in the Nix User Repository
+            type = "app";
+            program = builtins.toString (pkgs.writeShellScript "check-nur" ''
+              cd ${./.}/integrations/nur
+              NIX_PATH= NIXPKGS_ALLOW_UNSUPPORTED_SYSTEM=1 nix-env -f . -qa \* --meta --xml \
+                --allowed-uris https://static.rust-lang.org \
+                --option restrict-eval true \
+                --option allow-import-from-derivation true \
+                --drv-path --show-trace \
+                -I nixpkgs=$(nix-instantiate --find-file nixpkgs) \
+                -I ../../ \
+                | tee  # tee to prevent interactive mode
+            '');
+          };
+
+          check.host-configs = {
+            type = "app";
+            program = let
+              checkHost = host: let
+                shellHost = pkgs.lib.replaceStrings [ "-" ] [ "_" ] host;
+              in ''
+                nix build -v '.#nixosConfigurations.${host}.config.system.build.toplevel' --out-link ./result-${host} -j2 $@
+                RC_${shellHost}=$?
+              '';
+            in builtins.toString (pkgs.writeShellScript
+              "check-host-configs"
+              ''
+                # build minimally-usable hosts first, then their full image.
+                # this gives me a minimal image i can deploy or copy over, early.
+                ${checkHost "desko-light"}
+                ${checkHost "moby-light"}
+                ${checkHost "lappy-light"}
+
+                ${checkHost "desko"}
+                ${checkHost "lappy"}
+                ${checkHost "servo"}
+                ${checkHost "moby"}
+                ${checkHost "rescue"}
+
+                echo "desko: $RC_desko"
+                echo "lappy: $RC_lappy"
+                echo "servo: $RC_servo"
+                echo "moby: $RC_moby"
+                echo "rescue: $RC_rescue"
+                exit $(($RC_desko | $RC_lappy | $RC_servo | $RC_moby | $RC_rescue))
+              ''
+            );
+          };
+
+          check.rescue = {
+            type = "app";
+            program = builtins.toString (pkgs.writeShellScript "check-rescue" ''
+              nix build -v '.#imgs.rescue' --out-link ./result-rescue-img -j2
+            '');
+          };
+        };
+
+      templates = {
+        env.python-data = {
+          # initialize with:
+          # - `nix flake init -t '/home/colin/dev/nixos/#env.python-data'`
+          # then enter with:
+          # - `nix develop`
+          path = ./templates/env/python-data;
+          description = "python environment for data processing";
+        };
+        pkgs.rust-inline = {
+          # initialize with:
+          # - `nix flake init -t '/home/colin/dev/nixos/#pkgs.rust-inline'`
+          path = ./templates/pkgs/rust-inline;
+          description = "rust package and development environment (inline rust sources)";
+        };
+        pkgs.rust = {
+          # initialize with:
+          # - `nix flake init -t '/home/colin/dev/nixos/#pkgs.rust'`
+          path = ./templates/pkgs/rust;
+          description = "rust package fit to ship in nixpkgs";
+        };
+        pkgs.make = {
+          # initialize with:
+          # - `nix flake init -t '/home/colin/dev/nixos/#pkgs.make'`
+          path = ./templates/pkgs/make;
+          description = "default Makefile-based derivation";
+        };
+      };
+    };
+}
+

hosts/by-name/crappy/default.nix

@@ -1,33 +0,0 @@
-# Samsung chromebook XE303C12
-# - <https://wiki.postmarketos.org/wiki/Samsung_Chromebook_(google-snow)>
-{ ... }:
-{
-  imports = [
-    ./fs.nix
-  ];
-
-  sane.hal.samsung.enable = true;
-  sane.roles.client = true;
-  # sane.roles.pc = true;
-
-  users.users.colin.initialPassword = "147147";
-  sane.programs.sway.enableFor.user.colin = true;
-
-  sane.programs.calls.enableFor.user.colin = false;
-  sane.programs.consoleMediaUtils.enableFor.user.colin = true;
-  sane.programs.epiphany.enableFor.user.colin = true;
-  sane.programs.geary.enableFor.user.colin = false;
-  # sane.programs.firefox.enableFor.user.colin = true;
-  sane.programs.portfolio-filemanager.enableFor.user.colin = true;
-  sane.programs.signal-desktop.enableFor.user.colin = false;
-  sane.programs.wike.enableFor.user.colin = true;
-
-  sane.programs.dino.config.autostart = false;
-  sane.programs.dissent.config.autostart = false;
-  sane.programs.fractal.config.autostart = false;
-  sane.programs.sway.config.mod = "Mod1";  #< alt key instead of Super
-
-  # sane.programs.guiApps.enableFor.user.colin = false;
-
-  # sane.programs.pcGuiApps.enableFor.user.colin = false;  #< errors!
-}

hosts/by-name/crappy/fs.nix

@@ -1,16 +0,0 @@
-{ ... }:
-{
-  fileSystems."/nix" = {
-    device = "/dev/disk/by-uuid/55555555-0303-0c12-86df-eda9e9311526";
-    fsType = "btrfs";
-    options = [
-      "compress=zstd"
-      "defaults"
-    ];
-  };
-
-  fileSystems."/boot" = {
-    device = "/dev/disk/by-uuid/303C-5A37";
-    fsType = "vfat";
-  };
-}

hosts/by-name/desko/default.nix

@@ -4,53 +4,58 @@
     ./fs.nix
   ];
 
-  # sane.programs.devPkgs.enableFor.user.colin = true;
   # sane.guest.enable = true;
 
-  # don't enable wifi by default: it messes with connectivity.
-  # systemd.services.iwd.enable = false;
-  # networking.wireless.enable = false;
-  # systemd.services.wpa_supplicant.enable = false;
-  # sane.programs.wpa_supplicant.enableFor.user.colin = lib.mkForce false;
-  # sane.programs.wpa_supplicant.enableFor.system = lib.mkForce false;
-  # don't auto-connect to wifi networks
-  # see: <https://networkmanager.dev/docs/api/latest/NetworkManager.conf.html#device-spec>
-  networking.networkmanager.unmanaged = [ "type:wifi" ];
+  # services.distccd.enable = true;
+  # sane.programs.distcc.enableFor.user.guest = true;
 
   sops.secrets.colin-passwd.neededForUsers = true;
 
+  sane.ports.openFirewall = true;  # for e.g. nix-serve
+
   sane.roles.build-machine.enable = true;
   sane.roles.client = true;
+  sane.roles.dev-machine = true;
   sane.roles.pc = true;
-  sane.services.ollama.enable = true;
   sane.services.wg-home.enable = true;
   sane.services.wg-home.ip = config.sane.hosts.by-name."desko".wg-home.ip;
-  sane.ovpn.addrV4 = "172.26.55.21";
-  # sane.ovpn.addrV6 = "fd00:0000:1337:cafe:1111:1111:20c1:a73c";
-  sane.services.rsync-net.enable = true;
+  sane.services.duplicity.enable = true;
+  sane.services.nixserve.secretKeyFile = config.sops.secrets.nix_serve_privkey.path;
 
+  sane.nixcache.substituters.desko = false;
   sane.nixcache.remote-builders.desko = false;
 
-  sane.programs.firefox.config.formFactor = "desktop";
-
-  sane.programs.sane-private-unlock-remote.enableFor.user.colin = true;
-  sane.programs.sane-private-unlock-remote.config.hosts = [ "servo" ];
-
-  sane.programs.sway.enableFor.user.colin = true;
+  sane.gui.sway.enable = true;
+  sane.programs.iphoneUtils.enableFor.user.colin = true;
   sane.programs.steam.enableFor.user.colin = true;
 
-  sane.programs.nwg-panel.config = {
-    battery = false;
-    brightness = false;
-  };
+  # sane.programs.devPkgs.enableFor.user.colin = true;
 
-  sane.programs.mpv.config.defaultProfile = "high-quality";
+  sane.programs.signal-desktop.config.autostart = true;
+  sane.programs."gnome.geary".config.autostart = true;
 
+  boot.loader.efi.canTouchEfiVariables = false;
   sane.image.extraBootFiles = [ pkgs.bootpart-uefi-x86_64 ];
 
   # needed to use libimobiledevice/ifuse, for iphone sync
   services.usbmuxd.enable = true;
 
-  # TODO(2025-01-01): re-enable once rocm build is fixed: <https://github.com/NixOS/nixpkgs/pull/367695>
-  # hardware.amdgpu.opencl.enable = true;  # desktop (AMD's opencl implementation AKA "ROCM"); probably required for ollama
+  # don't enable wifi by default: it messes with connectivity.
+  systemd.services.iwd.enable = false;
+  systemd.services.wpa_supplicant.enable = false;
+
+  # default config: https://man.archlinux.org/man/snapper-configs.5
+  # defaults to something like:
+  #   - hourly snapshots
+  #   - auto cleanup; keep the last 10 hourlies, last 10 daylies, last 10 monthlys.
+  services.snapper.configs.nix = {
+    # TODO: for the impermanent setup, we'd prefer to just do /nix/persist,
+    # but that also requires setting up the persist dir as a subvol
+    SUBVOLUME = "/nix";
+    # TODO: ALLOW_USERS doesn't seem to work. still need `sudo snapper -c nix list`
+    ALLOW_USERS = [ "colin" ];
+  };
+
+  # docs: https://nixos.org/manual/nixos/stable/options.html#opt-system.stateVersion
+  system.stateVersion = "21.05";
 }

hosts/by-name/desko/fs.nix

@@ -3,9 +3,10 @@
 {
   # increase /tmp space (defaults to 50% of RAM) for building large nix things.
   # a cross-compiled kernel, particularly, will easily use 30+GB of tmp
-  fileSystems."/tmp".options = [ "size=128G" ];
+  fileSystems."/tmp".options = [ "size=64G" ];
 
   fileSystems."/nix" = {
+    # device = "/dev/disk/by-uuid/0ab0770b-7734-4167-88d9-6e4e20bb2a56";
     device = "/dev/disk/by-uuid/845d85bf-761d-431b-a406-e6f20909154f";
     fsType = "btrfs";
     options = [
@@ -15,6 +16,7 @@
   };
 
   fileSystems."/boot" = {
+    # device = "/dev/disk/by-uuid/41B6-BAEF";
     device = "/dev/disk/by-uuid/5049-9AFD";
     fsType = "vfat";
   };

hosts/by-name/lappy/default.nix

@@ -2,46 +2,35 @@
 {
   imports = [
     ./fs.nix
+    ./polyfill.nix
   ];
 
   sane.roles.client = true;
+  sane.roles.dev-machine = true;
   sane.roles.pc = true;
   sane.services.wg-home.enable = true;
   sane.services.wg-home.ip = config.sane.hosts.by-name."lappy".wg-home.ip;
-  sane.ovpn.addrV4 = "172.23.119.72";
-  # sane.ovpn.addrV6 = "fd00:0000:1337:cafe:1111:1111:0332:aa96/128";
 
   # sane.guest.enable = true;
+  sane.gui.sway.enable = true;
+  boot.loader.efi.canTouchEfiVariables = false;
   sane.image.extraBootFiles = [ pkgs.bootpart-uefi-x86_64 ];
 
-  sane.programs.sane-private-unlock-remote.enableFor.user.colin = true;
-  sane.programs.sane-private-unlock-remote.config.hosts = [ "servo" ];
-
-  sane.programs.firefox.config.formFactor = "laptop";
-  sane.programs.itgmania.enableFor.user.colin = true;
-  # sane.programs.stepmania.enableFor.user.colin = true;  #< TODO: fix build
-  sane.programs.sway.enableFor.user.colin = true;
+  sane.programs.stepmania.enableFor.user.colin = true;
 
   sops.secrets.colin-passwd.neededForUsers = true;
 
-  sane.services.rsync-net.enable = true;
-
-  # starting 2024/09, under default settings (apparently 256 quantum), audio would crackle under load.
-  # 1024 solves *most* crackles, but still noticable under heavier loads.
-  sane.programs.pipewire.config.min-quantum = 2048;
-
-  # TODO: enable snapper (need to make `/nix` or `/nix/persist` a subvolume, somehow).
   # default config: https://man.archlinux.org/man/snapper-configs.5
   # defaults to something like:
   #   - hourly snapshots
   #   - auto cleanup; keep the last 10 hourlies, last 10 daylies, last 10 monthlys.
-  # to list snapshots: `sudo snapper --config nix list`
-  # to take a snapshot: `sudo snapper --config nix create`
-  # services.snapper.configs.nix = {
-  #   # TODO: for the impermanent setup, we'd prefer to just do /nix/persist,
-  #   # but that also requires setting up the persist dir as a subvol
-  #   SUBVOLUME = "/nix";
-  #   # TODO: ALLOW_USERS doesn't seem to work. still need `sudo snapper -c nix list`
-  #   ALLOW_USERS = [ "colin" ];
-  # };
+  services.snapper.configs.nix = {
+    # TODO: for the impermanent setup, we'd prefer to just do /nix/persist,
+    # but that also requires setting up the persist dir as a subvol
+    SUBVOLUME = "/nix";
+    ALLOW_USERS = [ "colin" ];
+  };
+
+  # docs: https://nixos.org/manual/nixos/stable/options.html#opt-system.stateVersion
+  system.stateVersion = "21.05";
 }

hosts/by-name/lappy/fs.nix

@@ -14,4 +14,24 @@
     device = "/dev/disk/by-uuid/BD79-D6BB";
     fsType = "vfat";
   };
+
+  # fileSystems."/nix" = {
+  #   device = "/dev/disk/by-uuid/5a7fa69c-9394-8144-a74c-6726048b129f";
+  #   fsType = "btrfs";
+  # };
+
+  # fileSystems."/boot" = {
+  #   device = "/dev/disk/by-uuid/4302-1685";
+  #   fsType = "vfat";
+  # };
+
+  # fileSystems."/" = {
+  #   device = "none";
+  #   fsType = "tmpfs";
+  #   options = [
+  #     "mode=755"
+  #     "size=1G"
+  #     "defaults"
+  #   ];
+  # };
 }

hosts/by-name/lappy/polyfill.nix

@@ -0,0 +1,43 @@
+# doesn't actually *enable* anything,
+# but sets up any modules such that if they *were* enabled, they'll act as expected.
+{ pkgs, ... }:
+{
+  sane.gui.sxmo = {
+    greeter = "greetd-sway-gtkgreet";
+    noidle = true;  #< power button requires 1s hold, which makes it impractical to be dealing with.
+    settings = {
+      # XXX: make sure the user is part of the `input` group!
+      SXMO_LISGD_INPUT_DEVICE = "/dev/input/by-id/usb-Wacom_Co._Ltd._Pen_and_multitouch_sensor-event-if00";
+      # these identifiers are from `swaymsg -t get_inputs`
+      SXMO_VOLUME_BUTTON = "1:1:AT_Translated_Set_2_keyboard";
+      # SXMO_VOLUME_BUTTON = "none";
+      # N.B.: thinkpad's power button requires a full second press to do anything
+      SXMO_POWER_BUTTON = "0:1:Power_Button";
+      # SXMO_POWER_BUTTON = "none";
+      SXMO_DISABLE_LEDS = "1";
+      SXMO_UNLOCK_IDLE_TIME = "120";  # default
+      # sxmo tries to determine device type from /proc/device-tree/compatible,
+      # but that doesn't seem to exist on NixOS?  (or maybe it just doesn't exist
+      # on non-aarch64 builds).
+      # the device type informs (at least):
+      # - SXMO_WIFI_MODULE
+      # - SXMO_RTW_SCAN_INTERVAL
+      # - SXMO_SYS_FILES
+      # - SXMO_TOUCHSCREEN_ID
+      # - SXMO_MONITOR
+      # - SXMO_ALSA_CONTROL_NAME
+      # - SXMO_SWAY_SCALE
+      # see <repo:mil/sxmo-utils:scripts/deviceprofiles>
+      # SXMO_DEVICE_NAME = "pine64,pinephone-1.2";
+      # if sxmo doesn't know the device, it can't decide whether to use one_button or three_button mode
+      #   and so it just wouldn't handle any button inputs (sxmo_hook_inputhandler.sh not on path)
+      SXMO_DEVICE_NAME = "three_button_touchscreen";
+    };
+    package = (pkgs.sxmo-utils.override { preferSystemd = true; }).overrideAttrs (base: {
+      postPatch = (base.postPatch or "") + ''
+        # after volume-button navigation mode, restore full keyboard functionality
+        cp ${./xkb_mobile_normal_buttons} ./configs/xkb/xkb_mobile_normal_buttons
+      '';
+    });
+  };
+}

hosts/by-name/lappy/xkb_mobile_normal_buttons

@@ -0,0 +1,7 @@
+xkb_keymap {
+	xkb_keycodes  { include "evdev+aliases(qwerty)"	};
+	xkb_types     { include "complete"	};
+	xkb_compat    { include "complete"	};
+	xkb_symbols   { include "pc+us+inet(evdev)"	};
+	xkb_geometry  { include "pc(pc105)"	};
+};

hosts/by-name/moby/bootloader.nix

@@ -0,0 +1,12 @@
+{ config, pkgs, ... }:
+{
+  # we need space in the GPT header to place tow-boot.
+  # only actually need 1 MB, but better to over-allocate than under-allocate
+  sane.image.extraGPTPadding = 16 * 1024 * 1024;
+  sane.image.firstPartGap = 0;
+  system.build.img = pkgs.runCommand "nixos_full-disk-image.img" {} ''
+    cp -v ${config.system.build.img-without-firmware}/nixos.img $out
+    chmod +w $out
+    dd if=${pkgs.tow-boot-pinephone}/Tow-Boot.noenv.bin of=$out bs=1024 seek=8 conv=notrunc
+  '';
+}

hosts/by-name/moby/default.nix

@@ -1,4 +1,7 @@
 # Pinephone
+# other setups to reference:
+# - <https://hamblingreen.gitlab.io/2022/03/02/my-pinephone-setup.html>
+#   - sxmo Arch user. lots of app recommendations
 #
 # wikis, resources, ...:
 # - Linux Phone Apps: <https://linuxphoneapps.org/>
@@ -6,43 +9,64 @@
 # - Mobian wiki: <https://wiki.mobian-project.org/doku.php?id=start>
 #   - recommended apps, chatrooms
 
-{ config, ... }:
+{ config, pkgs, lib, ... }:
 {
   imports = [
+    ./bootloader.nix
     ./fs.nix
+    ./gps.nix
+    ./kernel.nix
+    ./polyfill.nix
   ];
 
-  sane.hal.pine64-pinephone-pro.enable = true;
   sane.roles.client = true;
   sane.roles.handheld = true;
+  sane.zsh.showDeadlines = false;  # unlikely to act on them when in shell
   sane.services.wg-home.enable = true;
   sane.services.wg-home.ip = config.sane.hosts.by-name."moby".wg-home.ip;
-  sane.ovpn.addrV4 = "172.24.87.255";
-  # sane.ovpn.addrV6 = "fd00:0000:1337:cafe:1111:1111:18cd:a72b";
 
   # XXX colin: phosh doesn't work well with passwordless login,
   # so set this more reliable default password should anything go wrong
   users.users.colin.initialPassword = "147147";
+  services.getty.autologinUser = "root";  # allows for emergency maintenance?
 
   sops.secrets.colin-passwd.neededForUsers = true;
 
-  sane.services.rsync-net.enable = true;
-
-  sane.programs.sway.enableFor.user.colin = true;
-  sane.programs.sway.config.mod = "Mod1";  #< alt key instead of Super
+  sane.gui.sxmo.enable = true;
+  # sane.programs.consoleUtils.enableFor.user.colin = false;
+  # sane.programs.guiApps.enableFor.user.colin = false;
+  sane.programs.blueberry.enableFor.user.colin = false;  # bluetooth manager: doesn't cross compile!
+  sane.programs.dialect.enableFor.user.colin = false;  # drags in 700MB of x86 dependencies (e.g. gtk4)
+  sane.programs.mercurial.enableFor.user.colin = false;  # does not cross compile
+  sane.programs.nvme-cli.enableFor.system = false;  # does not cross compile (libhugetlbfs)
 
   # enabled for easier debugging
   sane.programs.eg25-control.enableFor.user.colin = true;
-  # sane.programs.rtl8723cs-wowlan.enableFor.user.colin = true;
-  # sane.programs.eg25-manager.enableFor.user.colin = true;
+  sane.programs.rtl8723cs-wowlan.enableFor.user.colin = true;
 
   # sane.programs.ntfy-sh.config.autostart = true;
   sane.programs.dino.config.autostart = true;
-  sane.programs.signal-desktop.config.autostart = false;
-  sane.programs.geary.config.autostart = false;
+  sane.programs.signal-desktop.config.autostart = true;
+  # sane.programs."gnome.geary".config.autostart = true;
+  # sane.programs.calls.config.autostart = true;
+  sane.programs.mpv.config.vo = "wlshm";  #< see hosts/common/programs/mpv.nix for details
 
-  sane.programs.pipewire.config = {
-    # tune so Dino doesn't drop audio
+  sane.programs.firefox.mime.priority = 300;  # prefer other browsers when possible
+  # HACK/TODO: make `programs.P.env.VAR` behave according to `mime.priority`
+  sane.programs.firefox.env = lib.mkForce {};
+  sane.programs.epiphany.env.BROWSER = "epiphany";
+
+  # note the .conf.d approach: using ~/.config/pipewire/pipewire.conf directly breaks all audio,
+  # presumably because that deletes the defaults entirely whereas the .conf.d approach selectively overrides defaults
+  sane.user.fs.".config/pipewire/pipewire.conf.d/10-fix-dino-mic-cutout.conf".symlink.text = ''
+    # config docs: <https://gitlab.freedesktop.org/pipewire/pipewire/-/wikis/Config-PipeWire#properties>
+    # useful to run `pw-top` to see that these settings are actually having effect,
+    # and `pw-metadata` to see if any settings conflict (e.g. max-quantum < min-quantum)
+    #
+    # restart pipewire after editing these files:
+    # - `systemctl --user restart pipewire`
+    # - pipewire users will likely stop outputting audio until they are also restarted
+    #
     # there's seemingly two buffers for the mic (see: <https://gitlab.freedesktop.org/pipewire/pipewire/-/wikis/FAQ#pipewire-buffering-explained>)
     # 1. Pipewire buffering out of the driver and into its own member.
     # 2. Pipewire buffering into Dino.
@@ -53,12 +77,97 @@
     # `pw-metadata -n settings 0 clock.force-quantum 1024` reduces to about 1 error per second.
     # `pw-metadata -n settings 0 clock.force-quantum 2048` reduces to 1 error every < 10s.
     # pipewire default config includes `clock.power-of-two-quantum = true`
-    min-quantum = 2048;
-    max-quantum = 8192;
+    context.properties = {
+      default.clock.min-quantum = 2048
+      default.clock.max-quantum = 8192
+    }
+  '';
+
+  boot.loader.efi.canTouchEfiVariables = false;
+  # /boot space is at a premium. default was 20.
+  # even 10 can be too much
+  boot.loader.generic-extlinux-compatible.configurationLimit = 8;
+  # mobile.bootloader.enable = false;
+  # mobile.boot.stage-1.enable = false;
+  # boot.initrd.systemd.enable = false;
+  # boot.initrd.services.swraid.enable = false;  # attempt to fix dm_mod stuff
+
+  # hardware.firmware makes the referenced files visible to the kernel, for whenever a driver explicitly asks for them.
+  # these files are visible from userspace by following `/sys/module/firmware_class/parameters/path`
+  #
+  # mobile-nixos' /lib/firmware includes:
+  #   rtl_bt          (bluetooth)
+  #   anx7688-fw.bin  (USB-C chip: power negotiation, HDMI/dock)
+  #   ov5640_af.bin   (camera module)
+  # hardware.firmware = [ config.mobile.device.firmware ];
+  # hardware.firmware = [ pkgs.rtl8723cs-firmware ];
+  hardware.firmware = [
+    (pkgs.linux-firmware-megous.override {
+      # rtl_bt = false probably means no bluetooth connectivity.
+      # N.B.: DON'T RE-ENABLE without first confirming that wake-on-lan works during suspend (rtcwake).
+      # it seems the rtl_bt stuff ("bluetooth coexist") might make wake-on-LAN radically more flaky.
+      rtl_bt = false;
+    })
+  ];
+
+  system.stateVersion = "21.11";
+
+  # defined: https://www.freedesktop.org/software/systemd/man/machine-info.html
+  # XXX colin: not sure which, if any, software makes use of this
+  environment.etc."machine-info".text = ''
+    CHASSIS="handset"
+  '';
+
+  # enable rotation sensor
+  hardware.sensor.iio.enable = true;
+
+  # inject specialized alsa configs via the environment.
+  # specifically, this gets the pinephone headphones & internal earpiece working.
+  # see pkgs/patched/alsa-ucm-conf for more info.
+  environment.variables.ALSA_CONFIG_UCM2 = "/run/current-system/sw/share/alsa/ucm2";
+  environment.pathsToLink = [ "/share/alsa/ucm2" ];
+  environment.systemPackages = [
+    (pkgs.alsa-ucm-conf-sane.override {
+      # internal speaker has a tendency to break :(
+      preferEarpiece = true;
+    })
+  ];
+  systemd = let
+    ucm-env = config.environment.variables.ALSA_CONFIG_UCM2;
+  in {
+    # cribbed from <repo:nixos/mobile-nixos:modules/quirks/audio.nix>
+
+    # pipewire
+    user.services.pipewire.environment.ALSA_CONFIG_UCM2       = ucm-env;
+    user.services.pipewire-pulse.environment.ALSA_CONFIG_UCM2 = ucm-env;
+    user.services.wireplumber.environment.ALSA_CONFIG_UCM2    = ucm-env;
+    services.pipewire.environment.ALSA_CONFIG_UCM2            = ucm-env;
+    services.pipewire-pulse.environment.ALSA_CONFIG_UCM2      = ucm-env;
+    services.wireplumber.environment.ALSA_CONFIG_UCM2         = ucm-env;
+
+    # pulseaudio
+    # user.services.pulseaudio.environment.ALSA_CONFIG_UCM2 = ucm-env;
+    # services.pulseaudio.environment.ALSA_CONFIG_UCM2      = ucm-env;
+
+
+    # TODO: move elsewhere...
+    services.ModemManager.serviceConfig = {
+      # N.B.: the extra "" in ExecStart serves to force upstream ExecStart to be ignored
+      ExecStart = [ "" "${pkgs.modemmanager}/bin/ModemManager --debug" ];
+      # --debug sets DEBUG level logging: so reset
+      ExecStartPost = [ "${pkgs.modemmanager}/bin/mmcli --set-logging=INFO" ];
+    };
   };
 
-  sane.programs.mpv.config.defaultProfile = "fast";
+  services.udev.extraRules = let
+    chmod = "${pkgs.coreutils}/bin/chmod";
+    chown = "${pkgs.coreutils}/bin/chown";
+  in ''
+    # make Pinephone flashlight writable by user.
+    # taken from postmarketOS: <repo:postmarketOS/pmaports:device/main/device-pine64-pinephone/60-flashlight.rules>
+    SUBSYSTEM=="leds", DEVPATH=="*/*:flash", RUN+="${chmod} g+w /sys%p/brightness /sys%p/flash_strobe", RUN+="${chown} :video /sys%p/brightness /sys%p/flash_strobe"
 
-  # /boot space is at a premium, especially with uncompressed kernels. default was 20.
-  boot.loader.generic-extlinux-compatible.configurationLimit = 10;
+    # make Pinephone front LEDs writable by user.
+    SUBSYSTEM=="leds", DEVPATH=="*/*:indicator", RUN+="${chmod} g+w /sys%p/brightness", RUN+="${chown} :video /sys%p/brightness"
+  '';
 }

hosts/by-name/moby/gps.nix

@@ -0,0 +1,69 @@
+# pinephone GPS happens in EG25 modem
+# serial control interface to modem is /dev/ttyUSB2
+# after enabling GPS, readout is /dev/ttyUSB1
+#
+# minimal process to enable modem and GPS:
+# - `echo 1 > /sys/class/modem-power/modem-power/device/powered`
+# - `screen /dev/ttyUSB2 115200`
+#   - `AT+QGPSCFG="nmeasrc",1`
+#   - `AT+QGPS=1`
+# this process is automated by my `eg25-control` program and services (`eg25-control-powered`, `eg25-control-gps`)
+# - see the `modules/` directory further up this repository.
+#
+# now, something like `gpsd` can directly read from /dev/ttyUSB1,
+# or geoclue can query the GPS directly through modem-manager
+#
+# initial GPS fix can take 15+ minutes.
+# meanwhile, services like eg25-manager or eg25-control-freshen-agps can speed this up by uploading assisted GPS data to the modem.
+#
+# support/help:
+# - geoclue, gnome-maps
+#   - irc: #gnome-maps on irc.gimp.org
+#   - Matrix: #gnome-maps:gnome.org  (unclear if bridged to IRC)
+#
+# programs to pair this with:
+# - `satellite-gtk`: <https://codeberg.org/tpikonen/satellite>
+#   - shows/tracks which satellites the GPS is connected to; useful to understand fix characteristics
+# - `gnome-maps`: uses geoclue, has route planning
+# - `mepo`: uses gpsd, minimalist, flaky, and buttons are kinda hard to activate on mobile
+# - puremaps?
+# - osmin?
+#
+# known/outstanding bugs:
+# - `systemctl start eg25-control-gps` can the hang the whole system (2023/10/06)
+#   - i think it's actually `eg25-control-powered` which does this (started by the gps)
+#   - best guess is modem draws so much power at launch that other parts of the system see undervoltage
+#   - workaround is to hard power-cycle the system. the modem may not bring up after reboot: leave unpowered for 60s and boot again.
+#
+# future work:
+# - integrate with [wigle](https://www.wigle.net/) for offline equivalent to Mozilla Location Services
+
+{ config, lib, ... }:
+{
+  # test gpsd with `gpspipe -w -n 10 2> /dev/null | grep -m 1 TPV | jq '.lat, .lon' | tr '\n' ' '`
+  # ^ should return <lat> <long>
+  services.gpsd.enable = true;
+  services.gpsd.devices = [ "/dev/ttyUSB1" ];
+
+  # test geoclue2 by building `geoclue2-with-demo-agent`
+  # and running "${geoclue2-with-demo-agent}/libexec/geoclue-2.0/demos/where-am-i"
+  # note that geoclue is dbus-activated, and auto-stops after 60s with no caller
+  services.geoclue2.enable = true;
+  services.geoclue2.appConfig.where-am-i = {
+    # this is the default "agent", shipped by geoclue package: allow it to use location
+    isAllowed = true;
+    isSystem = false;
+    # XXX: setting users != [] might be causing `where-am-i` to time out
+    users = [
+      # restrict to only one set of users. empty array (default) means "allow any user to access geolocation".
+      (builtins.toString config.users.users.colin.uid)
+    ];
+  };
+  systemd.services.geoclue.after = lib.mkForce [];  #< defaults to network-online, but not all my sources require network
+  users.users.geoclue.extraGroups = [
+    "dialout"  # TODO: figure out if dialout is required. that's for /dev/ttyUSB1, but geoclue probably doesn't read that?
+  ];
+
+  sane.services.eg25-control.enable = true;
+  sane.programs.where-am-i.enableFor.user.colin = true;
+}

hosts/by-name/moby/kernel.nix

@@ -0,0 +1,89 @@
+{ pkgs, ... }:
+let
+  dmesg = "${pkgs.util-linux}/bin/dmesg";
+  grep = "${pkgs.gnugrep}/bin/grep";
+  modprobe = "${pkgs.kmod}/bin/modprobe";
+  ensureHWReady = ''
+    # common boot failure:
+    # blank screen (no backlight even), with the following log:
+    # ```syslog
+    # sun8i-dw-hdmi 1ee0000.hdmi: Couldn't get the HDMI PHY
+    # ...
+    # sun4i-drm display-engine: Couldn't bind all pipelines components
+    # ...
+    # sun8i-dw-hdmi: probe of 1ee0000.hdmi failed with error -17
+    # ```
+    #
+    # in particular, that `probe ... failed` occurs *only* on failed boots
+    # (the other messages might sometimes occur even on successful runs?)
+    #
+    # reloading the sun8i hdmi driver usually gets the screen on, showing boot text.
+    # then restarting display-manager.service gets us to the login.
+    #
+    # NB: the above log is default level. though less specific, there's a `err` level message that also signals this:
+    # sun4i-drm display-engine: failed to bind 1ee0000.hdmi (ops sun8i_dw_hdmi_ops [sun8i_drm_hdmi]): -17
+    # NB: this is the most common, but not the only, failure mode for `display-manager`.
+    # another error seems characterized by these dmesg logs, in which reprobing sun8i_drm_hdmi does not fix:
+    # ```syslog
+    # sun6i-mipi-dsi 1ca0000.dsi: Couldn't get the MIPI D-PHY
+    # sun4i-drm display-engine: Couldn't bind all pipelines components
+    # sun6i-mipi-dsi 1ca0000.dsi: Couldn't register our component
+    # ```
+
+    if (${dmesg} --kernel --level err --color=never --notime | ${grep} -q 'sun4i-drm display-engine: failed to bind 1ee0000.hdmi')
+    then
+      echo "reprobing sun8i_drm_hdmi"
+      # if a command here fails it errors the whole service, so prefer to log instead
+      ${modprobe} -r sun8i_drm_hdmi || echo "failed to unload sun8i_drm_hdmi"
+      ${modprobe} sun8i_drm_hdmi || echo "failed to load sub8i_drm_hdmi"
+    fi
+  '';
+in
+{
+  boot.kernelPackages = pkgs.linuxPackagesFor pkgs.linux-megous;
+  # boot.kernelPackages = pkgs.linuxPackagesFor pkgs.linux-manjaro;
+  # boot.kernelPackages = pkgs.linuxPackagesFor pkgs.linux_latest;
+
+  # alternatively, apply patches directly to stock nixos kernel:
+  # boot.kernelPatches = manjaroPatches ++ [
+  #   (patchDefconfig kernelConfig)
+  # ];
+
+  # configure nixos to build a compressed kernel image, since it doesn't usually do that for aarch64 target.
+  # without this i run out of /boot space in < 10 generations
+  nixpkgs.hostPlatform.linux-kernel = {
+    # defaults:
+    name = "aarch64-multiplatform";
+    baseConfig = "defconfig";
+    DTB = true;
+    autoModules = true;
+    preferBuiltin = true;
+    # extraConfig = ...
+    # ^-- raspberry pi stuff: we don't need it.
+
+    # target = "Image";  # <-- default
+    target = "Image.gz";  # <-- compress the kernel image
+    # target = "zImage";  # <-- confuses other parts of nixos :-(
+  };
+
+  # disable proximity sensor.
+  # the filtering/calibration is bad that it causes the screen to go fully dark at times.
+  boot.blacklistedKernelModules = [ "stk3310" ];
+
+  boot.kernelParams = [
+    # without this some GUI apps fail: `DRM_IOCTL_MODE_CREATE_DUMB failed: Cannot allocate memory`
+    # this is because they can't allocate enough video ram.
+    # see related nixpkgs issue: <https://github.com/NixOS/nixpkgs/issues/260222>
+    #
+    # the default CMA seems to be 32M.
+    # i was running fine with 256MB from 2022/07-ish through 2022/12-ish, but then the phone quit reliably coming back from sleep (phosh): maybe a memory leak?
+    # `cat /proc/meminfo` to see CmaTotal/CmaFree if interested in tuning this.
+    "cma=512M"
+    # 2023/10/20: potential fix for the lima (GPU) timeout bugs:
+    # - <https://gitlab.com/postmarketOS/pmaports/-/issues/805#note_890467824>
+    "lima.sched_timeout_ms=2000"
+  ];
+
+  services.xserver.displayManager.job.preStart = ensureHWReady;
+  systemd.services.greetd.preStart = ensureHWReady;
+}

hosts/by-name/moby/polyfill.nix

@@ -0,0 +1,96 @@
+# this file configures preferences per program, without actually enabling any programs.
+# the goal is to separate the place where we decide *what* to use (i.e. `sane.programs.firefox.enable = true` -- at the toplevel)
+# from where we specific how that thing should behave *if* it's in use.
+#
+# NixOS backgrounds:
+# - <https://github.com/NixOS/nixos-artwork>
+#   - <https://github.com/NixOS/nixos-artwork/issues/50>  (colorful; unmerged)
+#   - <https://github.com/NixOS/nixos-artwork/pull/60/files>  (desktop-oriented; clean; unmerged)
+# - <https://itsfoss.com/content/images/2023/04/nixos-tutorials.png>
+
+{ lib, pkgs, sane-lib, ... }:
+{
+  sane.programs.firefox.config = {
+    # compromise impermanence for the sake of usability
+    persistCache = "private";
+    persistData = "private";
+
+    # i don't do crypto stuff on moby
+    addons.ether-metamask.enable = false;
+    # sidebery UX doesn't make sense on small screen
+    addons.sidebery.enable = false;
+  };
+  sane.programs.swaynotificationcenter.config = {
+    backlight = "backlight";  # /sys/class/backlight/*backlight*/brightness
+  };
+
+  sane.gui.sxmo = {
+    nogesture = true;
+    settings = {
+      ### hardware: touch screen
+      SXMO_LISGD_INPUT_DEVICE = "/dev/input/by-path/platform-1c2ac00.i2c-event";
+      # vol and power are detected correctly by upstream
+
+      ### preferences
+      DEFAULT_COUNTRY = "US";
+
+      SXMO_AUTOROTATE = "1";  # enable auto-rotation at launch. has no meaning in stock/upstream sxmo-utils
+
+      # BEMENU lines (wayland DMENU):
+      # - camera is 9th entry
+      # - flashlight is 10th entry
+      # - config is 14th entry. inside that:
+      #   - autorotate is 11th entry
+      #   - system menu is 19th entry
+      #   - close is 20th entry
+      # - power is 15th entry
+      # - close is 16th entry
+      SXMO_BEMENU_LANDSCAPE_LINES = "11";  # default 8
+      SXMO_BEMENU_PORTRAIT_LINES = "16";  # default 16
+      SXMO_LOCK_IDLE_TIME = "15";  # how long between screenoff -> lock -> back to screenoff (default: 8)
+      # gravity: how far to tilt the device before the screen rotates
+      # for a given setting, normal <-> invert requires more movement then left <-> right
+      # i.e. the settingd doesn't feel completely symmetric
+      # SXMO_ROTATION_GRAVITY default is 16374
+      # SXMO_ROTATION_GRAVITY = "12800";  # uncomfortably high
+      # SXMO_ROTATION_GRAVITY = "12500";    # kinda uncomfortable when walking
+      SXMO_ROTATION_GRAVITY = "12000";
+      SXMO_SCREENSHOT_DIR = "/home/colin/Pictures";  # default: "$HOME"
+
+      # sway/wayland scaling:
+      # - conflicting info out there on how scaling actually works
+      #   at the least, for things where it matters (mpv), it seems like scale settings have 0 effect on perf
+      # ways to enforce scaling:
+      # - <https://wiki.archlinux.org/title/HiDPI>
+      # - `swaymsg -- output DSI-1 scale 2.0`  (scales everything)
+      # - `dconf write /org/gnome/desktop/interface/text-scaling-factor 2.0`  (scales ONLY TEXT)
+      # - `GDK_DPI_SCALE=2.0`  (scales ONLY TEXT)
+      #
+      # application notes:
+      # - cozy: in landscape, playback position is not visible unless scale <= 1.7
+      #   - if in a tab, then scale 1.6 is the max
+      # SXMO_SWAY_SCALE = "1.5";  # hard to press gPodder icons
+      SXMO_SWAY_SCALE = "1.6";
+      # SXMO_SWAY_SCALE = "1.8";
+      # SXMO_SWAY_SCALE = "2";
+      SXMO_WORKSPACE_WRAPPING = "5";  # how many workspaces. default: 4
+
+      # wvkbd layers:
+      # - full
+      # - landscape
+      # - special  (e.g. coding symbols like ~)
+      # - emoji
+      # - nav
+      # - simple  (like landscape, but no parens/tab/etc; even fewer chars)
+      # - simplegrid  (simple, but grid layout)
+      # - dialer  (digits)
+      # - cyrillic
+      # - arabic
+      # - persian
+      # - greek
+      # - georgian
+      WVKBD_LANDSCAPE_LAYERS = "landscape,special,emoji";
+      WVKBD_LAYERS = "full,special,emoji";
+    };
+  };
+}

hosts/by-name/rescue/default.nix

@@ -4,11 +4,15 @@
     ./fs.nix
   ];
 
+  boot.loader.efi.canTouchEfiVariables = false;
   sane.image.extraBootFiles = [ pkgs.bootpart-uefi-x86_64 ];
-  sane.persist.enable = false;  # what we mean here is that the image is immutable; `/` is still tmpfs.
+  sane.persist.enable = false;
   sane.nixcache.enable = false;  # don't want to be calling out to dead machines that we're *trying* to rescue
 
   # auto-login at shell
   services.getty.autologinUser = "colin";
   # users.users.colin.initialPassword = "colin";
+
+  # docs: https://nixos.org/manual/nixos/stable/options.html#opt-system.stateVersion
+  system.stateVersion = "21.05";
 }

hosts/by-name/servo/default.nix

@@ -3,34 +3,41 @@
 {
   imports = [
     ./fs.nix
-    ./net
+    ./net.nix
     ./services
-    ./users
   ];
 
-  # for administering services
-  sane.programs.clightning-sane.enableFor.user.colin = true;
-  # sane.programs.freshrss.enableFor.user.colin = true;
-  # sane.programs.signaldctl.enableFor.user.colin = true;
-  # sane.programs.matrix-synapse.enableFor.user.colin = true;
+  sane.programs = {
+    # for administering services
+    freshrss.enableFor.user.colin = true;
+    matrix-synapse.enableFor.user.colin = true;
+    signaldctl.enableFor.user.colin = true;
+  };
 
   sane.roles.build-machine.enable = true;
-  sane.programs.sane-deadlines.config.showOnLogin = false;  # ~/knowledge doesn't always exist
+  sane.roles.build-machine.emulation = false;
+  sane.zsh.showDeadlines = false;  # ~/knowledge doesn't always exist
   sane.programs.consoleUtils.suggestedPrograms = [
-    "consoleMediaUtils"  # notably, for go2tv / casting
     "pcConsoleUtils"
     "sane-scripts.stop-all-servo"
   ];
   sane.services.dyn-dns.enable = true;
+  sane.services.wg-home.enable = true;
+  sane.services.wg-home.visibleToWan = true;
+  sane.services.wg-home.forwardToWan = true;
+  sane.services.wg-home.routeThroughServo = false;
+  sane.services.wg-home.ip = config.sane.hosts.by-name."servo".wg-home.ip;
+  sane.nixcache.substituters.servo = false;
+  sane.nixcache.substituters.desko = false;
   sane.nixcache.remote-builders.desko = false;
   sane.nixcache.remote-builders.servo = false;
-  sane.services.rsync-net.enable = true;
+  # sane.services.duplicity.enable = true;  # TODO: re-enable after HW upgrade
 
   # automatically log in at the virtual consoles.
-  # using root here makes sure we always have an escape hatch.
-  # XXX(2024-07-27): this is incompatible if using s6, which needs to auto-login as `colin` to start its user services.
+  # using root here makes sure we always have an escape hatch
   services.getty.autologinUser = "root";
 
+  boot.loader.efi.canTouchEfiVariables = false;
   sane.image.extraBootFiles = [ pkgs.bootpart-uefi-x86_64 ];
 
   # both transmission and ipfs try to set different net defaults.
@@ -38,5 +45,13 @@
   boot.kernel.sysctl = {
     "net.core.rmem_max" = 4194304;  # 4MB
   };
+
+  # This value determines the NixOS release from which the default
+  # settings for stateful data, like file locations and database versions
+  # on your system were taken. It‘s perfectly fine and recommended to leave
+  # this value at the release version of the first install of this system.
+  # Before changing this value read the documentation for this option
+  # (e.g. man configuration.nix or on https://nixos.org/nixos/options.html).
+  system.stateVersion = "21.11";
 }
 

hosts/by-name/servo/fs.nix

@@ -1,16 +1,6 @@
-{ lib, pkgs, ... }:
+{ ... }:
 
 {
-  # hostId: not used for anything except zfs guardrail?
-  #   [hex(ord(x)) for x in 'serv']
-  # networking.hostId = "73657276";
-
-  sane.persist.stores."ext" = {
-    origin = "/mnt/pool/persist";
-    storeDescription = "external HDD storage";
-    defaultMethod = "bind";  #< TODO: change to "symlink"?
-  };
-
   # increase /tmp space (defaults to 50% of RAM) for building large nix things.
   # even the stock `nixpkgs.linux` consumes > 16 GB of tmp
   fileSystems."/tmp".options = [ "size=32G" ];
@@ -29,75 +19,97 @@
     fsType = "vfat";
   };
 
-  fileSystems."/mnt/pool" = {
-    # all btrfs devices of the same RAID volume use the same UUID.
-    device = "UUID=40fc6e1d-ba41-44de-bbf3-1aa02c3441df";
+  # slow, external storage (for archiving, etc)
+  fileSystems."/mnt/persist/ext" = {
+    device = "/dev/disk/by-uuid/aa272cff-0fcc-498e-a4cb-0d95fb60631b";
     fsType = "btrfs";
     options = [
-      # "compress=zstd"  #< not much point in compressing... mostly videos and music; media.
+      "compress=zstd"
       "defaults"
-      # `device=...` only needed if `btrfs scan` hasn't yet been run
-      # see: <https://askubuntu.com/a/484374>
-      # i don't know what guarantees NixOS/systemd make about that, so specifying all devices for now
-      # "device=/dev/disk/by-partuuid/14a7d00a-be53-2b4e-96f9-7e2c964674ec"  #< removed 2024-11-24 (for capacity upgrade)
-      "device=/dev/disk/by-partuuid/409a147e-2282-49eb-87a7-c968032ede88"  #< added 2024-11-24
-      "device=/dev/disk/by-partuuid/6b86cc10-c3cc-ec4d-b20d-b6688f0959a6"
-      # "device=/dev/disk/by-partuuid/7fd85cac-b6f3-8248-af4e-68e703d11020"  #< removed 2024-11-13 (early drive failure)
-      "device=/dev/disk/by-partuuid/d9ad5ebc-0fc4-4d89-9fd0-619ce5210f1b"  #< added 2024-11-13
-      "device=/dev/disk/by-partuuid/ef0e5c7b-fccf-f444-bac4-534424326159"
-      "nofail"
-      # "x-systemd.before=local-fs.target"
-      "x-systemd.device-bound=false"  #< don't unmount when `device` disappears (i thought this was necessary, for drive replacement, but it might not be)
-      "x-systemd.device-timeout=60s"
-      "x-systemd.mount-timeout=60s"
     ];
   };
 
-  # TODO: move this elsewhere and automate the ACLs!
-  # FIRST TIME SETUP FOR MEDIA DIRECTORY:
-  # - set the group sticky bit: `sudo find /var/media -type d -exec chmod g+s {} +`
-  #   - this ensures new files/dirs inherit the group of their parent dir (instead of the user who creates them)
-  # - ensure everything under /var/media is mounted with `-o acl`, to support acls
-  # - ensure all files are rwx by group: `setfacl --recursive --modify d:g::rwx /var/media`
-  #   - alternatively, `d:g:media:rwx` to grant `media` group even when file has a different owner, but that's a bit complex
-  sane.persist.sys.byStore.ext = [{
-    path = "/var/media";
-    user = "colin";
-    group = "media";
-    mode = "0775";
-  }];
-  sane.fs."/var/media/archive".dir = {};
-  # this is file.text instead of symlink.text so that it may be read over a remote mount (where consumers might not have any /nix/store/.../README.md path)
-  sane.fs."/var/media/archive/README.md".file.text = ''
+  sane.persist.stores."ext" = {
+    origin = "/mnt/persist/ext/persist";
+    storeDescription = "external HDD storage";
+  };
+  sane.fs."/mnt/persist/ext".mount = {};
+
+  sane.persist.sys.byStore.plaintext = [
+    # TODO: this is overly broad; only need media and share directories to be persisted
+    { user = "colin"; group = "users"; path = "/var/lib/uninsane"; }
+  ];
+  # force some problematic directories to always get correct permissions:
+  sane.fs."/var/lib/uninsane/media".dir.acl = {
+    user = "colin"; group = "media"; mode = "0775";
+  };
+  sane.fs."/var/lib/uninsane/media/archive".dir = {};
+  sane.fs."/var/lib/uninsane/media/archive/README.md".file.text = ''
     this directory is for media i wish to remove from my library,
     but keep for a short time in case i reverse my decision.
     treat it like a system trash can.
   '';
-  sane.fs."/var/media/Books".dir = {};
-  sane.fs."/var/media/Books/Audiobooks".dir = {};
-  sane.fs."/var/media/Books/Books".dir = {};
-  sane.fs."/var/media/Books/Visual".dir = {};
-  sane.fs."/var/media/collections".dir = {};
-  sane.fs."/var/media/freeleech".dir = {};
-  sane.fs."/var/media/Music".dir = {};
-  sane.fs."/var/media/Pictures".dir = {};
-  sane.fs."/var/media/Videos".dir = {};
-  sane.fs."/var/media/Videos/Film".dir = {};
-  sane.fs."/var/media/Videos/Shows".dir = {};
-  sane.fs."/var/media/Videos/Talks".dir = {};
+  sane.fs."/var/lib/uninsane/media/Books".dir = {};
+  sane.fs."/var/lib/uninsane/media/Books/Audiobooks".dir = {};
+  sane.fs."/var/lib/uninsane/media/Books/Books".dir = {};
+  sane.fs."/var/lib/uninsane/media/Books/Visual".dir = {};
+  sane.fs."/var/lib/uninsane/media/collections".dir = {};
+  sane.fs."/var/lib/uninsane/media/datasets".dir = {};
+  sane.fs."/var/lib/uninsane/media/freeleech".dir = {};
+  sane.fs."/var/lib/uninsane/media/Music".dir = {};
+  sane.fs."/var/lib/uninsane/media/Pictures".dir = {};
+  sane.fs."/var/lib/uninsane/media/Videos".dir = {};
+  sane.fs."/var/lib/uninsane/media/Videos/Film".dir = {};
+  sane.fs."/var/lib/uninsane/media/Videos/Shows".dir = {};
+  sane.fs."/var/lib/uninsane/media/Videos/Talks".dir = {};
+  sane.fs."/var/lib/uninsane/datasets/README.md".file.text = ''
+    this directory may seem redundant with ../media/datasets. it isn't.
+    this directory exists on SSD, allowing for speedy access to specific datasets when necessary.
+    the contents should be a subset of what's in ../media/datasets.
+  '';
+  # make sure large media is stored to the HDD
+  sane.persist.sys.byStore.ext = [
+    {
+      user = "colin";
+      group = "users";
+      mode = "0777";
+      path = "/var/lib/uninsane/media/Videos";
+    }
+    {
+      user = "colin";
+      group = "users";
+      mode = "0777";
+      path = "/var/lib/uninsane/media/freeleech";
+    }
+    {
+      user = "colin";
+      group = "users";
+      mode = "0777";
+      path = "/var/lib/uninsane/media/datasets";
+    }
+  ];
 
-  systemd.services.dedupe-media = {
-    description = "transparently de-duplicate /var/media entries by using block-level hardlinks";
-    script = ''
-      ${lib.getExe' pkgs.util-linux "hardlink"} /var/media --reflink=always --ignore-time --verbose
-    '';
-  };
-  systemd.timers.dedupe-media = {
-    wantedBy = [ "multi-user.target" ];
-    timerConfig = {
-      OnStartupSec = "23min";
-      OnUnitActiveSec = "720min";
-    };
-  };
+  # btrfs doesn't easily support swapfiles
+  # swapDevices = [
+  #   { device = "/nix/persist/swapfile"; size = 4096; }
+  # ];
+
+  # this can be a partition. create with:
+  #   fdisk <dev>
+  #     n
+  #     <default partno>
+  #     <start>
+  #     <end>
+  #     t
+  #     <partno>
+  #     19  # set part type to Linux swap
+  #     w   # write changes
+  #   mkswap -L swap <part>
+  # swapDevices = [
+  #   {
+  #     label = "swap";
+  #     # TODO: randomEncryption.enable = true;
+  #   }
+  # ];
 }
 

hosts/by-name/servo/net.nix

@@ -0,0 +1,233 @@
+{ config, lib, pkgs, ... }:
+
+let
+  portOpts = with lib; types.submodule {
+    options = {
+      visibleTo.ovpn = mkOption {
+        type = types.bool;
+        default = false;
+      };
+    };
+  };
+in
+{
+  options = with lib; {
+    sane.ports.ports = mkOption {
+      # add the `visibleTo.ovpn` option
+      type = types.attrsOf portOpts;
+    };
+  };
+
+  config = {
+    networking.domain = "uninsane.org";
+
+    sane.ports.openFirewall = true;
+    sane.ports.openUpnp = true;
+
+    # view refused packets with: `sudo journalctl -k`
+    # networking.firewall.logRefusedPackets = true;
+
+    # The global useDHCP flag is deprecated, therefore explicitly set to false here.
+    # Per-interface useDHCP will be mandatory in the future, so this generated config
+    # replicates the default behaviour.
+    networking.useDHCP = false;
+    networking.interfaces.eth0.useDHCP = true;
+    # XXX colin: probably don't need this. wlan0 won't be populated unless i touch a value in networking.interfaces.wlan0
+    networking.wireless.enable = false;
+
+    # this is needed to forward packets from the VPN to the host
+    boot.kernel.sysctl."net.ipv4.ip_forward" = 1;
+
+    # unless we add interface-specific settings for each VPN, we have to define nameservers globally.
+    # networking.nameservers = [
+    #   "1.1.1.1"
+    #   "9.9.9.9"
+    # ];
+
+    # use systemd's stub resolver.
+    # /etc/resolv.conf isn't sophisticated enough to use different servers per net namespace (or link).
+    # instead, running the stub resolver on a known address in the root ns lets us rewrite packets
+    # in the ovnps namespace to use the provider's DNS resolvers.
+    # a weakness is we can only query 1 NS at a time (unless we were to clone the packets?)
+    # there also seems to be some cache somewhere that's shared between the two namespaces.
+    # i think this is a libc thing. might need to leverage proper cgroups to _really_ kill it.
+    # - getent ahostsv4 www.google.com
+    # - try fix: <https://serverfault.com/questions/765989/connect-to-3rd-party-vpn-server-but-dont-use-it-as-the-default-route/766290#766290>
+    services.resolved.enable = true;
+    # without DNSSEC:
+    # - dig matrix.org => works
+    # - curl https://matrix.org => works
+    # with default DNSSEC:
+    # - dig matrix.org => works
+    # - curl https://matrix.org => fails
+    # i don't know why. this might somehow be interfering with the DNS run on this device (trust-dns)
+    services.resolved.dnssec = "false";
+    networking.nameservers = [
+      # use systemd-resolved resolver
+      # full resolver (which understands /etc/hosts) lives on 127.0.0.53
+      # stub resolver (just forwards upstream) lives on 127.0.0.54
+      "127.0.0.53"
+    ];
+
+    # nscd -- the Name Service Caching Daemon -- caches DNS query responses
+    # in a way that's unaware of my VPN routing, so routes are frequently poor against
+    # services which advertise different IPs based on geolocation.
+    # nscd claims to be usable without a cache, but in practice i can't get it to not cache!
+    # nsncd is the Name Service NON-Caching Daemon. it's a drop-in that doesn't cache;
+    # this is OK on the host -- because systemd-resolved caches. it's probably sub-optimal
+    # in the netns and we query upstream DNS more often than needed. hm.
+    # TODO: run a separate recursive resolver in each namespace.
+    services.nscd.enableNsncd = true;
+
+    # services.resolved.extraConfig = ''
+    #   # docs: `man resolved.conf`
+    #   # DNS servers to use via the `wg-ovpns` interface.
+    #   #   i hope that from the root ns, these aren't visible.
+    #   DNS=46.227.67.134%wg-ovpns 192.165.9.158%wg-ovpns
+    #   FallbackDNS=1.1.1.1 9.9.9.9
+    # '';
+
+    # OVPN CONFIG (https://www.ovpn.com):
+    # DOCS: https://nixos.wiki/wiki/WireGuard
+    # if you `systemctl restart wireguard-wg-ovpns`, make sure to also restart any other services in `NetworkNamespacePath = .../ovpns`.
+    # TODO: why not create the namespace as a seperate operation (nix config for that?)
+    networking.wireguard.enable = true;
+    networking.wireguard.interfaces.wg-ovpns = let
+      ip = "${pkgs.iproute2}/bin/ip";
+      in-ns = "${ip} netns exec ovpns";
+      iptables = "${pkgs.iptables}/bin/iptables";
+      veth-host-ip = "10.0.1.5";
+      veth-local-ip = "10.0.1.6";
+      vpn-ip = "185.157.162.178";
+      # DNS = 46.227.67.134, 192.165.9.158, 2a07:a880:4601:10f0:cd45::1, 2001:67c:750:1:cafe:cd45::1
+      vpn-dns = "46.227.67.134";
+      bridgePort = port: proto: ''
+        ${in-ns} ${iptables} -A PREROUTING -t nat -p ${proto} --dport ${port} -m iprange --dst-range ${vpn-ip} \
+          -j DNAT --to-destination ${veth-host-ip}
+      '';
+      bridgeStatements = lib.foldlAttrs
+        (acc: port: portCfg: acc ++ (builtins.map (bridgePort port) portCfg.protocol))
+        []
+        config.sane.ports.ports;
+    in {
+      privateKeyFile = config.sops.secrets.wg_ovpns_privkey.path;
+      # wg is active only in this namespace.
+      # run e.g. ip netns exec ovpns <some command like ping/curl/etc, it'll go through wg>
+      #   sudo ip netns exec ovpns ping www.google.com
+      interfaceNamespace = "ovpns";
+      ips = [
+        "185.157.162.178/32"
+      ];
+      peers = [
+        {
+          publicKey = "SkkEZDCBde22KTs/Hc7FWvDBfdOCQA4YtBEuC3n5KGs=";
+          endpoint = "185.157.162.10:9930";
+          # alternatively: use hostname, but that presents bootstrapping issues (e.g. if host net flakes)
+          # endpoint = "vpn36.prd.amsterdam.ovpn.com:9930";
+          allowedIPs = [ "0.0.0.0/0" ];
+          # nixOS says this is important for keeping NATs active
+          persistentKeepalive = 25;
+          # re-executes wg this often. docs hint that this might help wg notice DNS/hostname changes.
+          # so, maybe that helps if we specify endpoint as a domain name
+          # dynamicEndpointRefreshSeconds = 30;
+          # when refresh fails, try it again after this period instead.
+          # TODO: not avail until nixpkgs upgrade
+          # dynamicEndpointRefreshRestartSeconds = 5;
+        }
+      ];
+      preSetup = ''
+        ${ip} netns add ovpns || echo "ovpns already exists"
+      '';
+      postShutdown = ''
+        ${in-ns} ip link del ovpns-veth-b || echo "couldn't delete ovpns-veth-b"
+        ${ip} link del ovpns-veth-a || echo "couldn't delete ovpns-veth-a"
+        ${ip} netns delete ovpns || echo "couldn't delete ovpns"
+        # restore rules/routes
+        ${ip} rule del from ${veth-host-ip} lookup ovpns pref 50 || echo "couldn't delete init -> ovpns rule"
+        ${ip} route del default via ${veth-local-ip} dev ovpns-veth-a proto kernel src ${veth-host-ip} metric 1002 table ovpns || echo "couldn't delete init -> ovpns route"
+        ${ip} rule add from all lookup local pref 0
+        ${ip} rule del from all lookup local pref 100
+      '';
+      postSetup = ''
+        # DOCS:
+        # - some of this approach is described here: <https://josephmuia.ca/2018-05-16-net-namespaces-veth-nat/>
+        # - iptables primer: <https://danielmiessler.com/study/iptables/>
+        # create veth pair
+        ${ip} link add ovpns-veth-a type veth peer name ovpns-veth-b
+        ${ip} addr add ${veth-host-ip}/24 dev ovpns-veth-a
+        ${ip} link set ovpns-veth-a up
+
+        # mv veth-b into the ovpns namespace
+        ${ip} link set ovpns-veth-b netns ovpns
+        ${in-ns} ip addr add ${veth-local-ip}/24 dev ovpns-veth-b
+        ${in-ns} ip link set ovpns-veth-b up
+
+        # make it so traffic originating from the host side of the veth
+        # is sent over the veth no matter its destination.
+        ${ip} rule add from ${veth-host-ip} lookup ovpns pref 50
+        # for traffic originating at the host veth to the WAN, use the veth as our gateway
+        # not sure if the metric 1002 matters.
+        ${ip} route add default via ${veth-local-ip} dev ovpns-veth-a proto kernel src ${veth-host-ip} metric 1002 table ovpns
+        # give the default route lower priority
+        ${ip} rule add from all lookup local pref 100
+        ${ip} rule del from all lookup local pref 0
+
+        # in order to access DNS in this netns, we need to route it to the VPN's nameservers
+        # - alternatively, we could fix DNS servers like 1.1.1.1.
+        ${in-ns} ${iptables} -A OUTPUT -t nat -p udp --dport 53 -m iprange --dst-range 127.0.0.53 \
+          -j DNAT --to-destination ${vpn-dns}:53
+      '' + (lib.concatStringsSep "\n" bridgeStatements);
+    };
+
+    # create a new routing table that we can use to proxy traffic out of the root namespace
+    # through the ovpns namespace, and to the WAN via VPN.
+    networking.iproute2.rttablesExtraConfig = ''
+      5 ovpns
+    '';
+    networking.iproute2.enable = true;
+
+
+    # HURRICANE ELECTRIC CONFIG:
+    # networking.sits = {
+    #   hurricane = {
+    #     remote = "216.218.226.238";
+    #     local = "192.168.0.5";
+    #     # local = "10.0.0.5";
+    #     # remote = "10.0.0.1";
+    #     # local = "10.0.0.22";
+    #     dev = "eth0";
+    #     ttl = 255;
+    #   };
+    # };
+    # networking.interfaces."hurricane".ipv6 = {
+    #   addresses = [
+    #     # mx.uninsane.org (publically routed /64)
+    #     {
+    #       address = "2001:470:b:465::1";
+    #       prefixLength = 128;
+    #     }
+    #     # client addr
+    #     # {
+    #     #   address = "2001:470:a:466::2";
+    #     #   prefixLength = 64;
+    #     # }
+    #   ];
+    #   routes = [
+    #     {
+    #       address = "::";
+    #       prefixLength = 0;
+    #       # via = "2001:470:a:466::1";
+    #     }
+    #   ];
+    # };
+
+    # # after configuration, we want the hurricane device to look like this:
+    # # hurricane: flags=209<UP,POINTOPOINT,RUNNING,NOARP>  mtu 1480
+    # #            inet6 2001:470:a:450::2  prefixlen 64  scopeid 0x0<global>
+    # #            inet6 fe80::c0a8:16  prefixlen 64  scopeid 0x20<link>
+    # #            sit  txqueuelen 1000  (IPv6-in-IPv4)
+    # # test with:
+    # #   curl --interface hurricane http://[2607:f8b0:400a:80b::2004]
+    # #   ping 2607:f8b0:400a:80b::2004
+  };
+}

hosts/by-name/servo/net/default.nix

@@ -1,60 +0,0 @@
-# debugging:
-# - enable logs (shows handshake attempts)
-#   - `echo module wireguard +p | sane-sudo-redirect /sys/kernel/debug/dynamic_debug/control`
-#   - `sudo dmesg --follow`
-#     patterns: "Sending keepalive packet to peer NN (N.N.N.N:NNNNN)"
-#     patterns: "Sending handshake initiation to peer NN (N.N.N.N:NNNNN)"
-# - when wg-doof and wg-ovpns stop routing traffic, restart with:
-#   - `systemctl restart netns-doof-wg`
-# - handshaking:
-#   - `wg show` should *always* show "latest handshake: N", with N < 2 minutes ago.
-{ lib, ... }:
-let
-  portOpts = with lib; types.submodule {
-    options = {
-      visibleTo.ovpns = mkOption {
-        type = types.bool;
-        default = false;
-        description = ''
-          whether to forward inbound traffic on the OVPN vpn port to the corresponding localhost port.
-        '';
-      };
-      visibleTo.doof = mkOption {
-        type = types.bool;
-        default = false;
-        description = ''
-          whether to forward inbound traffic on the doofnet vpn port to the corresponding localhost port.
-        '';
-      };
-    };
-  };
-in
-{
-  options = with lib; {
-    sane.ports.ports = mkOption {
-      # add the `visibleTo.{doof,ovpns}` options
-      type = types.attrsOf portOpts;
-    };
-  };
-
-  imports = [
-    ./doof.nix
-    ./ovpn.nix
-    ./wg-home.nix
-  ];
-
-  config = {
-    networking.domain = "uninsane.org";
-    systemd.network.networks."50-eth0" = {
-      matchConfig.Name = "eth0";
-      networkConfig.Address = [
-        "205.201.63.12/32"
-        "10.78.79.51/22"
-      ];
-      networkConfig.DNS = [ "10.78.79.1" ];
-    };
-
-    sane.ports.openFirewall = true;
-    sane.ports.openUpnp = true;
-  };
-}

hosts/by-name/servo/net/doof.nix

@@ -1,27 +0,0 @@
-{ config, ... }:
-{
-  # tun-sea config
-  sane.dns.zones."uninsane.org".inet.A."doof.tunnel" = "205.201.63.12";
-  # sane.dns.zones."uninsane.org".inet.AAAA."doof.tunnel" = "2602:fce8:106::51";  #< TODO: enable IPv6 (i have /128)
-
-  # if the tunnel breaks, restart it manually:
-  # - `systemctl restart netns-doof.service`
-  sane.netns.doof = {
-    veth.initns.ipv4 = "10.0.2.5";
-    veth.netns.ipv4 = "10.0.2.6";
-    routeTable = 12;
-    # wg.port = 51821;
-    wg.privateKeyFile = config.sops.secrets.wg_doof_privkey.path;
-    wg.address.ipv4 = "205.201.63.12";
-    wg.peer.publicKey = "nuESyYEJ3YU0hTZZgAd7iHBz1ytWBVM5PjEL1VEoTkU=";
-    wg.peer.endpoint = "tun-sea.doof.net:53263";
-    # wg.peer.endpoint = "205.201.63.44:53263";
-  };
-
-  # inside doof, forward DNS requests back to the root machine
-  # this is fine: nothing inside the ns performs DNS except for wireguard,
-  # and we're not forwarding external DNS requests here
-  # XXX: ACTUALLY, CAN'T EASILY DO THAT BECAUSE HICKORY-DNS IS ALREADY USING PORT 53
-  # but that's ok, we don't really need DNS *inside* this namespace.
-  # sane.netns.doof.dns.ipv4 = config.sane.netns.doof.veth.netns.ipv4;
-}

hosts/by-name/servo/net/ovpn.nix

@@ -1,20 +0,0 @@
-{ config, ... }:
-{
-  sane.ovpn.addrV4 = "172.23.174.114";
-  # sane.ovpn.addrV6 = "fd00:0000:1337:cafe:1111:1111:8df3:14b0";
-
-  # OVPN CONFIG (https://www.ovpn.com):
-  # DOCS: https://nixos.wiki/wiki/WireGuard
-  sane.netns.ovpns = {
-    veth.initns.ipv4 = "10.0.1.5";
-    veth.netns.ipv4 = "10.0.1.6";
-    routeTable = 11;
-    dns.ipv4 = "46.227.67.134";  #< DNS requests inside the namespace are forwarded here
-    # wg.port = 51822;
-    wg.privateKeyFile = config.sops.secrets.wg_ovpns_privkey.path;
-    wg.address.ipv4 = "185.157.162.178";
-    wg.peer.publicKey = "SkkEZDCBde22KTs/Hc7FWvDBfdOCQA4YtBEuC3n5KGs=";
-    wg.peer.endpoint = "vpn36.prd.amsterdam.ovpn.com:9930";
-    # wg.peer.endpoint = "185.157.162.10:9930";
-  };
-}

hosts/by-name/servo/net/wg-home.nix

@@ -1,15 +0,0 @@
-{ config, ... }:
-{
-  sane.services.wg-home.enable = true;
-  sane.services.wg-home.visibleToWan = true;
-  sane.services.wg-home.forwardToWan = true;
-  sane.services.wg-home.routeThroughServo = false;
-  sane.services.wg-home.ip = config.sane.hosts.by-name."servo".wg-home.ip;
-  services.unbound.settings.server.interface = [
-    # provide DNS to my wireguard clients
-    config.sane.hosts.by-name."servo".wg-home.ip
-  ];
-  services.unbound.settings.server.access-control = [
-    "${config.sane.hosts.by-name."servo".wg-home.ip}/24 allow"
-  ];
-}

hosts/by-name/servo/services/calibre.nix

@@ -0,0 +1,34 @@
+{ config, lib, ... }:
+
+let
+  cweb-cfg = config.services.calibre-web;
+  inherit (cweb-cfg) user group;
+  inherit (cweb-cfg.listen) ip port;
+  svc-dir = "/var/lib/${cweb-cfg.dataDir}";
+in
+# XXX: disabled because of runtime errors like:
+# > File "/nix/store/c7jqvx980nlg9xhxi065cba61r2ain9y-calibre-web-0.6.19/lib/python3.10/site-packages/calibreweb/cps/db.py", line 926, in speaking_language
+# > languages = self.session.query(Languages) \
+# > AttributeError: 'NoneType' object has no attribute 'query'
+lib.mkIf false
+{
+  sane.persist.sys.byStore.plaintext = [
+    { inherit user group; mode = "0700"; path = svc-dir; }
+  ];
+
+  services.calibre-web.enable = true;
+  services.calibre-web.listen.ip = "127.0.0.1";
+  # XXX: externally populate `${svc-dir}/metadata.db` (once) from
+  #   <https://github.com/janeczku/calibre-web/blob/master/library/metadata.db>
+  # i don't know why you have to do this??
+  # services.calibre-web.options.calibreLibrary = svc-dir;
+
+  services.nginx.virtualHosts."calibre.uninsane.org" = {
+    addSSL = true;
+    enableACME = true;
+    locations."/" = {
+      proxyPass = "http://${ip}:${builtins.toString port}";
+    };
+  };
+  sane.dns.zones."uninsane.org".inet.CNAME."calibre" = "native";
+}

hosts/by-name/servo/services/coturn.nix

@@ -24,65 +24,50 @@
 #   that is NOT the case when the STUN server and client A are on the same LAN
 #   even if client A contacts the STUN server via its WAN address with port reflection enabled.
 #   hence, there's no obvious way to put the STUN server on the same LAN as either client and expect the rest to work.
-# - there an old version which *half worked*, which is:
-#   - run the turn server in the root namespace.
-#   - bind the turn server to the veth connecting it to the VPN namespace (so it sends outgoing traffic to the right place).
-#   - NAT the turn port range from VPN into root namespace (so it receives incomming traffic).
-#   - this approach would fail the prosody conversations.im check, but i didn't notice *obvious* call routing errors.
-#
-# debugging:
-# - log messages like 'usage: realm=<turn.uninsane.org>, username=<1715915193>, rp=14, rb=1516, sp=8, sb=684'
-#   - rp = received packets
-#   - rb = received bytes
-#   - sp = sent packets
-#   - sb = sent bytes
-
-{ config, lib, ... }:
+{ lib, ... }:
 let
-  # TURN port range (inclusive).
-  # default coturn behavior is to use the upper quarter of all ports. i.e. 49152 - 65535.
-  # i believe TURN allocations expire after either 5 or 10 minutes of inactivity.
-  turnPortLow = 49152; # 49152 = 0xc000
-  turnPortHigh = turnPortLow + 256;
+  # TODO: this range could be larger, but right now that's costly because each element is its own UPnP forward
+  # TURN port range (inclusive)
+  turnPortLow = 49152;
+  turnPortHigh = 49167;
   turnPortRange = lib.range turnPortLow turnPortHigh;
 in
 {
-  # the port definitions are only needed if running in the root net namespace
-  # sane.ports.ports = lib.mkMerge ([
-  #   {
-  #     "3478" = {
-  #       # this is the "control" port.
-  #       # i.e. no client data is forwarded through it, but it's where clients request tunnels.
-  #       protocol = [ "tcp" "udp" ];
-  #       # visibleTo.lan = true;
-  #       # visibleTo.wan = true;
-  #       visibleTo.ovpns = true;  # forward traffic from the VPN to the root NS
-  #       description = "colin-stun-turn";
-  #     };
-  #     "5349" = {
-  #       # the other port 3478 also supports TLS/DTLS, but presumably clients wanting TLS will default 5349
-  #       protocol = [ "tcp" ];
-  #       # visibleTo.lan = true;
-  #       # visibleTo.wan = true;
-  #       visibleTo.ovpns = true;
-  #       description = "colin-stun-turn-over-tls";
-  #     };
-  #   }
-  # ] ++ (builtins.map
-  #   (port: {
-  #     "${builtins.toString port}" = let
-  #       count = port - turnPortLow + 1;
-  #       numPorts = turnPortHigh - turnPortLow + 1;
-  #     in {
-  #       protocol = [ "tcp" "udp" ];
-  #       # visibleTo.lan = true;
-  #       # visibleTo.wan = true;
-  #       visibleTo.ovpns = true;
-  #       description = "colin-turn-${builtins.toString count}-of-${builtins.toString numPorts}";
-  #     };
-  #   })
-  #   turnPortRange
-  # ));
+  sane.ports.ports = lib.mkMerge ([
+    {
+      "3478" = {
+        # this is the "control" port.
+        # i.e. no client data is forwarded through it, but it's where clients request tunnels.
+        protocol = [ "tcp" "udp" ];
+        # visibleTo.lan = true;
+        # visibleTo.wan = true;
+        visibleTo.ovpn = true;
+        description = "colin-stun-turn";
+      };
+      "5349" = {
+        # the other port 3478 also supports TLS/DTLS, but presumably clients wanting TLS will default 5349
+        protocol = [ "tcp" ];
+        # visibleTo.lan = true;
+        # visibleTo.wan = true;
+        visibleTo.ovpn = true;
+        description = "colin-stun-turn-over-tls";
+      };
+    }
+  ] ++ (builtins.map
+    (port: {
+      "${builtins.toString port}" = let
+        count = port - turnPortLow + 1;
+        numPorts = turnPortHigh - turnPortLow + 1;
+      in {
+        protocol = [ "tcp" "udp" ];
+        # visibleTo.lan = true;
+        # visibleTo.wan = true;
+        visibleTo.ovpn = true;
+        description = "colin-turn-${builtins.toString count}-of-${builtins.toString numPorts}";
+      };
+    })
+    turnPortRange
+  ));
 
   services.nginx.virtualHosts."turn.uninsane.org" = {
     # allow ACME to procure a cert via nginx for this domain
@@ -104,6 +89,13 @@ in
     SRV."_turns._tcp" =                       "5 50 5349 turn";
   };
 
+  sane.derived-secrets."/var/lib/coturn/shared_secret.bin" = {
+    encoding = "base64";
+    # TODO: make this not globally readable
+    acl.mode = "0644";
+  };
+  sane.fs."/var/lib/coturn/shared_secret.bin".wantedBeforeBy = [ "coturn.service" ];
+
   # provide access to certs
   users.users.turnserver.extraGroups = [ "nginx" ];
 
@@ -111,33 +103,22 @@ in
   services.coturn.realm = "turn.uninsane.org";
   services.coturn.cert = "/var/lib/acme/turn.uninsane.org/fullchain.pem";
   services.coturn.pkey = "/var/lib/acme/turn.uninsane.org/key.pem";
-
-  # N.B.: prosody needs to read this shared secret
-  sops.secrets."coturn_shared_secret".owner = "turnserver";
-  sops.secrets."coturn_shared_secret".group = "turnserver";
-  sops.secrets."coturn_shared_secret".mode = "0440";
-
-  #v disable to allow unauthenticated access (or set `services.coturn.no-auth = true`)
   services.coturn.use-auth-secret = true;
-  services.coturn.static-auth-secret-file = "/run/secrets/coturn_shared_secret";
-  services.coturn.lt-cred-mech = true; #< XXX: use-auth-secret overrides lt-cred-mech
-
+  services.coturn.static-auth-secret-file = "/var/lib/coturn/shared_secret.bin";
+  services.coturn.lt-cred-mech = true;
   services.coturn.min-port = turnPortLow;
   services.coturn.max-port = turnPortHigh;
   # services.coturn.secure-stun = true;
   services.coturn.extraConfig = lib.concatStringsSep "\n" [
     "verbose"
-    # "Verbose"  #< even MORE verbosity than "verbose"  (it's TOO MUCH verbosity really)
-    "no-multicast-peers"  # disables sending to IPv4 broadcast addresses (e.g. 224.0.0.0/3)
-    # "listening-ip=${config.sane.netns.ovpns.veth.initns.ipv4}" "external-ip=${config.sane.netns.ovpns.wg.address.ipv4}"  #< 2024/04/25: works, if running in root namespace
-    "listening-ip=${config.sane.netns.ovpns.wg.address.ipv4}" "external-ip=${config.sane.netns.ovpns.wg.address.ipv4}"
-
-    # old attempts:
-    # "external-ip=${config.sane.netns.ovpns.wg.address.ipv4}/${config.sane.netns.ovpns.veth.initns.ipv4}"
+    # "Verbose"  #< even MORE verbosity than "verbose"
+    # "no-multicast-peers"  # disables sending to IPv4 broadcast addresses (e.g. 224.0.0.0/3)
+    "listening-ip=10.0.1.5"
+    # "external-ip=185.157.162.178/10.0.1.5"
+    "external-ip=185.157.162.178"
     # "listening-ip=10.78.79.51"  # can be specified multiple times; omit for *
     # "external-ip=97.113.128.229/10.78.79.51"
     # "external-ip=97.113.128.229"
     # "mobility"  # "mobility with ICE (MICE) specs support" (?)
   ];
-  systemd.services.coturn.serviceConfig.NetworkNamespacePath = "/run/netns/ovpns";
 }

hosts/by-name/servo/services/cryptocurrencies/bitcoin.nix

@@ -1,125 +0,0 @@
-# as of 2023/12/02: complete blockchain is 530 GiB (on-disk size may be larger)
-#
-# ports:
-# - 8333: for node-to-node communications
-# - 8332: rpc (client-to-node)
-#
-# rpc setup:
-# - generate a password
-#   - use: <https://github.com/bitcoin/bitcoin/blob/master/share/rpcauth/rpcauth.py>
-#     (rpcauth.py is not included in the `'.#bitcoin'` package result)
-#   - `wget https://raw.githubusercontent.com/bitcoin/bitcoin/master/share/rpcauth/rpcauth.py`
-#   - `python ./rpcauth.py colin`
-#   - copy the hash here. it's SHA-256, so safe to be public.
-#   - add "rpcuser=colin" and "rpcpassword=<output>" to secrets/servo/bitcoin.conf  (i.e. ~/.bitcoin/bitcoin.conf)
-#     - bitcoin.conf docs: <https://github.com/bitcoin/bitcoin/blob/master/doc/bitcoin-conf.md>
-# - validate with `bitcoin-cli -netinfo`
-{ config, lib, pkgs, sane-lib, ... }:
-let
-  # bitcoind = config.sane.programs.bitcoind.packageUnwrapped;
-  bitcoind = pkgs.bitcoind;
-  # wrapper to run bitcoind with the tor onion address as externalip (computed at runtime)
-  _bitcoindWithExternalIp = pkgs.writeShellScriptBin "bitcoind" ''
-    set -xeu
-    externalip="$(cat /var/lib/tor/onion/bitcoind/hostname)"
-    exec ${lib.getExe' bitcoind "bitcoind"} "-externalip=$externalip" "$@"
-  '';
-  # the package i provide to services.bitcoind ends up on system PATH, and used by other tools like clightning.
-  # therefore, even though services.bitcoind only needs `bitcoind` binary, provide all the other bitcoin-related binaries (notably `bitcoin-cli`) as well:
-  bitcoindWithExternalIp = pkgs.symlinkJoin {
-    name = "bitcoind-with-external-ip";
-    paths = [ _bitcoindWithExternalIp bitcoind ];
-  };
-in
-{
-  sane.persist.sys.byStore.ext = [
-    { user = "bitcoind-mainnet"; group = "bitcoind-mainnet"; path = "/var/lib/bitcoind-mainnet"; method = "bind"; }
-  ];
-
-  # sane.ports.ports."8333" = {
-  #   # this allows other nodes and clients to download blocks from me.
-  #   protocol = [ "tcp" ];
-  #   visibleTo.wan = true;
-  #   description = "colin-bitcoin";
-  # };
-
-  services.tor.relay.onionServices.bitcoind = {
-    version = 3;
-    map = [{
-      # by default tor will route public tor port P to 127.0.0.1:P.
-      # so if this port is the same as clightning would natively use, then no further config is needed here.
-      # see: <https://2019.www.torproject.org/docs/tor-manual.html.en#HiddenServicePort>
-      port = 8333;
-      # target.port; target.addr;  #< set if tor port != clightning port
-    }];
-    # allow "tor" group (i.e. bitcoind-mainnet) to read /var/lib/tor/onion/bitcoind/hostname
-    settings.HiddenServiceDirGroupReadable = true;
-  };
-
-  services.bitcoind.mainnet = {
-    enable = true;
-    package = bitcoindWithExternalIp;
-    rpc.users.colin = {
-      # see docs at top of file for how to generate this
-      passwordHMAC = "30002c05d82daa210550e17a182db3f3$6071444151281e1aa8a2729f75e3e2d224e9d7cac3974810dab60e7c28ffaae4";
-    };
-    extraConfig = ''
-      # checkblocks: default 6: how many blocks to verify on start
-      checkblocks=3
-      # don't load the wallet, and disable wallet RPC calls
-      disablewallet=1
-      # proxy all outbound traffic through Tor
-      proxy=127.0.0.1:9050
-    '';
-    extraCmdlineOptions = [
-      # "-debug"
-      # "-debug=estimatefee"
-      # "-debug=http"
-      # "-debug=net"
-      "-debug=proxy"
-      "-debug=rpc"
-      # "-debug=validation"
-    ];
-  };
-
-  users.users.bitcoind-mainnet.extraGroups = [ "tor" ];
-
-  systemd.services.bitcoind-mainnet = {
-    after = [ "tor.service" ];
-    requires = [ "tor.service" ];
-    serviceConfig.RestartSec = "30s";  #< default is 0
-
-    # hardening (systemd-analyze security bitcoind-mainnet)
-    serviceConfig.StateDirectory = "bitcoind-mainnet";
-    serviceConfig.LockPersonality = true;
-    serviceConfig.MemoryDenyWriteExecute = "true";
-    serviceConfig.NoNewPrivileges = "true";
-    serviceConfig.PrivateDevices = "true";
-    serviceConfig.PrivateMounts = true;
-    serviceConfig.PrivateTmp = "true";
-    serviceConfig.PrivateUsers = true;
-    serviceConfig.ProcSubset = "pid";
-    serviceConfig.ProtectControlGroups = true;
-    serviceConfig.ProtectHome = true;
-    serviceConfig.ProtectHostname = true;
-    serviceConfig.ProtectKernelLogs = true;
-    serviceConfig.ProtectKernelModules = true;
-    serviceConfig.ProtectKernelTunables = true;
-    serviceConfig.ProtectProc = "invisible";
-    serviceConfig.ProtectSystem = lib.mkForce "strict";
-    serviceConfig.RemoveIPC = true;
-    serviceConfig.RestrictAddressFamilies = "AF_UNIX AF_INET AF_INET6";
-    serviceConfig.RestrictNamespaces = true;
-    serviceConfig.RestrictSUIDSGID = true;
-    serviceConfig.SystemCallArchitectures = "native";
-    serviceConfig.SystemCallFilter = [ "@system-service" ];
-  };
-
-  sops.secrets."bitcoin.conf" = {
-    mode = "0600";
-    owner = "colin";
-    group = "users";
-  };
-
-  sane.programs.bitcoin-cli.enableFor.user.colin = true;  # for debugging/administration: `bitcoin-cli`
-}

hosts/by-name/servo/services/cryptocurrencies/clightning.nix

@@ -1,147 +0,0 @@
-# clightning is an implementation of Bitcoin's Lightning Network.
-# as such, this assumes that `services.bitcoin` is enabled.
-# docs:
-# - tor clightning config: <https://docs.corelightning.org/docs/tor>
-# - `lightning-cli` and subcommands: <https://docs.corelightning.org/reference/lightning-cli>
-# - `man lightningd-config`
-#
-# management/setup/use:
-# - guide: <https://github.com/ElementsProject/lightning>
-#
-# debugging:
-# - `lightning-cli getlog debug`
-# - `lightning-cli listpays`  -> show payments this node sent
-# - `lightning-cli listinvoices`  -> show payments this node received
-#
-# first, acquire peers:
-# - `lightning-cli connect id@host`
-#   where `id` is the node's pubkey, and `host` is perhaps an ip:port tuple, or a hash.onion:port tuple.
-#   for testing, choose any node listed on <https://1ml.com>
-# - `lightning-cli listpeers`
-#   should show the new peer, with `connected: true`
-#
-# then, fund the clightning wallet
-# - `lightning-cli newaddr`
-#
-# then, open channels
-# - `lightning-cli connect ...`
-# - `lightning-cli fundchannel <node_id> <amount_in_satoshis>`
-#
-# who to federate with?
-# - a lot of the larger nodes allow hands-free channel creation
-#   - either inbound or outbound, sometimes paid
-# - find nodes on:
-#   - <https://terminal.lightning.engineering/>
-#   - <https://1ml.com>
-#     - tor nodes: <https://1ml.com/node?order=capacity&iponionservice=true>
-#   - <https://lightningnetwork.plus>
-#   - <https://mempool.space/lightning>
-#   - <https://amboss.space>
-# - a few tor-capable nodes which allow channel creation:
-#   - <https://c-otto.de/>
-#   - <https://cyberdyne.sh/>
-#   - <https://yalls.org/about/>
-#   - <https://coincept.com/>
-# - more resources: <https://www.lopp.net/lightning-information.html>
-#   - node routability: https://hashxp.org/lightning/node/<id>
-# - especially, acquire inbound liquidity via lightningnetwork.plus's swap feature
-#   - most of the opportunities are gated behind a minimum connection or capacity requirement
-#
-# tune payment parameters
-# - `lightning-cli setchannel <id> [feebase] [feeppm] [htlcmin] [htlcmax] [enforcedelay] [ignorefeelimits]`
-#   - e.g. `lightning-cli setchannel all 0 10`
-#   - it's suggested that feebase=0 simplifies routing.
-#
-# teardown:
-# - `lightning-cli withdraw <bc1... dest addr> <amount in satoshis> [feerate]`
-#
-# sanity:
-# - `lightning-cli listfunds`
-#
-# to receive a payment (do as `clightning` user):
-# - `lightning-cli invoice <amount in millisatoshi> <label> <description>`
-#   - specify amount as `any` if undetermined
-#   - then give the resulting bolt11 URI to the payer
-# to send a payment:
-# - `lightning-cli pay <bolt11 URI>`
-#   - or `lightning-cli pay <bolt11 URI> [amount_msat] [label] [riskfactor] [maxfeepercent] ...`
-#   - amount_msat must be "null" if the bolt11 URI specifies a value
-#   - riskfactor defaults to 10
-#   - maxfeepercent defaults to 0.5
-#   - label is a human-friendly label for my records
-
-{ config, pkgs, ... }:
-{
-  sane.persist.sys.byStore.private = [
-    # clightning takes up only a few MB. but then several hundred MB of crash logs that i should probably GC.
-    { user = "clightning"; group = "clightning"; mode = "0710"; path = "/var/lib/clightning"; method = "bind"; }
-  ];
-
-  # see bitcoin.nix for how to generate this
-  services.bitcoind.mainnet.rpc.users.clightning.passwordHMAC =
-    "befcb82d9821049164db5217beb85439$2c31ac7db3124612e43893ae13b9527dbe464ab2d992e814602e7cb07dc28985";
-
-  sane.services.clightning.enable = true;
-  sane.services.clightning.proxy = "127.0.0.1:9050";  # proxy outgoing traffic through tor
-  # sane.services.clightning.publicAddress = "statictor:127.0.0.1:9051";
-  sane.services.clightning.getPublicAddressCmd = "cat /var/lib/tor/onion/clightning/hostname";
-
-  services.tor.relay.onionServices.clightning = {
-    version = 3;
-    map = [{
-      # by default tor will route public tor port P to 127.0.0.1:P.
-      # so if this port is the same as clightning would natively use, then no further config is needed here.
-      # see: <https://2019.www.torproject.org/docs/tor-manual.html.en#HiddenServicePort>
-      port = 9735;
-      # target.port; target.addr;  #< set if tor port != clightning port
-    }];
-    # allow "tor" group (i.e. clightning) to read /var/lib/tor/onion/clightning/hostname
-    settings.HiddenServiceDirGroupReadable = true;
-  };
-
-  # must be in "tor" group to read /var/lib/tor/onion/*/hostname
-  users.users.clightning.extraGroups = [ "tor" ];
-
-  systemd.services.clightning.after = [ "tor.service" ];
-  systemd.services.clightning.requires = [ "tor.service" ];
-
-  # lightning-config contains fields from here:
-  # - <https://docs.corelightning.org/docs/configuration>
-  # secret config includes:
-  # - bitcoin-rpcpassword
-  # - alias=nodename
-  # - rgb=rrggbb
-  # - fee-base=<millisatoshi>
-  # - fee-per-satoshi=<ppm>
-  # - feature configs (i.e. experimental-xyz options)
-  sane.services.clightning.extraConfig = ''
-    # log levels: "io", "trace", "debug", "info", "unusual", "broken"
-    # log-level=info
-    # log-level=info:lightningd
-    # log-level=debug:lightningd
-    log-level=debug
-    # log-level=io
-
-    disable-plugin=cln-xpay
-
-    # let me use `lightning-cli dev-*` subcommands, fucktards.
-    developer
-    # `developer` enables `dev-*` but *disables* the older commands. asshats.
-    allow-deprecated-apis=true
-
-    # peerswap:
-    # - config example: <https://github.com/fort-nix/nix-bitcoin/pull/462/files#diff-b357d832705b8ce8df1f41934d613f79adb77c4cd5cd9e9eb12a163fca3e16c6>
-    # XXX: peerswap crashes clightning on launch. stacktrace is useless.
-    # plugin={lib.getExe' pkgs.peerswap "peerswap"}
-    # peerswap-db-path=/var/lib/clightning/peerswap/swaps
-    # peerswap-policy-path=...
-  '';
-  sane.services.clightning.extraConfigFiles = [ config.sops.secrets."lightning-config".path ];
-  sops.secrets."lightning-config" = {
-    mode = "0640";
-    owner = "clightning";
-    group = "clightning";
-  };
-
-  sane.programs.lightning-cli.enableFor.user.colin = true;  # for debugging/admin:
-}

hosts/by-name/servo/services/cryptocurrencies/default.nix

@@ -1,10 +0,0 @@
-{ ... }:
-{
-  imports = [
-    ./bitcoin.nix
-    ./clightning.nix
-    ./i2p.nix
-    ./monero.nix
-    ./tor.nix
-  ];
-}

hosts/by-name/servo/services/cryptocurrencies/i2p.nix

@@ -1,5 +0,0 @@
-{ lib, ... }:
-lib.mkIf false  #< 2024/07/27: i don't use it, too much surface-area for me to run it pro-bono (`systemd-analyze security monero`)
-{
-  services.i2p.enable = true;
-}

hosts/by-name/servo/services/cryptocurrencies/tor.nix

@@ -1,25 +0,0 @@
-# tor settings: <https://2019.www.torproject.org/docs/tor-manual.html.en>
-{ lib, ... }:
-{
-  sane.persist.sys.byStore.ephemeral = [
-    # N.B.: tor hidden service hostnames aren't deterministic, so if you need them
-    # to be preserved across reboots then persist /var/lib/tor/onion in "private" store.
-   { user = "tor"; group = "tor"; mode = "0710"; path = "/var/lib/tor"; method = "bind"; }
-  ];
-
-  # tor: `tor.enable` doesn't start a relay, exit node, proxy, etc. it's minimal.
-  # tor.client.enable configures a torsocks proxy, accessible *only* to localhost.
-  #   at 127.0.0.1:9050
-  services.tor.enable = true;
-  services.tor.client.enable = true;
-
-  # in order for services to read /var/lib/tor/onion/*/hostname, they must be able to traverse /var/lib/tor,
-  # and /var/lib/tor must have g+x.
-  # DataDirectoryGroupReadable causes tor to use g+rx, technically more than we need, but all the files are 600 so it's fine.
-  services.tor.settings.DataDirectoryGroupReadable = true;
-  # StateDirectoryMode defaults to 0700, and thereby prevents the onion hostnames from being group readable
-  systemd.services.tor.serviceConfig.StateDirectoryMode = lib.mkForce "0710";
-  users.users.tor.homeMode = "0710";  # home mode defaults to 0700, causing readability problems, enforced by nixos "users" activation script
-
-  services.tor.settings.SafeLogging = false;  # show actual .onion names in the syslog, else debugging is impossible
-}

hosts/by-name/servo/services/ddns-afraid.nix

@@ -0,0 +1,27 @@
+{ config, lib, pkgs, ... }:
+
+# using manual ddns now
+lib.mkIf false
+{
+  systemd.services.ddns-afraid = {
+    description = "update dynamic DNS entries for freedns.afraid.org";
+    serviceConfig = {
+      EnvironmentFile = config.sops.secrets."ddns_afraid.env".path;
+      # TODO: ProtectSystem = "strict";
+      # TODO: ProtectHome = "full";
+      # TODO: PrivateTmp = true;
+    };
+    script = let
+      curl = "${pkgs.curl}/bin/curl -4";
+    in ''
+      ${curl} "https://freedns.afraid.org/dynamic/update.php?$AFRAID_KEY"
+    '';
+  };
+  systemd.timers.ddns-afraid = {
+    wantedBy = [ "multi-user.target" ];
+    timerConfig = {
+      OnStartupSec = "2min";
+      OnUnitActiveSec = "10min";
+    };
+  };
+}

hosts/by-name/servo/services/ddns-he.nix

@@ -0,0 +1,30 @@
+{ config, lib, pkgs, ... }:
+
+# we use manual DDNS now
+lib.mkIf false
+{
+  systemd.services.ddns-he = {
+    description = "update dynamic DNS entries for HurricaneElectric";
+    serviceConfig = {
+      EnvironmentFile = config.sops.secrets."ddns_he.env".path;
+      # TODO: ProtectSystem = "strict";
+      # TODO: ProtectHome = "full";
+      # TODO: PrivateTmp = true;
+    };
+    # HE DDNS API is documented: https://dns.he.net/docs.html
+    script = let
+      crl = "${pkgs.curl}/bin/curl -4";
+    in ''
+      ${crl} "https://he.uninsane.org:$HE_PASSPHRASE@dyn.dns.he.net/nic/update?hostname=he.uninsane.org"
+      ${crl} "https://native.uninsane.org:$HE_PASSPHRASE@dyn.dns.he.net/nic/update?hostname=native.uninsane.org"
+      ${crl} "https://uninsane.org:$HE_PASSPHRASE@dyn.dns.he.net/nic/update?hostname=uninsane.org"
+    '';
+  };
+  systemd.timers.ddns-he = {
+    wantedBy = [ "multi-user.target" ];
+    timerConfig = {
+      OnStartupSec = "2min";
+      OnUnitActiveSec = "10min";
+    };
+  };
+}

hosts/by-name/servo/services/default.nix

@@ -1,35 +1,35 @@
 { ... }:
 {
   imports = [
+    ./calibre.nix
     ./coturn.nix
-    ./cryptocurrencies
+    ./ddns-afraid.nix
+    ./ddns-he.nix
     ./email
     ./ejabberd.nix
     ./freshrss.nix
     ./export
-    ./hickory-dns.nix
-    ./gerbera.nix
     ./gitea.nix
     ./goaccess.nix
     ./ipfs.nix
-    ./jackett
-    ./jellyfin
+    ./jackett.nix
+    ./jellyfin.nix
     ./kiwix-serve.nix
     ./komga.nix
     ./lemmy.nix
     ./matrix
-    ./minidlna.nix
-    ./mumble.nix
+    ./monero.nix
     ./navidrome.nix
     ./nginx.nix
-    ./nixos-prebuild.nix
+    ./nixserve.nix
     ./ntfy
     ./pict-rs.nix
     ./pleroma.nix
-    ./postgresql
+    ./postgres.nix
     ./prosody
     ./slskd.nix
-    ./transmission
+    ./transmission.nix
+    ./trust-dns.nix
     ./wikipedia.nix
   ];
 }

hosts/by-name/servo/services/ejabberd.nix

@@ -44,61 +44,61 @@ in
 # everything configured below was fine: used ejabberd for several months.
 lib.mkIf false
 {
-  sane.persist.sys.byStore.private = [
-    { user = "ejabberd"; group = "ejabberd"; path = "/var/lib/ejabberd"; method = "bind"; }
+  sane.persist.sys.byStore.plaintext = [
+    { user = "ejabberd"; group = "ejabberd"; path = "/var/lib/ejabberd"; }
   ];
   sane.ports.ports = lib.mkMerge ([
     {
       "3478" = {
         protocol = [ "tcp" "udp" ];
-        visibleTo.doof = true;
         visibleTo.lan = true;
+        visibleTo.wan = true;
         description = "colin-xmpp-stun-turn";
       };
       "5222" = {
         protocol = [ "tcp" ];
-        visibleTo.doof = true;
         visibleTo.lan = true;
+        visibleTo.wan = true;
         description = "colin-xmpp-client-to-server";
       };
       "5223" = {
         protocol = [ "tcp" ];
-        visibleTo.doof = true;
         visibleTo.lan = true;
+        visibleTo.wan = true;
         description = "colin-xmpps-client-to-server";  # XMPP over TLS
       };
       "5269" = {
         protocol = [ "tcp" ];
-        visibleTo.doof = true;
+        visibleTo.wan = true;
         description = "colin-xmpp-server-to-server";
       };
       "5270" = {
         protocol = [ "tcp" ];
-        visibleTo.doof = true;
+        visibleTo.wan = true;
         description = "colin-xmpps-server-to-server";  # XMPP over TLS
       };
       "5280" = {
         protocol = [ "tcp" ];
-        visibleTo.doof = true;
         visibleTo.lan = true;
+        visibleTo.wan = true;
         description = "colin-xmpp-bosh";
       };
       "5281" = {
         protocol = [ "tcp" ];
-        visibleTo.doof = true;
         visibleTo.lan = true;
+        visibleTo.wan = true;
         description = "colin-xmpp-bosh-https";
       };
       "5349" = {
         protocol = [ "tcp" ];
-        visibleTo.doof = true;
         visibleTo.lan = true;
+        visibleTo.wan = true;
         description = "colin-xmpp-stun-turn-over-tls";
       };
       "5443" = {
         protocol = [ "tcp" ];
-        visibleTo.doof = true;
         visibleTo.lan = true;
+        visibleTo.wan = true;
         description = "colin-xmpp-web-services";  # file uploads, websockets, admin
       };
     }
@@ -109,8 +109,8 @@ lib.mkIf false
         numPorts = turnPortHigh - turnPortLow + 1;
       in {
         protocol = [ "tcp" "udp" ];
-        visibleTo.doof = true;
         visibleTo.lan = true;
+        visibleTo.wan = true;
         description = "colin-xmpp-turn-${builtins.toString count}-of-${builtins.toString numPorts}";
       };
     })
@@ -457,12 +457,13 @@ lib.mkIf false
         mod_version = {};
       };
     });
+    sed = "${pkgs.gnused}/bin/sed";
   in ''
     ip=$(cat '${config.sane.services.dyn-dns.ipPath}')
     # config is 444 (not 644), so we want to write out-of-place and then atomically move
     # TODO: factor this out into `sane-woop` helper?
     rm -f /var/lib/ejabberd/ejabberd.yaml.new
-    ${lib.getExe pkgs.gnused} "s/%ANATIVE%/$ip/g" ${config-in} > /var/lib/ejabberd/ejabberd.yaml.new
+    ${sed} "s/%ANATIVE%/$ip/g" ${config-in} > /var/lib/ejabberd/ejabberd.yaml.new
     mv /var/lib/ejabberd/ejabberd.yaml{.new,}
   '';
 

hosts/by-name/servo/services/email/dovecot.nix

@@ -8,14 +8,14 @@
 {
   sane.ports.ports."143" = {
     protocol = [ "tcp" ];
-    visibleTo.doof = true;
     visibleTo.lan = true;
+    visibleTo.wan = true;
     description = "colin-imap-imap.uninsane.org";
   };
   sane.ports.ports."993" = {
     protocol = [ "tcp" ];
-    visibleTo.doof = true;
     visibleTo.lan = true;
+    visibleTo.wan = true;
     description = "colin-imaps-imap.uninsane.org";
   };
 
@@ -83,8 +83,8 @@
     #   sieve_plugins = sieve_imapsieve
     # }
 
-    # mail_debug = yes
-    # auth_debug = yes
+    mail_debug = yes
+    auth_debug = yes
     # verbose_ssl = yes
   '';
 
@@ -127,11 +127,10 @@
   services.dovecot2.modules = [
     pkgs.dovecot_pigeonhole  # enables sieve execution (?)
   ];
-  services.dovecot2.sieve = {
-    extensions = [ "fileinto" ];
+  services.dovecot2.sieveScripts = {
     # if any messages fail to pass (or lack) DKIM, move them to Junk
     # XXX the key name ("after") is only used to order sieve execution/ordering
-    scripts.after = builtins.toFile "ensuredkim.sieve" ''
+    after = builtins.toFile "ensuredkim.sieve" ''
       require "fileinto";
 
       if not header :contains "Authentication-Results" "dkim=pass" {
@@ -140,6 +139,4 @@
       }
     '';
   };
-
-  systemd.services.dovecot2.serviceConfig.RestartSec = lib.mkForce "15s";  # nixos defaults this to 1s
 }

hosts/by-name/servo/services/email/postfix.nix

@@ -1,13 +1,6 @@
 # postfix config options: <https://www.postfix.org/postconf.5.html>
-# config files:
-# - /etc/postfix/main.cf
-# - /etc/postfix/master.cf
-#
-# logs:
-# - postfix logs directly to *syslog*,
-#   so check e.g. ~/.local/share/rsyslog
 
-{ config, lib, pkgs, ... }:
+{ lib, pkgs, ... }:
 
 let
   submissionOptions = {
@@ -25,14 +18,14 @@ let
   };
 in
 {
-  sane.persist.sys.byStore.private = [
+  sane.persist.sys.byStore.plaintext = [
     # TODO: mode? could be more granular
-    { user = "opendkim"; group = "opendkim"; path = "/var/lib/opendkim"; method = "bind"; }  #< TODO: migrate to secrets
-    { user = "root"; group = "root"; path = "/var/spool/mail"; method = "bind"; }
+    { user = "opendkim"; group = "opendkim"; path = "/var/lib/opendkim"; }
+    { user = "root"; group = "root"; path = "/var/lib/postfix"; }
+    { user = "root"; group = "root"; path = "/var/spool/mail"; }
     # *probably* don't need these dirs:
     # "/var/lib/dhparams"          # https://github.com/NixOS/nixpkgs/blob/master/nixos/modules/security/dhparams.nix
     # "/var/lib/dovecot"
-    # "/var/lib/postfix"
   ];
 
   # XXX(2023/10/20): opening these ports in the firewall has the OPPOSITE effect as intended.
@@ -63,7 +56,8 @@ in
 
   sane.dns.zones."uninsane.org".inet = {
     MX."@" = "10 mx.uninsane.org.";
-    A."mx" = "%AOVPNS%"; #< XXX: RFC's specify that the MX record CANNOT BE A CNAME. TODO: use "%AOVPNS%?
+    # XXX: RFC's specify that the MX record CANNOT BE A CNAME
+    A."mx" = "185.157.162.178";
 
     # Sender Policy Framework:
     #   +mx     => mail passes if it originated from the MX
@@ -102,7 +96,6 @@ in
   services.postfix.sslCert = "/var/lib/acme/mx.uninsane.org/fullchain.pem";
   services.postfix.sslKey = "/var/lib/acme/mx.uninsane.org/key.pem";
 
-  # see: `man 5 virtual`
   services.postfix.virtual = ''
     notify.matrix@uninsane.org matrix-synapse
     @uninsane.org colin
@@ -143,32 +136,17 @@ in
     # smtpd_sender_restrictions = reject_unknown_sender_domain
   };
 
-  # debugging options:
-  # services.postfix.masterConfig = {
-  #   "proxymap".args = [ "-v" ];
-  #   "proxywrite".args = [ "-v" ];
-  #   "relay".args = [ "-v" ];
-  #   "smtp".args = [ "-v" ];
-  #   "smtp_inet".args = [ "-v" ];
-  #   "submission".args = [ "-v" ];
-  #   "submissions".args = [ "-v" ];
-  #   "submissions".chroot = false;
-  #   "submissions".private = false;
-  #   "submissions".privileged = true;
-  # };
-
   services.postfix.enableSubmission = true;
   services.postfix.submissionOptions = submissionOptions;
   services.postfix.enableSubmissions = true;
   services.postfix.submissionsOptions = submissionOptions;
 
-  systemd.services.postfix.unitConfig.RequiresMountsFor = [
-    "/var/spool/mail"  # spooky errors when postfix is run w/o this: `warning: connect #1 to subsystem private/proxymap: Connection refused`
-    "/var/lib/opendkim"
-  ];
-
-  # run these behind the OVPN static VPN
-  sane.netns.ovpns.services = [ "opendkim" "postfix" ];
+  systemd.services.postfix.after = [ "wireguard-wg-ovpns.service" ];
+  systemd.services.postfix.partOf = [ "wireguard-wg-ovpns.service" ];
+  systemd.services.postfix.serviceConfig = {
+    # run this behind the OVPN static VPN
+    NetworkNamespacePath = "/run/netns/ovpns";
+  };
 
 
   #### OPENDKIM
@@ -187,37 +165,34 @@ in
   # keeping this the same as the hostname seems simplest
   services.opendkim.selector = "mx";
 
+  systemd.services.opendkim.after = [ "wireguard-wg-ovpns.service" ];
+  systemd.services.opendkim.partOf = [ "wireguard-wg-ovpns.service" ];
   systemd.services.opendkim.serviceConfig = {
+    # run this behind the OVPN static VPN
+    NetworkNamespacePath = "/run/netns/ovpns";
     # /run/opendkim/opendkim.sock needs to be rw by postfix
     UMask = lib.mkForce "0011";
   };
 
 
   #### OUTGOING MESSAGE REWRITING:
-  # - `man 5 header_checks`
-  #   - <https://www.postfix.org/header_checks.5.html>
-  # - populates `/var/lib/postfix/conf/header_checks`
-  # XXX(2024-08-06): registration gating via email matches is AWFUL:
-  # 1. bypassed if the service offers localization.
-  # 2. if i try to forward the registration request, it may match the filter again and get sent back to my inbox.
-  # 3. header checks are possibly under-used in the ecosystem, and may break postfix config.
-  # services.postfix.enableHeaderChecks = true;
-  # services.postfix.headerChecks = [
-  #   # intercept gitea registration confirmations and manually screen them
-  #   {
-  #     # headerChecks are somehow ignorant of alias rules: have to redirect to a real user
-  #     action = "REDIRECT colin@uninsane.org";
-  #     pattern = "/^Subject: Please activate your account/";
-  #   }
-  #   # intercept Matrix registration confirmations
-  #   {
-  #     action = "REDIRECT colin@uninsane.org";
-  #     pattern = "/^Subject:.*Validate your email/";
-  #   }
-  #   # XXX postfix only supports performing ONE action per header.
-  #   # {
-  #   #   action = "REPLACE Subject: git application: Please activate your account";
-  #   #   pattern = "/^Subject:.*activate your account/";
-  #   # }
-  # ];
+  services.postfix.enableHeaderChecks = true;
+  services.postfix.headerChecks = [
+    # intercept gitea registration confirmations and manually screen them
+    {
+      # headerChecks are somehow ignorant of alias rules: have to redirect to a real user
+      action = "REDIRECT colin@uninsane.org";
+      pattern = "/^Subject: Please activate your account/";
+    }
+    # intercept Matrix registration confirmations
+    {
+      action = "REDIRECT colin@uninsane.org";
+      pattern = "/^Subject:.*Validate your email/";
+    }
+    # XXX postfix only supports performing ONE action per header.
+    # {
+    #   action = "REPLACE Subject: git application: Please activate your account";
+    #   pattern = "/^Subject:.*activate your account/";
+    # }
+  ];
 }

hosts/by-name/servo/services/export/default.nix

@@ -2,15 +2,15 @@
 {
   imports = [
     ./nfs.nix
-    ./sftpgo
+    ./sftpgo.nix
   ];
 
   users.groups.export = {};
 
   fileSystems."/var/export/media" = {
     # everything in here could be considered publicly readable (based on the viewer's legal jurisdiction)
-    device = "/var/media";
-    options = [ "rbind" "nofail" ];
+    device = "/var/lib/uninsane/media";
+    options = [ "rbind" ];
   };
   # fileSystems."/var/export/playground" = {
   #   device = config.fileSystems."/mnt/persist/ext".device;
@@ -30,29 +30,24 @@
   # to query the quota/status:
   # - `sudo btrfs qgroup show -re /var/export/playground`
   sane.persist.sys.byStore.ext = [
-    { user = "root"; group = "export"; mode = "0775"; path = "/var/export/playground"; method = "bind"; }
+    { user = "root"; group = "export"; mode = "0775"; path = "/var/export/playground"; }
   ];
 
   sane.fs."/var/export/README.md" = {
+    wantedBy = [ "nfs.service" "sftpgo.service" ];
     file.text = ''
       - media/         read-only:  Videos, Music, Books, etc
-      - playground/    read-write*: use it to share files with other users of this server, inaccessible from the www
-                                    *if you can't write to it, make sure you're connected to the WiFi and not mobile.
+      - playground/    read-write: use it to share files with other users of this server
     '';
   };
 
   sane.fs."/var/export/playground/README.md" = {
+    wantedBy = [ "nfs.service" "sftpgo.service" ];
     file.text = ''
-      this directory is intentionally read+write by anyone with access.
+      this directory is intentionally read+write by anyone with access (i.e. on the LAN).
       - share files
       - write poetry
       - be a friendly troll
     '';
   };
-
-  sane.fs."/var/export/.public_for_test/test" = {
-    file.text = ''
-      automated tests read this file to probe connectivity
-    '';
-  };
 }

hosts/by-name/servo/services/export/nfs.nix

@@ -15,7 +15,6 @@
 # - could maybe be done with some mount option?
 
 { config, lib, ... }:
-lib.mkIf false  #< TODO: remove nfs altogether! it's not exactly the most secure
 {
   services.nfs.server.enable = true;
 
@@ -27,7 +26,7 @@ lib.mkIf false  #< TODO: remove nfs altogether! it's not exactly the most secure
     description = "NFS server portmapper";
   };
   sane.ports.ports."2049" = {
-    protocol = [ "tcp" "udp" ];
+    protocol = [ "tcp" ];
     visibleTo.lan = true;
     description = "NFS server";
   };
@@ -52,23 +51,6 @@ lib.mkIf false  #< TODO: remove nfs altogether! it's not exactly the most secure
   services.nfs.server.mountdPort = 4002;
   services.nfs.server.statdPort = 4000;
 
-  services.nfs.extraConfig = ''
-    [nfsd]
-    # XXX: NFS over UDP REQUIRES SPECIAL CONFIG TO AVOID DATA LOSS.
-    # see `man 5 nfs`: "Using NFS over UDP on high-speed links".
-    # it's actually just a general property of UDP over IPv4 (IPv6 fixes it).
-    # both the client and the server should configure a shorter-than-default IPv4 fragment reassembly window to mitigate.
-    # OTOH, tunneling NFS over Wireguard also bypasses this weakness, because a mis-assembled packet would not have a valid signature.
-    udp=y
-
-    [exports]
-    # all export paths are relative to rootdir.
-    # for NFSv4, the export with fsid=0 behaves as `/` publicly,
-    # but NFSv3 implements no such feature.
-    # using `rootdir` instead of relying on `fsid=0` allows consistent export paths regardless of NFS proto version
-    rootdir=/var/export
-  '';
-
   # format:
   #   fspoint	visibility(options)
   # options:
@@ -103,20 +85,13 @@ lib.mkIf false  #< TODO: remove nfs altogether! it's not exactly the most secure
       in "${export} 10.78.79.0/22(${lib.concatStringsSep "," lanOpts}) 10.0.10.0/24(${lib.concatStringsSep "," vpnOpts})";
   in lib.concatStringsSep "\n" [
     (fmtExport {
-      export = "/";
+      export = "/var/export";
       baseOpts = [ "crossmnt" "fsid=root" ];
       extraLanOpts = [ "ro" ];
       extraVpnOpts = [ "rw" "no_root_squash" ];
     })
     (fmtExport {
-      # provide /media as an explicit export. NFSv4 can transparently mount a subdir of an export, but NFSv3 can only mount paths which are exports.
-      export = "/media";
-      baseOpts = [ "crossmnt" ];  # TODO: is crossmnt needed here?
-      extraLanOpts = [ "ro" ];
-      extraVpnOpts = [ "rw" "no_root_squash" ];
-    })
-    (fmtExport {
-      export = "/playground";
+      export = "/var/export/playground";
       baseOpts = [
         "mountpoint"
         "all_squash"

hosts/by-name/servo/services/export/sftpgo.nix

@@ -0,0 +1,184 @@
+# docs:
+# - <https://github.com/drakkan/sftpgo>
+# - config options: <https://github.com/drakkan/sftpgo/blob/main/docs/full-configuration.md>
+# - config defaults: <https://github.com/drakkan/sftpgo/blob/main/sftpgo.json>
+# - nixos options: <repo:nixos/nixpkgs:nixos/modules/services/web-apps/sftpgo.nix>
+# - nixos example: <repo:nixos/nixpkgs:nixos/tests/sftpgo.nix>
+#
+# sftpgo is a FTP server that also supports WebDAV, SFTP, and web clients.
+#
+# TODO: change umask so sftpgo-created files default to 644.
+# - it does indeed appear that the 600 is not something sftpgo is explicitly doing.
+
+
+{ config, lib, pkgs, sane-lib, ... }:
+let
+  # user permissions:
+  # - see <repo:drakkan/sftpgo:internal/dataprovider/user.go>
+  # - "*" = grant all permissions
+  # - read-only perms:
+  #   - "list" = list files and directories
+  #   - "download"
+  # - rw perms:
+  #   - "upload"
+  #   - "overwrite" = allow uploads to replace existing files
+  #   - "delete" = delete files and directories
+  #     - "delete_files"
+  #     - "delete_dirs"
+  #   - "rename" = rename files and directories
+  #     - "rename_files"
+  #     - "rename_dirs"
+  #   - "create_dirs"
+  #   - "create_symlinks"
+  #   - "chmod"
+  #   - "chown"
+  #   - "chtimes" = change atime/mtime (access and modification times)
+  #
+  # home_dir:
+  # - it seems (empirically) that a user can't cd above their home directory.
+  #   though i don't have a reference for that in the docs.
+  authResponseSuccess = {
+    status = 1;
+    username = "anonymous";
+    expiration_date = 0;
+    home_dir = "/var/export";
+    # uid/gid 0 means to inherit sftpgo uid.
+    # - i.e. users can't read files which Linux user `sftpgo` can't read
+    # - uploaded files belong to Linux user `sftpgo`
+    # other uid/gid values aren't possible for localfs backend, unless i let sftpgo use `sudo`.
+    uid = 0;
+    gid = 0;
+    # uid = 65534;
+    # gid = 65534;
+    max_sessions = 0;
+    # quota_*: 0 means to not use SFTP's quota system
+    quota_size = 0;
+    quota_files = 0;
+    permissions = {
+      "/" = [ "list" "download" ];
+      "/playground" = [
+        # read-only:
+        "list"
+        "download"
+        # write:
+        "upload"
+        "overwrite"
+        "delete"
+        "rename"
+        "create_dirs"
+        "create_symlinks"
+        # intentionally omitted:
+        # "chmod"
+        # "chown"
+        # "chtimes"
+      ];
+    };
+    upload_bandwidth = 0;
+    download_bandwidth = 0;
+    filters = {
+      allowed_ip = [];
+      denied_ip = [];
+    };
+    public_keys = [];
+    # other fields:
+    # ? groups
+    # ? virtual_folders
+  };
+  authResponseFail = {
+    username = "";
+  };
+  authSuccessJson = pkgs.writeText "sftp-auth-success.json" (builtins.toJSON authResponseSuccess);
+  authFailJson = pkgs.writeText "sftp-auth-fail.json" (builtins.toJSON authResponseFail);
+  unwrappedAuthProgram = pkgs.static-nix-shell.mkBash {
+    pname = "sftpgo_external_auth_hook";
+    src = ./.;
+    pkgs = [ "coreutils" ];
+  };
+  authProgram = pkgs.writeShellScript "sftpgo-auth-hook" ''
+    ${unwrappedAuthProgram}/bin/sftpgo_external_auth_hook ${authFailJson} ${authSuccessJson}
+  '';
+in
+{
+  # Client initiates a FTP "control connection" on port 21.
+  # - this handles the client -> server commands, and the server -> client status, but not the actual data
+  # - file data, directory listings, etc need to be transferred on an ephemeral "data port".
+  # - 50000-50100 is a common port range for this.
+  sane.ports.ports = {
+    "21" = {
+      protocol = [ "tcp" ];
+      visibleTo.lan = true;
+      description = "colin-FTP server";
+    };
+  } // (sane-lib.mapToAttrs
+    (port: {
+      name = builtins.toString port;
+      value = {
+        protocol = [ "tcp" ];
+        visibleTo.lan = true;
+        description = "colin-FTP server data port range";
+      };
+    })
+    (lib.range 50000 50100)
+  );
+
+  services.sftpgo = {
+    enable = true;
+    group = "export";
+    settings = {
+      ftpd = {
+        bindings = [
+          {
+            # binding this means any wireguard client can connect
+            address = "10.0.10.5";
+            port = 21;
+            debug = true;
+          }
+          {
+            # binding this means any LAN client can connect
+            address = "10.78.79.51";
+            port = 21;
+            debug = true;
+          }
+        ];
+
+        # active mode is susceptible to "bounce attacks", without much benefit over passive mode
+        disable_active_mode = true;
+        hash_support = true;
+        passive_port_range = {
+          start = 50000;
+          end = 50100;
+        };
+
+        banner = ''
+          Welcome, friends, to Colin's read-only FTP server! Also available via NFS on the same host.
+          Username: "anonymous"
+          Password: "anonymous"
+          CONFIGURE YOUR CLIENT FOR "PASSIVE" mode, e.g. `ftp --passive uninsane.org`
+          Please let me know if anything's broken or not as it should be. Otherwise, browse and DL freely :)
+        '';
+
+      };
+      data_provider = {
+        driver = "memory";
+        external_auth_hook = "${authProgram}";
+        # track_quota:
+        # - 0: disable quota tracking
+        # - 1: quota is updated on every upload/delete, even if user has no quota restriction
+        # - 2: quota is updated on every upload/delete, but only if user/folder has a quota restriction  (default, i think)
+        # track_quota = 2;
+      };
+    };
+  };
+
+  users.users.sftpgo.extraGroups = [ "export" ];
+
+  systemd.services.sftpgo.serviceConfig = {
+    ReadOnlyPaths = [ "/var/export" ];
+    ReadWritePaths = [ "/var/export/playground" ];
+    after = [ "network-online.target" ];
+    wants = [ "network-online.target" ];
+
+    Restart = "always";
+    RestartSec = "20s";
+  };
+}

hosts/by-name/servo/services/export/sftpgo/default.nix

@@ -1,172 +0,0 @@
-# docs:
-# - <https://github.com/drakkan/sftpgo>
-# - config options: <https://github.com/drakkan/sftpgo/blob/main/docs/full-configuration.md>
-# - config defaults: <https://github.com/drakkan/sftpgo/blob/main/sftpgo.json>
-# - nixos options: <repo:nixos/nixpkgs:nixos/modules/services/web-apps/sftpgo.nix>
-# - nixos example: <repo:nixos/nixpkgs:nixos/tests/sftpgo.nix>
-#
-# sftpgo is a FTP server that also supports WebDAV, SFTP, and web clients.
-
-{ config, lib, pkgs, sane-lib, ... }:
-let
-  external_auth_hook = pkgs.static-nix-shell.mkPython3 {
-    pname = "external_auth_hook";
-    srcRoot = ./.;
-    pkgs = [ "python3.pkgs.passlib" ];
-  };
-  # Client initiates a FTP "control connection" on port 21.
-  # - this handles the client -> server commands, and the server -> client status, but not the actual data
-  # - file data, directory listings, etc need to be transferred on an ephemeral "data port".
-  # - 50000-50100 is a common port range for this.
-  #   50000 is used by soulseek.
-  passiveStart = 50050;
-  passiveEnd   = 50070;
-in
-{
-  sane.ports.ports = {
-    "21" = {
-      protocol = [ "tcp" ];
-      visibleTo.lan = true;
-      description = "colin-FTP server";
-    };
-    "990" = {
-      protocol = [ "tcp" ];
-      visibleTo.doof = true;
-      visibleTo.lan = true;
-      description = "colin-FTPS server";
-    };
-  } // (sane-lib.mapToAttrs
-    (port: {
-      name = builtins.toString port;
-      value = {
-        protocol = [ "tcp" ];
-        visibleTo.doof = true;
-        visibleTo.lan = true;
-        description = "colin-FTP server data port range";
-      };
-    })
-    (lib.range passiveStart passiveEnd)
-  );
-
-  # use nginx/acme to produce a cert for FTPS
-  services.nginx.virtualHosts."ftp.uninsane.org" = {
-    addSSL = true;
-    enableACME = true;
-  };
-  sane.dns.zones."uninsane.org".inet.CNAME."ftp" = "native";
-
-  services.sftpgo = {
-    enable = true;
-    group = "export";
-
-    package = pkgs.sftpgo.overrideAttrs (upstream: {
-      patches = (upstream.patches or []) ++ [
-        # fix for compatibility with kodi:
-        # ftp LIST operation returns entries over-the-wire like:
-        # - dgrwxrwxr-x 1 ftp ftp            9 Apr  9 15:05 Videos
-        # however not all clients understand all mode bits (like that `g`, indicating SGID / group sticky bit).
-        # instead, only send mode bits which are well-understood.
-        # the full set of bits, from which i filter, is found here: <https://pkg.go.dev/io/fs#FileMode>
-        ./safe_fileinfo.patch
-      ];
-    });
-
-    settings = {
-      ftpd = {
-        bindings = [
-          {
-            # binding this means any wireguard client can connect
-            address = "10.0.10.5";
-            port = 21;
-            debug = true;
-          }
-          {
-            # binding this means any wireguard client can connect
-            address = "10.0.10.5";
-            port = 990;
-            debug = true;
-            tls_mode = 2;  # 2 = "implicit FTPS": client negotiates TLS before any FTP command.
-          }
-          {
-            # binding this means any LAN client can connect (also WAN traffic forwarded from the gateway)
-            address = "10.78.79.51";
-            port = 21;
-            debug = true;
-          }
-          {
-            # binding this means any LAN client can connect (also WAN traffic forwarded from the gateway)
-            address = "10.78.79.51";
-            port = 990;
-            debug = true;
-            tls_mode = 2;  # 2 = "implicit FTPS": client negotiates TLS before any FTP command.
-          }
-          {
-            # binding this means any doof client can connect (TLS only)
-            address = config.sane.netns.doof.veth.initns.ipv4;
-            port = 990;
-            debug = true;
-            tls_mode = 2;  # 2 = "implicit FTPS": client negotiates TLS before any FTP command.
-          }
-          {
-            # binding this means any LAN client can connect via `ftp.uninsane.org` (TLS only)
-            address = config.sane.netns.doof.wg.address.ipv4;
-            port = 990;
-            debug = true;
-            tls_mode = 2;  # 2 = "implicit FTPS": client negotiates TLS before any FTP command.
-          }
-        ];
-
-        # active mode is susceptible to "bounce attacks", without much benefit over passive mode
-        disable_active_mode = true;
-        hash_support = true;
-        passive_port_range = {
-          start = passiveStart;
-          end = passiveEnd;
-        };
-
-        certificate_file = "/var/lib/acme/ftp.uninsane.org/full.pem";
-        certificate_key_file = "/var/lib/acme/ftp.uninsane.org/key.pem";
-
-        banner = ''
-          Welcome, friends, to Colin's FTP server! Also available via NFS on the same host, but LAN-only.
-
-          Read-only access (LAN clients see everything; WAN clients can only see /pub):
-          Username: "anonymous"
-          Password: "anonymous"
-
-          CONFIGURE YOUR CLIENT FOR "PASSIVE" MODE, e.g. `ftp --passive ftp.uninsane.org`.
-          Please let me know if anything's broken or not as it should be. Otherwise, browse and transfer freely :)
-        '';
-
-      };
-      data_provider = {
-        driver = "memory";
-        external_auth_hook = lib.getExe external_auth_hook;
-        # track_quota:
-        # - 0: disable quota tracking
-        # - 1: quota is updated on every upload/delete, even if user has no quota restriction
-        # - 2: quota is updated on every upload/delete, but only if user/folder has a quota restriction  (default, i think)
-        # track_quota = 2;
-      };
-    };
-  };
-
-  users.users.sftpgo.extraGroups = [
-    "export"
-    "media"
-    "nginx"  # to access certs
-  ];
-
-  systemd.services.sftpgo = {
-    after = [ "network-online.target" ];  #< so that it reliably binds to all interfaces/netns's?
-    wants = [ "network-online.target" ];
-    unitConfig.RequiresMountsFor = [
-      "/var/export/media"
-      "/var/export/playground"
-    ];
-    serviceConfig.ReadWritePaths = [ "/var/export" ];
-    serviceConfig.Restart = "always";
-    serviceConfig.RestartSec = "20s";
-    serviceConfig.UMask = lib.mkForce "0002";
-  };
-}

hosts/by-name/servo/services/export/sftpgo/external_auth_hook

@@ -1,191 +0,0 @@
-#!/usr/bin/env nix-shell
-#!nix-shell -i python3 -p python3 -p python3.pkgs.passlib
-# vim: set filetype=python :
-#
-# available environment variables:
-# - SFTPGO_AUTHD_USERNAME
-# - SFTPGO_AUTHD_USER
-# - SFTPGO_AUTHD_IP
-# - SFTPGO_AUTHD_PROTOCOL  = { "DAV", "FTP", "HTTP", "SSH" }
-# - SFTPGO_AUTHD_PASSWORD
-# - SFTPGO_AUTHD_PUBLIC_KEY
-# - SFTPGO_AUTHD_KEYBOARD_INTERACTIVE
-# - SFTPGO_AUTHD_TLS_CERT
-#
-# user permissions:
-# - see <repo:drakkan/sftpgo:internal/dataprovider/user.go>
-# - "*" = grant all permissions
-# - read-only perms:
-#   - "list" = list files and directories
-#   - "download"
-# - rw perms:
-#   - "upload"
-#   - "overwrite" = allow uploads to replace existing files
-#   - "delete" = delete files and directories
-#     - "delete_files"
-#     - "delete_dirs"
-#   - "rename" = rename files and directories
-#     - "rename_files"
-#     - "rename_dirs"
-#   - "create_dirs"
-#   - "create_symlinks"
-#   - "chmod"
-#   - "chown"
-#   - "chtimes" = change atime/mtime (access and modification times)
-#
-# home_dir:
-# - it seems (empirically) that a user can't cd above their home directory.
-#   though i don't have a reference for that in the docs.
-
-import json
-import os
-import passlib.hosts
-
-from hmac import compare_digest
-
-authFail = dict(username="")
-
-PERM_DENY = []
-PERM_LIST = [ "list" ]
-PERM_RO = [ "list", "download" ]
-PERM_RW = [
-  # read-only:
-  "list",
-  "download",
-  # write:
-  "upload",
-  "overwrite",
-  "delete",
-  "rename",
-  "create_dirs",
-  "create_symlinks",
-  # intentionally omitted:
-  # "chmod",
-  # "chown",
-  # "chtimes",
-]
-
-TRUSTED_CREDS = [
-  # /etc/shadow style creds.
-  # mkpasswd -m sha-512
-  # $<method>$<salt>$<hash>
-  "$6$Zq3c2u4ghUH4S6EP$pOuRt13sEKfX31OqPbbd1LuhS21C9MICMc94iRdTAgdAcJ9h95gQH/6Jf6Ie4Obb0oxQtojRJ1Pd/9QHOlFMW.",  #< m. rocket boy
-  "$6$B0NLGNdCL51PNse1$46G.aA1ATWIv5v.jUsKf4F3NS7emV2jB2gkZ3MytZtMvw2pjniHmRl0fywRjKW9TuXTeK9T50v.H0f2BaQ4PT1",  #< v. telephony
-]
-TRUSTED_VIEWING_OR_PLAYGROUND_CREDS = [
-  # "$6$iikDajz5b.YH1.on$tfSzzBEtX8IeDiJJXCasOTxRTd7cFDKXU6dhlWYVhK6xDeJhV2fh6bmm1WIHItjIth9Eh9zNgUB8xibMIWCm/."  # fedi (2024-08-27); music appreciation
-];
-
-def mkAuthOk(username: str, permissions: dict[str, list[str]]) -> dict:
-  return dict(
-    status = 1,
-    username = username,
-    expiration_date = 0,
-    home_dir = "/var/export",
-    # uid/gid 0 means to inherit sftpgo uid.
-    # - i.e. users can't read files which Linux user `sftpgo` can't read
-    # - uploaded files belong to Linux user `sftpgo`
-    # other uid/gid values aren't possible for localfs backend, unless i let sftpgo use `sudo`.
-    uid = 0,
-    gid = 0,
-    # uid = 65534,
-    # gid = 65534,
-    max_sessions = 0,
-    # quota_*: 0 means to not use SFTP's quota system
-    quota_size = 0,
-    quota_files = 0,
-    permissions = permissions,
-    upload_bandwidth = 0,
-    download_bandwidth = 0,
-    filters = dict(
-      allowed_ip = [],
-      denied_ip = [],
-    ),
-    public_keys = [],
-    # other fields:
-    # ? groups
-    # ? virtual_folders
-  )
-
-def isLan(ip: str) -> bool:
-  return ip.startswith("10.78.76.") \
-    or ip.startswith("10.78.77.") \
-    or ip.startswith("10.78.78.") \
-    or ip.startswith("10.78.79.")
-
-def isWireguard(ip: str) -> bool:
-  return ip.startswith("10.0.10.")
-
-def isTrustedCred(password: str, credlist: list[str] = TRUSTED_CREDS) -> bool:
-  for cred in credlist:
-    if passlib.hosts.linux_context.verify(password, cred):
-      return True
-
-  return False
-
-def getAuthResponse(ip: str, username: str, password: str) -> dict:
-  """
-  return a sftpgo auth response either denying the user or approving them
-  with a set of permissions.
-  """
-  if isTrustedCred(password) and username != "colin":
-    # allow r/w access from those with a special token
-    return mkAuthOk(username, permissions = {
-      "/": PERM_RW,
-      "/playground": PERM_RW,
-      "/.public_for_test": PERM_RO,
-      "/media/Music": PERM_RO,  #< i am too picky about Music organization
-    })
-  if isTrustedCred(password, TRUSTED_VIEWING_OR_PLAYGROUND_CREDS) and username != "colin":
-    return mkAuthOk(username, permissions = {
-      # error prone, but... not the worst if i miss something
-      "/": PERM_LIST,
-      "/media/archive": PERM_DENY,
-      "/media/Books": PERM_RO,
-      "/media/collections": PERM_DENY,
-      "/media/games": PERM_RO,
-      "/media/Music": PERM_RO,
-      "/media/Pictures": PERM_RO,
-      "/media/torrents": PERM_DENY,
-      "/media/Videos": PERM_RO,
-      "/playground": PERM_RW,
-      "/.public_for_test": PERM_RO,
-    })
-  if isWireguard(ip):
-    # allow any user from wireguard
-    return mkAuthOk(username, permissions = {
-      "/": PERM_RW,
-      "/playground": PERM_RW,
-      "/.public_for_test": PERM_RO,
-    })
-  if isLan(ip):
-    if username == "anonymous":
-      # allow anonymous users on the LAN
-      return mkAuthOk("anonymous", permissions = {
-        "/": PERM_RO,
-        "/playground": PERM_RW,
-        "/.public_for_test": PERM_RO,
-      })
-  if username == "anonymous":
-    # anonymous users from the www can have even more limited access.
-    # mostly because i need an easy way to test WAN connectivity :-)
-    return mkAuthOk("anonymous", permissions = {
-      # "/": PERM_DENY,
-      "/": PERM_LIST,  #< REQUIRED, even for lftp to list a subdir
-      "/media": PERM_DENY,
-      "/playground": PERM_DENY,
-      "/.public_for_test": PERM_RO,
-      # "/README.md": PERM_RO,  #< does not work
-    })
-
-  return authFail
-
-def main():
-  ip = os.environ.get("SFTPGO_AUTHD_IP", "")
-  username = os.environ.get("SFTPGO_AUTHD_USERNAME", "")
-  password = os.environ.get("SFTPGO_AUTHD_PASSWORD", "")
-  resp = getAuthResponse(ip, username, password)
-  print(json.dumps(resp))
-
-if __name__ == "__main__":
-  main()

hosts/by-name/servo/services/export/sftpgo/safe_fileinfo.patch

@@ -1,32 +0,0 @@
-diff --git a/internal/ftpd/handler.go b/internal/ftpd/handler.go
-index 036c3977..33211261 100644
---- a/internal/ftpd/handler.go
-+++ b/internal/ftpd/handler.go
-@@ -169,7 +169,7 @@ func (c *Connection) Stat(name string) (os.FileInfo, error) {
- 		}
- 		return nil, err
- 	}
--	return fi, nil
-+	return vfs.NewFileInfo(name, fi.IsDir(), fi.Size(), fi.ModTime(), false), nil
- }
-
- // Name returns the name of this connection
-@@ -315,7 +315,17 @@ func (c *Connection) ReadDir(name string) (ftpserver.DirLister, error) {
- 		}, nil
- 	}
-
--	return c.ListDir(name)
-+	lister, err := c.ListDir(name)
-+	if err != nil {
-+		return nil, err
-+	}
-+	return &patternDirLister{
-+		DirLister:      lister,
-+		pattern:        "*",
-+		lastCommand:    c.clientContext.GetLastCommand(),
-+		dirName:        name,
-+		connectionPath: c.clientContext.Path(),
-+	}, nil
- }
-
- // GetHandle implements ClientDriverExtentionFileTransfer

hosts/by-name/servo/services/export/sftpgo_external_auth_hook

@@ -0,0 +1,23 @@
+#!/usr/bin/env nix-shell
+#!nix-shell -i bash -p coreutils
+# vim: set filetype=bash :
+#
+# available environment variables:
+# - SFTPGO_AUTHD_USERNAME
+# - SFTPGO_AUTHD_USER
+# - SFTPGO_AUTHD_IP
+# - SFTPGO_AUTHD_PROTOCOL  = { "DAV", "FTP", "HTTP", "SSH" }
+# - SFTPGO_AUTHD_PASSWORD
+# - SFTPGO_AUTHD_PUBLIC_KEY
+# - SFTPGO_AUTHD_KEYBOARD_INTERACTIVE
+# - SFTPGO_AUTHD_TLS_CERT
+#
+#
+# call with <script_name> /path/to/fail/response.json /path/to/success/response.json
+
+
+if [ "$SFTPGO_AUTHD_USERNAME" = "anonymous" ]; then
+  cat "$2"
+else
+  cat "$1"
+fi

hosts/by-name/servo/services/freshrss.nix

@@ -10,14 +10,13 @@
 # ```
 
 { config, lib, pkgs, sane-lib, ... }:
-lib.mkIf false  #< 2024/07/04: i haven't actively used this for months
 {
   sops.secrets."freshrss_passwd" = {
     owner = config.users.users.freshrss.name;
     mode = "0400";
   };
   sane.persist.sys.byStore.plaintext = [
-    { user = "freshrss"; group = "freshrss"; path = "/var/lib/freshrss"; method = "bind"; }
+    { user = "freshrss"; group = "freshrss"; path = "/var/lib/freshrss"; }
   ];
 
   services.freshrss.enable = true;

hosts/by-name/servo/services/gerbera.nix

@@ -1,38 +0,0 @@
-# gerbera UPNP/media server
-# accessible from TVs on the LAN
-# unauthenticated admin and playback UI at http://servo:49152/
-#
-# supposedly does transcoding, but i poked at it for 10 minutes and couldn't get that working
-#
-# compatibility:
-# - LG TV: music: all working
-# - LG TV: videos: mixed
-{ lib, ... }:
-lib.mkIf false  #< XXX(2024-11-17): WORKS, but no better than any other service; slow to index and transcoding doesn't work
-{
-  sane.ports.ports."1900" = {
-    protocol = [ "udp" ];
-    visibleTo.lan = true;
-    description = "colin-upnp-for-gerbera";
-  };
-  sane.ports.ports."49152" = {
-    protocol = [ "tcp" "udp" ];  # TODO: is udp required?
-    visibleTo.lan = true;
-    description = "colin-gerbera-http";
-  };
-
-  sane.persist.sys.byStore.plaintext = [
-    # persist the index database, since it takes a good 30 minutes to scan the media collection
-    { user = "mediatomb"; group = "mediatomb"; mode = "0700"; path = "/var/lib/gerbera"; method = "bind"; }
-  ];
-
-  services.mediatomb.enable = true;
-  services.mediatomb.serverName = "servo";
-  services.mediatomb.transcoding = true;
-  services.mediatomb.mediaDirectories = [
-    { path = "/var/media/Music"; recursive = true; hidden-files = false; }
-    { path = "/var/media/Videos/Film"; recursive = true; hidden-files = false; }
-    { path = "/var/media/Videos/Shows"; recursive = true; hidden-files = false; }
-  ];
-  users.users.mediatomb.extraGroups = [ "media" ];
-}

hosts/by-name/servo/services/gitea.nix

@@ -1,33 +1,22 @@
 # config options: <https://docs.gitea.io/en-us/administration/config-cheat-sheet/>
-# TODO: service shouldn't run as `git` user, but as `gitea`
-{ pkgs, lib, ... }:
+{ config, pkgs, lib, ... }:
 
 {
-  sane.persist.sys.byStore.private = [
-    { user = "git"; group = "gitea"; mode = "0750"; path = "/var/lib/gitea"; method = "bind"; }
+  sane.persist.sys.byStore.plaintext = [
+    # TODO: mode? could be more granular
+    { user = "git"; group = "gitea"; path = "/var/lib/gitea"; }
   ];
-
-  sane.programs.gitea.enableFor.user.colin = true;  # for admin, and monitoring
-
   services.gitea.enable = true;
   services.gitea.user = "git";  # default is 'gitea'
+  services.gitea.database.type = "postgres";
+  services.gitea.database.user = "git";
   services.gitea.appName = "Perfectly Sane Git";
   # services.gitea.disableRegistration = true;
 
-  services.gitea.database.createDatabase = false;  # can only createDatabase if user ("git") == dbname ("gitea")
-  services.gitea.database.type = "postgres";
-  services.gitea.database.user = "git";
-  # createDatabase=false means manually specify the connection; see: <https://github.com/NixOS/nixpkgs/pull/268849>
-  services.gitea.database.name = "gitea";
+  services.gitea.database.createDatabase = false;  #< silence warning which wants db user and name to be equal
+  # TODO: remove this after merge: <https://github.com/NixOS/nixpkgs/pull/268849>
   services.gitea.database.socket = "/run/postgresql";  #< would have been set if createDatabase = true
 
-  services.postgresql.enable = true;
-  services.postgresql.ensureDatabases = [ "gitea" ];
-  services.postgresql.ensureUsers = [{
-    name = "git";
-    # ensureDBOwnership = true;  # not possible if db name ("gitea") != db username ("git"); one-time manual setup required to grant user ownership of the relevant db
-  }];
-
   # gitea doesn't create the git user
   users.users.git = {
     description = "Gitea Service";
@@ -49,41 +38,28 @@
       ROOT_URL = "https://git.uninsane.org/";
     };
     service = {
-      # timeout for email approval. 5760 = 4 days. 10080 = 7 days
-      ACTIVE_CODE_LIVE_MINUTES = 10080;
+      # timeout for email approval. 5760 = 4 days
+      ACTIVE_CODE_LIVE_MINUTES = 5760;
       # REGISTER_EMAIL_CONFIRM = false;
-      # REGISTER_EMAIL_CONFIRM = true;  #< override REGISTER_MANUAL_CONFIRM
-      REGISTER_MANUAL_CONFIRM = true;
-      # not sure what this notifies *on*...
+      # REGISTER_MANUAL_CONFIRM = true;
+      REGISTER_EMAIL_CONFIRM = true;
+      # not sure what this notified on?
       ENABLE_NOTIFY_MAIL = true;
       # defaults to image-based captcha.
       # also supports recaptcha (with custom URLs) or hCaptcha.
       ENABLE_CAPTCHA = true;
       NOREPLY_ADDRESS = "noreply.anonymous.git@uninsane.org";
-      EMAIL_DOMAIN_BLOCKLIST = lib.concatStringsSep ", " [
-        "*.claychoen.top"
-        "*.gemmasmith.co.uk"
-        "*.jenniferlawrence.uk"
-        "*.sarahconnor.co.uk"
-        "*.marymarshall.co.uk"
-      ];
-    };
-    session = {
-      COOKIE_SECURE = true;
-      # keep me logged in for 30 days
-      SESSION_LIFE_TIME = 60 * 60 * 24 * 30;
     };
+    session.COOKIE_SECURE = true;
     repository = {
       DEFAULT_BRANCH = "master";
-      ENABLE_PUSH_CREATE_USER = true;
-      ENABLE_PUSH_CREATE_ORG = true;
     };
     other = {
       SHOW_FOOTER_TEMPLATE_LOAD_TIME = false;
     };
     ui = {
-      # options: "gitea-auto" (adapt to system theme), "gitea-dark", "gitea-light"
-      # DEFAULT_THEME = "gitea-auto";
+      # options: "auto", "gitea", "arc-green"
+      DEFAULT_THEME = "arc-green";
       # cache frontend assets if true
       # USE_SERVICE_WORKER = true;
     };
@@ -92,10 +68,9 @@
       # alternative is to use nixos-level config:
       # services.gitea.mailerPasswordFile = ...
       ENABLED = true;
+      MAILER_TYPE = "sendmail";
       FROM = "notify.git@uninsane.org";
-      PROTOCOL = "sendmail";
-      SENDMAIL_PATH = lib.getExe' pkgs.postfix "sendmail";
-      SENDMAIL_ARGS = "--";  # most "sendmail" programs take options, "--" will prevent an email address being interpreted as an option.
+      SENDMAIL_PATH = "${pkgs.postfix}/bin/sendmail";
     };
     time = {
       # options: ANSIC, UnixDate, RubyDate, RFC822, RFC822Z, RFC850, RFC1123, RFC1123Z, RFC3339, RFC3339Nano, Kitchen, Stamp, StampMilli, StampMicro, StampNano
@@ -104,24 +79,17 @@
     };
   };
 
-  systemd.services.gitea.wants = [ "postgresql.service" ];
   systemd.services.gitea.serviceConfig = {
     # nix default is AF_UNIX AF_INET AF_INET6.
     # we need more protos for sendmail to work. i thought it only needed +AF_LOCAL, but that didn't work.
     RestrictAddressFamilies = lib.mkForce "~";
     # add maildrop to allow sendmail to work
-    ReadWritePaths = [
+    ReadWritePaths = lib.mkForce [
       "/var/lib/postfix/queue/maildrop"
+      "/var/lib/gitea"
     ];
-    # rate limit the restarts to prevent systemd from disabling it
-    RestartSec = 5;
-    RestartMaxDelaySec = 30;
-    StartLimitBurst = 120;
-    RestartSteps = 5;
   };
 
-  # services.openssh.settings.UsePAM = true;  #< required for `git` user to authenticate
-
   # hosted git (web view and for `git <cmd>` use
   # TODO: enable publog?
   services.nginx.virtualHosts."git.uninsane.org" = {
@@ -132,28 +100,6 @@
     locations."/" = {
       proxyPass = "http://127.0.0.1:3000";
     };
-    # fuck you @anthropic
-    locations."= /robots.txt".extraConfig = ''
-      return 200 "User-agent: *\nDisallow: /\n";
-    '';
-    # gitea serves all `raw` files as content-type: plain, but i'd like to serve them as their actual content type.
-    # or at least, enough to make specific pages viewable (serving unoriginal content as arbitrary content type is dangerous).
-    locations."~ ^/colin/phone-case-cq/raw/.*.html" = {
-      proxyPass = "http://127.0.0.1:3000";
-      extraConfig = ''
-        proxy_hide_header Content-Type;
-        default_type text/html;
-        add_header Content-Type text/html;
-      '';
-    };
-    locations."~ ^/colin/phone-case-cq/raw/.*.js" = {
-      proxyPass = "http://127.0.0.1:3000";
-      extraConfig = ''
-        proxy_hide_header Content-Type;
-        default_type text/html;
-        add_header Content-Type text/javascript;
-      '';
-    };
   };
 
   sane.dns.zones."uninsane.org".inet.CNAME."git" = "native";
@@ -161,7 +107,7 @@
   sane.ports.ports."22" = {
     protocol = [ "tcp" ];
     visibleTo.lan = true;
-    visibleTo.doof = true;
+    visibleTo.wan = true;
     description = "colin-git@git.uninsane.org";
   };
 }

hosts/by-name/servo/services/goaccess.nix

@@ -1,5 +1,4 @@
-{ lib, pkgs, ... }:
-lib.mkIf false  #< 2024/09/30: disabled because i haven't used it in several months
+{ pkgs, ... }:
 {
   # based on <https://bytes.fyi/real-time-goaccess-reports-with-nginx/>
   # log-format setting can be derived with this tool if custom:
@@ -11,7 +10,7 @@ lib.mkIf false  #< 2024/09/30: disabled because i haven't used it in several mon
     description = "GoAccess server monitoring";
     serviceConfig = {
       ExecStart = ''
-        ${lib.getExe pkgs.goaccess} \
+        ${pkgs.goaccess}/bin/goaccess \
           -f /var/log/nginx/public.log \
           --log-format=VCOMBINED \
           --real-time-html \
@@ -21,27 +20,25 @@ lib.mkIf false  #< 2024/09/30: disabled because i haven't used it in several mon
           --ignore-panel=HOSTS \
           --ws-url=wss://sink.uninsane.org:443/ws \
           --port=7890 \
-          -o /var/lib/goaccess/index.html
+          -o /var/lib/uninsane/sink/index.html
       '';
-      ExecReload = "${lib.getExe' pkgs.coreutils "kill"} -HUP $MAINPID";
+      ExecReload = "${pkgs.coreutils}/bin/kill -HUP $MAINPID";
       Type = "simple";
       Restart = "on-failure";
       RestartSec = "10s";
 
       # hardening
-      # TODO: run as `goaccess` user and add `goaccess` user to group `nginx`.
+      WorkingDirectory = "/tmp";
       NoNewPrivileges = true;
-      PrivateDevices = "yes";
       PrivateTmp = true;
       ProtectHome = "read-only";
+      ProtectSystem = "strict";
+      SystemCallFilter = "~@clock @cpu-emulation @debug @keyring @memlock @module @mount @obsolete @privileged @reboot @resources @setuid @swap @raw-io";
+      ReadOnlyPaths = "/";
+      ReadWritePaths = [ "/proc/self" "/var/lib/uninsane/sink" ];
+      PrivateDevices = "yes";
       ProtectKernelModules = "yes";
       ProtectKernelTunables = "yes";
-      ProtectSystem = "strict";
-      ReadOnlyPaths = [ "/var/log/nginx" ];
-      ReadWritePaths = [ "/proc/self" "/var/lib/goaccess" ];
-      StateDirectory = "goaccess";
-      SystemCallFilter = "~@clock @cpu-emulation @debug @keyring @memlock @module @mount @obsolete @privileged @reboot @resources @setuid @swap @raw-io";
-      WorkingDirectory = "/var/lib/goaccess";
     };
     after = [ "network.target" ];
     wantedBy = [ "multi-user.target" ];
@@ -52,7 +49,7 @@ lib.mkIf false  #< 2024/09/30: disabled because i haven't used it in several mon
     addSSL = true;
     enableACME = true;
     # inherit kTLS;
-    root = "/var/lib/goaccess";
+    root = "/var/lib/uninsane/sink";
 
     locations."/ws" = {
       proxyPass = "http://127.0.0.1:7890";

hosts/by-name/servo/services/hickory-dns.nix

@@ -1,150 +0,0 @@
-# TODO: split this file apart into smaller files to make it easier to understand
-{ config, lib, pkgs, ... }:
-
-let
-  dyn-dns = config.sane.services.dyn-dns;
-  nativeAddrs = lib.mapAttrs (_name: builtins.head) config.sane.dns.zones."uninsane.org".inet.A;
-in
-{
-  sane.ports.ports."53" = {
-    protocol = [ "udp" "tcp" ];
-    visibleTo.lan = true;
-    # visibleTo.wan = true;
-    visibleTo.ovpns = true;
-    visibleTo.doof = true;
-    description = "colin-dns-hosting";
-  };
-
-  sane.dns.zones."uninsane.org".TTL = 900;
-
-  # SOA record structure: <https://en.wikipedia.org/wiki/SOA_record#Structure>
-  # SOA MNAME RNAME (... rest)
-  # MNAME = Master name server for this zone. this is where update requests should be sent.
-  # RNAME = admin contact (encoded email address)
-  # Serial = YYYYMMDDNN, where N is incremented every time this file changes, to trigger secondary NS to re-fetch it.
-  # Refresh = how frequently secondary NS should query master
-  # Retry = how long secondary NS should wait until re-querying master after a failure (must be < Refresh)
-  # Expire = how long secondary NS should continue to reply to queries after master fails (> Refresh + Retry)
-  sane.dns.zones."uninsane.org".inet = {
-    SOA."@" = ''
-      ns1.uninsane.org. admin-dns.uninsane.org. (
-                                      2023092101 ; Serial
-                                      4h         ; Refresh
-                                      30m        ; Retry
-                                      7d         ; Expire
-                                      5m)        ; Negative response TTL
-    '';
-    TXT."rev" = "2023092101";
-
-    CNAME."native" = "%CNAMENATIVE%";
-    A."@" =      "%ANATIVE%";
-    A."servo.wan" = "%AWAN%";
-    A."servo.doof" = "%ADOOF%";
-    A."servo.lan" = config.sane.hosts.by-name."servo".lan-ip;
-    A."servo.hn" = config.sane.hosts.by-name."servo".wg-home.ip;
-
-    # XXX NS records must also not be CNAME
-    # it's best that we keep this identical, or a superset of, what org. lists as our NS.
-    # so, org. can specify ns2/ns3 as being to the VPN, with no mention of ns1. we provide ns1 here.
-    A."ns1" =    "%ANATIVE%";
-    A."ns2" =    "%ADOOF%";
-    A."ovpns" =  "%AOVPNS%";
-    NS."@" = [
-      "ns1.uninsane.org."
-      "ns2.uninsane.org."
-    ];
-  };
-
-  services.hickory-dns.settings.zones = [ "uninsane.org" ];
-
-
-  networking.nat.enable = true;  #< TODO: try removing this?
-  # networking.nat.extraCommands = ''
-  #   # redirect incoming DNS requests from LAN addresses
-  #   #   to the LAN-specialized DNS service
-  #   # N.B.: use the `nixos-*` chains instead of e.g. PREROUTING
-  #   #   because they get cleanly reset across activations or `systemctl restart firewall`
-  #   #   instead of accumulating cruft
-  #   iptables -t nat -A nixos-nat-pre -p udp --dport 53 \
-  #     -m iprange --src-range 10.78.76.0-10.78.79.255 \
-  #     -j DNAT --to-destination :1053
-  #   iptables -t nat -A nixos-nat-pre -p tcp --dport 53 \
-  #     -m iprange --src-range 10.78.76.0-10.78.79.255 \
-  #     -j DNAT --to-destination :1053
-  # '';
-  # sane.ports.ports."1053" = {
-  #   # because the NAT above redirects in nixos-nat-pre, LAN requests behave as though they arrived on the external interface at the redirected port.
-  #   # TODO: try nixos-nat-post instead?
-  #   # TODO: or, don't NAT from port 53 -> port 1053, but rather nat from LAN addr to a loopback addr.
-  #   # - this is complicated in that loopback is a different interface than eth0, so rewriting the destination address would cause the packets to just be dropped by the interface
-  #   protocol = [ "udp" "tcp" ];
-  #   visibleTo.lan = true;
-  #   description = "colin-redirected-dns-for-lan-namespace";
-  # };
-
-
-  sane.services.hickory-dns.enable = true;
-  sane.services.hickory-dns.instances = let
-    mkSubstitutions = flavor: {
-      "%ADOOF%" = config.sane.netns.doof.wg.address.ipv4;
-      "%ANATIVE%" = nativeAddrs."servo.${flavor}";
-      "%AOVPNS%" = config.sane.netns.ovpns.wg.address.ipv4;
-      "%AWAN%" = "$(cat '${dyn-dns.ipPath}')";
-      "%CNAMENATIVE%" = "servo.${flavor}";
-    };
-  in
-  {
-    doof = {
-      substitutions = mkSubstitutions "doof";
-      listenAddrsIpv4 = [
-        config.sane.netns.doof.veth.initns.ipv4
-        config.sane.netns.doof.wg.address.ipv4
-        nativeAddrs."servo.lan"
-        # config.sane.netns.ovpns.veth.initns.ipv4
-      ];
-    };
-    # hn = {
-    #   substitutions = mkSubstitutions "hn";
-    #   listenAddrsIpv4 = [ nativeAddrs."servo.hn" ];
-    #   enableRecursiveResolver = true;  #< allow wireguard clients to use this as their DNS resolver
-    #   # extraConfig = {
-    #   #   zones = [
-    #   #     {
-    #   #       # forward the root zone to the local DNS resolver
-    #   #       # to allow wireguard clients to use this as their DNS resolver
-    #   #       zone = ".";
-    #   #       zone_type = "Forward";
-    #   #       stores = {
-    #   #         type = "forward";
-    #   #         name_servers = [
-    #   #           {
-    #   #             socket_addr = "127.0.0.53:53";
-    #   #             protocol = "udp";
-    #   #             trust_nx_responses = true;
-    #   #           }
-    #   #         ];
-    #   #       };
-    #   #     }
-    #   #   ];
-    #   # };
-    # };
-    # lan = {
-    #   substitutions = mkSubstitutions "lan";
-    #   listenAddrsIpv4 = [ nativeAddrs."servo.lan" ];
-    #   # port = 1053;
-    # };
-    # wan = {
-    #   substitutions = mkSubstitutions "wan";
-    #   listenAddrsIpv4 = [
-    #     nativeAddrs."servo.lan"
-    #   ];
-    # };
-  };
-
-  systemd.services.hickory-dns-doof.after = [
-    # service will fail to bind the veth, otherwise
-    "netns-doof-veth.service"
-  ];
-
-  sane.services.dyn-dns.restartOnChange = lib.map (c: "${c.service}.service") (builtins.attrValues config.sane.services.hickory-dns.instances);
-}

hosts/by-name/servo/services/ipfs.nix

@@ -10,9 +10,9 @@
 
 lib.mkIf false # i don't actively use ipfs anymore
 {
-  sane.persist.sys.byStore.private = [
+  sane.persist.sys.byStore.plaintext = [
     # TODO: mode? could be more granular
-    { user = "261"; group = "261"; path = "/var/lib/ipfs"; method = "bind"; }
+    { user = "261"; group = "261"; path = "/var/lib/ipfs"; }
   ];
 
   networking.firewall.allowedTCPPorts = [ 4001 ];

hosts/by-name/servo/services/jackett.nix

@@ -0,0 +1,33 @@
+{ ... }:
+
+{
+  sane.persist.sys.byStore.plaintext = [
+    # TODO: mode? we only need this to save Indexer creds ==> migrate to config?
+    { user = "root"; group = "root"; path = "/var/lib/jackett"; }
+  ];
+  services.jackett.enable = true;
+
+  systemd.services.jackett.after = [ "wireguard-wg-ovpns.service" ];
+  systemd.services.jackett.partOf = [ "wireguard-wg-ovpns.service" ];
+  systemd.services.jackett.serviceConfig = {
+    # run this behind the OVPN static VPN
+    NetworkNamespacePath = "/run/netns/ovpns";
+    # patch jackett to listen on the public interfaces
+    # ExecStart = lib.mkForce "${pkgs.jackett}/bin/Jackett --NoUpdates --DataFolder /var/lib/jackett/.config/Jackett --ListenPublic";
+  };
+
+  # jackett torrent search
+  services.nginx.virtualHosts."jackett.uninsane.org" = {
+    forceSSL = true;
+    enableACME = true;
+    # inherit kTLS;
+    locations."/" = {
+      # proxyPass = "http://ovpns.uninsane.org:9117";
+      proxyPass = "http://10.0.1.6:9117";
+      recommendedProxySettings = true;
+    };
+  };
+
+  sane.dns.zones."uninsane.org".inet.CNAME."jackett" = "native";
+}
+

hosts/by-name/servo/services/jackett/default.nix

@@ -1,69 +0,0 @@
-{ config, lib, pkgs, ... }:
-
-let
-  cfg = config.services.jackett;
-in
-{
-  sane.persist.sys.byStore.private = [
-    # TODO: mode? we only need this to save Indexer creds ==> migrate to config?
-    { user = "jackett"; group = "jackett"; path = "/var/lib/jackett"; method = "bind"; }
-  ];
-  services.jackett.enable = true;
-
-  # run this behind the OVPN static VPN
-  sane.netns.ovpns.services = [ "jackett" ];
-  systemd.services.jackett = {
-    serviceConfig.ExecStartPre = [
-      # abort if public IP is not as expected
-      "${lib.getExe pkgs.sane-scripts.ip-check} --no-upnp --expect ${config.sane.netns.ovpns.wg.address.ipv4}"
-    ];
-    # patch in `--ListenPublic` so that it's reachable from the netns veth.
-    # this also makes it reachable from the VPN pub address. oh well.
-    serviceConfig.ExecStart = lib.mkForce "${lib.getExe' cfg.package "Jackett"} --ListenPublic --NoUpdates --DataFolder '${cfg.dataDir}'";
-    serviceConfig.RestartSec = "30s";
-
-    # hardening (systemd-analyze security jackett)
-    # TODO: upstream into nixpkgs
-    serviceConfig.StateDirectory = "jackett";
-    serviceConfig.LockPersonality = true;
-    serviceConfig.NoNewPrivileges = true;
-    # serviceConfig.MemoryDenyWriteExecute = true;  #< Failed to create CoreCLR, HRESULT: 0x80004005
-    serviceConfig.PrivateDevices = true;
-    serviceConfig.PrivateMounts = true;
-    serviceConfig.PrivateTmp = true;
-    serviceConfig.PrivateUsers = true;
-    serviceConfig.ProcSubset = "pid";
-    serviceConfig.ProtectClock = true;
-    serviceConfig.ProtectControlGroups = true;
-    serviceConfig.ProtectHome = true;
-    serviceConfig.ProtectHostname = true;
-    serviceConfig.ProtectKernelLogs = true;
-    serviceConfig.ProtectKernelModules = true;
-    serviceConfig.ProtectKernelTunables = true;
-    serviceConfig.ProtectProc = "invisible";
-    serviceConfig.ProtectSystem = "strict";
-    serviceConfig.RemoveIPC = true;
-    serviceConfig.RestrictAddressFamilies = "AF_UNIX AF_INET AF_INET6";
-    serviceConfig.RestrictNamespaces = true;
-    serviceConfig.RestrictSUIDSGID = true;
-    serviceConfig.SystemCallArchitectures = "native";
-    serviceConfig.SystemCallFilter = [ "@system-service" "~@privileged" ];
-  };
-
-  # jackett torrent search
-  services.nginx.virtualHosts."jackett.uninsane.org" = {
-    forceSSL = true;
-    enableACME = true;
-    # inherit kTLS;
-    locations."/" = {
-      proxyPass = "http://${config.sane.netns.ovpns.veth.netns.ipv4}:9117";
-      recommendedProxySettings = true;
-    };
-    locations."= /robots.txt".extraConfig = ''
-      return 200 "User-agent: *\nDisallow: /\n";
-    '';
-  };
-
-  sane.dns.zones."uninsane.org".inet.CNAME."jackett" = "native";
-}
-

hosts/by-name/servo/services/jellyfin.nix

@@ -0,0 +1,127 @@
+# configuration options (today i don't store my config in nix):
+#
+# - jellyfin-web can be statically configured (result/share/jellyfin-web/config.json)
+#   - <https://jellyfin.org/docs/general/clients/web-config>
+#   - configure server list, plugins, "menuLinks", colors
+#
+# - jellfyin server is configured in /var/lib/jellfin/
+#   - root/default/<LibraryType>/
+#     - <LibraryName>.mblink: contains the directory name where this library lives
+#     - options.xml: contains preferences which were defined in the web UI during import
+#       - e.g. `EnablePhotos`, `EnableChapterImageExtraction`, etc.
+#   - config/encoding.xml: transcoder settings
+#   - config/system.xml: misc preferences like log file duration, audiobook resume settings, etc.
+#   - data/jellyfin.db: maybe account definitions? internal state?
+
+{ config, lib, ... }:
+
+{
+  # https://jellyfin.org/docs/general/networking/index.html
+  sane.ports.ports."1900" = {
+    protocol = [ "udp" ];
+    visibleTo.lan = true;
+    description = "colin-upnp-for-jellyfin";
+  };
+  sane.ports.ports."7359" = {
+    protocol = [ "udp" ];
+    visibleTo.lan = true;
+    description = "colin-jellyfin-specific-client-discovery";
+    # ^ not sure if this is necessary: copied this port from nixos jellyfin.openFirewall
+  };
+  # not sure if 8096/8920 get used either:
+  sane.ports.ports."8096" = {
+    protocol = [ "tcp" ];
+    visibleTo.lan = true;
+    description = "colin-jellyfin-http-lan";
+  };
+  sane.ports.ports."8920" = {
+    protocol = [ "tcp" ];
+    visibleTo.lan = true;
+    description = "colin-jellyfin-https-lan";
+  };
+
+  sane.persist.sys.byStore.plaintext = [
+    { user = "jellyfin"; group = "jellyfin"; mode = "0700"; path = "/var/lib/jellyfin"; }
+  ];
+  sane.fs."/var/lib/jellyfin/config/logging.json" = {
+    # "Emby.Dlna" logging: <https://jellyfin.org/docs/general/networking/dlna>
+    symlink.text = ''
+      {
+        "Serilog": {
+          "MinimumLevel": {
+            "Default": "Information",
+            "Override": {
+              "Microsoft": "Warning",
+              "System": "Warning",
+              "Emby.Dlna": "Debug",
+              "Emby.Dlna.Eventing": "Debug"
+            }
+          },
+          "WriteTo": [
+            {
+              "Name": "Console",
+              "Args": {
+                "outputTemplate": "[{Timestamp:HH:mm:ss}] [{Level:u3}] [{ThreadId}] {SourceContext}: {Message:lj}{NewLine}{Exception}"
+              }
+            }
+          ],
+          "Enrich": [ "FromLogContext", "WithThreadId" ]
+        }
+      }
+    '';
+    wantedBeforeBy = [ "jellyfin.service" ];
+  };
+
+  # Jellyfin multimedia server
+  # this is mostly taken from the official jellfin.org docs
+  services.nginx.virtualHosts."jelly.uninsane.org" = {
+    addSSL = true;
+    enableACME = true;
+    # inherit kTLS;
+
+    locations."/" = {
+      proxyPass = "http://127.0.0.1:8096";
+      extraConfig = ''
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+        proxy_set_header X-Forwarded-Protocol $scheme;
+        proxy_set_header X-Forwarded-Host $http_host;
+
+        # Disable buffering when the nginx proxy gets very resource heavy upon streaming
+        proxy_buffering off;
+      '';
+    };
+    # locations."/web/" = {
+    #   proxyPass = "http://127.0.0.1:8096/web/index.html";
+    #   extraConfig = ''
+    #     proxy_set_header Host $host;
+    #     proxy_set_header X-Real-IP $remote_addr;
+    #     proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+    #     proxy_set_header X-Forwarded-Proto $scheme;
+    #     proxy_set_header X-Forwarded-Protocol $scheme;
+    #     proxy_set_header X-Forwarded-Host $http_host;
+    #   '';
+    # };
+    locations."/socket" = {
+      proxyPass = "http://127.0.0.1:8096";
+      extraConfig = ''
+        proxy_http_version 1.1;
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection "upgrade";
+
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+        proxy_set_header X-Forwarded-Protocol $scheme;
+        proxy_set_header X-Forwarded-Host $http_host;
+      '';
+    };
+  };
+
+  sane.dns.zones."uninsane.org".inet.CNAME."jelly" = "native";
+
+  services.jellyfin.enable = true;
+}

hosts/by-name/servo/services/jellyfin/default.nix

@@ -1,171 +0,0 @@
-# configuration options (today only a *subset* of the config is done in nix)
-# - jellyfin-web can be statically configured (result/share/jellyfin-web/config.json)
-#   - <https://jellyfin.org/docs/general/clients/web-config>
-#   - configure server list, plugins, "menuLinks", colors
-#
-# - jellfyin server is configured in /var/lib/jellfin/
-#   - root/default/<LibraryType>/
-#     - <LibraryName>.mblink: contains the directory name where this library lives
-#     - options.xml: contains preferences which were defined in the web UI during import
-#       - e.g. `EnablePhotos`, `EnableChapterImageExtraction`, etc.
-#   - config/encoding.xml: transcoder settings
-#   - config/system.xml: misc preferences like log file duration, audiobook resume settings, etc.
-#   - data/jellyfin.db: maybe account definitions? internal state?
-#
-# N.B.: default install DOES NOT SUPPORT DLNA out of the box.
-#       one must install it as a "plugin", which can be done through the UI.
-{ lib, ... }:
-
-# lib.mkIf false  #< XXX(2024-11-17): disabled because it hasn't been working for months; web UI hangs on load, TVs see no files
-{
-  # https://jellyfin.org/docs/general/networking/index.html
-  sane.ports.ports."1900" = {
-    protocol = [ "udp" ];
-    visibleTo.lan = true;
-    description = "colin-upnp-for-jellyfin";
-  };
-  sane.ports.ports."7359" = {
-    protocol = [ "udp" ];
-    visibleTo.lan = true;
-    description = "colin-jellyfin-specific-client-discovery";
-    # ^ not sure if this is necessary: copied this port from nixos jellyfin.openFirewall
-  };
-  # not sure if 8096/8920 get used either:
-  sane.ports.ports."8096" = {
-    protocol = [ "tcp" ];
-    visibleTo.lan = true;
-    description = "colin-jellyfin-http-lan";
-  };
-  sane.ports.ports."8920" = {
-    protocol = [ "tcp" ];
-    visibleTo.lan = true;
-    description = "colin-jellyfin-https-lan";
-  };
-
-  sane.persist.sys.byStore.plaintext = [
-    { user = "jellyfin"; group = "jellyfin"; mode = "0700"; path = "/var/lib/jellyfin/data"; method = "bind"; }
-    { user = "jellyfin"; group = "jellyfin"; mode = "0700"; path = "/var/lib/jellyfin/metadata"; method = "bind"; }
-    # TODO: ship plugins statically, via nix. that'll be less fragile
-    { user = "jellyfin"; group = "jellyfin"; mode = "0700"; path = "/var/lib/jellyfin/plugins/DLNA_5.0.0.0"; method = "bind"; }
-    { user = "jellyfin"; group = "jellyfin"; mode = "0700"; path = "/var/lib/jellyfin/root"; method = "bind"; }
-  ];
-  sane.persist.sys.byStore.ephemeral = [
-    { user = "jellyfin"; group = "jellyfin"; mode = "0700"; path = "/var/lib/jellyfin/log"; method = "bind"; }
-    { user = "jellyfin"; group = "jellyfin"; mode = "0700"; path = "/var/lib/jellyfin/transcodes"; method = "bind"; }
-  ];
-
-  services.jellyfin.enable = true;
-  users.users.jellyfin.extraGroups = [ "media" ];
-
-  sane.fs."/var/lib/jellyfin".dir.acl = {
-    user = "jellyfin";
-    group = "jellyfin";
-    mode = "0700";
-  };
-
-  # `"Jellyfin.Plugin.Dlna": "Debug"` logging: <https://jellyfin.org/docs/general/networking/dlna>
-  # TODO: switch Dlna back to 'Information' once satisfied with stability
-  sane.fs."/var/lib/jellyfin/config/logging.json".symlink.text = ''
-    {
-      "Serilog": {
-        "MinimumLevel": {
-          "Default": "Information",
-          "Override": {
-            "Microsoft": "Warning",
-            "System": "Warning",
-            "Jellyfin.Plugin.Dlna": "Debug"
-          }
-        },
-        "WriteTo": [
-          {
-            "Name": "Console",
-            "Args": {
-              "outputTemplate": "[{Timestamp:HH:mm:ss}] [{Level:u3}] [{ThreadId}] {SourceContext}: {Message:lj}{NewLine}{Exception}"
-            }
-          }
-        ],
-        "Enrich": [ "FromLogContext", "WithThreadId" ]
-      }
-    }
-  '';
-
-  sane.fs."/var/lib/jellyfin/config/network.xml".file.text = ''
-    <?xml version="1.0" encoding="utf-8"?>
-    <NetworkConfiguration xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
-      <BaseUrl />
-      <EnableHttps>false</EnableHttps>
-      <RequireHttps>false</RequireHttps>
-      <InternalHttpPort>8096</InternalHttpPort>
-      <InternalHttpsPort>8920</InternalHttpsPort>
-      <PublicHttpPort>8096</PublicHttpPort>
-      <PublicHttpsPort>8920</PublicHttpsPort>
-      <AutoDiscovery>true</AutoDiscovery>
-      <EnableUPnP>false</EnableUPnP>
-      <EnableIPv4>true</EnableIPv4>
-      <EnableIPv6>false</EnableIPv6>
-      <EnableRemoteAccess>true</EnableRemoteAccess>
-      <LocalNetworkSubnets>
-        <string>10.78.76.0/22</string>
-      </LocalNetworkSubnets>
-      <KnownProxies>
-        <string>127.0.0.1</string>
-        <string>localhost</string>
-        <string>10.78.79.1</string>
-      </KnownProxies>
-      <IgnoreVirtualInterfaces>false</IgnoreVirtualInterfaces>
-      <VirtualInterfaceNames />
-      <EnablePublishedServerUriByRequest>false</EnablePublishedServerUriByRequest>
-      <PublishedServerUriBySubnet />
-      <RemoteIPFilter />
-      <IsRemoteIPFilterBlacklist>false</IsRemoteIPFilterBlacklist>
-    </NetworkConfiguration>
-  '';
-
-  # guest user id is `5ad194d60dca41de84b332950ffc4308`
-  sane.fs."/var/lib/jellyfin/plugins/configurations/Jellyfin.Plugin.Dlna.xml".file.text = ''
-    <?xml version="1.0" encoding="utf-8"?>
-    <DlnaPluginConfiguration xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
-      <EnablePlayTo>true</EnablePlayTo>
-      <ClientDiscoveryIntervalSeconds>60</ClientDiscoveryIntervalSeconds>
-      <BlastAliveMessages>true</BlastAliveMessages>
-      <AliveMessageIntervalSeconds>180</AliveMessageIntervalSeconds>
-      <SendOnlyMatchedHost>true</SendOnlyMatchedHost>
-      <DefaultUserId>5ad194d6-0dca-41de-84b3-32950ffc4308</DefaultUserId>
-    </DlnaPluginConfiguration>
-  '';
-
-  # fix LG TV to play more files.
-  # there are certain files for which it only supports Direct Play (not even "Direct Stream" -- but "Direct Play").
-  # this isn't a 100% fix: patching the profile allows e.g. Azumanga Daioh to play,
-  # but A Place Further Than the Universe still fails as before.
-  #
-  # profile is based on upstream: <https://github.com/jellyfin/jellyfin-plugin-dlna>
-  sane.fs."/var/lib/jellyfin/plugins/DLNA_5.0.0.0/profiles/LG Smart TV.xml".symlink.target = ./dlna/user/LG_Smart_TV.xml;
-  # XXX(2024-11-17): old method, but the file referenced seems not to be used and setting just it causes failures:
-  # > [DBG] Jellyfin.Plugin.Dlna.ContentDirectory.ContentDirectoryService: Not eligible for DirectPlay due to unsupported subtitles
-  # sane.fs."/var/lib/jellyfin/plugins/configurations/dlna/user/LG Smart TV.xml".symlink.target = ./dlna/user/LG_Smart_TV.xml;
-
-  systemd.services.jellyfin.unitConfig.RequiresMountsFor = [
-    "/var/media"
-  ];
-
-  # Jellyfin multimedia server
-  # this is mostly taken from the official jellfin.org docs
-  services.nginx.virtualHosts."jelly.uninsane.org" = {
-    forceSSL = true;
-    enableACME = true;
-    # inherit kTLS;
-
-    locations."/" = {
-      proxyPass = "http://127.0.0.1:8096";
-      proxyWebsockets = true;
-      recommendedProxySettings = true;
-      # extraConfig = ''
-      #   # Disable buffering when the nginx proxy gets very resource heavy upon streaming
-      #   proxy_buffering off;
-      # '';
-    };
-  };
-
-  sane.dns.zones."uninsane.org".inet.CNAME."jelly" = "native";
-}

hosts/by-name/servo/services/jellyfin/dlna/user/LG_Smart_TV.xml

@@ -1,91 +0,0 @@
-<?xml version="1.0"?>
-<Profile xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-  xmlns:xsd="http://www.w3.org/2001/XMLSchema">
-  <Name>LG Smart TV</Name>
-  <Identification>
-    <ModelName>LG TV</ModelName>
-    <Headers />
-  </Identification>
-  <Manufacturer>Jellyfin</Manufacturer>
-  <ManufacturerUrl>https://github.com/jellyfin/jellyfin</ManufacturerUrl>
-  <ModelName>Jellyfin Server</ModelName>
-  <ModelDescription>UPnP/AV 1.0 Compliant Media Server</ModelDescription>
-  <ModelNumber>01</ModelNumber>
-  <ModelUrl>https://github.com/jellyfin/jellyfin</ModelUrl>
-  <EnableAlbumArtInDidl>false</EnableAlbumArtInDidl>
-  <EnableSingleAlbumArtLimit>false</EnableSingleAlbumArtLimit>
-  <EnableSingleSubtitleLimit>false</EnableSingleSubtitleLimit>
-  <SupportedMediaTypes>Audio,Photo,Video</SupportedMediaTypes>
-  <AlbumArtPn>JPEG_SM</AlbumArtPn>
-  <MaxAlbumArtWidth>480</MaxAlbumArtWidth>
-  <MaxAlbumArtHeight>480</MaxAlbumArtHeight>
-  <MaxIconWidth>48</MaxIconWidth>
-  <MaxIconHeight>48</MaxIconHeight>
-  <MaxStreamingBitrate>140000000</MaxStreamingBitrate>
-  <MaxStaticBitrate>140000000</MaxStaticBitrate>
-  <MusicStreamingTranscodingBitrate>192000</MusicStreamingTranscodingBitrate>
-  <MaxStaticMusicBitrate xsi:nil="true" />
-  <ProtocolInfo>http-get:*:video/mpeg:*,http-get:*:video/mp4:*,http-get:*:video/vnd.dlna.mpeg-tts:*,http-get:*:video/avi:*,http-get:*:video/x-matroska:*,http-get:*:video/x-ms-wmv:*,http-get:*:video/wtv:*,http-get:*:audio/mpeg:*,http-get:*:audio/mp3:*,http-get:*:audio/mp4:*,http-get:*:audio/x-ms-wma:*,http-get:*:audio/wav:*,http-get:*:audio/L16:*,http-get:*:image/jpeg:*,http-get:*:image/png:*,http-get:*:image/gif:*,http-get:*:image/tiff:*</ProtocolInfo>
-  <TimelineOffsetSeconds>10</TimelineOffsetSeconds>
-  <RequiresPlainVideoItems>false</RequiresPlainVideoItems>
-  <RequiresPlainFolders>false</RequiresPlainFolders>
-  <EnableMSMediaReceiverRegistrar>false</EnableMSMediaReceiverRegistrar>
-  <IgnoreTranscodeByteRangeRequests>false</IgnoreTranscodeByteRangeRequests>
-  <XmlRootAttributes />
-  <DirectPlayProfiles>
-    <DirectPlayProfile container="ts,mpegts,avi,mkv,m2ts" audioCodec="aac,ac3,eac3,mp3,dca,dts" videoCodec="h264,hevc" type="Video" />
-    <DirectPlayProfile container="mp4,m4v" audioCodec="aac,ac3,eac3,mp3,dca,dts" videoCodec="h264,mpeg4,hevc" type="Video" />
-    <DirectPlayProfile container="mp3" type="Audio" />
-    <DirectPlayProfile container="jpeg" type="Photo" />
-    <DirectPlayProfile container="" audioCodec="" videoCodec="" type="Video" />
-  </DirectPlayProfiles>
-  <TranscodingProfiles>
-    <TranscodingProfile container="mp3" type="Audio" audioCodec="mp3" estimateContentLength="false" enableMpegtsM2TsMode="false" transcodeSeekInfo="Auto" copyTimestamps="false" context="Streaming" enableSubtitlesInManifest="false" minSegments="0" segmentLength="0" breakOnNonKeyFrames="false" />
-    <TranscodingProfile container="ts" type="Video" videoCodec="h264" audioCodec="ac3,aac,mp3" estimateContentLength="false" enableMpegtsM2TsMode="false" transcodeSeekInfo="Auto" copyTimestamps="false" context="Streaming" enableSubtitlesInManifest="false" minSegments="0" segmentLength="0" breakOnNonKeyFrames="false" />
-    <TranscodingProfile container="jpeg" type="Photo" estimateContentLength="false" enableMpegtsM2TsMode="false" transcodeSeekInfo="Auto" copyTimestamps="false" context="Streaming" enableSubtitlesInManifest="false" minSegments="0" segmentLength="0" breakOnNonKeyFrames="false" />
-  </TranscodingProfiles>
-  <ContainerProfiles>
-    <ContainerProfile type="Photo">
-      <Conditions>
-        <ProfileCondition condition="LessThanEqual" property="Width" value="1920" isRequired="true" />
-        <ProfileCondition condition="LessThanEqual" property="Height" value="1080" isRequired="true" />
-      </Conditions>
-    </ContainerProfile>
-  </ContainerProfiles>
-  <CodecProfiles>
-    <CodecProfile type="Video" codec="mpeg4">
-      <Conditions>
-        <ProfileCondition condition="LessThanEqual" property="Width" value="1920" isRequired="true" />
-        <ProfileCondition condition="LessThanEqual" property="Height" value="1080" isRequired="true" />
-        <ProfileCondition condition="LessThanEqual" property="VideoFramerate" value="30" isRequired="true" />
-      </Conditions>
-      <ApplyConditions />
-    </CodecProfile>
-    <CodecProfile type="Video" codec="h264">
-      <Conditions>
-        <ProfileCondition condition="LessThanEqual" property="Width" value="1920" isRequired="true" />
-        <ProfileCondition condition="LessThanEqual" property="Height" value="1080" isRequired="true" />
-        <ProfileCondition condition="LessThanEqual" property="VideoLevel" value="41" isRequired="true" />
-      </Conditions>
-      <ApplyConditions />
-    </CodecProfile>
-    <CodecProfile type="VideoAudio" codec="ac3,eac3,aac,mp3">
-      <Conditions>
-        <ProfileCondition condition="LessThanEqual" property="AudioChannels" value="6" isRequired="true" />
-      </Conditions>
-      <ApplyConditions />
-    </CodecProfile>
-  </CodecProfiles>
-  <ResponseProfiles>
-    <ResponseProfile container="m4v" type="Video" mimeType="video/mp4">
-      <Conditions />
-    </ResponseProfile>
-    <ResponseProfile container="ts,mpegts" type="Video" mimeType="video/mpeg">
-      <Conditions />
-    </ResponseProfile>
-  </ResponseProfiles>
-  <SubtitleProfiles>
-    <SubtitleProfile format="srt" method="Embed" />
-    <SubtitleProfile format="srt" method="External" />
-  </SubtitleProfiles>
-</Profile>

hosts/by-name/servo/services/kiwix-serve.nix

@@ -1,26 +1,9 @@
-{ pkgs, ... }:
+{ ... }:
 {
   sane.services.kiwix-serve = {
     enable = true;
     port = 8013;
-    zimPaths = with pkgs.zimPackages; [
-      alpinelinux_en_all_maxi.zimPath
-      archlinux_en_all_maxi.zimPath
-      bitcoin_en_all_maxi.zimPath
-      devdocs_en_nix.zimPath
-      gentoo_en_all_maxi.zimPath
-      # khanacademy_en_all.zimPath  #< TODO: enable
-      openstreetmap-wiki_en_all_maxi.zimPath
-      psychonautwiki_en_all_maxi.zimPath
-      rationalwiki_en_all_maxi.zimPath
-      # wikipedia_en_100.zimPath
-      wikipedia_en_all_maxi.zimPath
-      # wikipedia_en_all_mini.zimPath
-      zimgit-food-preparation_en.zimPath
-      zimgit-medicine_en.zimPath
-      zimgit-post-disaster_en.zimPath
-      zimgit-water_en.zimPath
-    ];
+    zimPaths = [ "/var/lib/uninsane/www-archive/wikipedia_en_all_maxi_2022-05.zim" ];
   };
 
   services.nginx.virtualHosts."w.uninsane.org" = {
@@ -28,9 +11,6 @@
     enableACME = true;
     # inherit kTLS;
     locations."/".proxyPass = "http://127.0.0.1:8013";
-    locations."= /robots.txt".extraConfig = ''
-      return 200 "User-agent: *\nDisallow: /\n";
-    '';
   };
 
   sane.dns.zones."uninsane.org".inet.CNAME."w" = "native";

hosts/by-name/servo/services/komga.nix

@@ -1,26 +1,22 @@
-{ config, lib, ... }:
+{ config, ... }:
 let
   svc-cfg = config.services.komga;
   inherit (svc-cfg) user group port stateDir;
 in
-lib.mkIf false  #< 2024/09/30: disabled because i haven't used this for several months
 {
   sane.persist.sys.byStore.plaintext = [
-    { inherit user group; mode = "0700"; path = stateDir; method = "bind"; }
+    { inherit user group; mode = "0700"; path = stateDir; }
   ];
 
   services.komga.enable = true;
   services.komga.port = 11319;  # chosen at random
 
   services.nginx.virtualHosts."komga.uninsane.org" = {
-    forceSSL = true;
+    addSSL = true;
     enableACME = true;
     locations."/" = {
       proxyPass = "http://127.0.0.1:${builtins.toString port}";
     };
-    locations."= /robots.txt".extraConfig = ''
-      return 200 "User-agent: *\nDisallow: /\n";
-    '';
   };
   sane.dns.zones."uninsane.org".inet.CNAME."komga" = "native";
 }

hosts/by-name/servo/services/lemmy.nix

@@ -3,26 +3,23 @@
 # - <repo:LemmyNet/lemmy:docker/nginx.conf>
 # - <repo:LemmyNet/lemmy-ansible:templates/nginx.conf>
 
-{ lib, pkgs, ... }:
+{ config, lib, pkgs, ... }:
 let
+  inherit (builtins) toString;
+  inherit (lib) mkForce;
   uiPort = 1234;  # default ui port is 1234
   backendPort = 8536; # default backend port is 8536
   #^ i guess the "backend" port is used for federation?
-  pict-rs = pkgs.pict-rs;
-  # pict-rs configuration is applied in this order:
-  # - via toml
-  # - via env vars (overrides everything above)
-  # - via CLI flags (overrides everything above)
-  # some of the CLI flags have defaults, making it the only actual way to configure certain things even when docs claim otherwise.
-  # CLI args: <https://git.asonix.dog/asonix/pict-rs#user-content-running>
-  # TOML args: <https://git.asonix.dog/asonix/pict-rs/src/branch/main/pict-rs.toml>
-  toml = pkgs.formats.toml { };
-  tomlConfig = toml.generate "pict-rs.toml" pictrsConfig;
-  pictrsConfig = {
-    media.process_timeout = 120;
-    media.video.allow_audio = true;
-    media.video.max_frame_count = 30 * 60 * 60;
-  };
+  pict-rs = pkgs.pict-rs.overrideAttrs (upstream: {
+    # as of v 0.4.2, all non-GIF video is forcibly transcoded.
+    # that breaks lemmy, because of the request latency.
+    # and it eats up hella CPU.
+    # pict-rs is iffy around video altogether: mp4 seems the best supported.
+    postPatch = (upstream.postPatch or "") + ''
+      substituteInPlace src/validate.rs \
+        --replace 'if transcode_options.needs_reencode() {' 'if false {'
+    '';
+  });
 in {
   services.lemmy = {
     enable = true;
@@ -36,10 +33,14 @@ in {
     nginx.enable = true;
   };
 
+  systemd.services.lemmy.serviceConfig = {
+    # fix to use a normal user so we can configure perms correctly
+    DynamicUser = mkForce false;
+    User = "lemmy";
+    Group = "lemmy";
+  };
   systemd.services.lemmy.environment = {
     RUST_BACKTRACE = "full";
-    RUST_LOG = "error";
-    # RUST_LOG = "warn";
     # RUST_LOG = "debug";
     # RUST_LOG = "trace";
     # upstream defaults LEMMY_DATABASE_URL = "postgres:///lemmy?host=/run/postgresql";
@@ -50,8 +51,8 @@ in {
     # - postgresql://[user[:password]@][netloc][:port][/dbname][?param1=value1&...]
     # LEMMY_DATABASE_URL = "postgres://lemmy@/run/postgresql";  # connection to server on socket "/run/postgresql/.s.PGSQL.5432" failed: FATAL:  database "run/postgresql" does not exist
     # LEMMY_DATABASE_URL = "postgres://lemmy?host=/run/postgresql";  # no PostgreSQL user name specified in startup packet
-    # LEMMY_DATABASE_URL = lib.mkForce "postgres://lemmy@?host=/run/postgresql";  # WORKS
-    LEMMY_DATABASE_URL = lib.mkForce "postgres://lemmy@/lemmy?host=/run/postgresql";
+    # LEMMY_DATABASE_URL = mkForce "postgres://lemmy@?host=/run/postgresql";  # WORKS
+    LEMMY_DATABASE_URL = mkForce "postgres://lemmy@/lemmy?host=/run/postgresql";
   };
   users.groups.lemmy = {};
   users.users.lemmy = {
@@ -66,112 +67,19 @@ in {
 
   sane.dns.zones."uninsane.org".inet.CNAME."lemmy" = "native";
 
-  systemd.services.lemmy = {
-    # fix to use a normal user so we can configure perms correctly
-    # XXX(2024-07-28): this hasn't been rigorously tested:
-    # possible that i've set something too strict and won't notice right away
-    serviceConfig.DynamicUser = lib.mkForce false;
-    serviceConfig.User = "lemmy";
-    serviceConfig.Group = "lemmy";
-
-    # switch postgres from Requires -> Wants, so that postgres may restart without taking lemmy down with it.
-    requires = lib.mkForce [];
-    wants = [ "postgresql.service" ];
-
-    # hardening (systemd-analyze security lemmy)
-    # a handful of these are specified in upstream nixpkgs, but mostly not
-    serviceConfig.LockPersonality = true;
-    serviceConfig.NoNewPrivileges = true;
-    serviceConfig.MemoryDenyWriteExecute = true;
-    serviceConfig.PrivateDevices = true;
-    serviceConfig.PrivateMounts = true;
-    serviceConfig.PrivateTmp = true;
-    serviceConfig.PrivateUsers = true;
-    serviceConfig.ProcSubset = "pid";
-
-    serviceConfig.ProtectClock = true;
-    serviceConfig.ProtectControlGroups = true;
-    serviceConfig.ProtectHome = true;
-    serviceConfig.ProtectHostname = true;
-    serviceConfig.ProtectKernelLogs = true;
-    serviceConfig.ProtectKernelModules = true;
-    serviceConfig.ProtectKernelTunables = true;
-    serviceConfig.ProtectProc = "invisible";
-    serviceConfig.ProtectSystem = "strict";
-    serviceConfig.RemoveIPC = true;
-    serviceConfig.RestrictAddressFamilies = "AF_UNIX AF_INET AF_INET6";
-
-    serviceConfig.RestrictNamespaces = true;
-    serviceConfig.RestrictSUIDSGID = true;
-    serviceConfig.SystemCallArchitectures = "native";
-    serviceConfig.SystemCallFilter = [ "@system-service" ];
-  };
-
-  systemd.services.lemmy-ui = {
-    # hardening (systemd-analyze security lemmy-ui)
-    # TODO: upstream into nixpkgs
-    serviceConfig.LockPersonality = true;
-    serviceConfig.NoNewPrivileges = true;
-    # serviceConfig.MemoryDenyWriteExecute = true;  #< it uses v8, JIT
-    serviceConfig.PrivateDevices = true;
-    serviceConfig.PrivateMounts = true;
-    serviceConfig.PrivateTmp = true;
-    serviceConfig.PrivateUsers = true;
-    serviceConfig.ProcSubset = "pid";
-
-    serviceConfig.ProtectClock = true;
-    serviceConfig.ProtectControlGroups = true;
-    serviceConfig.ProtectHome = true;
-    serviceConfig.ProtectHostname = true;
-    serviceConfig.ProtectKernelLogs = true;
-    serviceConfig.ProtectKernelModules = true;
-    serviceConfig.ProtectKernelTunables = true;
-    serviceConfig.ProtectProc = "invisible";
-    serviceConfig.ProtectSystem = "strict";
-    serviceConfig.RemoveIPC = true;
-    serviceConfig.RestrictAddressFamilies = "AF_UNIX AF_INET AF_INET6";
-
-    serviceConfig.RestrictNamespaces = true;
-    serviceConfig.RestrictSUIDSGID = true;
-    serviceConfig.SystemCallArchitectures = "native";
-    serviceConfig.SystemCallFilter = [ "@system-service" "@pkey" "@sandbox" ];
-  };
-
   #v DO NOT REMOVE: defaults to 0.3, instead of latest, so always need to explicitly set this.
   services.pict-rs.package = pict-rs;
 
-  systemd.services.pict-rs = {
-    serviceConfig.ExecStart = lib.mkForce (lib.concatStringsSep " " [
-      (lib.getExe pict-rs)
-      "--config-file"
-      tomlConfig
-      "run"
-    ]);
-
-    # hardening (systemd-analyze security pict-rs)
-    # TODO: upstream into nixpkgs
-    serviceConfig.LockPersonality = true;
-    serviceConfig.NoNewPrivileges = true;
-    serviceConfig.MemoryDenyWriteExecute = true;
-    serviceConfig.PrivateDevices = true;
-    serviceConfig.PrivateMounts = true;
-    serviceConfig.PrivateTmp = true;
-    serviceConfig.PrivateUsers = true;
-    serviceConfig.ProcSubset = "pid";
-    serviceConfig.ProtectClock = true;
-    serviceConfig.ProtectControlGroups = true;
-    serviceConfig.ProtectHome = true;
-    serviceConfig.ProtectHostname = true;
-    serviceConfig.ProtectKernelLogs = true;
-    serviceConfig.ProtectKernelModules = true;
-    serviceConfig.ProtectKernelTunables = true;
-    serviceConfig.ProtectProc = "invisible";
-    serviceConfig.ProtectSystem = "strict";
-    serviceConfig.RemoveIPC = true;
-    serviceConfig.RestrictAddressFamilies = "AF_UNIX AF_INET AF_INET6";
-    serviceConfig.RestrictNamespaces = true;
-    serviceConfig.RestrictSUIDSGID = true;
-    serviceConfig.SystemCallArchitectures = "native";
-    serviceConfig.SystemCallFilter = [ "@system-service" ];
-  };
+  # pict-rs configuration is applied in this order:
+  # - via toml
+  # - via env vars (overrides everything above)
+  # - via CLI flags (overrides everything above)
+  # some of the CLI flags have defaults, making it the only actual way to configure certain things even when docs claim otherwise.
+  # CLI args: <https://git.asonix.dog/asonix/pict-rs#user-content-running>
+  systemd.services.pict-rs.serviceConfig.ExecStart = lib.mkForce (lib.concatStringsSep " " [
+    "${lib.getBin pict-rs}/bin/pict-rs run"
+    "--media-max-frame-count" (builtins.toString (30*60*60))
+    "--media-process-timeout 120"
+    "--media-enable-full-video true"  # allow audio
+  ]);
 }

hosts/by-name/servo/services/matrix/default.nix

@@ -1,6 +1,6 @@
 # docs: <https://nixos.wiki/wiki/Matrix>
 # docs: <https://nixos.org/manual/nixos/stable/index.html#module-services-matrix-synapse>
-# example config: <https://github.com/element-hq/synapse/blob/develop/docs/sample_config.yaml>
+# example config: <https://github.com/matrix-org/synapse/blob/develop/docs/sample_config.yaml>
 #
 # ENABLING PUSH NOTIFICATIONS (with UnifiedPush/ntfy):
 # - Matrix "pushers" API spec: <https://spec.matrix.org/latest/client-server-api/#post_matrixclientv3pushersset>
@@ -12,9 +12,7 @@
 # - delete a notification destination by setting `kind` to `null` (otherwise, request is identical to above)
 #
 { config, lib, pkgs, ... }:
-let
-  ntfy = config.services.ntfy-sh.enable;
-in
+
 {
   imports = [
     ./discord-puppet.nix
@@ -22,17 +20,19 @@ in
     ./signal.nix
   ];
 
-  sane.persist.sys.byStore.private = [
-    { user = "matrix-synapse"; group = "matrix-synapse"; path = "/var/lib/matrix-synapse"; method = "bind"; }
+  sane.persist.sys.byStore.plaintext = [
+    { user = "matrix-synapse"; group = "matrix-synapse"; path = "/var/lib/matrix-synapse"; }
   ];
   services.matrix-synapse.enable = true;
-  services.matrix-synapse.log.root.level = "ERROR";  # accepts "DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL" (?)
   services.matrix-synapse.settings = {
+    # this changes the default log level from INFO to WARN.
+    # maybe there's an easier way?
+    log_config = ./synapse-log_level.yaml;
     server_name = "uninsane.org";
 
     # services.matrix-synapse.enable_registration_captcha = true;
     # services.matrix-synapse.enable_registration_without_verification = true;
-    # enable_registration = true;
+    enable_registration = true;
     # services.matrix-synapse.registration_shared_secret = "<shared key goes here>";
 
     # default for listeners is port = 8448, tls = true, x_forwarded = false.
@@ -70,30 +70,21 @@ in
     config.sops.secrets."matrix_synapse_secrets.yaml".path
   ];
 
-  # tune restart settings to ensure systemd doesn't disable it, and we don't overwhelm postgres
-  systemd.services.matrix-synapse.serviceConfig.RestartSec = 5;
-  systemd.services.matrix-synapse.serviceConfig.RestartMaxDelaySec = 20;
-  systemd.services.matrix-synapse.serviceConfig.StartLimitBurst = 120;
-  systemd.services.matrix-synapse.serviceConfig.RestartSteps = 3;
-  # switch postgres from Requires -> Wants, so that postgres may restart without taking matrix down with it.
-  systemd.services.matrix-synapse.requires = lib.mkForce [];
-  systemd.services.matrix-synapse.wants = [ "postgresql.service" ];
-
-  systemd.services.matrix-synapse.postStart = lib.optionalString ntfy ''
-    ACCESS_TOKEN=$(${lib.getExe' pkgs.coreutils "cat"} ${config.sops.secrets.matrix_access_token.path})
-    TOPIC=$(${lib.getExe' pkgs.coreutils "cat"} ${config.sops.secrets.ntfy-sh-topic.path})
+  systemd.services.matrix-synapse.postStart = ''
+    ACCESS_TOKEN=$(${pkgs.coreutils}/bin/cat ${config.sops.secrets.matrix_access_token.path})
+    TOPIC=$(${pkgs.coreutils}/bin/cat ${config.sops.secrets.ntfy-sh-topic.path})
 
     echo "ensuring ntfy push gateway"
-    ${lib.getExe pkgs.curl} \
+    ${pkgs.curl}/bin/curl \
       --header "Authorization: Bearer $ACCESS_TOKEN" \
       --data "{ \"app_display_name\": \"ntfy-adapter\", \"app_id\": \"ntfy.uninsane.org\", \"data\": { \"url\": \"https://ntfy.uninsane.org/_matrix/push/v1/notify\", \"format\": \"event_id_only\" }, \"device_display_name\": \"ntfy-adapter\", \"kind\": \"http\", \"lang\": \"en-US\", \"profile_tag\": \"\", \"pushkey\": \"$TOPIC\" }" \
       localhost:8008/_matrix/client/v3/pushers/set
 
     echo "registered push gateways:"
-    ${lib.getExe pkgs.curl} \
+    ${pkgs.curl}/bin/curl \
       --header "Authorization: Bearer $ACCESS_TOKEN" \
       localhost:8008/_matrix/client/v3/pushers \
-      | ${lib.getExe pkgs.jq} .
+      | ${pkgs.jq}/bin/jq .
   '';
 
 
@@ -170,5 +161,5 @@ in
     owner = config.users.users.matrix-synapse.name;
   };
   # provide access to ntfy-sh-topic secret
-  users.users.matrix-synapse.extraGroups = lib.optionals ntfy [ "ntfy-sh" ];
+  users.users.matrix-synapse.extraGroups = [ "ntfy-sh" ];
 }

hosts/by-name/servo/services/matrix/discord-puppet.nix

@@ -5,8 +5,8 @@
 # - recommended to use mautrix-discord: <https://github.com/NixOS/nixpkgs/pull/200462>
 lib.mkIf false
 {
-  sane.persist.sys.byStore.private = [
-    { user = "matrix-synapse"; group = "matrix-synapse"; path = "/var/lib/mx-puppet-discord"; method = "bind"; }
+  sane.persist.sys.byStore.plaintext = [
+    { user = "matrix-synapse"; group = "matrix-synapse"; path = "/var/lib/mx-puppet-discord"; }
   ];
 
   services.matrix-synapse.settings.app_service_config_files = [

hosts/by-name/servo/services/matrix/irc.nix

@@ -1,13 +1,15 @@
 # config docs:
 # - <https://github.com/matrix-org/matrix-appservice-irc/blob/develop/config.sample.yaml>
-{ lib, ... }:
+#       probably want to remove that.
+{ config, lib, ... }:
 
 let
-  ircServer = { name, additionalAddresses ? [], ssl ? true, sasl ? true, port ? if ssl then 6697 else 6667 }: let
+  ircServer = { name, additionalAddresses ? [], sasl ? true, port ? 6697 }: let
     lowerName = lib.toLower name;
   in {
     # XXX sasl: appservice doesn't support NickServ identification (only SASL, or PASS if sasl = false)
-    inherit additionalAddresses name port sasl ssl;
+    inherit name additionalAddresses sasl port;
+    ssl = true;
     botConfig = {
       # bot has no presence in IRC channel; only real Matrix users
       enabled = false;
@@ -99,9 +101,9 @@ in
     })
   ];
 
-  sane.persist.sys.byStore.private = [
+  sane.persist.sys.byStore.plaintext = [
     # TODO: mode?
-    { user = "matrix-appservice-irc"; group = "matrix-appservice-irc"; path = "/var/lib/matrix-appservice-irc"; method = "bind"; }
+    { user = "matrix-appservice-irc"; group = "matrix-appservice-irc"; path = "/var/lib/matrix-appservice-irc"; }
   ];
 
   # XXX: matrix-appservice-irc PreStart tries to chgrp the registration.yml to matrix-synapse,
@@ -127,8 +129,6 @@ in
     };
 
     ircService = {
-      logging.level = "warn";  # "error", "warn", "info", "debug"
-      mediaProxy.publicUrl = "https://irc.matrix.uninsane.org/media";
       servers = {
         "irc.esper.net" = ircServer {
           name = "esper";
@@ -154,21 +154,8 @@ in
           # notable channels:
           # - #sxmo
           # - #sxmo-offtopic
-          # supposedly also available at <irc://37lnq2veifl4kar7.onion:6667/> (unofficial)
         };
         "irc.rizon.net" = ircServer { name = "Rizon"; };
-        # "irc.sdf.org" = ircServer {
-        #   # XXX(2024-11-06): seems it can't connect. "matrix-appservice-irc: WARN:Provisioner Provisioner only handles text 'yes'/'y' (from BASHy2-EU on irc.sdf.org)"
-        #   # use instead? <https://lemmy.sdf.org/c/sdfpubnix>
-        #   name = "sdf";
-        #   # sasl = false;
-        #   # notable channels (see: <https://sdf.org/?tutorials/irc-channels>)
-        #   # - #sdf
-        # };
-        "wigle.net" = ircServer {
-          name = "WiGLE";
-          ssl = false;
-        };
       };
     };
   };
@@ -178,16 +165,4 @@ in
     # the service actively uses at least one of these, and both of them are fairly innocuous
     SystemCallFilter = lib.mkForce "~@clock @cpu-emulation @debug @keyring @module @mount @obsolete @raw-io @setuid @swap";
   };
-
-  services.nginx.virtualHosts."irc.matrix.uninsane.org" = {
-    forceSSL = true;
-    enableACME = true;
-    locations."/media" = {
-      proxyPass = "http://127.0.0.1:11111";
-    };
-  };
-
-  sane.dns.zones."uninsane.org".inet = {
-    CNAME."irc.matrix" = "native";
-  };
 }

hosts/by-name/servo/services/matrix/signal.nix

@@ -1,12 +1,10 @@
 # config options:
 # - <https://github.com/mautrix/signal/blob/master/mautrix_signal/example-config.yaml>
-{ config, lib, pkgs, ... }:
-
-lib.mkIf false  # disabled 2024/01/11: i don't use it, and pkgs.mautrix-signal had some API changes
+{ config, pkgs, ... }:
 {
-  sane.persist.sys.byStore.private = [
-    { user = "mautrix-signal"; group = "mautrix-signal"; path = "/var/lib/mautrix-signal"; method = "bind"; }
-    { user = "signald"; group = "signald"; path = "/var/lib/signald"; method = "bind"; }
+  sane.persist.sys.byStore.plaintext = [
+    { user = "mautrix-signal"; group = "mautrix-signal"; path = "/var/lib/mautrix-signal"; }
+    { user = "signald"; group = "signald"; path = "/var/lib/signald"; }
   ];
 
   # allow synapse to read the registration file

hosts/by-name/servo/services/matrix/synapse-log_level.yaml

@@ -0,0 +1,27 @@
+version: 1
+
+# In systemd's journal, loglevel is implicitly stored, so let's omit it
+# from the message text.
+formatters:
+    journal_fmt:
+        format: '%(name)s: [%(request)s] %(message)s'
+
+filters:
+    context:
+        (): synapse.util.logcontext.LoggingContextFilter
+        request: ""
+
+handlers:
+    journal:
+        class: systemd.journal.JournalHandler
+        formatter: journal_fmt
+        filters: [context]
+        SYSLOG_IDENTIFIER: synapse
+
+# default log level: INFO
+root:
+    level: WARN
+    handlers: [journal]
+
+disable_existing_loggers: False
+

hosts/by-name/servo/services/minidlna.nix

@@ -1,39 +0,0 @@
-# - `man 5 minidlna.conf`
-# - `man 8 minidlnad`
-#
-# this is an extremely simple (but limited) DLNA server:
-# - no web UI
-# - no runtime configuration -- just statically configure media directories instead
-# - no transcoding
-# compatibility:
-# - LG TV: music: all working
-# - LG TV: videos: mixed. i can't see the pattern; HEVC works; H.264 sometimes works.
-{ lib, ... }:
-lib.mkIf false  #< XXX(2024-11-17): WORKS, but i'm trying gerbera instead for hopefully better transcoding
-{
-  sane.ports.ports."1900" = {
-    protocol = [ "udp" ];
-    visibleTo.lan = true;
-    description = "colin-upnp-for-minidlna";
-  };
-  sane.ports.ports."8200" = {
-    protocol = [ "tcp" ];
-    visibleTo.lan = true;
-    description = "colin-minidlna-http";
-  };
-
-  services.minidlna.enable = true;
-
-  services.minidlna.settings = {
-    media_dir = [
-      # A/V/P to restrict a directory to audio/video/pictures
-      "A,/var/media/Music"
-      "V,/var/media/Videos/Film"
-      # "V,/var/media/Videos/Milkbags"
-      "V,/var/media/Videos/Shows"
-    ];
-    notify_interval = 60;
-  };
-
-  users.users.minidlna.extraGroups = [ "media" ];
-}

hosts/by-name/servo/services/monero.nix

@@ -1,10 +1,9 @@
 # as of 2023/11/26: complete downloaded blockchain should be 200GiB on disk, give or take.
-{ lib, ... }:
-lib.mkIf false  #< 2024/07/27: i don't use it, too much surface-area for me to run it pro-bono (`systemd-analyze security monero`)
+{ ... }:
 {
   sane.persist.sys.byStore.ext = [
     # /var/lib/monero/lmdb is what consumes most of the space
-    { user = "monero"; group = "monero"; path = "/var/lib/monero"; method = "bind"; }
+    { user = "monero"; group = "monero"; path = "/var/lib/monero"; }
   ];
 
   services.monero.enable = true;
@@ -21,6 +20,12 @@ lib.mkIf false  #< 2024/07/27: i don't use it, too much surface-area for me to r
     tx-proxy=tor,127.0.0.1:9050
   '';
 
+  services.i2p.enable = true;
+  # tor: `tor.enable` doesn't start a relay, exit node, proxy, etc. it's minimal.
+  # tor.client.enable configures a torsocks proxy, accessible *only* to localhost.
+  services.tor.enable = true;
+  services.tor.client.enable = true;
+
   # monero ports: <https://monero.stackexchange.com/questions/604/what-ports-does-monero-use-rpc-p2p-etc>
   # - 18080 = "P2P" monero node <-> monero node connections
   # - 18081 = "RPC" monero client -> monero node connections

hosts/by-name/servo/services/mumble.nix

@@ -1,66 +0,0 @@
-# murmur is the server component of mumble.
-# - docs: <https://www.mumble.info/documentation/>
-# - config docs: <https://www.mumble.info/documentation/administration/config-file/>
-#
-# default port is 64738 (UDP and TCP)
-#
-# FIRST-RUN:
-# - login from mumble client as `SuperUser`, password taken from `journalctl -u murmur`.
-# - login from another machine and right click on self -> 'Register'
-# - as SuperUser, right click on server root -> edit
-#   - Groups tab: select "admin", then add the other registered user to the group.
-# - log out as SuperUser and manage the server using that other user now.
-#
-# USAGE:
-# - 'auth' group = any user who has registered a cert with the server.
-{ ... }:
-{
-  sane.persist.sys.byStore.private = [
-    { user = "murmur"; group = "murmur"; mode = "0700"; path = "/var/lib/murmur"; method = "bind"; }
-  ];
-
-  services.murmur.enable = true;
-  services.murmur.welcometext = "welcome to Colin's mumble voice chat server";
-  # max bandwidth (bps) **per user**. i believe this affects both voice and uploads?
-  # mumble defaults to 558000, but nixos service defaults to 72000.
-  services.murmur.bandwidth = 558000;
-  services.murmur.imgMsgLength = 8 * 1024 * 1024;
-
-  services.murmur.sslCert = "/var/lib/acme/mumble.uninsane.org/fullchain.pem";
-  services.murmur.sslKey = "/var/lib/acme/mumble.uninsane.org/key.pem";
-  services.murmur.sslCa = "/etc/ssl/certs/ca-bundle.crt";
-
-  # allow clients on the LAN to discover this server
-  services.murmur.bonjour = true;
-
-  # mumble has a public server listing.
-  # my server doesn't associate with that registry (unless i specify registerPassword).
-  # however these settings appear to affect how the server presents itself to clients, regardless of registration.
-  services.murmur.registerName = "mumble.uninsane.org";
-  services.murmur.registerUrl = "https://mumble.uninsane.org";
-  services.murmur.registerHostname = "mumble.uninsane.org";
-
-  # defaultchannel=ID makes it so that unauthenticated users are placed in some specific channel when they join
-  services.murmur.extraConfig = ''
-    defaultchannel=2
-  '';
-
-  users.users.murmur.extraGroups = [
-    "nginx"  # provide access to certs
-  ];
-  services.nginx.virtualHosts."mumble.uninsane.org" = {
-    # allow ACME to procure a cert via nginx for this domain
-    enableACME = true;
-  };
-
-  sane.dns.zones."uninsane.org".inet = {
-    CNAME."mumble" = "native";
-  };
-
-  sane.ports.ports."64738" = {
-    protocol = [ "tcp" "udp" ];
-    visibleTo.lan = true;
-    visibleTo.doof = true;
-    description = "colin-mumble";
-  };
-}

hosts/by-name/servo/services/navidrome.nix

@@ -1,16 +1,15 @@
 { lib, ... }:
 
-lib.mkIf false  #< i don't actively use navidrome
 {
   sane.persist.sys.byStore.plaintext = [
-    { user = "navidrome"; group = "navidrome"; path = "/var/lib/navidrome"; method = "bind"; }
+    { user = "navidrome"; group = "navidrome"; path = "/var/lib/navidrome"; }
   ];
   services.navidrome.enable = true;
   services.navidrome.settings = {
     # docs: https://www.navidrome.org/docs/usage/configuration-options/
     Address = "127.0.0.1";
     Port = 4533;
-    MusicFolder = "/var/media/Music";
+    MusicFolder = "/var/lib/uninsane/media/Music";
     CovertArtPriority = "*.jpg, *.JPG, *.png, *.PNG, embedded";
     AutoImportPlaylists = false;
     ScanSchedule = "@every 1h";

hosts/by-name/servo/services/nginx.nix

@@ -17,24 +17,18 @@ in
   sane.ports.ports."80" = {
     protocol = [ "tcp" ];
     visibleTo.lan = true;
-    visibleTo.ovpns = true;  # so that letsencrypt can procure a cert for the mx record
-    visibleTo.doof = true;
+    visibleTo.wan = true;
+    visibleTo.ovpn = true;  # so that letsencrypt can procure a cert for the mx record
     description = "colin-http-uninsane.org";
   };
   sane.ports.ports."443" = {
     protocol = [ "tcp" ];
     visibleTo.lan = true;
-    visibleTo.doof = true;
+    visibleTo.wan = true;
     description = "colin-https-uninsane.org";
   };
 
   services.nginx.enable = true;
-  # nginxStable is one release behind nginxMainline.
-  # nginx itself recommends running mainline; nixos defaults to stable.
-  # services.nginx.package = pkgs.nginxMainline;
-  # XXX(2024-07-31): nixos defaults to zlib-ng -- supposedly more performant, but spams log with
-  # "gzip filter failed to use preallocated memory: ..."
-  services.nginx.package = pkgs.nginxMainline.override { zlib = pkgs.zlib; };
   services.nginx.appendConfig = ''
     # use 1 process per core.
     # may want to increase worker_connections too, but `ulimit -n` must be increased first.
@@ -50,10 +44,8 @@ in
     log_format vcombined '$host:$server_port $remote_addr - $remote_user [$time_local] "$request" $status $body_bytes_sent "$http_referrer" "$http_user_agent"';
     access_log /var/log/nginx/private.log vcombined;
   '';
-  # enables gzip and sets gzip_comp_level = 5
+  # sets gzip_comp_level = 5
   services.nginx.recommendedGzipSettings = true;
-  # enables zstd and sets zstd_comp_level = 9
-  services.nginx.recommendedZstdSettings = true;
   # enables OCSP stapling (so clients don't need contact the OCSP server -- i do instead)
   # - doesn't seem to, actually: <https://www.ssllabs.com/ssltest/analyze.html?d=uninsane.org>
   # caches TLS sessions for 10m
@@ -62,10 +54,8 @@ in
   services.nginx.recommendedOptimisation = true;
 
   # web blog/personal site
-  # alternative way to link stuff into the share:
-  # sane.fs."/var/www/sites/uninsane.org/share/Ubunchu".mount.bind = "/var/media/Books/Visual/HiroshiSeo/Ubunchu";
-  # sane.fs."/var/media/Books/Visual/HiroshiSeo/Ubunchu".dir = {};
   services.nginx.virtualHosts."uninsane.org" = publog {
+    root = "${pkgs.uninsane-dot-org}/share/uninsane-dot-org";
     # a lot of places hardcode https://uninsane.org,
     # and then when we mix http + non-https, we get CORS violations
     # and things don't look right. so force SSL.
@@ -75,70 +65,9 @@ in
     # for OCSP stapling
     sslTrustedCertificate = "${pkgs.cacert}/etc/ssl/certs/ca-bundle.crt";
 
-    locations."/" = {
-      root = "${pkgs.uninsane-dot-org}/share/uninsane-dot-org";
-      tryFiles = "$uri $uri/ @fallback";
-    };
-
-    # unversioned files
-    locations."@fallback" = {
-      root = "/var/www/sites/uninsane.org";
-      extraConfig = ''
-        # instruct Google to not index these pages.
-        # see: <https://developers.google.com/search/docs/crawling-indexing/robots-meta-tag#xrobotstag>
-        add_header X-Robots-Tag 'none, noindex, nofollow';
-
-        # best-effort attempt to block archive.org from archiving these pages.
-        # reply with 403: Forbidden
-        # User Agent is *probably* "archive.org_bot"; maybe used to be "ia_archiver"
-        # source: <https://archive.org/details/archive.org_bot>
-        # additional UAs: <https://github.com/mitchellkrogza/nginx-ultimate-bad-bot-blocker>
-        #
-        # validate with: `curl -H 'User-Agent: "bot;archive.org_bot;like: something else"' -v https://uninsane.org/dne`
-        if ($http_user_agent ~* "(?:\b)archive.org_bot(?:\b)") {
-          return 403;
-        }
-        if ($http_user_agent ~* "(?:\b)archive.org(?:\b)") {
-          return 403;
-        }
-        if ($http_user_agent ~* "(?:\b)ia_archiver(?:\b)") {
-          return 403;
-        }
-      '';
-    };
-
-    # uninsane.org/share/foo => /var/www/sites/uninsane.org/share/foo.
-    # special-cased to enable directory listings
-    locations."/share" = {
-      root = "/var/www/sites/uninsane.org";
-      extraConfig = ''
-        # autoindex => render directory listings
-        autoindex on;
-        # don't follow any symlinks when serving files
-        # otherwise it allows a directory escape
-        disable_symlinks on;
-      '';
-    };
-    locations."/share/Milkbags/" = {
-      alias = "/var/media/Videos/Milkbags/";
-      extraConfig = ''
-        # autoindex => render directory listings
-        autoindex on;
-        # don't follow any symlinks when serving files
-        # otherwise it allows a directory escape
-        disable_symlinks on;
-      '';
-    };
-    locations."/share/Ubunchu/" = {
-      alias = "/var/media/Books/Visual/HiroshiSeo/Ubunchu/";
-      extraConfig = ''
-        # autoindex => render directory listings
-        autoindex on;
-        # don't follow any symlinks when serving files
-        # otherwise it allows a directory escape
-        disable_symlinks on;
-      '';
-    };
+    # uninsane.org/share/foo => /var/lib/uninsane/root/share/foo.
+    # yes, nginx does not strip the prefix when evaluating against the root.
+    locations."/share".root = "/var/lib/uninsane/root";
 
     # allow matrix users to discover that @user:uninsane.org is reachable via matrix.uninsane.org
     locations."= /.well-known/matrix/server".extraConfig =
@@ -179,19 +108,6 @@ in
     #   proxyPass = "http://127.0.0.1:4000";
     #   extraConfig = pleromaExtraConfig;
     # };
-
-    # redirect common feed URIs to the canonical feed
-    locations."= /atom".extraConfig = "return 301 /atom.xml;";
-    locations."= /feed".extraConfig = "return 301 /atom.xml;";
-    locations."= /feed.xml".extraConfig = "return 301 /atom.xml;";
-    locations."= /rss".extraConfig = "return 301 /atom.xml;";
-    locations."= /rss.xml".extraConfig = "return 301 /atom.xml;";
-    locations."= /blog/atom".extraConfig = "return 301 /atom.xml;";
-    locations."= /blog/atom.xml".extraConfig = "return 301 /atom.xml;";
-    locations."= /blog/feed".extraConfig = "return 301 /atom.xml;";
-    locations."= /blog/feed.xml".extraConfig = "return 301 /atom.xml;";
-    locations."= /blog/rss".extraConfig = "return 301 /atom.xml;";
-    locations."= /blog/rss.xml".extraConfig = "return 301 /atom.xml;";
   };
 
 
@@ -219,15 +135,9 @@ in
   security.acme.defaults.email = "admin.acme@uninsane.org";
 
   sane.persist.sys.byStore.plaintext = [
-    { user = "acme"; group = "acme"; path = "/var/lib/acme"; method = "bind"; }
-  ];
-  sane.persist.sys.byStore.private = [
-    { user = "colin"; group = "users"; path = "/var/www/sites"; method = "bind"; }
-  ];
-  sane.persist.sys.byStore.ephemeral = [
-    # logs *could* be persisted to private storage, but then there's the issue of
-    # "what if servo boots, isn't unlocked, and the whole / tmpfs is consumed by logs"
-    { user = "nginx"; group = "nginx"; path = "/var/log/nginx"; method = "bind"; }
+    # TODO: mode?
+    { user = "acme"; group = "acme"; path = "/var/lib/acme"; }
+    { user = "colin"; group = "users"; path = "/var/www/sites"; }
   ];
 
   # let's encrypt default chain looks like:
@@ -257,7 +167,7 @@ in
   # to accept it.
   system.activationScripts.generate-x509-self-signed.text = ''
     mkdir -p /var/www/certs/wildcard
-    test -f /var/www/certs/wildcard/key.pem || ${lib.getExe pkgs.openssl} \
+    test -f /var/www/certs/wildcard/key.pem || ${pkgs.openssl}/bin/openssl \
       req -x509 -newkey rsa:4096 \
       -keyout /var/www/certs/wildcard/key.pem \
       -out /var/www/certs/wildcard/cert.pem \

hosts/by-name/servo/services/nixos-prebuild.nix

@@ -1,26 +0,0 @@
-{ lib, pkgs, ... }:
-
-lib.optionalAttrs false  # disabled until i can be sure it's not gonna OOM my server in the middle of the night
-{
-  systemd.services.nixos-prebuild = {
-    description = "build a nixos image with all updated deps";
-    path = with pkgs; [ coreutils git nix ];
-    script = ''
-      working=$(mktemp -d /tmp/nixos-prebuild.XXXXXX)
-      pushd "$working"
-      git clone https://git.uninsane.org/colin/nix-files.git \
-        && cd nix-files \
-        && nix flake update \
-        || true
-      RC=$(nix run "$working/nix-files#check" -- -j1 --cores 5 --builders "")
-      popd
-      rm -rf "$working"
-      exit "$RC"
-    '';
-  };
-
-  systemd.timers.nixos-prebuild = {
-    wantedBy = [ "multi-user.target" ];
-    timerConfig.OnCalendar = "11,23:00:00";
-  };
-}

hosts/by-name/servo/services/nixserve.nix

@@ -0,0 +1,21 @@
+{ config, ... }:
+
+{
+  services.nginx.virtualHosts."nixcache.uninsane.org" = {
+    addSSL = true;
+    enableACME = true;
+    # inherit kTLS;
+    # serverAliases = [ "nixcache" ];
+    locations."/".extraConfig = ''
+      proxy_pass http://localhost:${toString config.services.nix-serve.port};
+      proxy_set_header Host $host;
+      proxy_set_header X-Real-IP $remote_addr;
+      proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+    '';
+  };
+
+  sane.dns.zones."uninsane.org".inet.CNAME."nixcache" = "native";
+
+  sane.services.nixserve.enable = true;
+  sane.services.nixserve.secretKeyFile = config.sops.secrets.nix_serve_privkey.path;
+}

hosts/by-name/servo/services/ntfy/default.nix

@@ -1,12 +1,12 @@
 # ntfy: UnifiedPush notification delivery system
 # - used to get push notifications out of Matrix and onto a Phone (iOS, Android, or a custom client)
-{ config, lib, ... }:
+{ config, ... }:
 {
   imports = [
     ./ntfy-waiter.nix
     ./ntfy-sh.nix
   ];
-  sops.secrets."ntfy-sh-topic" = lib.mkIf config.services.ntfy-sh.enable {
+  sops.secrets."ntfy-sh-topic" = {
     mode = "0440";
     owner = config.users.users.ntfy-sh.name;
     group = config.users.users.ntfy-sh.name;

hosts/by-name/servo/services/ntfy/ntfy-sh.nix

@@ -29,13 +29,12 @@ let
   # at the IP layer, to enable e.g. wake-on-lan.
   altPort = 2587;
 in
-lib.mkIf false  #< 2024/09/30: disabled because i haven't used it in several months
 {
-  sane.persist.sys.byStore.private = [
+  sane.persist.sys.byStore.plaintext = [
     # not 100% necessary to persist this, but ntfy does keep a 12hr (by default) cache
     # for pushing notifications to users who become offline.
     # ACLs also live here.
-    { user = "ntfy-sh"; group ="ntfy-sh"; path = "/var/lib/ntfy-sh"; method = "bind"; }
+    { user = "ntfy-sh"; group ="ntfy-sh"; path = "/var/lib/ntfy-sh"; }
   ];
 
   services.ntfy-sh.enable = true;
@@ -47,7 +46,7 @@ lib.mkIf false  #< 2024/09/30: disabled because i haven't used it in several mon
     # defaults to 45s.
     # note that the client may still do its own TCP-level keepalives, typically every 30s
     keepalive-interval = "15m";
-    log-level = "info";  # trace, debug, info (default), warn, error
+    log-level = "trace";  # trace, debug, info (default), warn, error
     auth-default-access = "deny-all";
   };
   systemd.services.ntfy-sh.serviceConfig.DynamicUser = lib.mkForce false;
@@ -59,7 +58,7 @@ lib.mkIf false  #< 2024/09/30: disabled because i haven't used it in several mon
     # note that this will fail upon first run, i.e. before ntfy has created its db.
     # just restart the service.
     topic=$(cat ${config.sops.secrets.ntfy-sh-topic.path})
-    ${lib.getExe' pkgs.ntfy-sh "ntfy"} access everyone "$topic" read-write
+    ${pkgs.ntfy-sh}/bin/ntfy access everyone "$topic" read-write
   '';
 
 
@@ -87,7 +86,7 @@ lib.mkIf false  #< 2024/09/30: disabled because i haven't used it in several mon
   sane.ports.ports."${builtins.toString altPort}" = {
     protocol = [ "tcp" ];
     visibleTo.lan = true;
-    visibleTo.doof = true;
+    visibleTo.wan = true;
     description = "colin-ntfy.uninsane.org";
   };
 }

hosts/by-name/servo/services/ntfy/ntfy-waiter

@@ -1,5 +1,5 @@
 #!/usr/bin/env nix-shell
-#!nix-shell -i python3 -p ntfy-sh -p python3
+#!nix-shell -i python3 -p "python3.withPackages (ps: [  ])" -p ntfy-sh
 
 import argparse
 import logging

hosts/by-name/servo/services/ntfy/ntfy-waiter.nix

@@ -14,7 +14,7 @@ let
     silence = port - portLow;
     flags = lib.optional cfg.verbose "--verbose";
     cli = [
-      (lib.getExe cfg.package)
+      "${cfg.package}/bin/ntfy-waiter"
       "--port"
       "${builtins.toString port}"
       "--silence"
@@ -31,7 +31,7 @@ let
         ExecStart = lib.concatStringsSep " " cli;
       };
       after = [ "network.target" ];
-      wantedBy = [ "ntfy-sh.service" ];
+      wantedBy = [ "default.target" ];
     };
   };
 in
@@ -39,7 +39,7 @@ in
   options = with lib; {
     sane.ntfy-waiter.enable = mkOption {
       type = types.bool;
-      default = config.services.ntfy-sh.enable;
+      default = true;
     };
     sane.ntfy-waiter.verbose = mkOption {
       type = types.bool;
@@ -47,9 +47,9 @@ in
     };
     sane.ntfy-waiter.package = mkOption {
       type = types.package;
-      default = pkgs.static-nix-shell.mkPython3 {
+      default = pkgs.static-nix-shell.mkPython3Bin {
         pname = "ntfy-waiter";
-        srcRoot = ./.;
+        src = ./.;
         pkgs = [ "ntfy-sh" ];
       };
       description = ''
@@ -62,9 +62,9 @@ in
     sane.ports.ports = lib.mkMerge (lib.forEach portRange (port: {
       "${builtins.toString port}" = {
         protocol = [ "tcp" ];
-        visibleTo.doof = true;
         visibleTo.lan = true;
-        description = "colin-notification-waiter-${builtins.toString (port - portLow + 1)}-of-${builtins.toString numPorts}";
+        visibleTo.wan = true;
+        description = "colin-notification-waiter-${builtins.toString (port+1)}-of-${builtins.toString numPorts}";
       };
     }));
     systemd.services = lib.mkMerge (builtins.map mkService portRange);

hosts/by-name/servo/services/pict-rs.nix

@@ -6,7 +6,7 @@ let
 in
 {
   sane.persist.sys.byStore.plaintext = lib.mkIf cfg.enable [
-    { user = "pict-rs"; group = "pict-rs"; path = cfg.dataDir; method = "bind"; }
+    { user = "pict-rs"; group = "pict-rs"; path = cfg.dataDir; }
   ];
 
   systemd.services.pict-rs.serviceConfig = {

hosts/by-name/servo/services/pleroma.nix

@@ -7,16 +7,15 @@
 # to run it in a oci-container: <https://github.com/barrucadu/nixfiles/blob/master/services/pleroma.nix>
 #
 # admin frontend: <https://fed.uninsane.org/pleroma/admin>
-{ config, lib, pkgs, ... }:
+{ config, pkgs, ... }:
 
 let
-  logLevel = "warning";
+  logLevel = "warn";
   # logLevel = "debug";
 in
 {
-  sane.persist.sys.byStore.private = [
-    # contains media i've uploaded to the server
-    { user = "pleroma"; group = "pleroma"; path = "/var/lib/pleroma"; method = "bind"; }
+  sane.persist.sys.byStore.plaintext = [
+    { user = "pleroma"; group = "pleroma"; path = "/var/lib/pleroma"; }
   ];
   services.pleroma.enable = true;
   services.pleroma.secretConfigFile = config.sops.secrets.pleroma_secrets.path;
@@ -26,7 +25,7 @@ in
 
     config :pleroma, Pleroma.Web.Endpoint,
       url: [host: "fed.uninsane.org", scheme: "https", port: 443],
-      http: [ip: {127, 0, 0, 1}, port: 4040]
+      http: [ip: {127, 0, 0, 1}, port: 4000]
     #   secret_key_base: "{secrets.pleroma.secret_key_base}",
     #   signing_salt: "{secrets.pleroma.signing_salt}"
 
@@ -46,7 +45,7 @@ in
     config :pleroma, Pleroma.Emails.Mailer,
       enabled: true,
       adapter: Swoosh.Adapters.Sendmail,
-      cmd_path: "${lib.getExe' pkgs.postfix "sendmail"}"
+      cmd_path: "${pkgs.postfix}/bin/sendmail"
 
     config :pleroma, Pleroma.User,
       restricted_nicknames: [ "admin", "uninsane", "root" ]
@@ -88,12 +87,6 @@ in
     # strip metadata from uploaded images
     config :pleroma, Pleroma.Upload, filters: [Pleroma.Upload.Filter.Exiftool.StripLocation]
 
-    # fix log spam: <https://git.pleroma.social/pleroma/pleroma/-/issues/1659>
-    # specifically, remove LAN addresses from `reserved`
-    config :pleroma, Pleroma.Web.Plugs.RemoteIp,
-      enabled: true,
-      reserved: ["127.0.0.0/8", "::1/128", "fc00::/7", "172.16.0.0/12"]
-
     # TODO: GET /api/pleroma/captcha is broken
     # there was a nixpkgs PR to fix this around 2022/10 though.
     config :pleroma, Pleroma.Captcha,
@@ -143,53 +136,25 @@ in
     pkgs.bash
     # used by Pleroma to strip geo tags from uploads
     pkgs.exiftool
-    # config.sane.programs.exiftool.package  #< XXX(2024-10-20): breaks image uploading
     # i saw some errors when pleroma was shutting down about it not being able to find `awk`. probably not critical
-    # config.sane.programs.gawk.package
+    pkgs.gawk
     # needed for email operations like password reset
     pkgs.postfix
   ];
 
-  systemd.services.pleroma = {
+  systemd.services.pleroma.serviceConfig = {
     # postgres can be slow to service early requests, preventing pleroma from starting on the first try
-    serviceConfig.Restart = "on-failure";
-    serviceConfig.RestartSec = "10s";
-
-    # hardening (systemd-analyze security pleroma)
-    # XXX(2024-07-28): this hasn't been rigorously tested:
-    # possible that i've set something too strict and won't notice right away
-    # make sure to test:
-    # - image/media uploading
-    serviceConfig.CapabilityBoundingSet = lib.mkForce [ "" "" ];  # nixos default is `~CAP_SYS_ADMIN`
-    serviceConfig.LockPersonality = true;
-    serviceConfig.NoNewPrivileges = true;
-    serviceConfig.MemoryDenyWriteExecute = true;
-    serviceConfig.PrivateDevices = lib.mkForce true;  #< dunno why nixpkgs has this set false; it seems to work as true
-    serviceConfig.PrivateMounts = true;
-    serviceConfig.PrivateTmp = true;
-    serviceConfig.PrivateUsers = true;
-
-    serviceConfig.ProtectProc = "invisible";
-    serviceConfig.ProcSubset = "all";  #< needs /proc/sys/kernel/overflowuid for bwrap
-
-    serviceConfig.ProtectClock = true;
-    serviceConfig.ProtectControlGroups = true;
-    serviceConfig.ProtectHome = true;
-    serviceConfig.ProtectKernelModules = true;
-    serviceConfig.ProtectSystem = lib.mkForce "strict";
-    serviceConfig.RemoveIPC = true;
-    serviceConfig.RestrictAddressFamilies = "AF_UNIX AF_INET AF_INET6 AF_NETLINK";
-
-    serviceConfig.RestrictSUIDSGID = true;
-    serviceConfig.SystemCallArchitectures = "native";
-    serviceConfig.SystemCallFilter = [ "@system-service" "@mount" "@sandbox" ];  #< "sandbox" might not actually be necessary
-
-    serviceConfig.ProtectHostname = false;  #< else brap can't mount /proc
-    serviceConfig.ProtectKernelLogs = false;  #< else breaks exiftool  ("bwrap: Can't mount proc on /newroot/proc: Operation not permitted")
-    serviceConfig.ProtectKernelTunables = false;  #< else breaks exiftool
-    serviceConfig.RestrictNamespaces = false;  # media uploads require bwrap
+    Restart = "on-failure";
+    RestartSec = "10s";
   };
 
+  # systemd.services.pleroma.serviceConfig = {
+  #   # required for sendmail. see https://git.pleroma.social/pleroma/pleroma/-/issues/2259
+  #   NoNewPrivileges = lib.mkForce false;
+  #   PrivateTmp = lib.mkForce false;
+  #   CapabilityBoundingSet = lib.mkForce "~";
+  # };
+
   # this is required to allow pleroma to send email.
   # raw `sendmail` works, but i think pleroma's passing it some funny flags or something, idk.
   # hack to fix that.
@@ -202,11 +167,38 @@ in
     enableACME = true;
     # inherit kTLS;
     locations."/" = {
-      proxyPass = "http://127.0.0.1:4040";
+      proxyPass = "http://127.0.0.1:4000";
       recommendedProxySettings = true;
       # documented: https://git.pleroma.social/pleroma/pleroma/-/blob/develop/installation/pleroma.nginx
       extraConfig = ''
-        # client_max_body_size defines the maximum upload size
+        # XXX colin: this block is in the nixos examples: i don't understand all of it
+        add_header 'Access-Control-Allow-Origin' '*' always;
+        add_header 'Access-Control-Allow-Methods' 'POST, PUT, DELETE, GET, PATCH, OPTIONS' always;
+        add_header 'Access-Control-Allow-Headers' 'Authorization, Content-Type, Idempotency-Key' always;
+        add_header 'Access-Control-Expose-Headers' 'Link, X-RateLimit-Reset, X-RateLimit-Limit, X-RateLimit-Remaining, X-Request-Id' always;
+        if ($request_method = OPTIONS) {
+            return 204;
+        }
+
+        add_header X-XSS-Protection "1; mode=block";
+        add_header X-Permitted-Cross-Domain-Policies none;
+        add_header X-Frame-Options DENY;
+        add_header X-Content-Type-Options nosniff;
+        add_header Referrer-Policy same-origin;
+        add_header X-Download-Options noopen;
+
+        # proxy_http_version 1.1;
+        # proxy_set_header Upgrade $http_upgrade;
+        # proxy_set_header Connection "upgrade";
+        # # proxy_set_header Host $http_host;
+        # proxy_set_header Host $host;
+        # proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+
+        # colin: added this due to Pleroma complaining in its logs
+        # proxy_set_header X-Real-IP $remote_addr;
+        # proxy_set_header X-Forwarded-Proto $scheme;
+
+        # NB: this defines the maximum upload size
         client_max_body_size 16m;
       '';
     };

hosts/by-name/servo/services/postgres.nix

@@ -6,9 +6,9 @@ let
   KiB = n: 1024*n;
 in
 {
-  sane.persist.sys.byStore.private = [
-    { user = "postgres"; group = "postgres"; mode = "0750"; path = "/var/lib/postgresql"; method = "bind"; }
-    { user = "postgres"; group = "postgres"; mode = "0750"; path = "/var/backup/postgresql"; method = "bind"; }
+  sane.persist.sys.byStore.plaintext = [
+    # TODO: mode?
+    { user = "postgres"; group = "postgres"; path = "/var/lib/postgresql"; }
   ];
   services.postgresql.enable = true;
 
@@ -29,10 +29,9 @@ in
   # - as `sudo su postgres`:
   #   - `cd /var/lib/postgreql`
   #   - `psql -f state.sql`
-  #     (for a compressed dump: `gunzip --stdout state.sql.gz | psql`)
   # - restart dependent services (maybe test one at a time)
 
-  services.postgresql.package = pkgs.postgresql_16;
+  services.postgresql.package = pkgs.postgresql_15;
 
 
   # XXX colin: for a proper deploy, we'd want to include something for Pleroma here too.
@@ -45,46 +44,34 @@ in
   #     LC_CTYPE = "C";
   # '';
 
+  # perf tuning
+  # - for recommended values see: <https://pgtune.leopard.in.ua/>
+  # - for official docs (sparse), see: <https://www.postgresql.org/docs/11/config-setting.html#CONFIG-SETTING-CONFIGURATION-FILE>
   services.postgresql.settings = {
-    # perf tuning
-    # - for recommended values see: <https://pgtune.leopard.in.ua/>
-    # - for official docs (sparse), see: <https://www.postgresql.org/docs/11/config-setting.html#CONFIG-SETTING-CONFIGURATION-FILE>
-    # DB Version: 16
+    # DB Version: 15
     # OS Type: linux
     # DB Type: web
-    # vvv artificially constrained because the server's resources are shared across maaany services
-    # Total Memory (RAM): 12 GB
+    # Total Memory (RAM): 32 GB
     # CPUs num: 12
     # Data Storage: ssd
     max_connections = 200;
-    shared_buffers = "3GB";
-    effective_cache_size = "9GB";
-    maintenance_work_mem = "768MB";
+    shared_buffers = "8GB";
+    effective_cache_size = "24GB";
+    maintenance_work_mem = "2GB";
     checkpoint_completion_target = 0.9;
     wal_buffers = "16MB";
     default_statistics_target = 100;
     random_page_cost = 1.1;
     effective_io_concurrency = 200;
-    work_mem = "3932kB";
+    work_mem = "10485kB";
     min_wal_size = "1GB";
     max_wal_size = "4GB";
     max_worker_processes = 12;
     max_parallel_workers_per_gather = 4;
     max_parallel_workers = 12;
     max_parallel_maintenance_workers = 4;
-
-    # DEBUG OPTIONS:
-    log_min_messages = "DEBUG1";
   };
 
-  # regulate the restarts, so that systemd never disables it
-  systemd.services.postgresql.serviceConfig.Restart = "on-failure";
-  systemd.services.postgresql.serviceConfig.RestartSec = 2;
-  systemd.services.postgresql.serviceConfig.RestartMaxDelaySec = 10;
-  systemd.services.postgresql.serviceConfig.RestartSteps = 4;
-  systemd.services.postgresql.serviceConfig.StartLimitBurst = 120;
-  # systemd.services.postgresql.serviceConfig.TimeoutStartSec = "14400s";  #< 14400 = 4 hours; recoveries are long
-
   # daily backups to /var/backup
   services.postgresqlBackup.enable = true;
 

hosts/by-name/servo/services/postgresql/recollate.sh

@@ -1,81 +0,0 @@
-#!/bin/sh
-# source: <https://gist.githubusercontent.com/troykelly/616df024050dd50744dde4a9579e152e/raw/fe84e53cedf0caa6903604894454629a15867439/reindex_and_refresh_collation.sh>
-#
-# run this whenever postgres complains like:
-# > WARNING:  database "gitea" has a collation version mismatch
-# > DETAIL:  The database was created using collation version 2.39, but the operating system provides version 2.40.
-# > HINT:  Rebuild all objects in this database that use the default collation and run ALTER DATABASE gitea REFRESH COLLATION VERSION, or build PostgreSQL with the right library version.
-#
-# this script checks which databases are in need of a collation update,
-# and re-collates them as appropriate.
-# invoking this script should have low perf impact in the non-upgrade case,
-# so safe to do this as a cron job.
-#
-# invoke as postgres user
-
-log_info() {
-  >&2 echo "$@"
-}
-
-list_databases() {
-  log_info "Retrieving list of databases from the PostgreSQL server..."
-  psql --dbname="postgres" -Atc \
-    "SELECT datname FROM pg_database WHERE datistemplate = false"
-}
-
-refresh_collation_version() {
-  local db=$1
-  log_info "Refreshing collation version for database: $db..."
-  psql --dbname="$db" -c \
-    "ALTER DATABASE \"$db\" REFRESH COLLATION VERSION;"
-}
-
-check_collation_mismatches() {
-  local error=
-  log_info "Checking for collation mismatches in all databases..."
-  # Loop through each database and check for mismatching collations in table columns.
-  while IFS= read -r db; do
-    if [ -n "$db" ]; then
-      log_info "Checking database: $db for collation mismatches..."
-      local mismatches=$(psql --dbname="$db" -Atc \
-        "SELECT 'Mismatch in table ' || table_name || ' column ' || column_name || ' with collation ' || collation_name
-         FROM information_schema.columns
-         WHERE collation_name IS NOT NULL AND collation_name <> 'default' AND table_schema = 'public'
-         EXCEPT
-         SELECT 'No mismatch - default collation of ' || datcollate || ' used.'
-         FROM pg_database WHERE datname = '$db';"
-      )
-      if [ -z "$mismatches" ]; then
-        log_info "No collation mismatches found in database: $db"
-      else
-        # Print an informational message to stderr.
-        log_info "Collation mismatches found in database: $db:"
-        log_info "$mismatches"
-        error=1
-      fi
-    fi
-  done
-
-  if [ -n "$error" ]; then
-    exit 1
-  fi
-}
-
-log_info "Starting the reindexing and collation refresh process for all databases..."
-
-databases=$(list_databases)
-
-if [ -z "$databases" ]; then
-  log_info "No databases found for reindexing or collation refresh. Please check connection details to PostgreSQL server."
-  exit 1
-fi
-
-for db in $databases; do
-  refresh_collation_version "$db"
-done
-
-# Checking for collation mismatches after reindexing and collation refresh.
-# Pass the list of databases to the check_collation_mismatches function through stdin.
-echo "$databases" | check_collation_mismatches
-
-log_info "Reindexing and collation refresh process completed."

hosts/by-name/servo/services/prosody/default.nix

@@ -49,62 +49,60 @@
 # - disable or fix bosh (jabber over http):
 #   - "certmanager: No certificate/key found for client_https port 0"
 
-{ config, lib, pkgs, ... }:
+{ lib, pkgs, ... }:
 
 let
   # enables very verbose logging
   enableDebug = false;
 in
 {
-  sane.persist.sys.byStore.private = [
-    # TODO: mode?
-    { user = "prosody"; group = "prosody"; path = "/var/lib/prosody"; method = "bind"; }
+  sane.persist.sys.byStore.plaintext = [
+    { user = "prosody"; group = "prosody"; path = "/var/lib/prosody"; }
   ];
   sane.ports.ports."5000" = {
     protocol = [ "tcp" ];
-    visibleTo.doof = true;
     visibleTo.lan = true;
+    visibleTo.wan = true;
     description = "colin-xmpp-prosody-fileshare-proxy65";
   };
   sane.ports.ports."5222" = {
     protocol = [ "tcp" ];
-    visibleTo.doof = true;
     visibleTo.lan = true;
+    visibleTo.wan = true;
     description = "colin-xmpp-client-to-server";
   };
   sane.ports.ports."5223" = {
     protocol = [ "tcp" ];
-    visibleTo.doof = true;
     visibleTo.lan = true;
+    visibleTo.wan = true;
     description = "colin-xmpps-client-to-server";  # XMPP over TLS
   };
   sane.ports.ports."5269" = {
     protocol = [ "tcp" ];
-    visibleTo.doof = true;
+    visibleTo.wan = true;
     description = "colin-xmpp-server-to-server";
   };
   sane.ports.ports."5270" = {
     protocol = [ "tcp" ];
-    visibleTo.doof = true;
+    visibleTo.wan = true;
     description = "colin-xmpps-server-to-server";  # XMPP over TLS
   };
   sane.ports.ports."5280" = {
     protocol = [ "tcp" ];
-    visibleTo.doof = true;
     visibleTo.lan = true;
+    visibleTo.wan = true;
     description = "colin-xmpp-bosh";
   };
   sane.ports.ports."5281" = {
     protocol = [ "tcp" ];
-    visibleTo.doof = true;
     visibleTo.lan = true;
+    visibleTo.wan = true;
     description = "colin-xmpp-prosody-https";  # necessary?
   };
 
   users.users.prosody.extraGroups = [
     "nginx"  # provide access to certs
     "ntfy-sh"  # access to secret ntfy topic
-    "turnserver"  # to access the coturn shared secret
   ];
 
   security.acme.certs."uninsane.org".extraDomainNames = [
@@ -150,8 +148,14 @@ in
   # pointing it to /var/lib/acme doesn't quite work because it expects the private key
   # to be named `privkey.pem` instead of acme's `key.pem`
   # <https://prosody.im/doc/certificates#automatic_location>
-  environment.etc."prosody/certs/uninsane.org/fullchain.pem".source = "/var/lib/acme/uninsane.org/fullchain.pem";
-  environment.etc."prosody/certs/uninsane.org/privkey.pem".source = "/var/lib/acme/uninsane.org/key.pem";
+  sane.fs."/etc/prosody/certs/uninsane.org/fullchain.pem" = {
+    symlink.target = "/var/lib/acme/uninsane.org/fullchain.pem";
+    wantedBeforeBy = [ "prosody.service" ];
+  };
+  sane.fs."/etc/prosody/certs/uninsane.org/privkey.pem" = {
+    symlink.target = "/var/lib/acme/uninsane.org/key.pem";
+    wantedBeforeBy = [ "prosody.service" ];
+  };
 
   services.prosody = {
     enable = true;
@@ -237,7 +241,6 @@ in
       # legacy coturn integration
       # see: <https://modules.prosody.im/mod_turncredentials.html>
       # "turncredentials"
-    ] ++ lib.optionals config.services.ntfy-sh.enable [
       "sane_ntfy"
     ] ++ lib.optionals enableDebug [
       "stanza_debug"  #< logs EVERY stanza as debug: <https://prosody.im/doc/modules/mod_stanza_debug>
@@ -269,34 +272,18 @@ in
       s2s_direct_tls_ports = { 5270 }
 
       turn_external_host = "turn.uninsane.org"
-      turn_external_secret = readAll("/run/secrets/coturn_shared_secret")
+      turn_external_secret = readAll("/var/lib/coturn/shared_secret.bin")
       -- turn_external_user = "prosody"
 
       -- legacy mod_turncredentials integration
       -- turncredentials_host = "turn.uninsane.org"
-      -- turncredentials_secret = readAll("/run/secrets/coturn_shared_secret")
+      -- turncredentials_secret = readAll("/var/lib/coturn/shared_secret.bin")
+
+      ntfy_binary = "${pkgs.ntfy-sh}/bin/ntfy"
+      ntfy_topic = readAll("/run/secrets/ntfy-sh-topic")
 
       -- s2s_require_encryption = true
       -- c2s_require_encryption = true
-    '' + lib.optionalString config.services.ntfy-sh.enable ''
-      ntfy_binary = "${lib.getExe' pkgs.ntfy-sh "ntfy"}"
-      ntfy_topic = readAll("/run/secrets/ntfy-sh-topic")
     '';
   };
-
-  systemd.services.prosody = {
-    # hardening (systemd-analyze security prosody)
-    serviceConfig.LockPersonality = true;
-    serviceConfig.NoNewPrivileges = true;
-    serviceConfig.PrivateUsers = true;
-    serviceConfig.ProcSubset = "pid";
-    serviceConfig.ProtectClock = true;
-    serviceConfig.ProtectKernelLogs = true;
-    serviceConfig.ProtectProc = "invisible";
-    serviceConfig.ProtectSystem = "strict";
-    serviceConfig.RemoveIPC = true;
-    serviceConfig.RestrictAddressFamilies = "AF_UNIX AF_INET AF_INET6";
-    serviceConfig.SystemCallArchitectures = "native";
-    serviceConfig.SystemCallFilter = [ "@system-service" "~@privileged" "~@resources" ];
-  };
 }

hosts/by-name/servo/services/slskd.nix

@@ -3,17 +3,10 @@
 #
 # config precedence (higher precedence overrules lower precedence):
 # - Default Values < Environment Variables < YAML Configuraiton File < Command Line Arguments
-#
-# debugging:
-# - soulseek is just *flaky*. if you see e.g. DNS errors, even though you can't replicate them via `dig` or `getent ahostsv4`, just give it 10 minutes to work out:
-#   - "Soulseek.AddressException: Failed to resolve address 'vps.slsknet.org': Resource temporarily unavailable"
-{ config, lib, pkgs, ... }:
-
+{ config, lib, ... }:
 {
-  sane.persist.sys.byStore.ephemeral = [
-    # {data,downloads,incomplete,logs}: contains logs, search history, and downloads
-    # so, move the downloaded data to persistent storage regularly, or configure the downloads/incomplete dirs to point to persisted storage (in nixpkgs slskd config)
-    { user = "slskd"; group = "media"; path = "/var/lib/slskd"; method = "bind"; }
+  sane.persist.sys.byStore.plaintext = [
+    { user = "slskd"; group = "slskd"; path = "/var/lib/slskd"; }
   ];
   sops.secrets."slskd_env" = {
     owner = config.users.users.slskd.name;
@@ -22,9 +15,10 @@
 
   users.users.slskd.extraGroups = [ "media" ];
 
-  sane.ports.ports."50300" = {
+  sane.ports.ports."50000" = {
     protocol = [ "tcp" ];
-    # visibleTo.ovpns = true;  #< not needed: it runs in the ovpns namespace
+    # not visible to WAN: i run this in a separate netns
+    visibleTo.ovpn = true;
     description = "colin-soulseek";
   };
 
@@ -34,14 +28,12 @@
     forceSSL = true;
     enableACME = true;
     locations."/" = {
-      proxyPass = "http://${config.sane.netns.ovpns.veth.netns.ipv4}:5030";
+      proxyPass = "http://10.0.1.6:5001";
       proxyWebsockets = true;
     };
   };
 
   services.slskd.enable = true;
-  services.slskd.domain = null;  # i'll manage nginx for it
-  services.slskd.group = "media";
   # env file, for auth (SLSKD_SLSK_PASSWORD, SLSKD_SLSK_USERNAME)
   services.slskd.environmentFile = config.sops.secrets.slskd_env.path;
   services.slskd.settings = {
@@ -52,41 +44,31 @@
       # [Alias]/path/on/disk
       # NOTE: Music library is quick to scan; videos take a solid 10min to scan.
       # TODO: re-enable the other libraries
-      # "[Audioooks]/var/media/Books/Audiobooks"
-      # "[Books]/var/media/Books/Books"
-      # "[Manga]/var/media/Books/Visual"
-      # "[games]/var/media/games"
-      "[Music]/var/media/Music"
-      # "[Film]/var/media/Videos/Film"
-      # "[Shows]/var/media/Videos/Shows"
+      # "[Audioooks]/var/lib/uninsane/media/Books/Audiobooks"
+      # "[Books]/var/lib/uninsane/media/Books/Books"
+      # "[Manga]/var/lib/uninsane/media/Books/Visual"
+      # "[games]/var/lib/uninsane/media/games"
+      "[Music]/var/lib/uninsane/media/Music"
+      # "[Film]/var/lib/uninsane/media/Videos/Film"
+      # "[Shows]/var/lib/uninsane/media/Videos/Shows"
     ];
     # directories.downloads = "..." # TODO
     # directories.incomplete = "..." # TODO
     # what unit is this? kbps??
     global.upload.speed_limit = 32000;
     web.logging = true;
-    # debug = true;
+    debug = true;
     flags.no_logo = true;  # don't show logo at start
     # flags.volatile = true;  # store searches and active transfers in RAM (completed transfers still go to disk). rec for btrfs/zfs
   };
 
   systemd.services.slskd = {
-    # run this behind the OVPN static VPN
-    serviceConfig.NetworkNamespacePath = "/run/netns/ovpns";
-    serviceConfig.ExecStartPre = [
-      # abort if public IP is not as expected
-      "${lib.getExe pkgs.sane-scripts.ip-check} --no-upnp --expect ${config.sane.netns.ovpns.wg.address.ipv4}"
-    ];
-
-    serviceConfig.Restart = lib.mkForce "always";  # exits "success" when it fails to connect to soulseek server
-    serviceConfig.RestartSec = "60s";
-
-    # hardening (systemd-analyze security slskd)
-    # upstream nixpkgs specifies moderate defaults; these are supplementary
-    # serviceConfig.MemoryDenyWriteExecute = true;
-    # serviceConfig.ProcSubset = "pid";
-    # serviceConfig.RestrictAddressFamilies = "AF_UNIX AF_INET AF_INET6";
-    # serviceConfig.SystemCallArchitectures = "native";
-    # serviceConfig.SystemCallFilter = [ "@system-service" ];
+    serviceConfig = {
+      # run this behind the OVPN static VPN
+      NetworkNamespacePath = "/run/netns/ovpns";
+      Restart = "on-failure";
+      RestartSec = "30s";
+      Group = "media";
+    };
   };
 }

hosts/by-name/servo/services/transmission.nix

@@ -0,0 +1,100 @@
+{ config, pkgs, ... }:
+
+{
+  sane.persist.sys.byStore.plaintext = [
+    # TODO: mode? we need this specifically for the stats tracking in .config/
+    { user = "transmission"; group = config.users.users.transmission.group; path = "/var/lib/transmission"; }
+  ];
+  users.users.transmission.extraGroups = [ "media" ];
+
+  services.transmission.enable = true;
+  services.transmission.package = pkgs.transmission_4;  #< 2023/09/06: nixpkgs `transmission` defaults to old 3.00
+  #v setting `group` this way doesn't tell transmission to `chown` the files it creates
+  #  it's a nixpkgs setting which just runs the transmission daemon as this group
+  services.transmission.group = "media";
+
+  # transmission will by default not allow the world to read its files.
+  services.transmission.downloadDirPermissions = "775";
+  services.transmission.extraFlags = [
+    "--log-level=debug"
+  ];
+
+  services.transmission.settings = {
+    # message-level = 3;  #< enable for debug logging. 0-3, default is 2.
+    # 0.0.0.0 => allow rpc from any host: we gate it via firewall and auth requirement
+    rpc-bind-address = "0.0.0.0";
+    #rpc-host-whitelist = "bt.uninsane.org";
+    #rpc-whitelist = "*.*.*.*";
+    rpc-authentication-required = true;
+    rpc-username = "colin";
+    # salted pw. to regenerate, set this plaintext, run nixos-rebuild, and then find the salted pw in:
+    # /var/lib/transmission/.config/transmission-daemon/settings.json
+    rpc-password = "{503fc8928344f495efb8e1f955111ca5c862ce0656SzQnQ5";
+    rpc-whitelist-enabled = false;
+
+    # hopefully, make the downloads world-readable
+    # umask = 0;  #< default is 2: i.e. deny writes from world
+
+    # force peer connections to be encrypted
+    encryption = 2;
+
+    # units in kBps
+    speed-limit-down = 3000;
+    speed-limit-down-enabled = true;
+    speed-limit-up = 600;
+    speed-limit-up-enabled = true;
+
+    # see: https://git.zknt.org/mirror/transmission/commit/cfce6e2e3a9b9d31a9dafedd0bdc8bf2cdb6e876?lang=bg-BG
+    anti-brute-force-enabled = false;
+
+    download-dir = "/var/lib/uninsane/media";
+    incomplete-dir = "/var/lib/uninsane/media/incomplete";
+    # transmission regularly fails to move stuff from the incomplete dir to the main one, so disable:
+    # TODO: uncomment this line!
+    incomplete-dir-enabled = false;
+  };
+
+  systemd.services.transmission.after = [ "wireguard-wg-ovpns.service" ];
+  systemd.services.transmission.partOf = [ "wireguard-wg-ovpns.service" ];
+  systemd.services.transmission.serviceConfig = {
+    # run this behind the OVPN static VPN
+    NetworkNamespacePath = "/run/netns/ovpns";
+    Restart = "on-failure";
+    RestartSec = "30s";
+  };
+
+  # service to automatically backup torrents i add to transmission
+  systemd.services.backup-torrents = {
+    description = "archive torrents to storage not owned by transmission";
+    script = ''
+      ${pkgs.rsync}/bin/rsync -arv /var/lib/transmission/.config/transmission-daemon/torrents/ /var/backup/torrents/
+    '';
+  };
+  systemd.timers.backup-torrents = {
+    wantedBy = [ "multi-user.target" ];
+    timerConfig = {
+      OnStartupSec = "11min";
+      OnUnitActiveSec = "240min";
+    };
+  };
+
+  # transmission web client
+  services.nginx.virtualHosts."bt.uninsane.org" = {
+    # basicAuth is literally cleartext user/pw, so FORCE this to happen over SSL
+    forceSSL = true;
+    enableACME = true;
+    # inherit kTLS;
+    locations."/" = {
+      # proxyPass = "http://ovpns.uninsane.org:9091";
+      proxyPass = "http://10.0.1.6:9091";
+    };
+  };
+
+  sane.dns.zones."uninsane.org".inet.CNAME."bt" = "native";
+  sane.ports.ports."51413" = {
+    protocol = [ "tcp" "udp" ];
+    visibleTo.ovpn = true;
+    description = "colin-bittorrent";
+  };
+}
+

hosts/by-name/servo/services/transmission/default.nix

@@ -1,172 +0,0 @@
-{ config, lib, pkgs, ... }:
-
-let
-  # 2023/09/06: nixpkgs `transmission` defaults to old 3.00
-  # 2024/02/15: some torrent trackers whitelist clients; everyone is still on 3.00 for some reason :|
-  #             some do this via peer-id (e.g. baka); others via user-agent (e.g. MAM).
-  #             peer-id format is essentially the same between 3.00 and 4.x (just swap the MAJOR/MINOR/PATCH numbers).
-  #             user-agent format has changed. `Transmission/3.00` (old) v.s. `TRANSMISSION/MAJ.MIN.PATCH` (new).
-  realTransmission = pkgs.transmission_4;
-  realVersion = {
-    major = lib.versions.major realTransmission.version;
-    minor = lib.versions.minor realTransmission.version;
-    patch = lib.versions.patch realTransmission.version;
-  };
-  package = realTransmission.overrideAttrs (upstream: {
-    # `cmakeFlags = [ "-DTR_VERSION_MAJOR=3" ]`, etc, doesn't seem to take effect.
-    postPatch = (upstream.postPatch or "") + ''
-      substituteInPlace CMakeLists.txt \
-        --replace-fail 'TR_VERSION_MAJOR "${realVersion.major}"' 'TR_VERSION_MAJOR "3"' \
-        --replace-fail 'TR_VERSION_MINOR "${realVersion.minor}"' 'TR_VERSION_MINOR "0"' \
-        --replace-fail 'TR_VERSION_PATCH "${realVersion.patch}"' 'TR_VERSION_PATCH "0"' \
-        --replace-fail 'set(TR_USER_AGENT_PREFIX "''${TR_SEMVER}")' 'set(TR_USER_AGENT_PREFIX "3.00")'
-    '';
-  });
-  download-dir = "/var/media/torrents";  #< keep in sync with consts embedded in `torrent-done`
-  torrent-done = pkgs.static-nix-shell.mkBash {
-    pname = "torrent-done";
-    srcRoot = ./.;
-    pkgs = [
-      "acl"
-      "coreutils"
-      "findutils"
-      "rsync"
-    ];
-  };
-in
-{
-  sane.persist.sys.byStore.private = [
-    # TODO: mode? we need this specifically for the stats tracking in .config/
-    { user = "transmission"; group = config.users.users.transmission.group; path = "/var/lib/transmission"; method = "bind"; }
-    { user = "transmission"; group = config.users.users.transmission.group; path = "/var/backup/torrents"; method = "bind"; }
-  ];
-  users.users.transmission.extraGroups = [ "media" ];
-
-  services.transmission.enable = true;
-  services.transmission.package = package;
-  #v setting `group` this way doesn't tell transmission to `chown` the files it creates
-  #  it's a nixpkgs setting which just runs the transmission daemon as this group
-  services.transmission.group = "media";
-
-  # transmission will by default not allow the world to read its files.
-  services.transmission.downloadDirPermissions = "775";
-  services.transmission.extraFlags = [
-    # "--log-level=debug"
-  ];
-
-  services.transmission.settings = {
-    # DOCUMENTATION/options list: <https://github.com/transmission/transmission/blob/main/docs/Editing-Configuration-Files.md#options>
-
-    # message-level = 3;  #< enable for debug logging. 0-3, default is 2.
-    # ovpns.veth.netns.ipv4 => allow rpc only from the root servo ns. it'll tunnel things to the net, if need be.
-    rpc-bind-address = config.sane.netns.ovpns.veth.netns.ipv4;
-    #rpc-host-whitelist = "bt.uninsane.org";
-    #rpc-whitelist = "*.*.*.*";
-    rpc-authentication-required = true;
-    rpc-username = "colin";
-    # salted pw. to regenerate, set this plaintext, run nixos-rebuild, and then find the salted pw in:
-    # /var/lib/transmission/.config/transmission-daemon/settings.json
-    rpc-password = "{503fc8928344f495efb8e1f955111ca5c862ce0656SzQnQ5";
-    rpc-whitelist-enabled = false;
-
-    # force behind ovpns in case the NetworkNamespace fails somehow
-    bind-address-ipv4 = config.sane.netns.ovpns.wg.address.ipv4;
-    port-forwarding-enabled = false;
-
-    # hopefully, make the downloads world-readable
-    # umask = 0;  #< default is 2: i.e. deny writes from world
-
-    # force peer connections to be encrypted
-    encryption = 2;
-
-    # units in kBps
-    speed-limit-down = 12000;
-    speed-limit-down-enabled = true;
-    speed-limit-up = 800;
-    speed-limit-up-enabled = true;
-
-    # see: https://git.zknt.org/mirror/transmission/commit/cfce6e2e3a9b9d31a9dafedd0bdc8bf2cdb6e876?lang=bg-BG
-    anti-brute-force-enabled = false;
-
-    inherit download-dir;
-    incomplete-dir = "${download-dir}/incomplete";
-    # transmission regularly fails to move stuff from the incomplete dir to the main one, so disable:
-    incomplete-dir-enabled = false;
-
-    # env vars available in script:
-    # - TR_APP_VERSION - Transmission's short version string, e.g. `4.0.0`
-    # - TR_TIME_LOCALTIME
-    # - TR_TORRENT_BYTES_DOWNLOADED - Number of bytes that were downloaded for this torrent
-    # - TR_TORRENT_DIR - Location of the downloaded data
-    # - TR_TORRENT_HASH - The torrent's info hash
-    # - TR_TORRENT_ID
-    # - TR_TORRENT_LABELS - A comma-delimited list of the torrent's labels
-    # - TR_TORRENT_NAME - Name of torrent (not filename)
-    # - TR_TORRENT_TRACKERS - A comma-delimited list of the torrent's trackers' announce URLs
-    script-torrent-done-enabled = true;
-    script-torrent-done-filename = lib.getExe torrent-done;
-  };
-
-  # run this behind the OVPN static VPN
-  sane.netns.ovpns.services = [ "transmission" ];
-  systemd.services.transmission = {
-    environment.TR_DEBUG = "1";
-    serviceConfig.ExecStartPre = [
-      # abort if public IP is not as expected
-      "${lib.getExe pkgs.sane-scripts.ip-check} --no-upnp --expect ${config.sane.netns.ovpns.wg.address.ipv4}"
-    ];
-
-    serviceConfig.Restart = "on-failure";
-    serviceConfig.RestartSec = "30s";
-    serviceConfig.BindPaths = [ "/var/media" ];  #< so it can move completed torrents into the media library
-    serviceConfig.SystemCallFilter = lib.mkForce [
-      # the torrent-done script does stuff which fails the nixos default syscall filter.
-      # allow a bunch of stuff, speculatively, to hopefully fix that:
-      "@aio"
-      "@basic-io"
-      "@chown"
-      "@file-system"
-      "@io-event"
-      "@process"
-      "@sandbox"
-      "@sync"
-      "@system-service"
-      "quotactl"
-    ];
-  };
-
-  # service to automatically backup torrents i add to transmission
-  systemd.services.backup-torrents = {
-    description = "archive torrents to storage not owned by transmission";
-    script = ''
-      ${lib.getExe pkgs.rsync} -arv /var/lib/transmission/.config/transmission-daemon/torrents/ /var/backup/torrents/
-    '';
-  };
-  systemd.timers.backup-torrents = {
-    wantedBy = [ "multi-user.target" ];
-    timerConfig = {
-      OnStartupSec = "11min";
-      OnUnitActiveSec = "240min";
-    };
-  };
-
-  # transmission web client
-  services.nginx.virtualHosts."bt.uninsane.org" = {
-    # basicAuth is literally cleartext user/pw, so FORCE this to happen over SSL
-    forceSSL = true;
-    enableACME = true;
-    # inherit kTLS;
-    locations."/" = {
-      # proxyPass = "http://ovpns.uninsane.org:9091";
-      proxyPass = "http://${config.sane.netns.ovpns.veth.netns.ipv4}:9091";
-    };
-  };
-
-  sane.dns.zones."uninsane.org".inet.CNAME."bt" = "native";
-  sane.ports.ports."51413" = {
-    protocol = [ "tcp" "udp" ];
-    # visibleTo.ovpns = true;  #< not needed: it runs in the ovpns namespace
-    description = "colin-bittorrent";
-  };
-}
-

hosts/by-name/servo/services/transmission/torrent-done

@@ -1,70 +0,0 @@
-#!/usr/bin/env nix-shell
-#!nix-shell -i bash -p acl -p bash -p coreutils -p findutils -p rsync
-
-# transmission invokes this with no args, and the following env vars:
-# - TR_TORRENT_DIR: full path to the folder i told transmission to download it to.
-#     e.g. /var/media/torrents/Videos/Film/Jason.Bourne-2016
-# optionally:
-# - TR_DRY_RUN=1
-# - TR_DEBUG=1
-
-DOWNLOAD_DIR=/var/media/torrents
-
-destructive() {
-  if [ -n "${TR_DRY_RUN-}" ]; then
-    echo "[dry-run] $*"
-  else
-    debug "$@"
-    "$@"
-  fi
-}
-debug() {
-  if [ -n "${TR_DEBUG-}" ]; then
-    echo "$@"
-  fi
-}
-
-echo "TR_TORRENT_DIR=$TR_TORRENT_DIR torrent-done $*"
-
-if [[ "$TR_TORRENT_DIR" =~ ^.*freeleech.*$ ]]; then
-  # freeleech torrents have no place in my permanent library
-  echo "freeleech: nothing to do"
-  exit 0
-fi
-if ! [[ "$TR_TORRENT_DIR" =~ ^$DOWNLOAD_DIR/.*$ ]]; then
-  echo "unexpected torrent dir, aborting: $TR_TORRENT_DIR"
-  exit 0
-fi
-
-REL_DIR="${TR_TORRENT_DIR#$DOWNLOAD_DIR/}"
-MEDIA_DIR="/var/media/$REL_DIR"
-
-destructive mkdir -p "$(dirname "$MEDIA_DIR")"
-destructive rsync -rlv "$TR_TORRENT_DIR/" "$MEDIA_DIR/"
-# make the media rwx by anyone in the group
-destructive find "$MEDIA_DIR" -type d -exec setfacl --recursive --modify d:g::rwx,o::rx {} \;
-destructive find "$MEDIA_DIR" -type d -exec chmod g+rw,a+rx {} \;
-destructive find "$MEDIA_DIR" -type f -exec chmod g+rw,a+r {} \;
-
-# if there's a single directory inside the media dir, then inline that
-subdirs=("$MEDIA_DIR"/*)
-debug "top-level items in torrent dir:" "${subdirs[@]}"
-if [ ${#subdirs[@]} -eq 1 ]; then
-  dirname="${subdirs[0]}"
-  debug "exactly one top-level item, checking if directory: $dirname"
-  if [ -d "$dirname" ]; then
-    destructive mv "$dirname"/* "$MEDIA_DIR/" && destructive rmdir "$dirname"
-  fi
-fi
-
-# remove noisy files:
-# -iname means "insensitive", but the syntax is NOT regex -- more similar to shell matching
-destructive find "$MEDIA_DIR/" -type f \(\
-     -iname '*downloaded?from*' \
-  -o -iname 'source.txt' \
-  -o -iname '*upcoming?releases*' \
-  -o -iname 'www.YTS*.jpg' \
-  -o -iname 'WWW.YIFY*.COM.jpg' \
-  -o -iname 'YIFY*.com.txt' \
-  -o -iname 'YTS*.com.txt' \
-  \) -exec rm {} \;

hosts/by-name/servo/services/trust-dns.nix

@@ -0,0 +1,210 @@
+# TODO: split this file apart into smaller files to make it easier to understand
+{ config, lib, pkgs, ... }:
+
+let
+  nativeAddrs = lib.mapAttrs (_name: builtins.head) config.sane.dns.zones."uninsane.org".inet.A;
+  bindOvpn = "10.0.1.5";
+in lib.mkMerge [
+{
+  services.trust-dns.enable = true;
+
+  # don't bind to IPv6 until i explicitly test that stack
+  services.trust-dns.settings.listen_addrs_ipv6 = [];
+  services.trust-dns.quiet = true;
+  # FIXME(2023/11/26): services.trust-dns.debug doesn't log requests: use RUST_LOG=debug env for that.
+  # - see: <https://github.com/hickory-dns/hickory-dns/issues/2082>
+  # services.trust-dns.debug = true;
+
+  sane.ports.ports."53" = {
+    protocol = [ "udp" "tcp" ];
+    visibleTo.lan = true;
+    visibleTo.wan = true;
+    visibleTo.ovpn = true;
+    description = "colin-dns-hosting";
+  };
+
+  sane.dns.zones."uninsane.org".TTL = 900;
+
+  # SOA record structure: <https://en.wikipedia.org/wiki/SOA_record#Structure>
+  # SOA MNAME RNAME (... rest)
+  # MNAME = Master name server for this zone. this is where update requests should be sent.
+  # RNAME = admin contact (encoded email address)
+  # Serial = YYYYMMDDNN, where N is incremented every time this file changes, to trigger secondary NS to re-fetch it.
+  # Refresh = how frequently secondary NS should query master
+  # Retry = how long secondary NS should wait until re-querying master after a failure (must be < Refresh)
+  # Expire = how long secondary NS should continue to reply to queries after master fails (> Refresh + Retry)
+  sane.dns.zones."uninsane.org".inet = {
+    SOA."@" = ''
+      ns1.uninsane.org. admin-dns.uninsane.org. (
+                                      2023092101 ; Serial
+                                      4h         ; Refresh
+                                      30m        ; Retry
+                                      7d         ; Expire
+                                      5m)        ; Negative response TTL
+    '';
+    TXT."rev" = "2023092101";
+
+    CNAME."native" = "%CNAMENATIVE%";
+    A."@" =      "%ANATIVE%";
+    A."servo.wan" = "%AWAN%";
+    A."servo.lan" = config.sane.hosts.by-name."servo".lan-ip;
+    A."servo.hn" = config.sane.hosts.by-name."servo".wg-home.ip;
+
+    # XXX NS records must also not be CNAME
+    # it's best that we keep this identical, or a superset of, what org. lists as our NS.
+    # so, org. can specify ns2/ns3 as being to the VPN, with no mention of ns1. we provide ns1 here.
+    A."ns1" =    "%ANATIVE%";
+    A."ns2" =    "185.157.162.178";
+    A."ns3" =    "185.157.162.178";
+    A."ovpns" =  "185.157.162.178";
+    NS."@" = [
+      "ns1.uninsane.org."
+      "ns2.uninsane.org."
+      "ns3.uninsane.org."
+    ];
+  };
+
+  services.trust-dns.settings.zones = [ "uninsane.org" ];
+
+  # TODO: can i transform this into some sort of service group?
+  # have `systemctl restart trust-dns.service` restart all the individual services?
+  systemd.services.trust-dns.serviceConfig = {
+    DynamicUser = lib.mkForce false;
+    User = "trust-dns";
+    Group = "trust-dns";
+    wantedBy = lib.mkForce [];
+  };
+  systemd.services.trust-dns.enable = false;
+
+  users.groups.trust-dns = {};
+  users.users.trust-dns = {
+    group = "trust-dns";
+    isSystemUser = true;
+  };
+
+  # sane.services.dyn-dns.restartOnChange = [ "trust-dns.service" ];
+
+  networking.nat.enable = true;
+  networking.nat.extraCommands = ''
+    # redirect incoming DNS requests from LAN addresses
+    #   to the LAN-specialized DNS service
+    # N.B.: use the `nixos-*` chains instead of e.g. PREROUTING
+    #   because they get cleanly reset across activations or `systemctl restart firewall`
+    #   instead of accumulating cruft
+    iptables -t nat -A nixos-nat-pre -p udp --dport 53 \
+      -m iprange --src-range 10.78.76.0-10.78.79.255 \
+      -j DNAT --to-destination :1053
+    iptables -t nat -A nixos-nat-pre -p tcp --dport 53 \
+      -m iprange --src-range 10.78.76.0-10.78.79.255 \
+      -j DNAT --to-destination :1053
+  '';
+  sane.ports.ports."1053" = {
+    # because the NAT above redirects in nixos-nat-pre, LAN requests behave as though they arrived on the external interface at the redirected port.
+    # TODO: try nixos-nat-post instead?
+    # TODO: or, don't NAT from port 53 -> port 1053, but rather nat from LAN addr to a loopback addr.
+    # - this is complicated in that loopback is a different interface than eth0, so rewriting the destination address would cause the packets to just be dropped by the interface
+    protocol = [ "udp" "tcp" ];
+    visibleTo.lan = true;
+    description = "colin-redirected-dns-for-lan-namespace";
+  };
+}
+{
+  systemd.services =
+    let
+      sed = "${pkgs.gnused}/bin/sed";
+      stateDir = "/var/lib/trust-dns";
+      zoneTemplate = pkgs.writeText "uninsane.org.zone.in" config.sane.dns.zones."uninsane.org".rendered;
+
+      zoneDirFor = flavor: "${stateDir}/${flavor}";
+      zoneFor = flavor: "${zoneDirFor flavor}/uninsane.org.zone";
+      mkTrustDnsService = opts: flavor: let
+        flags = let baseCfg = config.services.trust-dns; in
+          (lib.optional baseCfg.debug "--debug") ++ (lib.optional baseCfg.quiet "--quiet");
+        flagsStr = builtins.concatStringsSep " " flags;
+
+        anative = nativeAddrs."servo.${flavor}";
+
+        toml = pkgs.formats.toml { };
+        configTemplate = opts.config or (toml.generate "trust-dns-${flavor}.toml" (
+          (
+            lib.filterAttrsRecursive (_: v: v != null) config.services.trust-dns.settings
+          ) // {
+            listen_addrs_ipv4 = opts.listen or [ anative ];
+          }
+        ));
+        configFile = "${stateDir}/${flavor}-config.toml";
+
+        port = opts.port or 53;
+      in {
+        description = "trust-dns Domain Name Server (serving ${flavor})";
+        unitConfig.Documentation = "https://trust-dns.org/";
+
+        preStart = ''
+          wan=$(cat '${config.sane.services.dyn-dns.ipPath}')
+          ${sed} s/%AWAN%/$wan/ ${configTemplate} > ${configFile}
+        '' + lib.optionalString (!opts ? config) ''
+          mkdir -p ${zoneDirFor flavor}
+          ${sed} \
+            -e s/%CNAMENATIVE%/servo.${flavor}/ \
+            -e s/%ANATIVE%/${anative}/ \
+            -e s/%AWAN%/$wan/ \
+            -e s/%AOVPNS%/185.157.162.178/ \
+            ${zoneTemplate} > ${zoneFor flavor}
+        '';
+        serviceConfig = config.systemd.services.trust-dns.serviceConfig // {
+          ExecStart = ''
+            ${pkgs.trust-dns}/bin/${pkgs.trust-dns.meta.mainProgram} \
+            --port ${builtins.toString port} \
+            --zonedir ${zoneDirFor flavor}/ \
+            --config ${configFile} ${flagsStr}
+          '';
+        };
+
+        after = [ "network.target" ];
+        wantedBy = [ "multi-user.target" ];
+      };
+    in {
+      trust-dns-wan = mkTrustDnsService { listen = [ nativeAddrs."servo.lan" bindOvpn ]; } "wan";
+      trust-dns-lan = mkTrustDnsService { port = 1053; } "lan";
+      trust-dns-hn = mkTrustDnsService { port = 1053; } "hn";
+      trust-dns-hn-resolver = mkTrustDnsService {
+        config = pkgs.writeText "hn-resolver-config.toml" ''
+          # i host a resolver in the wireguard VPN so that clients can resolve DNS through the VPN.
+          # (that's what this file achieves).
+          #
+          # one would expect this resolver could host the authoritative zone for `uninsane.org`, and then forward everything else to the system resolver...
+          # and while that works for `dig`, it breaks for `nslookup` (and so `ssh`, etc).
+          #
+          # DNS responses include a flag for if the responding server is the authority of the zone queried.
+          # it seems that default Linux stub resolvers either:
+          # - expect DNSSEC when the response includes that bit, or
+          # - expect A records to be in the `answer` section instead of `additional` section.
+          # or perhaps something more nuanced. but for `nslookup` to be reliable, it has to talk to an
+          # instance of trust-dns which is strictly a resolver, with no authority.
+          # hence, this config: a resolver which forwards to the actual authority.
+
+          listen_addrs_ipv4 = ["${nativeAddrs."servo.hn"}"]
+          listen_addrs_ipv6 = []
+
+          [[zones]]
+          zone = "uninsane.org"
+          zone_type = "Forward"
+          stores = { type = "forward", name_servers = [{ socket_addr = "${nativeAddrs."servo.hn"}:1053", protocol = "udp", trust_nx_responses = true }] }
+
+          [[zones]]
+          # forward the root zone to the local DNS resolver
+          zone = "."
+          zone_type = "Forward"
+          stores = { type = "forward", name_servers = [{ socket_addr = "127.0.0.53:53", protocol = "udp", trust_nx_responses = true }] }
+        '';
+      } "hn-resolver";
+    };
+
+  sane.services.dyn-dns.restartOnChange = [
+    "trust-dns-wan.service"
+    "trust-dns-lan.service"
+    "trust-dns-hn.service"
+    # "trust-dns-hn-resolver.service"  # doesn't need restart because it doesn't know about WAN IP
+  ];
+}
+]

hosts/by-name/servo/users/default.nix

@@ -1,6 +0,0 @@
-{ ... }:
-{
-  imports = [
-    ./shelvacu.nix
-  ];
-}

hosts/by-name/servo/users/shelvacu.nix

@@ -1,65 +0,0 @@
-{ lib, pkgs, ... }:
-{
-  users.users.shelvacu = {
-    isNormalUser = true;
-    home = "/home/shelvacu";
-    subUidRanges = [
-      { startUid=300000; count=1; }
-    ];
-    group = "users";
-    initialPassword = lib.mkDefault "";
-    shell = pkgs.bash;
-
-    openssh.authorizedKeys.keys = [
-      "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIKoy1TrmfhBGWtVedgOM1FB1oD2UdodN3LkBnnLx6Tug compute-deck"
-      "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIAxAFFxQMXAgi+0cmGaNE/eAkVfEl91wafUqFIuAkI5I compute-deck-root"
-      "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAINQ2c0GzlVMjV06CS7bWbCaAbzG2+7g5FCg/vClJPe0C fw"
-      "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIGHLPOxRd68+DJ/bYmqn0wsgwwIcMSMyuU1Ya16hCb/m fw-root"
-      "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIOre0FnYDm3arsFj9c/l5H2Q8mdmv7kmvq683pL4heru legtop"
-      "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAINznGot+L8kYoVQqdLV/R17XCd1ILMoDCILOg+I3s5wC pixel9pro-nod"
-      "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIDcRDekd8ZOYfQS5X95/yNof3wFYIbHqWeq4jY0+ywQX pro1x-nod"
-      "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIJNFbzt0NHVTaptBI38YtwLG+AsmeNYy0Nr5yX2zZEPE root@vacuInstaller toptop-root"
-      "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAICVeSzDkGTueZijB0xUa08e06ovAEwwZK/D+Cc7bo91g triple-dezert"
-      "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIOtwtao/TXbiuQOYJbousRPVesVcb/2nP0PCFUec0Nv8 triple-dezert-root"
-    ];
-  };
-
-  security.sudo.extraRules = [
-    {
-      users = [ "shelvacu" ];
-      runAs = "postgres";
-      commands = [
-        {
-          command = "ALL";
-          options = [ "NOPASSWD" ];
-        }
-      ];
-    }
-  ];
-
-  security.polkit.extraConfig = ''
-    // allow:
-    // - systemctl restart|start|stop SERVICE
-    polkit.addRule(function(action, subject) {
-      if (subject.user == "shelvacu" && action.id == "org.freedesktop.systemd1.manage-units") {
-        switch (action.lookup("verb")) {
-          // case "cancel":
-          // case "reenable":
-          case "restart":
-          // case "reload":
-          // case "reload-or-restart":
-          case "start":
-          case "stop":
-          // case "try-reload-or-restart":
-          // case "try-restart":
-            return polkit.Result.YES;
-          default:
-        }
-      }
-    })
-  '';
-
-  sane.persist.sys.byStore.private = [
-    { path = "/home/shelvacu/persist"; user = "shelvacu"; group = "users"; mode = "0700"; }
-  ];
-}

hosts/common/boot.nix

@@ -1,50 +0,0 @@
-{ lib, pkgs, ... }:
-{
-  boot.initrd.supportedFilesystems = [ "ext4" "btrfs" "ext2" "ext3" "vfat" ];
-  # useful emergency utils
-  boot.initrd.extraUtilsCommands = ''
-    copy_bin_and_libs ${lib.getExe' pkgs.btrfs-progs "btrfstune"}
-    copy_bin_and_libs ${lib.getExe' pkgs.util-linux "{cfdisk,lsblk,lscpu}"}
-    copy_bin_and_libs ${lib.getExe' pkgs.gptfdisk "{cgdisk,gdisk}"}
-    copy_bin_and_libs ${lib.getExe' pkgs.smartmontools "smartctl"}
-    copy_bin_and_libs ${lib.getExe' pkgs.e2fsprogs "resize2fs"}
-    copy_bin_and_libs ${lib.getExe pkgs.nvme-cli}
-  '';
-  boot.kernelParams = [
-    "boot.shell_on_fail"
-    #v experimental full pre-emption for hopefully better call/audio latency on moby.
-    # also toggleable at runtime via /sys/kernel/debug/sched/preempt
-    # defaults to preempt=voluntary
-    # "preempt=full"
-  ];
-  # other kernelParams:
-  #   "boot.trace"
-  #   "systemd.log_level=debug"
-  #   "systemd.log_target=console"
-
-  # moby has to run recent kernels (defined elsewhere).
-  # meanwhile, kernel variation plays some minor role in things like sandboxing (landlock) and capabilities.
-  # - as of 2024/08/xx, my boot fails on 6.6, but works on 6.9 and (probably; recently) 6.8.
-  # simpler to keep near the latest kernel on all devices,
-  # and also makes certain that any weird system-level bugs i see aren't likely to be stale kernel bugs.
-  boot.kernelPackages = lib.mkDefault pkgs.linuxPackages_latest;
-
-  # hack in the `boot.shell_on_fail` arg since that doesn't always seem to work.
-  boot.initrd.preFailCommands = "allowShell=1";
-
-  # default: 4 (warn). 7 is debug
-  boot.consoleLogLevel = 7;
-
-  boot.loader.grub.enable = lib.mkDefault false;
-  boot.loader.generic-extlinux-compatible.enable = lib.mkDefault true;
-
-  hardware.enableAllFirmware = true;  # firmware with licenses that don't allow for redistribution. fuck lawyers, fuck IP, give me the goddamn firmware.
-  # hardware.enableRedistributableFirmware = true;  # proprietary but free-to-distribute firmware (extraneous to `enableAllFirmware` option)
-
-  # default is 252274, which is too low particularly for servo.
-  # manifests as spurious "No space left on device" when trying to install watches,
-  # e.g. in dyn-dns by `systemctl start dyn-dns-watcher.path`.
-  # see: <https://askubuntu.com/questions/828779/failed-to-add-run-systemd-ask-password-to-directory-watch-no-space-left-on-dev>
-  boot.kernel.sysctl."fs.inotify.max_user_watches" = 4194304;
-  boot.kernel.sysctl."fs.inotify.max_user_instances" = 4194304;
-}

hosts/common/default.nix

@@ -1,30 +1,24 @@
 { lib, pkgs, ... }:
 {
   imports = [
-    ./boot.nix
     ./feeds.nix
-    ./fs
+    ./fs.nix
+    ./hardware
     ./home
+    ./hostnames.nix
     ./hosts.nix
     ./ids.nix
     ./machine-id.nix
-    ./net
-    ./nix.nix
-    ./polyunfill.nix
+    ./net.nix
+    ./nix-path
+    ./persist.nix
     ./programs
-    ./quirks.nix
     ./secrets.nix
-    ./snapper.nix
     ./ssh.nix
-    ./systemd.nix
     ./users
+    ./vpn.nix
   ];
 
-
-  # docs: https://nixos.org/manual/nixos/stable/options.html#opt-system.stateVersion
-  # this affects where nixos modules look for stateful data which might have been migrated across releases.
-  system.stateVersion = "21.11";
-
   sane.nixcache.enable-trusted-keys = true;
   sane.nixcache.enable = lib.mkDefault true;
   sane.persist.enable = lib.mkDefault true;
@@ -32,30 +26,98 @@
   sane.programs.sysadminUtils.enableFor.system = lib.mkDefault true;
   sane.programs.consoleUtils.enableFor.user.colin = lib.mkDefault true;
 
-  services.buffyboard.enable = true;
-  services.buffyboard.settings.theme.default = "pmos-light";
-  # services.buffyboard.settings.quirks.fbdev_force_refresh = true;
-  services.buffyboard.extraFlags = [ "--verbose" ];
-
-  # irqbalance monitors interrupt count (as a daemon) and assigns high-frequency interrupts to different CPUs.
-  # that reduces contention between simultaneously-fired interrupts.
-  services.irqbalance.enable = true;
+  nixpkgs.config.allowUnfree = true;  # NIXPKGS_ALLOW_UNFREE=1
+  nixpkgs.config.allowBroken = true;  # NIXPKGS_ALLOW_BROKEN=1
 
   # time.timeZone = "America/Los_Angeles";
   time.timeZone = "Etc/UTC";  # DST is too confusing for me => use a stable timezone
 
+  nix.extraOptions = ''
+    # see: `man nix.conf`
+    # useful when a remote builder has a faster internet connection than me
+    builders-use-substitutes = true  # default: false
+    # maximum seconds to wait when connecting to binary substituter
+    connect-timeout = 3  # default: 0
+    # download-attempts = 5  # default: 5
+    # allow `nix flake ...` command
+    experimental-features = nix-command flakes
+    # whether to build from source when binary substitution fails
+    fallback = true  # default: false
+    # whether to keep building dependencies if any other one fails
+    keep-going = true  # default: false
+    # whether to keep build-only dependencies of GC roots (e.g. C compiler) when doing GC
+    keep-outputs = true  # default: false
+    # how many lines to show from failed build
+    log-lines = 30  # default: 10
+    # narinfo-cache-negative-ttl = 3600  # default: 3600
+    # whether to use ~/.local/state/nix/profile instead of ~/.nix-profile, etc
+    use-xdg-base-directories = true  # default: false
+    # whether to warn if repository has uncommited changes
+    warn-dirty = false  # default: true
+  '';
+  # hardlinks identical files in the nix store to save 25-35% disk space.
+  # unclear _when_ this occurs. it's not a service.
+  # does the daemon continually scan the nix store?
+  # does the builder use some content-addressed db to efficiently dedupe?
+  nix.settings.auto-optimise-store = true;
+  # TODO: see if i can remove this?
+  nix.settings.trusted-users = [ "root" ];
+
+  services.journald.extraConfig = ''
+    # docs: `man journald.conf`
+    # merged journald config is deployed to /etc/systemd/journald.conf
+    [Journal]
+    # disable journal compression because the underlying fs is compressed
+    Compress=no
+  '';
+
+  systemd.services.nix-daemon.serviceConfig = {
+    # the nix-daemon manages nix builders
+    # kill nix-daemon subprocesses when systemd-oomd detects an out-of-memory condition
+    # see:
+    # - nixos PR that enabled systemd-oomd: <https://github.com/NixOS/nixpkgs/pull/169613>
+    # - systemd's docs on these properties: <https://www.freedesktop.org/software/systemd/man/systemd.resource-control.html#ManagedOOMSwap=auto%7Ckill>
+    #
+    # systemd's docs warn that without swap, systemd-oomd might not be able to react quick enough to save the system.
+    # see `man oomd.conf` for further tunables that may help.
+    #
+    # alternatively, apply this more broadly with `systemd.oomd.enableSystemSlice = true` or `enableRootSlice`
+    # TODO: also apply this to the guest user's slice (user-1100.slice)
+    # TODO: also apply this to distccd
+    ManagedOOMMemoryPressure = "kill";
+    ManagedOOMSwap = "kill";
+  };
+
+
   system.activationScripts.nixClosureDiff = {
     supportsDryActivation = true;
     text = ''
       # show which packages changed versions or are new/removed in this upgrade
       # source: <https://github.com/luishfonseca/dotfiles/blob/32c10e775d9ec7cc55e44592a060c1c9aadf113e/modules/upgrade-diff.nix>
-      # modified to not error on boot (when /run/current-system doesn't exist)
-      if [ -d /run/current-system ]; then
-        ${lib.getExe pkgs.nvd} --nix-bin-dir=${pkgs.nix}/bin diff /run/current-system "$systemConfig"
-      fi
+      ${pkgs.nvd}/bin/nvd --nix-bin-dir=${pkgs.nix}/bin diff /run/current-system "$systemConfig"
     '';
   };
 
+  # disable non-required packages like nano, perl, rsync, strace
+  environment.defaultPackages = [];
+
+  # dconf docs: <https://access.redhat.com/documentation/en-us/red_hat_enterprise_linux/7/html/desktop_migration_and_administration_guide/profiles>
+  # this lets programs temporarily write user-level dconf settings (aka gsettings).
+  # they're written to ~/.config/dconf/user, unless `DCONF_PROFILE` is set to something other than the default of /etc/dconf/profile/user
+  # find keys/values with `dconf dump /`
+  programs.dconf.enable = true;
+  programs.dconf.packages = [
+    (pkgs.writeTextFile {
+      name = "dconf-user-profile";
+      destination = "/etc/dconf/profile/user";
+      text = ''
+        user-db:user
+        system-db:site
+      '';
+    })
+  ];
+  # sane.programs.glib.enableFor.user.colin = true;  # for `gsettings`
+
   # link debug symbols into /run/current-system/sw/lib/debug
   # hopefully picked up by gdb automatically?
   environment.enableDebugInfo = true;

hosts/common/feeds.nix

@@ -1,14 +1,13 @@
 # where to find good stuff?
-# - universal search/directory: <https://podcastindex.org>
-#   - the full database is downloadable
-# - find adjacent podcasts: <https://rephonic.com/graph>
-# - charts: <https://rephonic.com/charts/apple/united-states/technology>
-# - list of lists: <https://en.wikipedia.org/wiki/Category:Lists_of_podcasts>
 # - podcasts w/ a community: <https://lemmyverse.net/communities?query=podcast>
-# - podcast recs:
-#   - active lemmy: <https://slrpnk.net/c/podcasts>
-#   - old thread: <https://lemmy.ml/post/1565858>
+# - podcast rec thread: <https://lemmy.ml/post/1565858>
 #
+# candidates:
+# - The Nonlinear Library (podcast): <https://forum.effectivealtruism.org/posts/JTZTBienqWEAjGDRv/listen-to-more-ea-content-with-the-nonlinear-library>
+#   - has ~10 posts per day, text-to-speech; i would need better tagging before adding this
+# - <https://www.metaculus.com/questions/11102/introducing-the-metaculus-journal-podcast/>
+#   - dead since 2022/10 - 2023/03
+
 { lib, sane-data, ... }:
 let
   hourly = { freq = "hourly"; };
@@ -51,8 +50,6 @@ let
         else
           "infrequent"
       ));
-    } // lib.optionalAttrs (lib.hasPrefix "https://www.youtube.com/" raw.url) {
-      format = "video";
     } // lib.optionalAttrs (raw.is_podcast or false) {
       format = "podcast";
     } // lib.optionalAttrs (raw.title or "" != "") {
@@ -60,98 +57,53 @@ let
     };
 
   podcasts = [
-    (fromDb "404media.co/the-404-media-podcast" // tech)
     (fromDb "acquiredlpbonussecretsecret.libsyn.com" // tech)  # ACQ2 - more "Acquired" episodes
-    (fromDb "adventofcomputing.com" // tech)  # computing history
-    (fromDb "api.oyez.org/podcasts/oral-arguments/2015" // pol)  # Supreme Court Oral Arguments ("2015" in URL means nothing -- it's still updated)
+    (fromDb "allinchamathjason.libsyn.com" // pol)
     (fromDb "anchor.fm/s/34c7232c/podcast/rss" // tech)  # Civboot -- https://anchor.fm/civboot
-    (fromDb "anchor.fm/s/2da69154/podcast/rss" // tech)  # POD OF JAKE -- https://podofjake.com/
     (fromDb "cast.postmarketos.org" // tech)
     (fromDb "congressionaldish.libsyn.com" // pol)  # Jennifer Briney
     (fromDb "craphound.com" // pol)  # Cory Doctorow -- both podcast & text entries
     (fromDb "darknetdiaries.com" // tech)
-    (fromDb "dwarkeshpatel.com" // tech)
+    (fromDb "feed.podbean.com/matrixlive/feed.xml" // tech)  # Matrix (chat) Live
     (fromDb "feeds.99percentinvisible.org/99percentinvisible" // pol)  # 99% Invisible -- also available here: <https://feeds.simplecast.com/BqbsxVfO>
-    (fromDb "feeds.acast.com/public/shows/lawfare" // pol)  # <https://www.lawfaremedia.org/podcasts-multimedia/podcast/the-lawfare-podcast>
-    (fromDb "feeds.buzzsprout.com/2412334.rss")  # Matt Stoller's _Organized Money_ <https://www.organizedmoney.fm/>
-    (fromDb "feeds.eff.org/howtofixtheinternet" // pol)
     (fromDb "feeds.feedburner.com/80000HoursPodcast" // rat)
     (fromDb "feeds.feedburner.com/dancarlin/history" // rat)
     (fromDb "feeds.feedburner.com/radiolab" // pol)  # Radiolab -- also available here, but ONLY OVER HTTP: <http://feeds.wnyc.org/radiolab>
-    (fromDb "feeds.megaphone.fm/CHTAL4990341033" // pol)  # ChinaTalk: https://www.chinatalk.media/podcast
-    (fromDb "feeds.megaphone.fm/GLT1412515089" // pol)  # JRE: Joe Rogan Experience
+    (fromDb "feeds.libsyn.com/421877" // rat)  # Less Wrong Curated
     (fromDb "feeds.megaphone.fm/behindthebastards" // pol)  # also Maggie Killjoy
-    (fromDb "feeds.megaphone.fm/cspantheweekly" // pol)
-    (fromDb "feeds.megaphone.fm/econ102")  # Noah Smith + Erik Torenberg <https://www.podpage.com/econ102/>
-    (fromDb "feeds.megaphone.fm/history102")  # <https://www.podpage.com/history-102-with-whatifalthist/>
+    (fromDb "feeds.megaphone.fm/hubermanlab" // uncat)  # Daniel Huberman on sleep
     (fromDb "feeds.megaphone.fm/recodedecode" // tech)  # The Verge - Decoder
-    (fromDb "feeds.megaphone.fm/thiswontlast" // tech)  # <https://www.podpage.com/thiswontlast/>
-    (fromDb "feeds.megaphone.fm/unexplainable")
+    (fromDb "feeds.simplecast.com/54nAGcIl" // pol)  # The Daily
+    (fromDb "feeds.simplecast.com/82FI35Px" // pol)  # Ezra Klein Show
     (fromDb "feeds.simplecast.com/wgl4xEgL" // rat)  # Econ Talk
-    (fromDb "feeds.simplecast.com/whlwDbyc" // tech)  # Tech Lounge: <https://chrischinchilla.com/podcast/techlounge/>
+    (fromDb "feeds.simplecast.com/xKJ93w_w" // uncat)  # Atlas Obscura
+    (fromDb "feeds.simplecast.com/l2i9YnTd" // tech // pol)  # Hard Fork (NYtimes tech)
     (fromDb "feeds.transistor.fm/acquired" // tech)
-    (fromDb "feeds.transistor.fm/complex-systems-with-patrick-mckenzie-patio11" // tech)  # Patrick Mackenzie (from Bits About Money)
-    (fromDb "feeds.twit.tv/floss.xml" // tech)
-    (fromDb "fulltimenix.com" // tech)
-    (fromDb "futureofcoding.org/episodes" // tech)
-    (fromDb "hackerpublicradio.org" // tech)
     (fromDb "lexfridman.com/podcast" // rat)
-    (fromDb "linktr.ee/betteroffline" // pol)
-    (fromDb "linuxdevtime.com" // tech)
-    (fromDb "malicious.life" // tech)
     (fromDb "mapspodcast.libsyn.com" // uncat)  # Multidisciplinary Association for Psychedelic Studies
-    (fromDb "microarch.club" // tech)
     (fromDb "omegataupodcast.net" // tech)  # 3/4 German; 1/4 eps are English
     (fromDb "omny.fm/shows/cool-people-who-did-cool-stuff" // pol)  # Maggie Killjoy -- referenced by Cory Doctorow
-    (fromDb "omny.fm/shows/money-stuff-the-podcast")  # Matt Levine
-    (fromDb "omny.fm/shows/stuff-you-should-know-1")
-    (fromDb "omny.fm/shows/the-dollop-with-dave-anthony-and-gareth-reynolds")  # The Dollop history/comedy
-    (fromDb "omny.fm/shows/weird-little-guys")  # Cool Zone Media
-    (fromDb "originstories.libsyn.com" // uncat)
-    (fromDb "podcast.ergaster.org/@flintandsilicon" // tech)  # Thib's podcast: public interest tech, gnome, etc: <https://fed.uninsane.org/users/$ALLO9MZ5g5CsQTCBH6>
+    (fromDb "podcast.posttv.com/itunes/post-reports.xml" // pol)
+    (fromDb "podcast.thelinuxexp.com" // tech)
     (fromDb "politicalorphanage.libsyn.com" // pol)
     (fromDb "reverseengineering.libsyn.com/rss" // tech)  # UnNamed Reverse Engineering Podcast
-    (fromDb "rss.acast.com/ft-tech-tonic" // tech)  # Financial Time's: Tech Tonic
+    (fromDb "rss.acast.com/deconstructed")  # The Intercept - Deconstructed
+    (fromDb "rss.acast.com/ft-tech-tonic" // tech)
+    (fromDb "rss.acast.com/intercepted-with-jeremy-scahill")  # The Intercept - Intercepted
+    (fromDb "rss.art19.com/60-minutes" // pol)
     (fromDb "rss.art19.com/the-portal" // rat)  # Eric Weinstein
-    (fromDb "seattlenice.buzzsprout.com" // pol)  # Seattle Nice
-    (fromDb "sites.libsyn.com/438684" // humor)  # Quorators - digging up *weird* Quota questions
-    (fromDb "speedboatdope.com" // pol)  # Chapo Trap House (premium feed)
-    (fromDb "srslywrong.com" // pol)
+    (fromDb "seattlenice.buzzsprout.com" // pol)
     (fromDb "sharkbytes.transistor.fm" // tech)  # Wireshark Podcast o_0
-    (fromDb "sharptech.fm/feed/podcast" // tech)  # Ben Thompson
-    (fromDb "sscpodcast.libsyn.com" // rat)  # Astral Codex Ten; Scott Alexander
+    (fromDb "sscpodcast.libsyn.com" // rat)  # Astral Codex Ten
     (fromDb "talesfromthebridge.buzzsprout.com" // tech)  # Sci-Fi? has Peter Watts; author of No Moods, Ads or Cutesy Fucking Icons (rifters.com)
-    (fromDb "techtalesshow.com" // tech)  # Corbin Davenport
-    (fromDb "theamphour.com" // tech)  # The Amp Hour
-    (fromDb "the-ben-marc-show.simplecast.com" // tech // pol)  # Ben Horowitz + Marc Andreessen; love to hate em
-    (fromDb "timclicks.dev/compose-podcast" // tech)  # Rust-heavy dev interviews
-    (fromDb "werenotwrong.fireside.fm" // pol)  # We're Not Wrong
-    (fromDb "whycast.podcast.audio/@whycast" // tech)  # What Hackers Yearn [for]: <https://why2025.org/>
-    (mkPod "https://sfconservancy.org/casts/the-corresponding-source/feeds/ogg/" // tech)
+    (fromDb "techwontsave.us" // pol)  # rec by Cory Doctorow
+    # (fromDb "trashfuturepodcast.podbean.com" // pol)  # rec by Cory Doctorow, but way rambly
+    (fromDb "wakingup.libsyn.com" // pol)  # Sam Harris
+    (fromDb "werenotwrong.fireside.fm" // pol)
 
-    # (fromDb "allinchamathjason.libsyn.com" // pol)
-    # (fromDb "feed.podbean.com/matrixlive/feed.xml" // tech)  # Matrix (chat) Live
-    # (fromDb "feeds.libsyn.com/421877" // rat)  # Less Wrong Curated
-    # (fromDb "feeds.megaphone.fm/hubermanlab" // uncat)  # Daniel Huberman on sleep
-    # (fromDb "feeds.simplecast.com/54nAGcIl" // pol)  # The Daily
-    # (fromDb "feeds.simplecast.com/82FI35Px" // pol)  # Ezra Klein Show
-    # (fromDb "feeds.simplecast.com/l2i9YnTd" // tech // pol)  # Hard Fork (NYtimes tech)
-    # (fromDb "feeds.simplecast.com/xKJ93w_w" // uncat)  # Atlas Obscura
-    # (fromDb "lastweekinai.com" // tech)  # Last Week in AI
-    # (fromDb "mintcast.org" // tech)
-    # (fromDb "politicspoliticspolitics.com" // pol)  # don't judge me. Justin Robert Young.
-    # (fromDb "podcast.posttv.com/itunes/post-reports.xml" // pol)
-    # (fromDb "podcast.sustainoss.org" // tech)  # "Sustainable tech", only... it somehow manages to avoid any tech which is actually sustainable, and most of the time doesn't even talk about Open Source Software (!). normie/surface-level/"feel good"
-    # (fromDb "podcast.thelinuxexp.com" // tech)  # low-brow linux/foss PR announcements
-    # (fromDb "rss.acast.com/deconstructed")  # The Intercept - Deconstructed
-    # (fromDb "rss.acast.com/intercepted-with-jeremy-scahill")  # The Intercept - Intercepted
-    # (fromDb "rss.art19.com/60-minutes" // pol)
     # (fromDb "rss.art19.com/your-welcome" // pol)  # Michael Malice - Your Welcome -- also available here: <https://origin.podcastone.com/podcast?categoryID2=2232>
     # (fromDb "rss.prod.firstlook.media/deconstructed/podcast.rss" // pol)  #< possible URL rot
     # (fromDb "rss.prod.firstlook.media/intercepted/podcast.rss" // pol)  #< possible URL rot
-    # (fromDb "techwontsave.us" // pol)  # rec by Cory Doctorow, but way too info-sparse
-    # (fromDb "trashfuturepodcast.podbean.com" // pol)  # rec by Cory Doctorow, but way rambly
-    # (fromDb "wakingup.libsyn.com" // pol)  # Sam Harris, but he just repeats himself now
     # (mkPod "https://anchor.fm/s/21bc734/podcast/rss" // pol // infrequent)  # Emerge: making sense of what's next -- <https://www.whatisemerging.com/emergepodcast>
     # (mkPod "https://audioboom.com/channels/5097784.rss" // tech)  # Lateral with Tom Scott
     # (mkPod "https://feeds.megaphone.fm/RUNMED9919162779" // pol // infrequent)  # The Witch Trials of J.K. Rowling: <https://www.thefp.com/witchtrials>
@@ -159,151 +111,137 @@ let
   ];
 
   texts = [
-    (fromDb "ergaster.org/blog" // tech)  # Thib's blog: public interest tech, gnome, etc: <https://fed.uninsane.org/users/$ALLO9MZ5g5CsQTCBH6>
-    (fromDb "acoup.blog/feed")  # history, states. author: <https://historians.social/@bretdevereaux/following>
-    (fromDb "amosbbatto.wordpress.com" // tech)
-    (fromDb "anish.lakhwara.com" // tech)
-    (fromDb "antipope.org")  # Charles Stross
-    (fromDb "apenwarr.ca/log/rss.php" // tech)  # CEO of tailscale
-    (fromDb "applieddivinitystudies.com" // rat)
-    (fromDb "artemis.sh" // tech)
-    (fromDb "ascii.textfiles.com" // tech)  # Jason Scott
-    (fromDb "austinvernon.site" // tech)
-    (fromDb "buttondown.email" // tech)
-    (fromDb "ben-evans.com/benedictevans" // pol)
-    (fromDb "bitbashing.io" // tech)
-    (fromDb "bitsaboutmoney.com" // uncat)
-    (fromDb "blog.danieljanus.pl" // tech)
-    (fromDb "blog.dshr.org" // pol)  # David Rosenthal
-    (fromDb "blog.jmp.chat" // tech)
-    (fromDb "blog.rust-lang.org" // tech)
-    (fromDb "blog.thalheim.io" // tech)  # Mic92
-    (fromDb "blog.brixit.nl" // tech)  # Martijn Braam
-    (fromDb "bunniestudios.com" // tech)  # Bunnie Juang
-    (fromDb "capitolhillseattle.com" // pol)
-    (fromDb "edwardsnowden.substack.com" // pol // text)
-    (fromDb "fasterthanli.me" // tech)
-    (fromDb "gwern.net" // rat)
-    (fromDb "hardcoresoftware.learningbyshipping.com" // tech)  # Steven Sinofsky
-    (fromDb "harihareswara.net" // tech // pol)  # rec by Cory Doctorow
-    (fromDb "ianthehenry.com" // tech)
-    (fromDb "idiomdrottning.org" // uncat)
-    (fromDb "interconnected.org/home/feed" // rat)  # Matt Webb -- engineering-ish, but dreamy
-    (fromDb "jeffgeerling.com" // tech)
-    (fromDb "jefftk.com" // tech)
-    (fromDb "justine.lol" // tech)
-    (fromDb "jwz.org/blog" // tech // pol)  # DNA lounge guy, loooong-time blogger
-    (fromDb "kill-the-newsletter.com/feeds/joh91bv7am2pnznv.xml" // pol)  # Matt Levine - Money Stuff
-    (fromDb "kosmosghost.github.io/index.xml" // tech)
-    (fromDb "linmob.net" // tech)
+    # AGGREGATORS (> 1 post/day)
     (fromDb "lwn.net" // tech)
-    (fromDb "lynalden.com" // pol)
-    (fromDb "mako.cc/copyrighteous" // tech // pol)  # rec by Cory Doctorow
-    (fromDb "mg.lol" // tech)
-    (fromDb "mindingourway.com" // rat)
-    (fromDb "momi.ca" // tech)  # Anjan, pmOS
-    (fromDb "morningbrew.com/feed" // pol)
-    (fromDb "nixpkgs.news" // tech)
-    (fromDb "overcomingbias.com" // rat)  # Robin Hanson
-    (fromDb "palladiummag.com" // uncat)
-    (fromDb "philosopher.coach" // rat)  # Peter Saint-Andre -- side project of stpeter.im
-    (fromDb "pomeroyb.com" // tech)
-    (fromDb "postmarketos.org/blog" // tech)
-    (fromDb "preposterousuniverse.com" // rat)  # Sean Carroll
-    (fromDb "project-insanity.org" // tech)  # shared blog by a few NixOS devs, notably onny
-    (fromDb "putanumonit.com" // rat)  # mostly dating topics. not advice, or humor, but looking through a social lens
-    (fromDb "richardcarrier.info" // rat)
-    (fromDb "rifters.com/crawl" // uncat)  # No Moods, Ads or Cutesy Fucking Icons
-    (fromDb "righto.com" // tech)  # Ken Shirriff
-    (fromDb "rootsofprogress.org" // rat)  # Jason Crawford
-    (fromDb "samuel.dionne-riel.com" // tech)  # SamuelDR
-    (fromDb "sagacioussuricata.com" // tech)  # ian (Sanctuary)
-    (fromDb "semiaccurate.com" // tech)
-    (fromDb "sideways-view.com" // rat)  # Paul Christiano
-    (fromDb "slatecave.net" // tech)
-    (fromDb "slimemoldtimemold.com" // rat)
-    (fromDb "spectrum.ieee.org" // tech)
-    (fromDb "stpeter.im/atom.xml" // pol)
-    (fromDb "thisweek.gnome.org" // tech)
-    (fromDb "tuxphones.com" // tech)
-    (fromDb "uninsane.org" // tech)
-    (fromDb "unintendedconsequenc.es" // rat)
-    (fromDb "vitalik.eth.limo" // tech)  # Vitalik Buterin
-    (fromDb "weekinethereumnews.com" // tech)
-    (fromDb "willow.phantoma.online")  # wizard@xyzzy.link
-    (fromDb "xn--gckvb8fzb.com" // tech)
-    (fromDb "xorvoid.com" // tech)
-    (fromDb "www.thebignewsletter.com" // pol)
-    (mkSubstack "astralcodexten" // rat // daily)  # Scott Alexander
-    (mkSubstack "chlamchowder" // tech)  # details CPU advancements
-    (mkSubstack "eliqian" // rat // weekly)
-    (mkSubstack "oversharing" // pol // daily)
-    (mkSubstack "samkriss" // humor // infrequent)
-    (mkText "http://benjaminrosshoffman.com/feed" // pol // weekly)
-    (mkText "http://boginjr.com/feed" // tech // infrequent)
-    (mkText "https://forum.merveilles.town/rss.xml" // pol // infrequent)  #quality RSS list here: <https://forum.merveilles.town/thread/57/share-your-rss-feeds%21-6/>
-    (mkText "https://icm.museum/rss20.xml" // tech // infrequent)  # Interim Computer Museum
-    (mkText "https://jvns.ca/atom.xml" // tech // weekly)  # Julia Evans
-    (mkText "https://linuxphoneapps.org/blog/atom.xml" // tech // infrequent)
-    (mkText "https://nixos.org/blog/announcements-rss.xml" // tech // infrequent)  # more nixos stuff here, but unclear how to subscribe: <https://nixos.org/blog/categories.html>
-    (mkText "https://nixos.org/blog/stories-rss.xml" // tech // weekly)
-    (mkText "https://solar.lowtechmagazine.com/posts/index.xml" // tech // weekly)
-    (mkText "https://www.stratechery.com/rss" // pol // weekly)  # Ben Thompson
-
-    # (fromDb "balajis.com" // pol)  # Balaji
-    # (fromDb "drewdevault.com" // tech)
-    # (fromDb "econlib.org" // pol)
     # (fromDb "lesswrong.com" // rat)
-    # (fromDb "profectusmag.com" // pol)  # some conservative/libertarian think tank
-    # (fromDb "thediff.co" // pol)  # Byrne Hobart; 80% is subscriber-only
-    # (fromDb "thesideview.co" // uncat)  # spiritual journal; RSS items are stubs
+    # (fromDb "econlib.org" // pol)
+
+    # AGGREGATORS (< 1 post/day)
+    (fromDb "palladiummag.com" // uncat)
+    (fromDb "profectusmag.com" // uncat)
+    (fromDb "semiaccurate.com" // tech)
+    (mkText "https://linuxphoneapps.org/blog/atom.xml" // tech // infrequent)
+    (fromDb "tuxphones.com" // tech)
+    (fromDb "spectrum.ieee.org" // tech)
     # (fromDb "theregister.com" // tech)
-    # (fromDb "vitalik.ca" // tech)  # moved to vitalik.eth.limo
-    # (fromDb "webcurious.co.uk" // uncat)  # link aggregator; defunct?
-    # (mkSubstack "doomberg" // tech // weekly)  # articles are all pay-walled
-    # (mkText "https://github.com/Kaiteki-Fedi/Kaiteki/commits/master.atom" // tech // infrequent)
+    (fromDb "thisweek.gnome.org" // tech)
+    # more nixos stuff here, but unclear how to subscribe: <https://nixos.org/blog/categories.html>
+    (mkText "https://nixos.org/blog/announcements-rss.xml" // tech // infrequent)
+    (mkText "https://nixos.org/blog/stories-rss.xml" // tech // weekly)
+    ## n.b.: quality RSS list here: <https://forum.merveilles.town/thread/57/share-your-rss-feeds%21-6/>
+    (mkText "https://forum.merveilles.town/rss.xml" // pol // infrequent)
+
+    ## No Moods, Ads or Cutesy Fucking Icons
+    (fromDb "rifters.com/crawl" // uncat)
+
+    # DEVELOPERS
+    (fromDb "blog.jmp.chat" // tech)
+    (fromDb "uninsane.org" // tech)
+    (fromDb "blog.thalheim.io" // tech)  # Mic92
+    (fromDb "ascii.textfiles.com" // tech)  # Jason Scott
+    (fromDb "xn--gckvb8fzb.com" // tech)
+    (fromDb "amosbbatto.wordpress.com" // tech)
+    (fromDb "fasterthanli.me" // tech)
+    (fromDb "jeffgeerling.com" // tech)
+    (fromDb "mg.lol" // tech)
+    # (fromDb "drewdevault.com" // tech)
+    ## Ken Shirriff
+    (fromDb "righto.com" // tech)
+    ## shared blog by a few NixOS devs, notably onny
+    (fromDb "project-insanity.org" // tech)
+    ## Vitalik Buterin
+    (fromDb "vitalik.ca" // tech)
+    ## ian (Sanctuary)
+    (fromDb "sagacioussuricata.com" // tech)
+    (fromDb "artemis.sh" // tech)
+    ## Bunnie Juang
+    (fromDb "bunniestudios.com" // tech)
+    (fromDb "blog.danieljanus.pl" // tech)
+    (fromDb "ianthehenry.com" // tech)
+    (fromDb "bitbashing.io" // tech)
+    (fromDb "idiomdrottning.org" // uncat)
+    (mkText "http://boginjr.com/feed" // tech // infrequent)
+    (mkText "https://anish.lakhwara.com/home.html" // tech // weekly)
+    (fromDb "jefftk.com" // tech)
+    (fromDb "pomeroyb.com" // tech)
+    (fromDb "harihareswara.net" // tech // pol)  # rec by Cory Doctorow
+    (fromDb "mako.cc/copyrighteous" // tech // pol)  # rec by Cory Doctorow
     # (mkText "https://til.simonwillison.net/tils/feed.atom" // tech // weekly)
-    # (mkText "https://www.bloomberg.com/opinion/authors/ARbTQlRLRjE/matthew-s-levine.rss" // pol // weekly)  # Matt Levine (preview/paywalled)
-  ];
 
-  videos = [
-    (fromDb "youtube.com/@Channel5YouTube" // pol)
-    (fromDb "youtube.com/@ContraPoints" // pol)
-    (fromDb "youtube.com/@Exurb1a")
-    (fromDb "youtube.com/@hbomberguy")
-    (fromDb "youtube.com/@JackStauber")
-    (fromDb "youtube.com/@mii_beta" // tech)  # Baby Wogue / gnome reviewer
-    (fromDb "youtube.com/@Matrixdotorg" // tech)  # Matrix Live
-    (fromDb "youtube.com/@NativLang")
-    (fromDb "youtube.com/@PolyMatter")
-    (fromDb "youtube.com/@TechnologyConnections" // tech)
-    (fromDb "youtube.com/@TomScottGo")
-    (fromDb "youtube.com/@TVW_Washington" // pol)  # interviews with WA public officials
-    (fromDb "youtube.com/@Vihart")
-    (fromDb "youtube.com/@InnuendoStudios" // pol)  # breaks down the nastier political strategies, from a "politics is power" angle
+    # TECH PROJECTS
+    (fromDb "blog.rust-lang.org" // tech)
 
-    # (fromDb "youtube.com/@ColdFusion")
-    # (fromDb "youtube.com/@rossmanngroup" // pol // tech)  # Louis Rossmann
-    # (fromDb "youtube.com/@TheB1M")
-    # (fromDb "youtube.com/@tested" // tech)  # Adam Savage  (uploads too frequently)
-    # (fromDb "youtube.com/@Vox")
-    # (fromDb "youtube.com/@Vsauce")  # they're all like 1-minute long videos now? what happened @Vsauce?
+    # (TECH; POL) COMMENTATORS
+    ## Matt Webb -- engineering-ish, but dreamy
+    (fromDb "interconnected.org/home/feed" // rat)
+    (fromDb "edwardsnowden.substack.com" // pol // text)
+    ## Julia Evans
+    (mkText "https://jvns.ca/atom.xml" // tech // weekly)
+    (mkText "http://benjaminrosshoffman.com/feed" // pol // weekly)
+    ## Ben Thompson
+    (mkText "https://www.stratechery.com/rss" // pol // weekly)
+    ## Balaji
+    (fromDb "balajis.com" // pol)
+    (fromDb "ben-evans.com/benedictevans" // pol)
+    (fromDb "lynalden.com" // pol)
+    (fromDb "austinvernon.site" // tech)
+    (mkSubstack "oversharing" // pol // daily)
+    (mkSubstack "byrnehobart" // pol // infrequent)
+    # (mkSubstack "doomberg" // tech // weekly)  # articles are all pay-walled
+    ## David Rosenthal
+    (fromDb "blog.dshr.org" // pol)
+    ## Matt Levine
+    (mkText "https://www.bloomberg.com/opinion/authors/ARbTQlRLRjE/matthew-s-levine.rss" // pol // weekly)
+    (fromDb "stpeter.im/atom.xml" // pol)
+    ## Peter Saint-Andre -- side project of stpeter.im
+    (fromDb "philosopher.coach" // rat)
+    (fromDb "morningbrew.com/feed" // pol)
+
+    # RATIONALITY/PHILOSOPHY/ETC
+    (mkSubstack "samkriss" // humor // infrequent)
+    (fromDb "unintendedconsequenc.es" // rat)
+    (fromDb "applieddivinitystudies.com" // rat)
+    (fromDb "slimemoldtimemold.com" // rat)
+    (fromDb "richardcarrier.info" // rat)
+    (fromDb "gwern.net" // rat)
+    ## Jason Crawford
+    (fromDb "rootsofprogress.org" // rat)
+    ## Robin Hanson
+    (fromDb "overcomingbias.com" // rat)
+    ## Scott Alexander
+    (mkSubstack "astralcodexten" // rat // daily)
+    ## Paul Christiano
+    (fromDb "sideways-view.com" // rat)
+    ## Sean Carroll
+    (fromDb "preposterousuniverse.com" // rat)
+    (mkSubstack "eliqian" // rat // weekly)
+    (mkText "https://acoup.blog/feed" // rat // weekly)
+    (fromDb "mindingourway.com" // rat)
+
+    ## mostly dating topics. not advice, or humor, but looking through a social lens
+    (fromDb "putanumonit.com" // rat)
+
+    # LOCAL
+    (fromDb "capitolhillseattle.com" // pol)
+
+    # CODE
+    # (mkText "https://github.com/Kaiteki-Fedi/Kaiteki/commits/master.atom" // tech // infrequent)
   ];
 
   images = [
-    (fromDb "catandgirl.com" // img // humor)
-    (fromDb "davidrevoy.com" // img // art)
-    (fromDb "grumpy.website" // img // humor)
-    (fromDb "miniature-calendar.com" // img // art // daily)
-    (fromDb "pbfcomics.com" // img // humor)
-    (fromDb "poorlydrawnlines.com/feed" // img // humor)
     (fromDb "smbc-comics.com" // img // humor)
-    (fromDb "turnoff.us" // img // humor)
     (fromDb "xkcd.com" // img // humor)
+    (fromDb "turnoff.us" // img // humor)
+    (fromDb "pbfcomics.com" // img // humor)
+    # (mkImg "http://dilbert.com/feed" // humor // daily)
+    (fromDb "poorlydrawnlines.com/feed" // img // humor)
+
+    # ART
+    (fromDb "miniature-calendar.com" // img // art // daily)
   ];
 in
 {
-  sane.feeds = texts ++ images ++ podcasts ++ videos;
+  sane.feeds = texts ++ images ++ podcasts;
 
   assertions = builtins.map
     (p: {

hosts/common/fs.nix

@@ -0,0 +1,143 @@
+# docs
+# - x-systemd options: <https://www.freedesktop.org/software/systemd/man/systemd.mount.html>
+
+{ lib, pkgs, sane-lib, ... }:
+
+let
+  fsOpts = rec {
+    common = [
+      "_netdev"
+      "noatime"
+      "user"  # allow any user with access to the device to mount the fs
+      "x-systemd.requires=network-online.target"
+      "x-systemd.after=network-online.target"
+      "x-systemd.mount-timeout=10s"  # how long to wait for mount **and** how long to wait for unmount
+    ];
+    auto = [ "x-systemd.automount" ];
+    noauto = [ "noauto" ];  # don't mount as part of remote-fs.target
+    wg = [
+      "x-systemd.requires=wireguard-wg-home.service"
+      "x-systemd.after=wireguard-wg-home.service"
+    ];
+
+    ssh = common ++ [
+      "identityfile=/home/colin/.ssh/id_ed25519"
+      "allow_other"
+      "default_permissions"
+    ];
+    sshColin = ssh ++ [
+      "transform_symlinks"
+      "idmap=user"
+      "uid=1000"
+      "gid=100"
+    ];
+    sshRoot = ssh ++ [
+      # we don't transform_symlinks because that breaks the validity of remote /nix stores
+      "sftp_server=/run/wrappers/bin/sudo\\040/run/current-system/sw/libexec/sftp-server"
+    ];
+    # in the event of hunt NFS mounts, consider:
+    # - <https://unix.stackexchange.com/questions/31979/stop-broken-nfs-mounts-from-locking-a-directory>
+
+    # NFS options: <https://linux.die.net/man/5/nfs>
+    # actimeo=n  = how long (in seconds) to cache file/dir attributes (default: 3-60s)
+    # bg         = retry failed mounts in the background
+    # retry=n    = for how many minutes `mount` will retry NFS mount operation
+    # soft       = on "major timeout", report I/O error to userspace
+    # retrans=n  = how many times to retry a NFS request before giving userspace a "server not responding" error (default: 3)
+    # timeo=n    = number of *deciseconds* to wait for a response before retrying it (default: 600)
+    #              note: client uses a linear backup, so the second request will have double this timeout, then triple, etc.
+    nfs = common ++ [
+      # "actimeo=10"
+      "bg"
+      "retrans=4"
+      "retry=0"
+      "soft"
+      "timeo=15"
+      "nofail"  # don't fail remote-fs.target when this mount fails  (not an option for sshfs else would be common)
+    ];
+  };
+  remoteHome = host: {
+    fileSystems."/mnt/${host}-home" = {
+      device = "colin@${host}:/home/colin";
+      fsType = "fuse.sshfs";
+      options = fsOpts.sshColin ++ fsOpts.noauto;
+      noCheck = true;
+    };
+    sane.fs."/mnt/${host}-home" = sane-lib.fs.wantedDir;
+  };
+in
+lib.mkMerge [
+  {
+    # some services which use private directories error if the parent (/var/lib/private) isn't 700.
+    sane.fs."/var/lib/private".dir.acl.mode = "0700";
+
+    # in-memory compressed RAM
+    # defaults to compressing at most 50% size of RAM
+    # claimed compression ratio is about 2:1
+    # - but on moby w/ zstd default i see 4-7:1  (ratio lowers as it fills)
+    # note that idle overhead is about 0.05% of capacity (e.g. 2B per 4kB page)
+    # docs: <https://www.kernel.org/doc/Documentation/blockdev/zram.txt>
+    #
+    # to query effectiveness:
+    # `cat /sys/block/zram0/mm_stat`. whitespace separated fields:
+    # - *orig_data_size*  (bytes)
+    # - *compr_data_size* (bytes)
+    # - mem_used_total    (bytes)
+    # - mem_limit         (bytes)
+    # - mem_used_max      (bytes)
+    # - *same_pages*  (pages which are e.g. all zeros (consumes no additional mem))
+    # - *pages_compacted*  (pages which have been freed thanks to compression)
+    # - huge_pages  (incompressible)
+    #
+    # see also:
+    # - `man zramctl`
+    zramSwap.enable = true;
+    # how much ram can be swapped into the zram device.
+    # this shouldn't be higher than the observed compression ratio.
+    # the default is 50% (why?)
+    # 100% should be "guaranteed" safe so long as the data is even *slightly* compressible.
+    # but it decreases working memory under the heaviest of loads by however much space the compressed memory occupies (e.g. 50% if 2:1; 25% if 4:1)
+    zramSwap.memoryPercent = 100;
+
+    # fileSystems."/mnt/servo-nfs" = {
+    #   device = "servo-hn:/";
+    #   noCheck = true;
+    #   fsType = "nfs";
+    #   options = fsOpts.nfs ++ fsOpts.auto ++ fsOpts.wg;
+    # };
+    fileSystems."/mnt/servo-nfs/media" = {
+      device = "servo-hn:/media";
+      noCheck = true;
+      fsType = "nfs";
+      options = fsOpts.nfs ++ fsOpts.auto ++ fsOpts.wg;
+    };
+    fileSystems."/mnt/servo-nfs/playground" = {
+      device = "servo-hn:/playground";
+      noCheck = true;
+      fsType = "nfs";
+      options = fsOpts.nfs ++ fsOpts.auto ++ fsOpts.wg;
+    };
+    # fileSystems."/mnt/servo-media-nfs" = {
+    #   device = "servo-hn:/media";
+    #   noCheck = true;
+    #   fsType = "nfs";
+    #   options = fsOpts.common ++ fsOpts.auto;
+    # };
+    sane.fs."/mnt/servo-media" = sane-lib.fs.wantedSymlinkTo "/mnt/servo-nfs/media";
+
+    environment.pathsToLink = [
+      # needed to achieve superuser access for user-mounted filesystems (see optionsRoot above)
+      # we can only link whole directories here, even though we're only interested in pkgs.openssh
+      "/libexec"
+    ];
+
+    environment.systemPackages = [
+      pkgs.sshfs-fuse
+    ];
+  }
+
+  (remoteHome "desko")
+  (remoteHome "lappy")
+  (remoteHome "moby")
+]
+

hosts/common/fs/default.nix

@@ -1,51 +0,0 @@
-{ ... }:
-{
-  imports = [
-    ./remote-home.nix
-    ./remote-servo.nix
-  ];
-  # some services which use private directories error if the parent (/var/lib/private) isn't 700.
-  sane.fs."/var/lib/private".dir.acl.mode = "0700";
-
-
-  # allocate a proper /tmp fs, else its capacity will be limited as per impermanence defaults (i.e. 1 GB).
-  fileSystems."/tmp" = {
-    device = "none";
-    fsType = "tmpfs";
-    options = [
-      "mode=777"
-      "defaults"
-    ];
-  };
-
-  # in-memory compressed RAM
-  # defaults to compressing at most 50% size of RAM
-  # claimed compression ratio is about 2:1
-  # - but on moby w/ zstd default i see 4-7:1  (ratio lowers as it fills)
-  # note that idle overhead is about 0.05% of capacity (e.g. 2B per 4kB page)
-  # docs: <https://www.kernel.org/doc/Documentation/blockdev/zram.txt>
-  #
-  # to query effectiveness:
-  # `cat /sys/block/zram0/mm_stat`. whitespace separated fields:
-  # - *orig_data_size*  (bytes)
-  # - *compr_data_size* (bytes)
-  # - mem_used_total    (bytes)
-  # - mem_limit         (bytes)
-  # - mem_used_max      (bytes)
-  # - *same_pages*  (pages which are e.g. all zeros (consumes no additional mem))
-  # - *pages_compacted*  (pages which have been freed thanks to compression)
-  # - huge_pages  (incompressible)
-  #
-  # see also:
-  # - `man zramctl`
-  zramSwap.enable = true;
-  # how much ram can be swapped into the zram device.
-  # this shouldn't be higher than the observed compression ratio.
-  # the default is 50% (why?)
-  # 100% should be "guaranteed" safe so long as the data is even *slightly* compressible.
-  # but it decreases working memory under the heaviest of loads by however much space the compressed memory occupies (e.g. 50% if 2:1; 25% if 4:1)
-  zramSwap.memoryPercent = 100;
-
-  programs.fuse.userAllowOther = true;  #< necessary for `allow_other` or `allow_root` options.
-}
-

hosts/common/fs/fs-opts.nix

@@ -1,76 +0,0 @@
-# docs
-# - x-systemd options: <https://www.freedesktop.org/software/systemd/man/systemd.mount.html>
-# - fuse options: `man mount.fuse`
-rec {
-  common = [
-    "_netdev"
-    "noatime"
-    # user: allow any user with access to the device to mount the fs.
-    #       note that this requires a suid `mount` binary; see: <https://zameermanji.com/blog/2022/8/5/using-fuse-without-root-on-linux/>
-    "user"
-    "x-systemd.requires=network-online.target"
-    "x-systemd.after=network-online.target"
-    "x-systemd.mount-timeout=10s"  # how long to wait for mount **and** how long to wait for unmount
-    # disable defaults: don't fail local-fs.target if this mount fails
-    "nofail"
-  ];
-  # x-systemd.automount: mount the fs automatically *on first access*.
-  # creates a `path-to-mount.automount` systemd unit.
-  automount = [ "x-systemd.automount" ];
-  # noauto: don't mount as part of remote-fs.target.
-  # N.B.: `remote-fs.target` is a dependency of multi-user.target, itself of graphical.target.
-  # hence, omitting `noauto` can slow down boots.
-  noauto = [ "noauto" ];
-  # lazyMount: defer mounting until first access from userspace.
-  # see: `man systemd.automount`, `man automount`, `man autofs`
-  lazyMount = noauto ++ automount;
-
-  fuse = [
-    "allow_other"  # allow users other than the one who mounts it to access it. needed, if systemd is the one mounting this fs (as root)
-    # allow_root: allow root to access files on this fs (if mounted by non-root, else it can always access them).
-    #             N.B.: if both allow_root and allow_other are specified, then only allow_root takes effect.
-    # "allow_root"
-    # default_permissions: enforce local permissions check. CRUCIAL if using `allow_other`.
-    # w/o this, permissions mode of sshfs is like:
-    # - sshfs runs all remote commands as the remote user.
-    # - if a local user has local permissions to the sshfs mount, then their file ops are sent blindly across the tunnel.
-    # - `allow_other` allows *any* local user to access the mount, and hence any local user can now freely become the remote mapped user.
-    # with default_permissions, sshfs doesn't tunnel file ops from users until checking that said user could perform said op on an equivalent local fs.
-    "default_permissions"
-    "drop_privileges"
-    "auto_unmount"  #< ensures that when the fs exits, it releases its mountpoint. then systemd can recognize it as failed.
-  ];
-  fuseColin = fuse ++ [
-    "uid=1000"
-    "gid=100"
-  ];
-
-  ssh = common ++ fuseColin ++ [
-    "identityfile=/home/colin/.ssh/id_ed25519"
-    # i *think* idmap=user means that `colin` on `localhost` and `colin` on the remote are actually treated as the same user, even if their uid/gid differs?
-    # i.e., local colin's id is translated to/from remote colin's id on every operation?
-    "idmap=user"
-  ];
-  sshColin = ssh ++ fuseColin ++ [
-    # follow_symlinks: remote files which are symlinks are presented to the local system as ordinary files (as the target of the symlink).
-    #                  if the symlink target does not exist, the presentation is unspecified.
-    #                  symlinks which point outside the mount ARE followed. so this is more capable than `transform_symlinks`
-    "follow_symlinks"
-    # symlinks on the remote fs which are absolute paths are presented to the local system as relative symlinks pointing to the expected data on the remote fs.
-    # only symlinks which would point inside the mountpoint are translated.
-    "transform_symlinks"
-  ];
-  # sshRoot = ssh ++ [
-  #   # we don't transform_symlinks because that breaks the validity of remote /nix stores
-  #   "sftp_server=/run/wrappers/bin/sudo\\040/run/current-system/sw/libexec/sftp-server"
-  # ];
-
-  # manually perform a ftp mount via e.g.
-  #   curlftpfs -o ftpfs_debug=2,user=anonymous:anonymous,connect_timeout=10 -f -s ftp://servo-hn /mnt/my-ftp
-  ftp = common ++ fuseColin ++ [
-    # "ftpfs_debug=2"
-    "user=colin:ipauth"
-    # connect_timeout=10: casting shows to T.V. fails partway through about half the time
-    "connect_timeout=20"
-  ];
-}

hosts/common/fs/remote-home.nix

@@ -1,73 +0,0 @@
-{ config, lib, ... }:
-let
-  fsOpts = import ./fs-opts.nix;
-  ifSshAuthorized = lib.mkIf (((config.sane.hosts.by-name."${config.networking.hostName}" or {}).ssh or {}).authorized or false);
-
-  remoteHome = name: { host ? name }: let
-    mountpoint = "/mnt/${name}/home";
-    device = "sshfs#colin@${host}:/home/colin";
-    fsType = "fuse3";
-    options = fsOpts.sshColin ++ fsOpts.lazyMount;
-  in {
-    sane.programs.sshfs-fuse.enableFor.system = true;
-    system.fsPackages = [
-      config.sane.programs.sshfs-fuse.package
-    ];
-    fileSystems."${mountpoint}" = {
-      inherit device fsType options;
-      noCheck = true;
-    };
-    # tell systemd about the mount so that i can sandbox it
-    systemd.mounts = [{
-      where = mountpoint;
-      what = device;
-      type = fsType;
-      options = lib.concatStringsSep "," options;
-      wantedBy = [ "default.target" ];
-      after = [ "network-online.target" ];
-      requires = [ "network-online.target" ];
-
-      mountConfig.ExecSearchPath = [ "/run/current-system/sw/bin" ];
-      mountConfig.User = "colin";
-      mountConfig.AmbientCapabilities = "CAP_SETPCAP CAP_SYS_ADMIN";
-      # hardening (systemd-analyze security mnt-desko-home.mount):
-      # TODO: i can't use ProtectSystem=full here, because i can't create a new mount space; but...
-      # with drop_privileges, i *could* sandbox the actual `sshfs` program using e.g. bwrap
-      mountConfig.CapabilityBoundingSet = "CAP_SETPCAP CAP_SYS_ADMIN";
-      mountConfig.LockPersonality = true;
-      mountConfig.MemoryDenyWriteExecute = true;
-      mountConfig.NoNewPrivileges = true;
-      mountConfig.ProtectClock = true;
-      mountConfig.ProtectHostname = true;
-      mountConfig.RemoveIPC = true;
-      mountConfig.RestrictAddressFamilies = "AF_UNIX AF_INET AF_INET6";
-      #VVV this includes anything it reads from, e.g. /bin/sh; /nix/store/...
-      # see `systemd-analyze filesystems` for a full list
-      mountConfig.RestrictFileSystems = "@common-block @basic-api fuse";
-      mountConfig.RestrictRealtime = true;
-      mountConfig.RestrictSUIDSGID = true;
-      mountConfig.SystemCallArchitectures = "native";
-      mountConfig.SystemCallFilter = [
-        "@system-service"
-        "@mount"
-        "~@chown"
-        "~@cpu-emulation"
-        "~@keyring"
-        # could remove almost all io calls, however one has to keep `open`, and `write`, to communicate with the fuse device.
-        # so that's pretty useless as a way to prevent write access
-      ];
-      mountConfig.IPAddressDeny = "any";
-      mountConfig.IPAddressAllow = "10.0.0.0/8";
-      mountConfig.DevicePolicy = "closed";  # only allow /dev/{null,zero,full,random,urandom}
-      mountConfig.DeviceAllow = "/dev/fuse";
-      # mount.mountConfig.RestrictNamespaces = true;  #< my sshfs sandboxing uses bwrap
-    }];
-  };
-in
-lib.mkMerge [
-  (ifSshAuthorized (remoteHome "crappy" {}))
-  (ifSshAuthorized (remoteHome "desko" {}))
-  (ifSshAuthorized (remoteHome "lappy" {}))
-  (ifSshAuthorized (remoteHome "moby" { host = "moby-hn"; }))
-  (ifSshAuthorized (remoteHome "servo" {}))
-]

hosts/common/fs/remote-servo.nix

@@ -1,134 +0,0 @@
-{ config, lib, utils, ... }:
-let
-  fsOpts = import ./fs-opts.nix;
-  commonOptions = fsOpts.ftp ++ fsOpts.noauto;
-  mountpoint = "/mnt/.servo_ftp";
-  systemdName = utils.escapeSystemdPath mountpoint;
-  device = "curlftpfs#ftp://servo-hn:/";
-  fsType = "fuse3";
-  options = commonOptions ++ [
-    # systemd (or maybe fuse?) swallows stderr of mount units with no obvious fix.
-    # instead, use this flag to log the mount output to disk
-    "stderr_path=/var/log/curlftpfs/servo-hn.stderr"
-  ];
-
-  remoteServo = subdir: let
-    systemdBindName = utils.escapeSystemdPath "/mnt/servo/${subdir}";
-  in {
-    # sane.fs."/mnt/servo/${subdir}".mount.bind = "/mnt/.servo_ftp/${subdir}";
-    systemd.mounts = [{
-      where = "/mnt/servo/${subdir}";
-      what = "/mnt/.servo_ftp/${subdir}";
-      options = "bind,nofail";
-      type = "auto";
-
-      after = [ "${systemdName}.mount" ];
-      upheldBy = [ "${systemdName}.mount" ];  #< start this mount whenever the underlying becomes available
-      bindsTo = [ "${systemdName}.mount" ];  #< stop this mount whenever the underlying disappears
-    }];
-  };
-in
-lib.mkMerge [
-  {
-    sane.programs.curlftpfs.enableFor.system = true;
-    system.fsPackages = [
-      config.sane.programs.curlftpfs.package
-    ];
-
-    sane.fs."/var/log/curlftpfs".dir.acl.mode = "0777";
-
-    fileSystems."/mnt/.servo_ftp" = {
-      inherit device fsType options;
-      noCheck = true;
-    };
-    systemd.mounts = [{
-      where = mountpoint;
-      what = device;
-      type = fsType;
-      options = lib.concatStringsSep "," options;
-      wantedBy = [ "default.target" ];
-      after = [ "network-online.target" ];
-      requires = [ "network-online.target" ];
-
-      #VVV patch so that when the mount fails, we start a timer to remount it.
-      #    and for a disconnection after a good mount (onSuccess), restart the timer to be more aggressive
-      unitConfig.OnFailure = [ "${systemdName}.timer" ];
-      unitConfig.OnSuccess = [ "${systemdName}-restart-timer.target" ];
-
-      mountConfig.TimeoutSec = "10s";
-      mountConfig.ExecSearchPath = [ "/run/current-system/sw/bin" ];
-      mountConfig.User = "colin";
-      mountConfig.AmbientCapabilities = "CAP_SETPCAP CAP_SYS_ADMIN";
-      # hardening (systemd-analyze security mnt-servo-playground.mount)
-      mountConfig.CapabilityBoundingSet = "CAP_SETPCAP CAP_SYS_ADMIN";
-      mountConfig.LockPersonality = true;
-      mountConfig.MemoryDenyWriteExecute = true;
-      mountConfig.NoNewPrivileges = true;
-      mountConfig.ProtectClock = true;
-      mountConfig.ProtectHostname = true;
-      mountConfig.RemoveIPC = true;
-      mountConfig.RestrictAddressFamilies = "AF_UNIX AF_INET AF_INET6";
-      #VVV this includes anything it reads from, e.g. /bin/sh; /nix/store/...
-      # see `systemd-analyze filesystems` for a full list
-      mountConfig.RestrictFileSystems = "@common-block @basic-api fuse";
-      mountConfig.RestrictRealtime = true;
-      mountConfig.RestrictSUIDSGID = true;
-      mountConfig.SystemCallArchitectures = "native";
-      mountConfig.SystemCallFilter = [
-        "@system-service"
-        "@mount"
-        "~@chown"
-        "~@cpu-emulation"
-        "~@keyring"
-        # could remove almost all io calls, however one has to keep `open`, and `write`, to communicate with the fuse device.
-        # so that's pretty useless as a way to prevent write access
-      ];
-      mountConfig.IPAddressDeny = "any";
-      mountConfig.IPAddressAllow = "10.0.10.5";
-      mountConfig.DevicePolicy = "closed";  # only allow /dev/{null,zero,full,random,urandom}
-      mountConfig.DeviceAllow = "/dev/fuse";
-      # mountConfig.RestrictNamespaces = true;
-    }];
-
-    systemd.targets."${systemdName}-restart-timer" = {
-      # hack unit which, when started, stops the timer (if running), and then starts it again.
-      after = [ "${systemdName}.timer" ];
-      conflicts = [ "${systemdName}.timer" ];
-      upholds = [ "${systemdName}.timer" ];
-      unitConfig.StopWhenUnneeded = true;
-    };
-    systemd.timers."${systemdName}" = {
-      timerConfig.Unit = "${systemdName}.mount";
-      timerConfig.AccuracySec = "2s";
-      timerConfig.OnActiveSec = [
-        # try to remount at these timestamps, backing off gradually
-        # there seems to be an implicit mount attempt at t=0.
-        "10s"
-        "30s"
-        "60s"
-        "120s"
-      ];
-      # cap the backoff to a fixed interval.
-      timerConfig.OnUnitActiveSec = [ "120s" ];
-    };
-  }
-
-  # this granularity of servo media mounts is necessary to support sandboxing. consider:
-  #   1. servo offline
-  #   2. launch a long-running app
-  #   3. servo comes online
-  # in order for the servo mount to be propagated into the app's namespace, we need to bind
-  # the root mountpoint into the app namespace. if we wish to only grant the app selective access
-  # to servo, we must create *multiple* mountpoints: /mnt/servo/FOO directories which always exist,
-  # and are individually bound to /mnt/.servo_ftp/FOO as the latter becomes available.
-  (remoteServo "media/archive")
-  (remoteServo "media/Books")
-  (remoteServo "media/collections")
-  # (remoteServo "media/datasets")
-  (remoteServo "media/games")
-  (remoteServo "media/Music")
-  (remoteServo "media/Pictures/macros")
-  (remoteServo "media/torrents")
-  (remoteServo "media/Videos")
-  (remoteServo "playground")
-]