From 3d4a39dc7482fb614b6f2888fb2023e61e377ddb Mon Sep 17 00:00:00 2001 From: m3ta-chiron Date: Mon, 2 Nov 2026 08:00:24 +0100 Subject: [PATCH 1/4] docs(t3code): add design and implementation plan Co-Authored-By: Claude Opus 5.5 --- .../plans/2026-11-02-t3code-nixos-module.md | 139 ++++++++++++ .../2026-11-02-t3code-nixos-module-design.md | 197 ++++++++++++++++++ 2 files changed, 336 insertions(+) create mode 100644 docs/superpowers/plans/2026-11-02-t3code-nixos-module.md create mode 100644 docs/superpowers/specs/2026-11-02-t3code-nixos-module-design.md diff --git a/docs/superpowers/plans/2026-11-02-t3code-nixos-module.md b/docs/superpowers/plans/2026-11-02-t3code-nixos-module.md new file mode 100644 index 0000000..eb0e78d --- /dev/null +++ b/docs/superpowers/plans/2026-11-02-t3code-nixos-module.md @@ -0,0 +1,139 @@ +# T3 Code als NixOS-Modul: Implementierungsplan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** T3 Code läuft aus einem Modul in m3ta-home auf m3-kratos und AZ-LT-NIX, folgt dem aktiven NetBird-Profil, und T3-Agents arbeiten auf beiden Gitea-Instanzen als `m3ta-chiron`. + +**Architecture:** m3ta-home exportiert `nixosModules.t3code` und `overlays.t3code-agent-identity`. `nixos-config` und AZ-NIX-CLIENTS binden beides ein und liefern pro Host nur `enable`, `user`, `port` und Secrets. + +**Tech Stack:** Nix Flakes, NixOS-Module, systemd, agenix, tea, NetBird 0.81. + +**Spec:** `docs/superpowers/specs/2026-11-02-t3code-nixos-module-design.md` + +## Global Constraints + +- Secret-Pfade: `/run/agenix/agent-gitea-token-m3ta` und `/run/agenix/agent-gitea-token-az`. +- Instanzen: `m3ta` = `https://code.m3ta.dev`, SSH-Port 22; `az` = `https://git.az-gruppe.com`, SSH-Port 2022; SSH-User jeweils `gitea`. +- Identität: `m3ta-chiron` / `m3ta-chiron@agentmail.to`; Schlüssel `~/.ssh/m3ta-chiron`. +- Host-Keys: `code.m3ta.dev ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIFmmqZ4GgDEXJgj8uYrZAr/EoLIA6LJGkTIyKGQD/60a` und `[git.az-gruppe.com]:2022 ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIItSijmU5YwcJcoshtmYxpxBaVA4TPaCMk23ws7KDkAH`. +- Port-Default `3773`; Interface-Default `wt0`. +- Kein `switch`, kein Push und kein Merge ohne ausdrückliche Freigabe. Arbeit in jedem Repo auf dem Branch `feat/t3code-module`. +- `nixos-config` nur in einem Worktree auf Basis von `origin/master` ändern; `secrets/rustfs-secret-key.age` im Hauptcheckout bleibt unberührt. +- Tokens nie in Logs, Testausgaben oder den Nix-Store. + +## Review Focus + +- `wt0` ist beim Dienststart da, hat aber noch keine IPv4: Das Skript wartet höchstens 60 Sekunden und bindet nie an `0.0.0.0` (Test Task 1). +- Nur ein Token ist lesbar: Genau dieser Login wird erzeugt und trägt `default: true` (Test Task 2). +- Kein Token ist lesbar: `tea` läuft ohne Login weiter, ohne Abbruch im Wrapper (Test Task 2). +- `user` fehlt oder NetBird ist aus: Die Evaluation scheitert mit klarer Meldung statt zur Laufzeit (Test Task 1). +- Git-Remote auf `git.az-gruppe.com`: SSH nutzt Port 2022 und `m3ta-chiron`, andere Hosts weiter `~/.ssh/config` (Test Task 2). + +--- + +### Task 0: Voraussetzungen durch Sascha + +Nicht durch Agents ausführbar. Task 1 hängt nur an Schritt 1, Task 4 und 5 auch an den Secrets. + +- [ ] **Step 1: `wt0`-Verhalten prüfen.** Zweites Profil anlegen, wechseln und `ip monitor link dev wt0` beobachten. Erwartet: `wt0` verschwindet und entsteht neu. Sonst bekommt Task 1 den in der Spec genannten `ip monitor`-Watcher. +- [ ] **Step 2: Schlüssel und Tokens.** Tabelle „Voraussetzungen“ der Spec abarbeiten. +- [ ] **Step 3: `.age`-Dateien** laut Tabelle „Secrets“ der Spec erzeugen, nachdem Task 4 und 5 die `secrets.nix`-Einträge ergänzt haben. + +### Task 1: NixOS-Modul + +**Files:** +- Create: `modules/nixos/t3code.nix` +- Create: `modules/nixos/t3code.test.sh` +- Modify: `flake.nix` + +**Interfaces:** +- Produces: `nixosModules.t3code` mit den Optionen `m3ta.t3code.{enable,user,port,interface,package}` aus der Spec. + +- [ ] **Step 1: Test schreiben.** `t3code.test.sh` evaluiert das Modul per `nixpkgs.lib.nixosSystem` mit einem Stub-`llm-agents.t3code` (Stil wie `profiles/sets/coding/agents/ai-memory.test.sh`) und prüft: + - `bindsTo` und `wantedBy` enthalten `sys-subsystem-net-devices-wt0.device` + - `serviceConfig.User` ist `alice`, `environment.T3CODE_PORT` ist `"3773"`, `HOME` ist `/home/alice` + - `networking.firewall.interfaces.wt0.allowedTCPPorts` ist `[3773]` + - ohne `services.netbird.enable` scheitert der Build von `system.build.toplevel` mit `m3ta.t3code requires services.netbird.enable` + - ohne `user` scheitert die Evaluation + - `enable = false` erzeugt keinen Dienst +- [ ] **Step 2: Startskript-Test ergänzen.** Das Skript mit einem Stub für `ip` und `t3` starten. Liefert der Stub sofort eine Adresse, ist der `t3`-Aufruf `serve --host 100.1.2.3`. Liefert er keine, endet das Skript mit Exit 1 (Timeout im Test per `T3CODE_ADDR_TIMEOUT=1`, Default `60`) und ruft `t3` nicht auf. +- [ ] **Step 3: Test ausführen.** `bash modules/nixos/t3code.test.sh`; erwartet: FAIL, weil das Modul fehlt. +- [ ] **Step 4: Modul schreiben** laut Abschnitt „Modul“ der Spec. Startskript per `pkgs.writeShellApplication`, Adresse per `ip -4 -o addr show dev `, Aufruf mit `exec`. In `flake.nix`: `nixosModules.t3code = ./modules/nixos/t3code.nix`. +- [ ] **Step 5: Test ausführen.** Erwartet: PASS. +- [ ] **Step 6: Commit** `feat(t3code): add NixOS module bound to the NetBird interface`. + +### Task 2: Identitäts-Overlay mit zwei Instanzen + +**Files:** +- Create: `overlays/t3code-agent-identity.nix` +- Create: `overlays/t3code-agent-identity.test.sh` +- Modify: `flake.nix` + +**Interfaces:** +- Produces: `overlays.t3code-agent-identity`. Die Datei ist `{tokenFiles ? {}}: final: prev: {…}`; die Instanzliste steht in der Datei, `tokenFiles` überschreibt Token-Pfade pro Instanzname (für Tests). Der Flake exportiert die Standardanwendung und behält `inputs.m3ta-nixpkgs.overlays` per `//`. + +- [ ] **Step 1: Test schreiben.** Overlay mit Test-Instanzen und temporären Token-Dateien anwenden, gegen einen Stub-`llm-agents.t3code` bauen und prüfen: + - beide Tokens lesbar: `tea logins` listet `m3ta` und `az` mit ihren URLs + - nur `az` lesbar: nur `az`, mit `default: true` + - keiner lesbar: `tea logins` endet mit Exit 0 und leerer Liste + - ein gefälschtes Token taucht nach dem Lauf nirgends unter `$TMPDIR` auf (Temp-Verzeichnis aufgeräumt) und nicht im Closure (`nix-store -qR` + `grep`) + - `ssh -F -G git.az-gruppe.com`: `port 2022`, `user gitea`, `identityfile ~/.ssh/m3ta-chiron` + - `ssh -F -G code.m3ta.dev`: `port 22`, `user gitea`, gleicher Schlüssel + - `ssh -F -G example.org` mit Test-`HOME` und eigener `~/.ssh/config`: nutzt deren Werte, kein `m3ta-chiron` + - im Wrapper sind `GIT_AUTHOR_NAME` und `GIT_COMMITTER_NAME` `m3ta-chiron` +- [ ] **Step 2: Test ausführen.** Erwartet: FAIL. +- [ ] **Step 3: Overlay schreiben.** Aus `git show origin/master:overlays/default.nix` in `nixos-config` übernehmen (`t3code-agent-identity`) und nur die festen Werte durch `instances` ersetzen. Der Rest-Block wird `Host * !code.m3ta.dev !git.az-gruppe.com`, aus `instances` erzeugt. Beibehalten: privates Temp-Verzeichnis pro Aufruf und der Kommentar zum `IdentityFile`-Verhalten. +- [ ] **Step 4: Test ausführen.** Erwartet: PASS. +- [ ] **Step 5: Commit** `feat(t3code): move agent identity overlay here, support two Gitea instances`. + +### Task 3: `gitIdentity.sshKey` überschreibbar + +**Files:** +- Modify: `profiles/sets/coding/agents/agents.nix:16` + +- [ ] **Step 1: Ändern.** `sshKey = lib.mkDefault "/home/m3tam3re/.ssh/gitea"`, `lib` in die Modulargumente aufnehmen. +- [ ] **Step 2: Prüfen.** Aus AZ-NIX-CLIENTS: `nix eval --raw --override-input m3ta-home path: .#nixosConfigurations.AZ-LT-NIX.config.home-manager.users."sascha.koenig".coding.agents.gitIdentity.sshKey`. Erwartet: `/home/m3tam3re/.ssh/gitea`, also unverändert ohne Override. +- [ ] **Step 3: Commit** `fix(agents): let hosts override the agent SSH key path`. + +### Task 4: AZ-NIX-CLIENTS einbinden + +**Files** (Repo `AZ-NIX-CLIENTS`): +- Modify: `hosts/common/default.nix` (Overlay nach `llm-agents-overrides`, Modul-Import) +- Modify: `hosts/common/ports.nix` (`t3code = 3773`) +- Modify: `hosts/common/users/sascha.koenig.nix` (`coding.agents.gitIdentity.sshKey = "/home/sascha.koenig/.ssh/m3ta-chiron"` in den AZ-LT-NIX-Flags) +- Modify: `hosts/AZ-LT-NIX/services/default.nix` oder neue `services/t3code.nix` (`m3ta.t3code`) +- Modify: `hosts/AZ-LT-NIX/secrets.nix`, `secrets.nix` + +**Interfaces:** +- Consumes: `nixosModules.t3code`, `overlays.t3code-agent-identity`. + +- [ ] **Step 1: Änderungen ohne Secrets einbauen.** `m3ta.t3code = { enable = true; user = "sascha.koenig"; port = config.m3ta.ports.get "t3code"; };` +- [ ] **Step 2: Bauen.** `nixos-rebuild build --flake .#AZ-LT-NIX --override-input m3ta-home path:`; erwartet: Erfolg. +- [ ] **Step 3: Werte prüfen.** Per `nix eval`: `systemd.services.t3code.serviceConfig.User` ist `sascha.koenig`, `gitIdentity.sshKey` ist der neue Pfad. +- [ ] **Step 4: Thin Client prüfen.** `nix eval .#nixosConfigurations.AZ-TC-01.config.systemd.services.t3code.enable` mit Override: Fehler oder fehlender Dienst; der Host bekommt keinen T3-Dienst. +- [ ] **Step 5: Commit** `feat(AZ-LT-NIX): run T3 Code from the m3ta-home module`. +- [ ] **Step 6: Secret-Einträge ergänzen,** sobald Saschas `.age`-Dateien da sind (Rezept: `publicKeys` aus der Spec), bauen, Commit `feat(AZ-LT-NIX): add agent Gitea tokens`. + +### Task 5: nixos-config umstellen + +**Files** (Repo `nixos-config`, Worktree auf `origin/master`): +- Modify: `hosts/common/default.nix`, `overlays/default.nix` (lokales Overlay entfernen, das aus m3ta-home einbinden, Modul-Import) +- Delete: `hosts/m3-kratos/services/t3code.nix` +- Modify: `hosts/m3-kratos/services/default.nix`, `hosts/m3-kratos/secrets.nix`, `hosts/m3-hermes/secrets.nix`, `hosts/m3-hermes/services/t3code.nix` (Kommentar zum Secret-Namen), `secrets.nix` + +**Interfaces:** +- Consumes: wie Task 4. + +- [ ] **Step 1: Worktree anlegen** und Modul sowie Overlay einbinden. Für m3-kratos: `m3ta.t3code` laut Spec. +- [ ] **Step 2: Bauen.** m3-kratos und m3-hermes mit `--override-input m3ta-home path:`; erwartet: Erfolg. +- [ ] **Step 3: Prüfen.** m3-hermes-`ExecStart` enthält weiter `--host 0.0.0.0`. m3-kratos-`ExecStart` enthält keine feste IP mehr. +- [ ] **Step 4: Commit** `refactor(m3-kratos): use the T3 Code module from m3ta-home`. +- [ ] **Step 5: Secrets umstellen,** sobald Saschas `.age`-Dateien da sind: `hermes-gitea-token` durch `agent-gitea-token-m3ta` ersetzen, `agent-gitea-token-az` nur auf m3-kratos. `git grep hermes-gitea-token` ist danach leer. Bauen, Commit `refactor(secrets): rename agent Gitea tokens per instance`. + +### Task 6: Abschluss und Rollout + +Pushes, Lock-Updates und `switch` nur nach ausdrücklicher Freigabe. + +- [ ] **Step 1:** m3ta-home mergen und pushen, in beiden Repos `nix flake update m3ta-home`, ohne Override erneut bauen. +- [ ] **Step 2:** Deployment auf AZ-LT-NIX, dann m3-kratos; m3-hermes erhält nur den Secret-Wechsel. +- [ ] **Step 3: Kriterien 2 bis 6 der Spec prüfen.** Je Profil `ss -ltnp | grep 3773` zeigt die aktuelle NetBird-IP. Je Instanz ein Testcommit aus einer T3-Session (`git log -1 --format='%an %cn'`), Push und `tea repos`. Pairing pro Netz prüfen und das Ergebnis in die Spec schreiben. diff --git a/docs/superpowers/specs/2026-11-02-t3code-nixos-module-design.md b/docs/superpowers/specs/2026-11-02-t3code-nixos-module-design.md new file mode 100644 index 0000000..e0d89c9 --- /dev/null +++ b/docs/superpowers/specs/2026-11-02-t3code-nixos-module-design.md @@ -0,0 +1,197 @@ +# T3 Code als NixOS-Modul in m3ta-home + +## Ziel + +Der T3-Code-Server wird einmal in m3ta-home definiert statt pro Host. Er läuft auf +m3-kratos (`nixos-config`) und AZ-LT-NIX (`AZ-NIX-CLIENTS`) und ist nur aus dem +gerade aktiven NetBird-Netz erreichbar. Zwischen privatem und Firmen-Control-Server +wird zur Laufzeit per NetBird-Profil gewechselt, ohne Rebuild. Von T3 gestartete +Agents committen auf beiden Hosts als `m3ta-chiron`. + +## Erfolgskriterien + +1. Beide Hosts bauen mit `m3ta.t3code.enable = true`; pro Host sind nur `enable` und `user` nötig. +2. Nach `netbird up --profile ` lauscht T3 Code auf der neuen NetBird-IP, ohne manuellen Eingriff. +3. Der Port ist nur über `wt0` offen, und der Server bindet nie an eine andere Adresse. +4. Ein Commit aus einer T3-Session auf AZ-LT-NIX hat `m3ta-chiron` als Author und Committer. +5. Pushes aus einer T3-Session nach `code.m3ta.dev` und `git.az-gruppe.com` nutzen `~/.ssh/m3ta-chiron`. +6. Tea nutzt in Repos beider Instanzen den passenden Token. + +## Nicht im Umfang + +- m3-hermes behält seinen Dienst und seine Agent-Runtime. Der Host bekommt nur das Overlay aus der neuen Quelle. +- Beide NetBird-Netze gleichzeitig (`services.netbird.clients`). +- Deklarative NetBird-Profile: Sie enthalten die Peer-Registrierung und bleiben imperativ. +- Die übrige NetBird-Konfiguration der Hosts. + +## Modul + +`modules/nixos/t3code.nix`, exportiert als `nixosModules.t3code`. + +| Option | Typ | Default | +| --- | --- | --- | +| `m3ta.t3code.enable` | bool | `false` | +| `m3ta.t3code.user` | str | keiner (Pflichtfeld) | +| `m3ta.t3code.port` | port | `3773` | +| `m3ta.t3code.interface` | str | `"wt0"` | +| `m3ta.t3code.package` | package | `pkgs.llm-agents.t3code` | + +Eine Assertion verlangt `services.netbird.enable = true`. + +`systemd.services.t3code`: + +- Läuft als `user` mit Gruppe `users`; `HOME` und `WorkingDirectory` kommen aus `config.users.users..home`. +- `T3CODE_PORT` kommt aus `port`. +- `path` enthält `/etc/profiles/per-user/` und `/run/current-system/sw`. +- `Restart = "on-failure"`, `RestartSec = 5`. +- `bindsTo`, `after` und `wantedBy` zeigen auf `sys-subsystem-net-devices-.device`. +- `after` enthält zusätzlich `netbird.service`. + +Das Startskript wartet auf die IPv4-Adresse des Interface und führt dann +`t3 serve --host ` per `exec` aus. Kommt innerhalb von 60 Sekunden keine Adresse, +beendet es sich mit Fehler und `Restart` versucht es erneut. + +Die Firewall öffnet `networking.firewall.interfaces..allowedTCPPorts = [port]`. + +Der Import steht in `hosts/common` beider Repos, `enable` und `user` in der Host-Konfiguration. + +## Profilwechsel + +Die Profile werden einmal pro Host angelegt: + +```bash +netbird profile add private +netbird up --profile private --management-url https:// +``` + +Danach genügt `netbird up --profile `. Das Profil `default` ist auf AZ-LT-NIX +der Firmen-Server. `wt0` verschwindet beim Wechsel und entsteht neu, dadurch startet +der Dienst über die Device-Unit neu. + +**Annahme, vor der Implementierung zu prüfen:** Dieses Verhalten von `wt0` ist nicht +getestet. Bleibt `wt0` beim Wechsel bestehen, kommt eine Überwachung von +Adressänderungen dazu (`ip monitor address dev wt0`), die den Dienst neu startet. + +T3-Clients brauchen pro Netz einen eigenen Eintrag und müssen im selben Netz sein. +Ob pro Adresse neu gepairt werden muss, wird beim Rollout geprüft. + +## Agent-Identität + +Das Overlay `t3code-agent-identity` wandert aus `nixos-config/overlays/default.nix` +nach m3ta-home und wird als `overlays.t3code-agent-identity` zusätzlich zu den +`m3ta-nixpkgs`-Overlays exportiert. Beide Repos binden es nach +`llm-agents.overlays.shared-nixpkgs` ein, AZ-NIX-CLIENTS zusätzlich nach +`llm-agents-overrides`. Es umhüllt `t3code` und `t3code-desktop`, also gilt die +Identität auch für die Desktop-App. + +Die Identität gilt nur für Prozesse, die T3 startet. Die globale Git-Konfiguration +auf AZ-LT-NIX bleibt `Sascha König`. Author und Committer gelten für jedes Remote. + +### Mehrere Gitea-Instanzen + +`m3ta-chiron` existiert auf zwei Instanzen, jede mit eigenem Token. Das Overlay +bekommt dafür eine Instanzliste statt der festen Werte für `code.m3ta.dev`: + +| Name | URL | SSH | Token-Datei | +| --- | --- | --- | --- | +| `m3ta` | `https://code.m3ta.dev` | `gitea@code.m3ta.dev:22` | `/run/agenix/agent-gitea-token-m3ta` | +| `az` | `https://git.az-gruppe.com` | `gitea@git.az-gruppe.com:2022` | `/run/agenix/agent-gitea-token-az` | + +Daraus erzeugt das Overlay: + +- **tea:** Der Wrapper schreibt pro lesbarer Token-Datei einen Login. Tea wählt den Login selbst anhand des Hosts im Git-Remote (`MatchLogins`), der Token geht also nur an seine Instanz. Fehlt eine Datei, entfällt nur dieser Login. `default: true` trägt der erste erzeugte Login. +- **SSH:** Pro Instanz ein `Host`-Block mit `User gitea`, Port, `IdentityFile ~/.ssh/m3ta-chiron` und `IdentitiesOnly yes`. Alle anderen Hosts nutzen weiter `~/.ssh/config`. +- **Known Hosts:** Die Host-Keys beider Instanzen, für `git.az-gruppe.com` als `[git.az-gruppe.com]:2022`. + +Eine Instanz, die nicht in der Liste steht, bekommt weder SSH-Einstellungen noch Token. + +Beide Accounts nutzen denselben Schlüssel `~/.ssh/m3ta-chiron` pro Host. + +### Secrets + +Pro Instanz gibt es eine eigene Datei, damit sich Tokens einzeln rotieren lassen und +der Arbeits-Token nur auf den Hosts liegt, die ihn brauchen. + +| Repo | Datei | `publicKeys` | Hosts | +| --- | --- | --- | --- | +| AZ-NIX-CLIENTS | `secrets/agent-gitea-token-m3ta.age` | `[AZ-LT-NIX sascha.koenig]` | AZ-LT-NIX | +| AZ-NIX-CLIENTS | `secrets/agent-gitea-token-az.age` | `[AZ-LT-NIX sascha.koenig]` | AZ-LT-NIX | +| nixos-config | `secrets/agent-gitea-token-m3ta.age` | wie bisher `hermes-gitea-token` | m3-kratos, m3-hermes | +| nixos-config | `secrets/agent-gitea-token-az.age` | `[m3-kratos] ++ users` | m3-kratos | + +m3-hermes bekommt den Arbeits-Token nicht. + +In nixos-config ersetzt die neue Datei `hermes-gitea-token.age`; der Inhalt bleibt +gleich. Alle Tokens gehören dem Account `m3ta-chiron` der jeweiligen Instanz. + +### Voraussetzungen + +| Was | Wie | Durch | +| --- | --- | --- | +| `~/.ssh/m3ta-chiron` auf AZ-LT-NIX | `ssh-keygen -t ed25519 -N "" -C chiron-t3-az-lt-nix -f ~/.ssh/m3ta-chiron` | Sascha | +| `~/.ssh/m3ta-chiron` auf m3-kratos | Vorhandenen Schlüssel prüfen, sonst wie oben mit `-C chiron-t3-m3-kratos` anlegen | Sascha | +| Public Keys | Beide Hosts beim Account `m3ta-chiron` auf beiden Instanzen eintragen | Sascha | +| Erreichbarkeit | Von m3-kratos `ssh -T -p 2022 gitea@git.az-gruppe.com` testen | Sascha | +| Tokens und `.age`-Dateien | Pro Instanz einen Token erzeugen und mit `agenix -e` verschlüsseln | Sascha | +| agenix-Einträge in den Host-`secrets.nix` | Owner ist der jeweilige T3-User | Implementierung | + +### Korrektur an `coding.agents.gitIdentity` + +`profiles/sets/coding/agents/agents.nix` setzt `sshKey` fest auf +`/home/m3tam3re/.ssh/gitea`. Auf AZ-LT-NIX steht dieser Pfad deshalb schon heute in +`GIT_SSH_COMMAND` in `hm-session-vars.sh`, obwohl die Datei dort nicht existiert. + +- `agents.nix` setzt den Wert per `lib.mkDefault`. +- AZ-LT-NIX setzt `coding.agents.gitIdentity.sshKey = "/home/sascha.koenig/.ssh/m3ta-chiron"`. + +Dieselbe `gitIdentity` exportiert `GIT_AUTHOR_*` und `GIT_SSH_COMMAND` für alle Shells, +die `hm-session-vars.sh` laden. In Nushell sind die Variablen nicht gesetzt. In Shells, +die die Datei laden, committet und pusht auf AZ-LT-NIX also auch manuelles Git als +`m3ta-chiron`. Dieses Verhalten bleibt unverändert. + +## Änderungen pro Repo + +**m3ta-home** + +- Neu: `modules/nixos/t3code.nix` +- `flake.nix`: Outputs `nixosModules.t3code` und `overlays.t3code-agent-identity` +- `agents.nix`: `sshKey` per `mkDefault` + +**nixos-config** + +- Flake-Input `m3ta-home` aktualisieren, Modul und Overlay aus m3ta-home einbinden +- Lokales Overlay und `hosts/m3-kratos/services/t3code.nix` entfernen +- m3-kratos: `m3ta.t3code = { enable = true; user = "m3tam3re"; port = config.m3ta.ports.get "t3code"; };` +- `hermes-gitea-token` durch `agent-gitea-token-m3ta` ersetzen (`secrets.nix`, m3-kratos, m3-hermes) +- `agent-gitea-token-az` ergänzen (`secrets.nix`, m3-kratos) + +**AZ-NIX-CLIENTS** + +- Flake-Input `m3ta-home` aktualisieren, Modul und Overlay einbinden +- `t3code = 3773` in `hosts/common/ports.nix` +- AZ-LT-NIX: `m3ta.t3code`, `gitIdentity.sshKey`, beide Secret-Einträge +- `secrets.nix`: Einträge für beide Tokens + +Der lokale `nixos-config`-Klon ist 112 Commits hinter `origin/master` und hat eine +lokale Änderung an `secrets/rustfs-secret-key.age`. Die Arbeit dort startet in einem +eigenen Worktree auf Basis von `origin/master`. + +## Reihenfolge + +1. Prüfung des `wt0`-Verhaltens durch Sascha, weil die Firmenverbindung dabei kurz wegfällt. +2. m3ta-home implementieren. +3. Beide Hosts mit `--override-input m3ta-home path:…` bauen, ohne `switch`. +4. Schlüssel und Secret für AZ-LT-NIX anlegen (siehe Voraussetzungen). +5. Deployment auf AZ-LT-NIX, dann m3-kratos. + +## Fehlerfälle + +- **Keine Adresse auf `wt0`:** Das Startskript scheitert nach 60 Sekunden, systemd versucht es erneut. +- **NetBird getrennt:** Der Dienst stoppt mit `wt0` und startet nur mit `wt0` wieder. T3 Code ist dann offline, aber nie außerhalb des Mesh erreichbar. +- **Schlüssel fehlt:** Der Push zu einer der beiden Instanzen scheitert, es gibt keinen Rückfall auf einen persönlichen Schlüssel. +- **Token fehlt:** T3 erkennt die betroffene Instanz nicht als Gitea. Commits und Pushes funktionieren weiter, Change Requests nicht. Die andere Instanz ist nicht betroffen. + +## Prüfung + +- `nix eval` und `nixos-rebuild build` für AZ-LT-NIX und m3-kratos. +- Nach dem Deployment: Kriterien 2 bis 6, je Profil mit `ss -ltnp`, je Instanz mit einem Testcommit und `tea repos`. -- 2.56.0 From f683e8bf43454b32a8aacd8b97f85286907c2077 Mon Sep 17 00:00:00 2001 From: m3ta-chiron Date: Mon, 2 Nov 2026 08:00:24 +0100 Subject: [PATCH 2/4] feat(t3code): add NixOS module bound to the NetBird interface Co-Authored-By: Claude Opus 5.5 --- flake.nix | 12 ++++- modules/nixos/t3code-serve.sh | 23 ++++++++ modules/nixos/t3code.nix | 94 +++++++++++++++++++++++++++++++++ modules/nixos/t3code.test.sh | 99 +++++++++++++++++++++++++++++++++++ 4 files changed, 226 insertions(+), 2 deletions(-) create mode 100644 modules/nixos/t3code-serve.sh create mode 100644 modules/nixos/t3code.nix create mode 100644 modules/nixos/t3code.test.sh diff --git a/flake.nix b/flake.nix index 57daa86..6a7ae9b 100644 --- a/flake.nix +++ b/flake.nix @@ -50,6 +50,10 @@ selfPath = self.outPath; }; + # NixOS modules — import in nixos-config via: + # imports = [ inputs.m3ta-home.nixosModules.t3code ]; + nixosModules.t3code = ./modules/nixos/t3code.nix; + # Library functions — use in nixos-config via: # m3ta-lib = inputs.m3ta-home.lib; # imports = [ (m3ta-lib.mkHome { ... }) ]; @@ -58,7 +62,11 @@ selfPath = self.outPath; }; - # Overlays (re-exports from m3ta-nixpkgs) - overlays = inputs.m3ta-nixpkgs.overlays; + # Overlays (re-exports from m3ta-nixpkgs, plus our own) + overlays = + inputs.m3ta-nixpkgs.overlays + // { + t3code-agent-identity = import ./overlays/t3code-agent-identity.nix {}; + }; }; } diff --git a/modules/nixos/t3code-serve.sh b/modules/nixos/t3code-serve.sh new file mode 100644 index 0000000..63aea6a --- /dev/null +++ b/modules/nixos/t3code-serve.sh @@ -0,0 +1,23 @@ +# Start T3 Code on the interface's current IPv4 address. The address changes +# with the NetBird profile, so it cannot be a Nix value. +# Usage: t3code-serve.sh +interface="$1" +t3="$2" +timeout="${T3CODE_ADDR_TIMEOUT:-60}" + +address="" +for ((waited = 0; waited < timeout; waited++)); do + line="$(ip -4 -o addr show dev "$interface" 2>/dev/null || true)" + if [[ "$line" =~ inet[[:space:]]+([0-9.]+)/ ]]; then + address="${BASH_REMATCH[1]}" + break + fi + sleep 1 +done + +if [[ -z "$address" ]]; then + echo "no IPv4 address on $interface after ${timeout}s" >&2 + exit 1 +fi + +exec "$t3" serve --host "$address" diff --git a/modules/nixos/t3code.nix b/modules/nixos/t3code.nix new file mode 100644 index 0000000..6620854 --- /dev/null +++ b/modules/nixos/t3code.nix @@ -0,0 +1,94 @@ +# T3 Code server, reachable from the active NetBird network only. +# +# The service follows the mesh interface: it stops when NetBird removes the +# interface and starts again with the new address when a profile comes up +# (`netbird up --profile `). It owns ~/.t3, so a desktop app on the same +# host must connect as a client with its local environment off. +# +# Wanted by the device rather than multi-user.target, so a host without NetBird +# connection does not wait for it at boot. A first deploy with the interface +# already up needs one `systemctl start t3code`. +{ + config, + lib, + pkgs, + utils, + ... +}: let + cfg = config.m3ta.t3code; + device = "${utils.escapeSystemdPath "/sys/subsystem/net/devices/${cfg.interface}"}.device"; + home = config.users.users.${cfg.user}.home; + + serve = pkgs.writeShellApplication { + name = "t3code-serve"; + runtimeInputs = [pkgs.iproute2 pkgs.coreutils]; + text = builtins.readFile ./t3code-serve.sh; + }; +in { + options.m3ta.t3code = { + enable = lib.mkEnableOption "the T3 Code server on the NetBird interface"; + + user = lib.mkOption { + type = lib.types.str; + description = "User running the server; the harnesses come from this user's profile."; + example = "m3tam3re"; + }; + + port = lib.mkOption { + type = lib.types.port; + default = 3773; + description = "Port for the HTTP/WebSocket server."; + }; + + interface = lib.mkOption { + type = lib.types.str; + default = "wt0"; + description = "NetBird interface to bind to and open the port on."; + }; + + package = lib.mkOption { + type = lib.types.package; + default = pkgs.llm-agents.t3code; + defaultText = lib.literalExpression "pkgs.llm-agents.t3code"; + description = "T3 Code package."; + }; + }; + + config = lib.mkIf cfg.enable { + assertions = [ + { + assertion = config.services.netbird.enable; + message = "m3ta.t3code requires services.netbird.enable"; + } + ]; + + systemd.services.t3code = { + description = "T3 Code server"; + after = [device "netbird.service"]; + bindsTo = [device]; + wantedBy = [device]; + + serviceConfig = { + User = cfg.user; + Group = "users"; + WorkingDirectory = home; + ExecStart = "${serve}/bin/t3code-serve ${cfg.interface} ${cfg.package}/bin/t3"; + Restart = "on-failure"; + RestartSec = "5"; + }; + + environment = { + T3CODE_PORT = toString cfg.port; + HOME = home; + }; + + # The harnesses come from the user's profile, not from the service. + path = [ + "/etc/profiles/per-user/${cfg.user}" + "/run/current-system/sw" + ]; + }; + + networking.firewall.interfaces.${cfg.interface}.allowedTCPPorts = [cfg.port]; + }; +} diff --git a/modules/nixos/t3code.test.sh b/modules/nixos/t3code.test.sh new file mode 100644 index 0000000..4421b6c --- /dev/null +++ b/modules/nixos/t3code.test.sh @@ -0,0 +1,99 @@ +#!/usr/bin/env bash +# Eval and start-script checks for nixosModules.t3code. +# Usage: t3code.test.sh +set -euo pipefail + +here="$(cd "$(dirname "$0")" && pwd)" +repo="$(cd "$here/../.." && pwd)" +fail=0 + +check() { # name, got, want + if [[ "$2" == "$3" ]]; then echo "ok $1"; else echo "FAIL $1: got '$2', want '$3'"; fail=1; fi +} +contains() { # name, haystack, needle + if [[ "$2" == *"$3"* ]]; then echo "ok $1"; else echo "FAIL $1: missing '$3' in '$2'"; fail=1; fi +} + +# ev ; prints JSON, or the error on stderr. +ev() { + nix eval --impure --json --expr " + let + flake = builtins.getFlake \"path:$repo\"; + system = flake.inputs.nixpkgs.lib.nixosSystem { + modules = [ + flake.nixosModules.t3code + ({pkgs, ...}: { + nixpkgs.hostPlatform = \"x86_64-linux\"; + nixpkgs.overlays = [(final: prev: {llm-agents.t3code = final.hello;})]; + boot.loader.grub.enable = false; + fileSystems.\"/\" = {device = \"none\"; fsType = \"tmpfs\";}; + system.stateVersion = \"25.05\"; + users.users.alice = {isNormalUser = true; home = \"/home/alice\";}; + }) + ($1) + ]; + }; + config = system.config; + in $2" +} + +on='{services.netbird.enable = true; m3ta.t3code = {enable = true; user = "alice";};}' +dev="sys-subsystem-net-devices-wt0.device" + +check "bindsTo" "$(ev "$on" 'config.systemd.services.t3code.bindsTo')" "[\"$dev\"]" +check "wantedBy" "$(ev "$on" 'config.systemd.services.t3code.wantedBy')" "[\"$dev\"]" +contains "after device" "$(ev "$on" 'config.systemd.services.t3code.after')" "$dev" +contains "after netbird" "$(ev "$on" 'config.systemd.services.t3code.after')" "netbird.service" +check "user" "$(ev "$on" 'config.systemd.services.t3code.serviceConfig.User')" '"alice"' +check "port env" "$(ev "$on" 'config.systemd.services.t3code.environment.T3CODE_PORT')" '"3773"' +check "home env" "$(ev "$on" 'config.systemd.services.t3code.environment.HOME')" '"/home/alice"' +check "firewall" "$(ev "$on" 'config.networking.firewall.interfaces.wt0.allowedTCPPorts')" '[3773]' +contains "path has user profile" \ + "$(ev "$on" 'map toString config.systemd.services.t3code.path')" "/etc/profiles/per-user/alice" + +custom='{services.netbird.enable = true; m3ta.t3code = {enable = true; user = "alice"; port = 4000; interface = "nb-x";};}' +check "custom port" "$(ev "$custom" 'config.networking.firewall.interfaces."nb-x".allowedTCPPorts')" '[4000]' +contains "custom interface" "$(ev "$custom" 'config.systemd.services.t3code.bindsTo')" 'nb\\x2dx.device' + +check "disabled has no service" \ + "$(ev '{services.netbird.enable = true;}' 'config.systemd.services ? t3code')" "false" + +err="$(ev '{m3ta.t3code = {enable = true; user = "alice";};}' 'config.system.build.toplevel.drvPath' 2>&1 || true)" +contains "netbird assertion" "$err" "m3ta.t3code requires services.netbird.enable" + +err="$(ev '{services.netbird.enable = true; m3ta.t3code.enable = true;}' 'config.systemd.services.t3code.serviceConfig.User' 2>&1 || true)" +contains "user is required" "$err" "m3ta.t3code.user" + +# ── Start script, with stubs for ip and t3 ── +stubs="$(mktemp -d)" +trap 'rm -rf "$stubs"' EXIT +cat >"$stubs/t3" <<'EOF' +#!/usr/bin/env bash +echo "t3 $*" +EOF +chmod +x "$stubs/t3" + +run() { # ip stub body + cat >"$stubs/ip" <&1 +} + +check "binds the interface address" \ + "$(run 'echo "5: wt0 inet 100.1.2.3/16 brd 100.1.255.255 scope global wt0"')" "t3 serve --host 100.1.2.3" + +set +e +out="$(run 'exit 0')"; rc=$? +set -e +check "no address exits 1" "$rc" "1" +if [[ "$out" == *"t3 serve"* ]]; then echo "FAIL no address must not start t3: $out"; fail=1; else echo "ok no address does not start t3"; fi + +set +e +out="$(run 'echo "Device does not exist" >&2; exit 1')"; rc=$? +set -e +check "missing interface exits 1" "$rc" "1" + +exit "$fail" -- 2.56.0 From 071161b6d656c64d01a2c9c7d8738dcd88f9f872 Mon Sep 17 00:00:00 2001 From: m3ta-chiron Date: Mon, 2 Nov 2026 08:00:24 +0100 Subject: [PATCH 3/4] feat(t3code): move agent identity overlay here, support two Gitea instances Co-Authored-By: Claude Opus 5.5 --- overlays/t3code-agent-identity.nix | 120 +++++++++++++++++++++++++ overlays/t3code-agent-identity.test.sh | 89 ++++++++++++++++++ 2 files changed, 209 insertions(+) create mode 100644 overlays/t3code-agent-identity.nix create mode 100644 overlays/t3code-agent-identity.test.sh diff --git a/overlays/t3code-agent-identity.nix b/overlays/t3code-agent-identity.nix new file mode 100644 index 0000000..7c3c906 --- /dev/null +++ b/overlays/t3code-agent-identity.nix @@ -0,0 +1,120 @@ +# T3 Code agents act as the m3ta-chiron bot on every host. Baked into the +# T3 packages rather than a session or service: everything T3 spawns +# inherits it, however T3 was launched (desktop launcher, systemd, shell), +# and any host installing T3 gets it. Must come AFTER shared-nixpkgs. +# +# Push auth needs ~/.ssh/m3ta-chiron on each host, with its pubkey on the +# m3ta-chiron account of each Gitea instance. A missing key fails the push +# instead of falling back to a personal key. Other hosts keep the user's own +# ssh config. +# +# Change requests need one agenix secret per instance, owned by the T3 user. +# Without it T3 cannot recognize that instance as Gitea; the others still work. +{tokenFiles ? {}}: final: prev: let + identity = { + name = "m3ta-chiron"; + email = "m3ta-chiron@agentmail.to"; + }; + + instances = [ + { + name = "m3ta"; + url = "https://code.m3ta.dev"; + host = "code.m3ta.dev"; + port = 22; + knownHost = "code.m3ta.dev"; + hostKey = "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIFmmqZ4GgDEXJgj8uYrZAr/EoLIA6LJGkTIyKGQD/60a"; + } + { + name = "az"; + url = "https://git.az-gruppe.com"; + host = "git.az-gruppe.com"; + port = 2022; + knownHost = "[git.az-gruppe.com]:2022"; + hostKey = "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIItSijmU5YwcJcoshtmYxpxBaVA4TPaCMk23ws7KDkAH"; + } + ]; + + tokenFile = instance: tokenFiles.${instance.name} or "/run/agenix/agent-gitea-token-${instance.name}"; + + giteaKnownHosts = final.writeText "gitea-known-hosts" ( + final.lib.concatMapStrings (instance: "${instance.knownHost} ${instance.hostKey}\n") instances + ); + + # ssh expands ~ from passwd, so this does not depend on $HOME. + sshConfig = final.writeText "t3-agent-ssh-config" '' + ${final.lib.concatMapStrings (instance: '' + Host ${instance.host} + User gitea + Port ${toString instance.port} + IdentityFile ~/.ssh/m3ta-chiron + IdentitiesOnly yes + UserKnownHostsFile ${giteaKnownHosts} + + '') + instances} + # Conditional: IdentityFile accumulates across matching blocks, so a + # personal entry for these hosts must not be read. + Host * ${final.lib.concatMapStringsSep " " (instance: "!${instance.host}") instances} + Include ~/.ssh/config + ''; + + # T3 only recognizes a Gitea on a custom domain through a matching tea + # login, and tea picks the login by the host of the git remote, so a token + # only reaches its own instance. The config lives in a private temp dir per + # call: tokens stay out of the nix store and a personal ~/.config/tea is left + # alone. + agentTea = final.writeShellApplication { + name = "tea"; + text = '' + config="$(${final.coreutils}/bin/mktemp -d)" + trap '${final.coreutils}/bin/rm -rf "$config"' EXIT + ${final.coreutils}/bin/mkdir "$config/tea" + default=true + ${final.lib.concatMapStrings (instance: '' + if [ -r ${tokenFile instance} ]; then + if [ "$default" = true ]; then + printf 'logins:\n' >"$config/tea/config.yml" + fi + printf ' - name: %s\n url: %s\n token: %s\n user: %s\n default: %s\n' \ + ${instance.name} ${instance.url} "$(${final.coreutils}/bin/cat ${tokenFile instance})" \ + ${identity.name} "$default" >>"$config/tea/config.yml" + default=false + fi + '') + instances} + XDG_CONFIG_HOME="$config" ${final.tea}/bin/tea "$@" + ''; + }; + + wrapperArgs = final.lib.concatStringsSep " " (final.lib.mapAttrsToList (name: value: "--set ${name} ${final.lib.escapeShellArg value}") { + GIT_AUTHOR_NAME = identity.name; + GIT_AUTHOR_EMAIL = identity.email; + GIT_COMMITTER_NAME = identity.name; + GIT_COMMITTER_EMAIL = identity.email; + JJ_USER = identity.name; + JJ_EMAIL = identity.email; + # bd otherwise falls back to the user's git user.name for its audit trail. + BEADS_ACTOR = identity.name; + GIT_SSH_COMMAND = "${final.openssh}/bin/ssh -F ${sshConfig}"; + }); + + wrapT3 = package: + final.symlinkJoin { + inherit (package) name meta passthru; + paths = [package]; + nativeBuildInputs = [final.makeWrapper]; + postBuild = '' + for program in $out/bin/*; do + wrapProgram "$program" ${wrapperArgs} --prefix PATH : ${agentTea}/bin + done + ''; + }; +in { + llm-agents = + prev.llm-agents + // { + t3code = wrapT3 prev.llm-agents.t3code; + t3code-desktop = wrapT3 prev.llm-agents.t3code-desktop; + }; +} diff --git a/overlays/t3code-agent-identity.test.sh b/overlays/t3code-agent-identity.test.sh new file mode 100644 index 0000000..4cf40bd --- /dev/null +++ b/overlays/t3code-agent-identity.test.sh @@ -0,0 +1,89 @@ +#!/usr/bin/env bash +# Checks for overlays.t3code-agent-identity with a stub t3 that runs its +# arguments inside the wrapper's environment. +# Usage: t3code-agent-identity.test.sh +set -euo pipefail + +here="$(cd "$(dirname "$0")" && pwd)" +repo="$(cd "$here/.." && pwd)" +fail=0 + +contains() { # name, haystack, needle + if [[ "$2" == *"$3"* ]]; then echo "ok $1"; else echo "FAIL $1: missing '$3' in '$2'"; fail=1; fi +} +refute() { # name, haystack, needle + if [[ "$2" == *"$3"* ]]; then echo "FAIL $1: found '$3'"; fail=1; else echo "ok $1"; fi +} + +work="$(mktemp -d)" +trap 'rm -rf "$work"' EXIT +secret="fake-token-$$-do-not-leak" + +build() { # m3ta token file, az token file + nix build --no-link --print-out-paths --impure --expr " + let + flake = builtins.getFlake \"path:$repo\"; + pkgs = import flake.inputs.nixpkgs { + system = \"x86_64-linux\"; + overlays = [ + (final: prev: { + llm-agents.t3code = final.writeShellScriptBin \"t3\" ''exec \"\$@\"''; + llm-agents.t3code-desktop = final.writeShellScriptBin \"t3-desktop\" ''exec \"\$@\"''; + }) + (import $repo/overlays/t3code-agent-identity.nix { + tokenFiles = {m3ta = \"$1\"; az = \"$2\";}; + }) + ]; + }; + in pkgs.llm-agents.t3code" +} + +printf '%s' "$secret" >"$work/token" +both="$(build "$work/token" "$work/token")" +az_only="$(build "$work/missing" "$work/token")" +none="$(build "$work/missing" "$work/missing")" + +export TMPDIR="$work/tmp" +mkdir "$TMPDIR" + +t3() { "$1/bin/t3" "${@:2}"; } + +out="$(t3 "$both" tea logins)" +contains "both: m3ta login" "$out" "https://code.m3ta.dev" +contains "both: az login" "$out" "https://git.az-gruppe.com" +refute "login list hides the token" "$out" "$secret" + +out="$(t3 "$az_only" tea logins)" +contains "az only: az login" "$out" "https://git.az-gruppe.com" +refute "az only: no m3ta login" "$out" "code.m3ta.dev" +out="$(t3 "$az_only" tea logins default)" +contains "az only: az is default" "$out" "az" + +t3 "$none" tea logins >/dev/null && echo "ok no token: tea still runs" || { echo "FAIL no token: tea failed"; fail=1; } + +if [ -n "$(ls -A "$TMPDIR")" ]; then echo "FAIL temp config left behind"; fail=1; else echo "ok temp config removed"; fi +if grep -rqF "$secret" "$both/bin"/; then echo "FAIL token in the store"; fail=1; else echo "ok token not in the wrapper"; fi + +sshcmd="$(t3 "$both" printenv GIT_SSH_COMMAND)" +g() { $sshcmd -G "$1"; } + +out="$(g git.az-gruppe.com)" +contains "az: port" "$out" "port 2022" +contains "az: user" "$out" "user gitea" +contains "az: key" "$out" "identityfile ~/.ssh/m3ta-chiron" +known="$(echo "$out" | awk '/^userknownhostsfile/ {print $2}')" +contains "az: host key" "$(cat "$known")" "[git.az-gruppe.com]:2022 ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIItSijmU5YwcJcoshtmYxpxBaVA4TPaCMk23ws7KDkAH" + +out="$(g code.m3ta.dev)" +contains "m3ta: port" "$out" "port 22" +contains "m3ta: user" "$out" "user gitea" +contains "m3ta: key" "$out" "identityfile ~/.ssh/m3ta-chiron" +contains "m3ta: host key" "$(cat "$known")" "code.m3ta.dev ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIFmmqZ4GgDEXJgj8uYrZAr/EoLIA6LJGkTIyKGQD/60a" + +refute "other hosts keep their own key" "$(g example.org)" "m3ta-chiron" + +contains "author" "$(t3 "$both" printenv GIT_AUTHOR_NAME)" "m3ta-chiron" +contains "committer" "$(t3 "$both" printenv GIT_COMMITTER_EMAIL)" "m3ta-chiron@agentmail.to" +contains "beads actor" "$(t3 "$both" printenv BEADS_ACTOR)" "m3ta-chiron" + +exit "$fail" -- 2.56.0 From 04a563ee3e21b3523d68b4920227c0d6eaad17b3 Mon Sep 17 00:00:00 2001 From: m3ta-chiron Date: Mon, 2 Nov 2026 08:00:24 +0100 Subject: [PATCH 4/4] fix(agents): let hosts override the agent SSH key path Co-Authored-By: Claude Opus 5.5 --- profiles/sets/coding/agents/agents.nix | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/profiles/sets/coding/agents/agents.nix b/profiles/sets/coding/agents/agents.nix index 67e0a79..36f4717 100644 --- a/profiles/sets/coding/agents/agents.nix +++ b/profiles/sets/coding/agents/agents.nix @@ -2,6 +2,7 @@ # Relies on coding.agents options provided by home/common/default.nix # (m3taHomeInputs.m3ta-nixpkgs.homeManagerModules.default). { + lib, m3taHomeInputs, pkgs, videoDrivers ? [], @@ -13,7 +14,7 @@ enable = true; name = "m3ta-chiron"; email = "m3ta-chiron@agentmail.to"; - sshKey = "/home/m3tam3re/.ssh/gitea"; + sshKey = lib.mkDefault "/home/m3tam3re/.ssh/gitea"; }; imports = [ -- 2.56.0