Compare commits

...
24 Commits
Author SHA1 Message Date
m3ta-chironandClaude Opus 5.5 04528f206f docs(agents): Projektlandschaft-Abschnitt mit Verweis auf PM
CLAUDE.md und AGENTS.md nennen die direkten Abhängigkeiten zu den
Nachbar-Repos unter ~/ap und verweisen auf Gesamtübersicht und
OKF-Konzept im PM-Repo.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-14 19:34:06 +01:00
m3tam3re 3809d2e276 Merge pull request 'feat(coding/agents): split headless agent CLIs into cli.nix' (#11) from feat/coding-agents-cli-split into master
Reviewed-on: #11
2026-11-14 09:33:41 +01:00
m3ta-chironandClaude Opus 5.5 ab0439cbba feat(coding/agents): split headless agent CLIs into cli.nix
Move agent-lib and beads into a desktop-free module so servers that skip
the full coding set (AZ-PRM-1) can import it on its own.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-14 09:25:59 +01:00
m3tam3re e3c8498fde Merge pull request 'feat(coding/agents): add Outlook MCP server via Microsoft Graph' (#10) from feat/outlook-graph-mcp into master
Reviewed-on: #10
2026-11-12 09:13:07 +01:00
m3ta-chiron 3b370a067d feat(coding/agents): add Outlook MCP server via Microsoft Graph
- Package marlonluo2018/microsoft_graph_mcp_server as a Python app; it talks to the Graph API, so it runs on Linux
- Register it as the Outlook entry in the shared MCP catalogue (mcp.nix)
- Authenticate with the device-code flow (`auth` tool, start then complete); tokens are stored in ~/.microsoft_graph_mcp_tokens.json
- Default USER_TIMEZONE to Europe/Berlin
2026-11-12 09:09:40 +01:00
m3ta-chiron f4ab2ab6c9 Merge pull request 'feat(coding/agents): hand the shared MCP catalogue to Claude Code' (#9) from feat/claude-mcp-integration into master 2026-11-10 20:16:00 +01:00
m3ta-chironandClaude Fable 5.1 c9f68a4361 feat(coding/agents): hand the shared MCP catalogue to Claude Code
- Move programs.mcp.servers out of agents.nix into mcp.nix so hosts that
  do not load the whole coding set (T3 Code servers) can import it alone
- Add claude-code.nix: programs.claude-code with enableMcpIntegration,
  replacing the bare llm-agents.claude-code package (would collide on
  bin/claude). home-manager delivers the catalogue as a generated plugin,
  ~/.claude/settings.json and ~/.claude.json stay writable
- ai-memory: register the session-aware Claude bridge via
  programs.claude-code.mcpServers instead of `ai-memory install-mcp`;
  activation only removes the stale user-scope entry now
- Adjust ai-memory.test.sh accordingly

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
2026-11-10 20:15:24 +01:00
m3ta-chiron b63db50485 Merge branch 'master' of code.m3ta.dev:m3tam3re/m3ta-home 2026-11-05 07:59:10 +01:00
m3ta-chiron 11ddf5e00c Merge branch 'feat/t3code-environment-file' 2026-11-05 07:58:22 +01:00
m3ta-chironandClaude Opus 5.5 2187d9263d feat(t3code): add environmentFile option
Loads an optional KEY=value file (e.g. an agenix secret) as the
service's systemd EnvironmentFile. Store paths are rejected so secrets
cannot end up in the Nix store.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-05 07:48:18 +01:00
m3ta-chiron 4e46e08e4d Merge pull request 'fix(nushell): keep loadSessionVariables off explicitly' (#8) from fix/nushell-session-variables into master 2026-11-03 18:09:08 +01:00
m3ta-chironandClaude Opus 5.5 0c509a7c90 fix(nushell): keep loadSessionVariables off explicitly
home-manager changed the default to true for stateVersion 26.11 and warns
on every host evaluation. Setting the legacy value keeps nushell's
behaviour and silences the warning.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 18:09:00 +01:00
m3ta-chiron 38d53d68c0 Merge pull request 'revert: fix(nushell): set loadSessionVariables explicitly' (#7) from revert/nushell-session-variables into master 2026-11-03 16:20:03 +01:00
m3ta-chironandClaude Opus 5.5 6f1826b96b revert: fix(nushell): set loadSessionVariables explicitly
nixos-config's home-manager pin predates the option, so every host failed
to evaluate. Set it again once that pin moves past the default change.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 16:19:57 +01:00
m3ta-chiron e7bbc6275a Merge pull request 'fix(nushell): set loadSessionVariables explicitly' (#6) from fix/nushell-session-variables into master 2026-11-03 16:18:00 +01:00
m3ta-chironandClaude Opus 5.5 6fba804e5f fix(nushell): set loadSessionVariables explicitly
home-manager changed its default and warns on every host evaluation.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 16:16:07 +01:00
m3ta-chiron 2a36d43d9d Merge pull request 'chore(shell): remove Fish configuration' (#5) from chore/remove-fish into master
Reviewed-on: #5
2026-11-02 12:27:44 +01:00
m3ta-chironandClaude Opus 5.5 a60a28fb9c docs(t3code): record the NetBird profile switch test
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 12:18:08 +01:00
m3tam3re 751f93156c Merge pull request 'Feat/t3code module' (#4) from feat/t3code-module into master
Reviewed-on: #4
2026-11-02 11:01:14 +01:00
m3ta-chironandClaude Opus 5.5 04a563ee3e fix(agents): let hosts override the agent SSH key path
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 08:00:24 +01:00
m3ta-chironandClaude Opus 5.5 071161b6d6 feat(t3code): move agent identity overlay here, support two Gitea instances
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 08:00:24 +01:00
m3ta-chironandClaude Opus 5.5 f683e8bf43 feat(t3code): add NixOS module bound to the NetBird interface
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 08:00:24 +01:00
m3ta-chironandClaude Opus 5.5 3d4a39dc74 docs(t3code): add design and implementation plan
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 08:00:24 +01:00
m3ta-chironandClaude Opus 5.5 396c41d99d chore(shell): remove Fish configuration
Nushell is the only interactive shell now. base.shell.fish.enable stays as a
deprecated no-op with a warning, because AZ-NIX-CLIENTS and AZ-NIX-SERVERS
still set it and would otherwise fail to evaluate after a lock update.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-01 13:23:07 +01:00
29 changed files with 1002 additions and 182 deletions

No files matched your search

+11
View File
@@ -126,3 +126,14 @@ bd prime # Refresh Beads context
**Architecture in one line:** issues live in a local Dolt DB; sync uses `refs/dolt/data` on your git remote; `.beads/issues.jsonl` is a passive export. See https://github.com/gastownhall/beads/blob/main/docs/core-concepts/sync-concepts.md for details and anti-patterns.
<!-- END BEADS CODEX SETUP -->
<!-- BEGIN PM-PROJEKTLANDSCHAFT -->
## Projektlandschaft
Dieses Repo ist eines von mehreren Projekten unter `~/ap`. Die Gesamtübersicht (Zweck, Remotes, Abhängigkeiten aller Repos) und das OKF-Wissensbündel liegen im privaten PM-Repo (`~/ap/PM/CLAUDE.md`, `~/ap/PM/.okf/`); das Konzept zu diesem Repo ist `.okf/systems/m3ta-home.md`. Ist das PM-Repo nicht vorhanden, diesen Abschnitt ignorieren. Ändern sich Zweck, Schnittstellen oder Abhängigkeiten dieses Repos, dort das Konzept aktualisieren und `.okf/log.md` ergänzen.
Direkte Abhängigkeiten:
- Konsumiert Pakete aus `m3ta-nixpkgs` (u. a. `agent-lib`, `talk`).
- `profiles/sets/coding/agents/claude-skills.nix` spiegelt `~/.agents/skills` (Ziel von `agent-lib sync` aus `agent-prod`) nach `~/.claude/skills` — Änderungen dort wirken auf alle Skills in Claude Code.
<!-- END PM-PROJEKTLANDSCHAFT -->
+11
View File
@@ -75,3 +75,14 @@ _Add a brief overview of your project architecture_
## Conventions & Patterns
_Add your project-specific conventions here_
<!-- BEGIN PM-PROJEKTLANDSCHAFT -->
## Projektlandschaft
Dieses Repo ist eines von mehreren Projekten unter `~/ap`. Die Gesamtübersicht (Zweck, Remotes, Abhängigkeiten aller Repos) und das OKF-Wissensbündel liegen im privaten PM-Repo (`~/ap/PM/CLAUDE.md`, `~/ap/PM/.okf/`); das Konzept zu diesem Repo ist `.okf/systems/m3ta-home.md`. Ist das PM-Repo nicht vorhanden, diesen Abschnitt ignorieren. Ändern sich Zweck, Schnittstellen oder Abhängigkeiten dieses Repos, dort das Konzept aktualisieren und `.okf/log.md` ergänzen.
Direkte Abhängigkeiten:
- Konsumiert Pakete aus `m3ta-nixpkgs` (u. a. `agent-lib`, `talk`).
- `profiles/sets/coding/agents/claude-skills.nix` spiegelt `~/.agents/skills` (Ziel von `agent-lib sync` aus `agent-prod`) nach `~/.claude/skills` — Änderungen dort wirken auf alle Skills in Claude Code.
<!-- END PM-PROJEKTLANDSCHAFT -->
+1 -2
View File
@@ -142,7 +142,7 @@ If you bring a work NixOS machine into your fleet, you can use the same `m3ta-ho
This gives you:
- Your familiar shell setup (fish, starship, nushell)
- Your familiar shell setup (starship, nushell)
- Your CLI tools (fzf, bat, eza, zoxide, etc.)
- Your editor configs (neovim, zed)
- Work git identity and SSH configuration automatically
@@ -162,7 +162,6 @@ Every module in m3ta-home has an `enable` option. Base modules default to `true`
```
base.cliTools.ansible.enable # Ansible (config rollout to servers)
base.shell.fish.enable # Fish shell
base.shell.nushell.enable # Nushell
base.shell.starship.enable # Starship prompt
base.cliTools.fzf.enable # Fuzzy finder
@@ -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 <interface>`, 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 <config> -G git.az-gruppe.com`: `port 2022`, `user gitea`, `identityfile ~/.ssh/m3ta-chiron`
- `ssh -F <config> -G code.m3ta.dev`: `port 22`, `user gitea`, gleicher Schlüssel
- `ssh -F <config> -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:<m3ta-home> .#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:<m3ta-home>`; 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:<m3ta-home>`; 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.
@@ -0,0 +1,199 @@
# 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 <name>` 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` |
| `m3ta.t3code.environmentFile` | null oder absoluter Pfad außerhalb des Stores | `null` |
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.<user>.home`.
- `T3CODE_PORT` kommt aus `port`.
- `environmentFile` wird, falls gesetzt, als `EnvironmentFile` geladen (`KEY=value`-Zeilen, z. B. ein agenix-Secret).
- `path` enthält `/etc/profiles/per-user/<user>` und `/run/current-system/sw`.
- `Restart = "on-failure"`, `RestartSec = 5`.
- `bindsTo`, `after` und `wantedBy` zeigen auf `sys-subsystem-net-devices-<interface>.device`.
- `after` enthält zusätzlich `netbird.service`.
Das Startskript wartet auf die IPv4-Adresse des Interface und führt dann
`t3 serve --host <ip>` 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.<interface>.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://<privater-server>
```
Danach genügt `netbird up --profile <name>`. 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.
**Bestätigt am 2026-11-02 auf AZ-LT-NIX:** Wechsel zwischen den Netzen über den
NetBird-Client funktioniert, T3 Code folgt ohne Eingriff. Ein Watcher für
Adressänderungen ist nicht nötig.
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`.
+10 -2
View File
@@ -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 {};
};
};
}
+23
View File
@@ -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> <t3 binary>
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"
+109
View File
@@ -0,0 +1,109 @@
# 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 <name>`). 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.";
};
environmentFile = lib.mkOption {
type = lib.types.nullOr (lib.types.pathWith {
inStore = false;
absolute = true;
});
default = null;
example = "/run/agenix/t3code-env";
description = ''
File with `KEY=value` lines loaded into the server's environment
(systemd `EnvironmentFile`), e.g. tokens for the harnesses. Keep it
outside the Nix store, for example as an agenix secret.
'';
};
};
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";
EnvironmentFile = lib.mkIf (cfg.environmentFile != null) cfg.environmentFile;
};
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];
};
}
+99
View File
@@ -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 <module-attrs> <expression over `config`>; 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" <<EOF
#!/usr/bin/env bash
$1
EOF
chmod +x "$stubs/ip"
PATH="$stubs:$PATH" T3CODE_ADDR_TIMEOUT=1 bash "$here/t3code-serve.sh" wt0 "$stubs/t3" 2>&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"
+120
View File
@@ -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;
};
}
+89
View File
@@ -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"
+1 -2
View File
@@ -1,4 +1,4 @@
# Carapace — multi-shell completion engine with Fish, Nushell, and Bash integration.
# Carapace — multi-shell completion engine with Nushell and Bash integration.
{
config,
lib,
@@ -13,7 +13,6 @@ in {
config = mkIf cfg.enable {
programs.carapace = {
enable = true;
enableFishIntegration = true;
enableNushellIntegration = true;
enableBashIntegration = true;
};
-1
View File
@@ -13,7 +13,6 @@ in {
config = mkIf cfg.enable {
programs.eza = {
enable = true;
enableFishIntegration = true;
enableBashIntegration = true;
extraOptions = ["-l" "--icons" "--git" "-a"];
};
-1
View File
@@ -16,7 +16,6 @@ in {
programs.fzf =
{
enable = true;
enableFishIntegration = true;
colors = {
"fg" = "#${config.colorScheme.palette.base05}";
"bg" = "#${config.colorScheme.palette.base00}";
-1
View File
@@ -17,7 +17,6 @@ in {
programs.nix-index = {
enable = true;
enableBashIntegration = true;
enableFishIntegration = true;
enableNushellIntegration = true;
};
};
+1 -2
View File
@@ -1,4 +1,4 @@
# Zoxide — smarter cd with Fish and Nushell integration.
# Zoxide — smarter cd with Nushell integration.
{
config,
lib,
@@ -13,7 +13,6 @@ in {
config = mkIf cfg.enable {
programs.zoxide = {
enable = true;
enableFishIntegration = true;
enableNushellIntegration = true;
};
};
+1 -1
View File
@@ -1,7 +1,7 @@
# profiles/base/default.nix — Always loaded on every host.
#
# Provides:
# - Shell (nushell, fish, starship) with enable options
# - Shell (nushell, starship) with enable options
# - CLI tools (bat, carapace, direnv, eza, fzf, lf, nitch, television, zellij, zoxide)
# - Secrets management (pass-wayland)
# - Color scheme (dracula)
+1 -1
View File
@@ -1,4 +1,4 @@
# Shell aggregator — imports Nushell (primary), Fish, and Starship prompt.
# Shell aggregator — imports Nushell and Starship prompt.
{...}: {
imports = [
./nushell.nix
+10 -112
View File
@@ -1,118 +1,16 @@
# Fish shell configuration exposed under the new base namespace.
# Deprecated: Fish was removed in favour of Nushell. The option stays as a no-op
# so configs that still set it keep evaluating; delete once none do.
{
config,
lib,
...
}:
with lib; let
cfg = config.base.shell.fish;
in {
# Enabled by default — base modules are always-on.
options.base.shell.fish.enable = (mkEnableOption "enable fish shell") // {default = true;};
config = mkIf cfg.enable {
programs.fish = {
enable = true;
interactiveShellInit = ''
# Fish colors using universal nix-colors palette
# Text colors
set -g fish_color_normal ${config.colorScheme.palette.base05} # text
set -g fish_color_param ${config.colorScheme.palette.base05} # text
set -g fish_color_comment ${config.colorScheme.palette.base03} # muted
set -g fish_color_autosuggestion ${config.colorScheme.palette.base03} # muted
# Command colors
set -g fish_color_command ${config.colorScheme.palette.base0D} # accent6 (blue)
set -g fish_color_quote ${config.colorScheme.palette.base0A} # accent3 (yellow)
set -g fish_color_redirection ${config.colorScheme.palette.base0E} # accent7 (purple)
set -g fish_color_end ${config.colorScheme.palette.base08} # accent1 (red)
set -g fish_color_error ${config.colorScheme.palette.base08} # accent1 (red)
set -g fish_color_operator ${config.colorScheme.palette.base0C} # accent5 (cyan)
set -g fish_color_escape ${config.colorScheme.palette.base09} # accent2 (orange)
# Path colors
set -g fish_color_cwd ${config.colorScheme.palette.base0B} # accent4 (green)
set -g fish_color_cwd_root ${config.colorScheme.palette.base08} # accent1 (red)
set -g fish_color_valid_path --underline
# Interactive colors
set -g fish_color_match ${config.colorScheme.palette.base0B} # accent4 (green)
set -g fish_color_selection --background=${config.colorScheme.palette.base02} # overlay
set -g fish_color_search_match --background=${config.colorScheme.palette.base02} # overlay
set -g fish_color_history_current --bold
set -g fish_color_user ${config.colorScheme.palette.base0B} # accent4 (green)
set -g fish_color_host ${config.colorScheme.palette.base0D} # accent6 (blue)
set -g fish_color_cancel -r
# Pager colors
set -g fish_pager_color_completion normal
set -g fish_pager_color_description ${config.colorScheme.palette.base03} # muted
set -g fish_pager_color_prefix ${config.colorScheme.palette.base0E} # accent7 (purple)
set -g fish_pager_color_progress ${config.colorScheme.palette.base0B} # accent4 (green)
'';
loginShellInit = ''
set -x NIX_PATH nixpkgs=channel:nixos-unstable
set -x NIX_LOG info
set -x WEBKIT_DISABLE_COMPOSITING_MODE 1
set -x TERMINAL ghostty
set -x EDITOR nvim
set -x VISUAL zed
set -x XDG_DATA_HOME $HOME/.local/share
set -x FZF_CTRL_R_OPTS "
--preview='bat --color=always -n {}'
--preview-window up:3:hidden:wrap
--bind 'ctrl-/:toggle-preview'
--bind 'ctrl-y:execute-silent(echo -n {2..} | wl-copy)+abort'
--color header:bold
--header 'Press CTRL-Y to copy command into clipboard'"
set -x FZF_DEFAULT_COMMAND fd --type f --exclude .git --follow --hidden
set -x FZF_CTRL_T_COMMAND "$FZF_DEFAULT_COMMAND"
set -x FLAKE $HOME/p/nixos/nixos-config
source /run/agenix/${config.home.username}-secrets
if test (tty) = "/dev/tty1"
exec uwsm start -F /run/current-system/sw/bin/Hyprland
end
if test (tty) = "/dev/tty2"
exec gamescope -O HDMI-A-1 -W 1920 -H 1080 --adaptive-sync --hdr-enabled --rt --steam -- steam -pipewire-dmabuf -tenfoot
end
'';
shellAbbrs = {
".." = "cd ..";
"..." = "cd ../..";
b = "yazi";
ls = "eza";
l = "eza -l --icons --git -a";
lt = "eza --tree --level=2 --long --icons --git";
grep = "rg";
ps = "procs";
just = "just --unstable";
node = "bun";
npx = "bunx";
fs = "du -ah . | sort -hr | head -n 10";
n = "nix";
nd = "nix develop -c $SHELL";
ns = "nix shell";
nsn = "nix shell nixpkgs#";
nb = "nix build";
nbn = "nix build nixpkgs#";
nf = "nix flake";
nr = "sudo nixos-rebuild --flake .";
nrs = "sudo nixos-rebuild switch --flake .#(uname -n)";
snr = "sudo nixos-rebuild --flake .";
snrs = "sudo nixos-rebuild --flake . switch";
hm = "home-manager --flake .";
hms = "home-manager --flake . switch";
hmr = "cd ~/projects/nix-configurations; nix flake lock --update-input dotfiles; home-manager --flake .#(whoami)@(hostname) switch";
tsu = "sudo tailscale up";
tsd = "sudo tailscale down";
vi = "nvim";
vim = "nvim";
};
};
}: {
options.base.shell.fish.enable = lib.mkOption {
type = lib.types.bool;
default = false;
visible = false;
description = "Deprecated no-op. Fish is no longer configured by m3ta-home.";
};
config.warnings = lib.optional config.base.shell.fish.enable "base.shell.fish.enable has no effect anymore: Fish was removed from m3ta-home. Drop the setting.";
}
+3
View File
@@ -15,6 +15,9 @@ in {
config = mkIf cfg.enable {
programs.nushell = {
enable = true;
# Keep the pre-26.11 behaviour; set explicitly to silence the
# home-manager default-change warning.
loadSessionVariables = false;
envFile.text = ''
$env.config.show_banner = false
$env.NIX_PATH = "nixpkgs=channel:nixos-unstable"
-1
View File
@@ -13,7 +13,6 @@ in {
config = mkIf cfg.enable {
programs.starship = {
enable = true;
enableFishIntegration = true;
enableNushellIntegration = true;
settings = {
format = "$all$character";
-1
View File
@@ -94,7 +94,6 @@
programs.ghostty = {
enable = true;
enableFishIntegration = true;
enableBashIntegration = true;
settings = {
font-family = "Fira Code";
+8 -43
View File
@@ -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,54 +14,21 @@
enable = true;
name = "m3ta-chiron";
email = "m3ta-chiron@agentmail.to";
sshKey = "/home/m3tam3re/.ssh/gitea";
sshKey = lib.mkDefault "/home/m3tam3re/.ssh/gitea";
};
imports = [
# ai-memory client, skill mirror and OpenCode config
# ai-memory client, skill mirror, shared MCP catalogue, OpenCode and
# Claude Code config
./ai-memory.nix
./claude-skills.nix
./mcp.nix
./opencode.nix
./claude-code.nix
# headless agent CLIs (beads, agent-lib)
./cli.nix
];
programs.mcp = {
enable = true;
servers = {
ContextMode = {
command = "bash";
args = ["-c" "exec bunx context-mode@latest"];
};
DeepWiki = {
url = "https://mcp.deepwiki.com/mcp";
};
Exa = {
command = "bash";
args = ["-c" "EXA_API_KEY=$(cat /run/agenix/exa-key) exec bunx exa-mcp-server@latest tools=web_search_exa"];
};
SallyAI = {
url = "https://app.sally.io/api/v1/McpExternal";
};
Metabase = {
url = "https://kpi.az-gruppe.com/api/metabase-mcp";
};
Outline = {
url = "https://wiki.az-gruppe.com/mcp";
};
Playwright = {
command = "bash";
args = ["-c" "exec bunx @playwright/mcp@latest"];
};
Ref = {
command = "bash";
args = ["-c" "REF_API_KEY=$(cat /run/agenix/ref-key) exec bunx ref-tools-mcp@latest"];
};
Teams = {
command = "bunx";
args = ["-y" "@floriscornel/teams-mcp@latest"];
};
};
};
# NOTE: llm-agent packages are consumed via the `llm-agents` namespace
# (pkgs.llm-agents.*), provided by numtide/llm-agents.nix's
# `overlays.shared-nixpkgs`. The consumer's nixos-config MUST apply that
@@ -68,10 +36,7 @@
# silently falling back to (outdated) nixpkgs attributes.
home.packages = with pkgs; [
agenix-cli
agent-lib
llm-agents.agent-browser
llm-agents.beads
llm-agents.claude-code
llm-agents.claude-desktop
crunch
docker-sbx
+21 -11
View File
@@ -3,12 +3,13 @@
# The server runs on m3-hermes (nixos-config) and is reached at
# memory.m3ta.dev; no server runs on clients. Hybrid setup:
# - Nix owns the package, the client config (server URL + bearer token
# file), the OpenCode MCP entry (via programs.mcp, since opencode.json
# is a home-manager symlink) and the scope markers (~/.ai-memory.toml
# plus one marker per workspace directory).
# - Activation runs ai-memory's own installers for the lifecycle hooks,
# the session-aware Claude Code MCP entry and the skills, so generated
# files always match the installed ai-memory version.
# file), the MCP entries (programs.mcp for OpenCode, and a session-aware
# override in programs.claude-code.mcpServers for Claude Code, both
# delivered through the agents' enableMcpIntegration) and the scope
# markers (~/.ai-memory.toml plus one marker per workspace directory).
# - Activation runs ai-memory's own installers for the lifecycle hooks and
# the skills, so generated files always match the installed ai-memory
# version.
#
# The bearer token (an `aim_` API key, one per host) is an agenix secret the
# host repo provides at `tokenFile`. It is never copied into a generated
@@ -100,6 +101,18 @@ in {
args = ["mcp-bridge" "--no-session-id" "--server-url" "${cfg.serverUrl}/mcp"];
};
# Claude Code gets the same server name through
# programs.claude-code.enableMcpIntegration, but session-aware: the stdio
# bridge forwards the lifecycle-hook session id and reads the token file
# itself. (A plain HTTP entry carries no credentials, and Claude Code then
# tries OAuth client registration, which ai-memory does not offer.)
# Claude Code's own mcpServers take precedence over the shared entry, so
# this is one server, not two.
programs.claude-code.mcpServers.ai-memory = mkIf (elem "claude-code" cfg.agents) {
command = exe;
args = ["mcp-bridge" "--server-url" "${cfg.serverUrl}/mcp"];
};
home.file =
{
# Client config: `ai-memory hook`, `mcp-bridge` and the installers
@@ -130,13 +143,10 @@ in {
'')
cfg.agents}
${optionalString (elem "claude-code" cfg.agents) ''
# The MCP entry now comes from programs.claude-code (see above);
# drop the user-scope entry earlier versions wrote into ~/.claude.json.
export PATH="${pkgs.llm-agents.claude-code}/bin:$PATH"
run claude mcp remove ai-memory -s user >/dev/null 2>&1 || true
# --session-aware: stdio bridge that reads the token file itself. A
# plain HTTP entry carries no credentials, and Claude Code then tries
# OAuth client registration, which ai-memory does not offer.
run ${exe} install-mcp --client claude-code --apply --session-aware \
--server-url ${escapeShellArg "${cfg.serverUrl}/mcp"}
''}
# Into ~/.agents/skills; claude-skills-sync mirrors them to Claude.
run ${exe} install-skills --scope global --agent agents
@@ -51,7 +51,12 @@ check "hooks opencode2" "$act" "install-hooks --agent opencode2 --apply"
check "auth-token symlink" "$act" "ln -sfn /run/agenix/ai-memory-token "
refute "no token on command lines" "$act" "--auth-token"
refute "activation must not write opencode.json (home-manager symlink)" "$act" "install-mcp --client opencode"
check "claude mcp is the session-aware bridge" "$act" "install-mcp --client claude-code --apply --session-aware"
refute "activation no longer registers the claude mcp itself" "$act" "install-mcp --client claude-code"
check "stale user-scope claude entry is removed" "$act" "claude mcp remove ai-memory -s user"
claude="$(ev programs.claude-code.mcpServers.ai-memory.args --apply 'builtins.concatStringsSep " "')"
check "claude mcp is the session-aware bridge" "$claude" "mcp-bridge --server-url https://memory.m3ta.dev/mcp"
refute "claude mcp forwards the session id" "$claude" "--no-session-id"
# Missing token file: skip with a warning, exit 0, never call ai-memory.
script="$(printf '%s\n' "$act" | sed 's|/run/agenix/ai-memory-token|/nonexistent/ai-memory-token|g')"
@@ -0,0 +1,20 @@
# Claude Code via home-manager `programs.claude-code`.
#
# enableMcpIntegration hands the shared programs.mcp catalogue (mcp.nix) to
# Claude Code the same way opencode.nix does for OpenCode: home-manager
# generates a plugin carrying .mcp.json and registers it (as a personal plugin
# under ~/.claude/skills/claude-code-home-manager on home-manager master, via a
# `--plugin-dir` wrapper on release-26.05). Nothing in ~/.claude is turned
# into a store symlink: settings.json (ai-memory hooks, plugins, theme) and
# ~/.claude.json (logins) stay writable for Claude Code itself.
#
# Do NOT add llm-agents.claude-code to home.packages next to this module;
# programs.claude-code installs its (possibly wrapped) package and a second
# `claude` would collide in the profile.
{pkgs, ...}: {
programs.claude-code = {
enable = true;
package = pkgs.llm-agents.claude-code;
enableMcpIntegration = true;
};
}
+11
View File
@@ -0,0 +1,11 @@
# Headless agent CLIs — safe for servers without a desktop.
# Imported by agents.nix; servers that skip the full "coding" set (e.g.
# AZ-PRM-1 in AZ-NIX-SERVERS) can import this file on its own.
# Packages from the `llm-agents` namespace need numtide/llm-agents.nix's
# `overlays.shared-nixpkgs` in the consumer (see agents.nix).
{pkgs, ...}: {
home.packages = with pkgs; [
agent-lib
llm-agents.beads
];
}
+51
View File
@@ -0,0 +1,51 @@
# Shared MCP server catalogue (home-manager `programs.mcp`).
#
# Single source for every agent that integrates with programs.mcp:
# OpenCode (opencode.nix, enableMcpIntegration) and Claude Code
# (claude-code.nix, enableMcpIntegration). ai-memory adds its own entry in
# ai-memory.nix. Hosts that do not load the whole coding set (servers running
# T3 Code) import this file directly.
{pkgs, ...}: {
programs.mcp = {
enable = true;
servers = {
ContextMode = {
command = "bash";
args = ["-c" "exec bunx context-mode@latest"];
};
DeepWiki = {
url = "https://mcp.deepwiki.com/mcp";
};
Exa = {
command = "bash";
args = ["-c" "EXA_API_KEY=$(cat /run/agenix/exa-key) exec bunx exa-mcp-server@latest tools=web_search_exa"];
};
SallyAI = {
url = "https://app.sally.io/api/v1/McpExternal";
};
Metabase = {
url = "https://kpi.az-gruppe.com/api/metabase-mcp";
};
Outline = {
url = "https://wiki.az-gruppe.com/mcp";
};
# Outlook mail, calendar and contacts via Microsoft Graph. First use:
# call the `auth` tool (start, then complete) for the device-code login.
Outlook = {
command = "${pkgs.callPackage ./microsoft-graph-mcp-server.nix {}}/bin/microsoft-graph-mcp-server";
};
Playwright = {
command = "bash";
args = ["-c" "exec bunx @playwright/mcp@latest"];
};
Ref = {
command = "bash";
args = ["-c" "REF_API_KEY=$(cat /run/agenix/ref-key) exec bunx ref-tools-mcp@latest"];
};
Teams = {
command = "bunx";
args = ["-y" "@floriscornel/teams-mcp@latest"];
};
};
};
}
@@ -0,0 +1,57 @@
# Microsoft Graph MCP server (mail, calendar, contacts of the signed-in M365
# account) by marlonluo2018. Chosen over the author's outlook-mcp-server,
# which drives the Outlook desktop client through win32COM and therefore only
# runs on Windows; this one talks to the Graph API and is plain Python.
#
# Not on PyPI, so it is built from the GitHub source. Auth is the device-code
# flow against Microsoft's public client id (no Azure app registration);
# tokens land in ~/.microsoft_graph_mcp_tokens.json. Settings come from env
# vars (CLIENT_ID, TENANT_ID, USER_TIMEZONE, ...); the optional .env the
# upstream README mentions would sit inside the store and is not used.
{
lib,
python3Packages,
fetchFromGitHub,
}:
python3Packages.buildPythonApplication {
pname = "microsoft-graph-mcp-server";
version = "0.1.0-unstable-2026-11-12";
pyproject = true;
src = fetchFromGitHub {
owner = "marlonluo2018";
repo = "microsoft_graph_mcp_server";
rev = "b4c2725ee9e3d47dce8641d5ca90434aca16c9db";
hash = "sha256-RSPyjq3Zu9WBbihI4yuB3PhxgRaF9G2gl+xaslnBdJI=";
};
build-system = with python3Packages; [hatchling];
dependencies = with python3Packages; [
mcp_1 # upstream targets the 1.x low-level Server API (list_tools decorators); mcp 2.x removed it
msal
httpx
pydantic
pydantic-settings
python-dotenv
click
rich
typing-extensions
tzdata
pillow # optional image attachments (MULTIMODAL_SUPPORTED)
];
# Upstream defaults USER_TIMEZONE to Asia/Shanghai; the env still wins.
makeWrapperArgs = ["--set-default" "USER_TIMEZONE" "Europe/Berlin"];
# server.py builds an MSAL client at import time, which hits the network,
# so only the config module is import-checked in the sandbox.
pythonImportsCheck = ["microsoft_graph_mcp_server.config"];
meta = {
description = "MCP server for Microsoft Graph (Outlook mail, calendar, contacts)";
homepage = "https://github.com/marlonluo2018/microsoft_graph_mcp_server";
license = lib.licenses.mit;
mainProgram = "microsoft-graph-mcp-server";
};
}