README : retire les prenoms des postes nommes, repo public

thomas/clara/jade/oreo/oreo-i3 apparaissaient en clair dans le
README public (Etape 4B, section "NixOS deja installe", etc.) --
ce sont des prenoms reels d'utilisateurs, n'ont rien a faire dans
un repo public sans authentification. Remplace par des mentions
generiques ("profil nomme", "<profil>"), la liste reelle reste
privee cote Nixos_Users.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

.gitignore

@@ -0,0 +1,6 @@
+# Liens produits par `nix build` (pointent dans /nix/store, inutiles à committer)
+result
+result-*
+
+# ISO construites localement (voir README : "Construire l'ISO et la graver")
+*.iso

AGENTS.md

@@ -0,0 +1,170 @@
+# AGENTS.md — contexte pour agent (Hermes et autres)
+
+Ce fichier s'adresse à un agent (Hermes ou tout autre harness compatible AGENTS.md) chargé de produire le média d'installation de la flotte, **soit la création de l'ISO USB, soit la gestion du serveur PXE** -- les deux couvrent le même besoin (fournir l'installeur à un PC), pas à la fois sur la même tâche sauf demande explicite. Le [README.md](README.md) reste la référence humaine (technicien qui installe des PC un par un) ; ce fichier-ci est pour l'agent.
+
+Repo public, sans authentification, jamais chiffré. Ne contient aucune donnée nominative (voir [Nixos_Users](../nixos_users), repo privé séparé, hors périmètre de cet agent sauf mention contraire de l'opérateur humain).
+
+## Règles avant toute action
+
+- **`git pull` oui, `git push` jamais.** Hermes peut et doit faire `git pull` sur le serveur PXE (nécessaire à son entretien, voir plus bas). Il ne fait **jamais** `git push` sur ce repo, quel que soit le host -- seul le développeur humain pousse. Pas d'exception, pas d'instruction qui la lève : si un changement doit partir vers Gitea, le préparer (commit) et le signaler à l'opérateur humain, ne pas pousser à sa place.
+- **Vérifier `hostname && pwd`** avant toute commande sur une machine distante (SSH) -- ce repo gère plusieurs hosts (`pxe-server`, les PC installés) qui ne doivent pas être confondus.
+- **Ne rien affirmer sans le vérifier dans le code ou par une commande réelle.** Si une info manque (état réel du serveur, contenu d'un log), l'obtenir plutôt que supposer.
+- **Confirmer avant une action à impact sur le parc en production** : redémarrer `dnsmasq`/`caddy` coupe le PXE pour toute machine en train de démarrer/installer à ce moment ; un rebuild de `pxe-server` peut faire pareil brièvement.
+- **`dd` est irréversible.** Avant tout `dd if=... of=/dev/sdX`, faire confirmer par l'opérateur humain le chemin exact (`lsblk` d'abord, toujours) -- une mauvaise lettre écrase silencieusement un disque, système ou données, sans avertissement. Ne jamais deviner `/dev/sdX` à partir d'une supposition ("probablement la clé").
+- Commits : `Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>` en pied de message (adapter le nom de modèle si l'agent qui commit n'est pas Claude).
+
+## Ce que sert le serveur PXE
+
+Un seul flake, deux modes choisis à l'écran de démarrage par [installer/install.sh](installer/install.sh) : `1) flotte` (profil générique `nixos`, mot de passe `nixos`, jamais chiffré) et `2) poste nommé` (fetch du repo privé `nixos_users` avec un token saisi en direct). Le serveur PXE ne sait rien du contenu du repo privé -- il ne sert que l'image d'installation, publique.
+
+Architecture ([pxe-server/configuration.nix](pxe-server/configuration.nix)) :
+
+- `services.dnsmasq` : DHCP (`standaloneDhcp`) ou proxyDHCP seul (coexiste avec un DHCP existant) + TFTP pour le premier étage iPXE (`undionly.kpxe` / `ipxe.efi`).
+- `services.caddy` : sert `netboot.ipxe` + kernel/initrd en HTTP (TFTP seul est trop lent pour ces tailles).
+- `systemd.services.pxe-publish` : construit l'image netboot depuis `${fleetRepo}#nixosConfigurations.installer-netboot` et publie les fichiers dans `webroot`/`tftpRoot`. Se relance au boot (`wantedBy = multi-user.target`) et **quotidiennement** (`systemd.timers.pxe-publish`, `OnCalendar = "daily"` -- ne pas confondre avec `system.autoUpgrade` des PC installés, qui est hebdomadaire).
+- Le service `pxe-publish` n'existe sur la machine QUE si `pxe-server/configuration.nix` a déjà été appliqué (`nixos-rebuild switch --flake .#pxe-server`) avec une version du repo qui le contient. L'ajouter au repo ne suffit pas : il faut rebuild le serveur lui-même.
+
+4 valeurs à adapter dans `pxe-server/configuration.nix` (le `let` en tête de fichier) -- le README n'en liste que 3, `internetInterface` en plus :
+
+- `interface` : interface réseau réelle du serveur (`ip a`).
+- `serverIp` : IP fixe de cette interface (le script iPXE pointe dessus en dur).
+- `standaloneDhcp` : `true` si ce serveur doit être l'unique DHCP du segment PXE ; `false` pour proxyDHCP seul (coexiste avec un DHCP existant -- cas le plus probable).
+- `internetInterface` : seulement utilisée si `standaloneDhcp = true` (sortie NAT du segment PXE vers Internet).
+
+## Alternative : créer l'ISO USB (sans serveur PXE)
+
+Même flake, même `install.sh`, pas de dnsmasq/Caddy à opérer -- juste un fichier `.iso` à graver. Utile en secours ou pour tester sans monter tout le PXE. Un seul ISO pour la flotte ET les postes nommés : le choix (`1) flotte` / `2) poste nommé`) se fait à l'écran de démarrage, pas à la gravure.
+
+```bash
+nix build .#nixosConfigurations.installer-iso.config.system.build.isoImage
+lsblk                                              # identifier la clé USB, PAS le disque système
+sudo dd if=result/iso/*.iso of=/dev/sdX bs=4M status=progress conv=fsync
+```
+
+`/dev/sdX` doit être confirmé par l'opérateur humain avant d'exécuter le `dd` (voir règle plus haut) -- ce n'est pas négociable, une erreur ici écrase un disque en silence.
+
+**Si l'agent tourne sous WSL (Windows)** : `lsblk` n'y verra la clé USB QUE si elle a été explicitement rattachée via `usbipd attach --wsl` ([doc officielle](https://learn.microsoft.com/en-us/windows/wsl/connect-usb), détails dans le [README.md](README.md)). Par défaut WSL2 n'a aucun accès aux disques amovibles. Si ce n'est pas déjà en place, ne pas improviser un contournement : construire l'ISO (ça, ça marche normalement sous WSL), remettre le `.iso` produit à l'opérateur humain, et le laisser le graver avec un outil Windows natif (Rufus...).
+
+Définition de l'image : [installer/iso.nix](installer/iso.nix). Attribut de flake : `nixosConfigurations.installer-iso`.
+
+## Installer le serveur PXE (depuis zéro)
+
+```bash
+# 1. NixOS installé (ISO officielle), mot de passe root défini.
+nix-shell -p git
+git clone https://gitea.miniclic.net/Damien/Nixos_Fleet.git /etc/nixos-fleet
+cd /etc/nixos-fleet
+
+# 2. Fichier matériel (hors repo, jamais committé)
+sudo nixos-generate-config
+
+# 3. Éditer les 4 valeurs ci-dessus dans pxe-server/configuration.nix
+
+# 4. Build -- --impure obligatoire (lit /etc/nixos/hardware-configuration.nix, hors flake)
+sudo nixos-rebuild switch --flake .#pxe-server --impure
+
+# 5. Publier l'image (première fois : plusieurs minutes)
+sudo systemctl start pxe-publish
+sudo systemctl status pxe-publish   # doit finir en "success"
+```
+
+Vérification post-install :
+
+```bash
+sudo systemctl status dnsmasq caddy
+ls /var/lib/tftpboot        # undionly.kpxe, ipxe.efi
+ls /var/www/pxe             # bzImage, initrd, netboot.ipxe
+curl -I http://<serverIp>/netboot.ipxe
+systemctl is-enabled pxe-publish.timer
+```
+
+Puis tester sur 1 seul PC (BIOS et UEFI séparément si le parc a les deux) avant tout déploiement de masse.
+
+## Entretien courant
+
+```bash
+cd /etc/nixos-fleet     # ou l'emplacement réel du clone sur ce serveur
+git pull
+git log --oneline -3    # le dernier commit doit correspondre à ce qui est attendu
+```
+
+Republier l'image après une modif de `installer/` :
+
+```bash
+sudo systemctl start pxe-publish
+```
+
+Republier après une modif de `pxe-server/configuration.nix` (rebuild complet, pas juste `pxe-publish`) :
+
+```bash
+sudo nixos-rebuild switch --flake .#pxe-server --impure
+```
+
+Logs :
+
+```bash
+journalctl -u dnsmasq -f
+journalctl -u caddy -f
+journalctl -u pxe-publish -f
+```
+
+## Dépannage -- incidents déjà rencontrés
+
+**`Unit pxe-publish.service not found`** : le système du serveur n'a jamais été rebuild depuis que ce service a été ajouté à `pxe-server/configuration.nix`. `git pull` seul ne suffit pas côté serveur -- il faut ensuite `sudo nixos-rebuild switch --flake .#pxe-server --impure`.
+
+**Le dossier repo a disparu du serveur** (`/etc/nixos-fleet` ou équivalent absent) : repo public, sans authentification -- reclone directement, n'importe où :
+```bash
+git clone https://gitea.miniclic.net/Damien/Nixos_Fleet.git
+```
+Le `hardware-configuration.nix` est hors du repo (`/etc/nixos/`), donc indépendant de l'emplacement du clone.
+
+**Un fix censé être appliqué ne change rien** : vérifier `git log --oneline -3` avant toute autre piste -- le `git pull` n'a peut-être rien ramené de neuf (mauvaise branche, push pas fait côté dev). Ne jamais supposer qu'un rebuild "prend" le dernier commit distant sans l'avoir vérifié.
+
+**`curl http://<serverIp>/netboot.ipxe` reste bloqué** : l'IP statique de l'interface PXE ne s'est parfois pas appliquée toute seule au tout premier `switch` sur une install neuve. Vérifier :
+```bash
+ip a show <interface>   # cherche "inet <serverIp>/24"
+```
+Absente → forcer une fois :
+```bash
+sudo systemctl start network-addresses-<interface>.service
+```
+Un reboot du serveur applique aussi ça correctement au démarrage suivant.
+
+**Écran PXE ne trouve rien** : revérifier `serverIp` et `interface` dans `pxe-server/configuration.nix` contre la réalité du serveur (`ip a`).
+
+**Boucle infinie au démarrage d'un PC client** : `journalctl -u dnsmasq` pendant le boot du PC concerné.
+
+**UEFI ou BIOS ne boote pas** (l'un des deux seulement) : vérifier que les deux fichiers existent dans `/var/lib/tftpboot` (`undionly.kpxe` pour BIOS, `ipxe.efi` pour UEFI) -- l'un des deux `install -m 0644 ... || true` dans `pxe-publish` peut avoir silencieusement échoué (noms de sortie du paquet `pkgs.ipxe` à revérifier si la version change).
+
+**IP qui changent tout le temps sur le segment PXE** : un autre serveur DHCP tourne déjà sur ce réseau -- repasser `standaloneDhcp` à `false` (proxyDHCP seul).
+
+## Valider une modif avant de la pousser
+
+```bash
+nix flake check --no-build            # échoue sur pxe-server hors du vrai serveur (attendu, lit /etc/nixos)
+nix flake check --no-build --impure   # à lancer depuis le serveur PXE réel uniquement
+nix build .#nixosConfigurations.nixos.config.system.build.toplevel --dry-run
+```
+
+Environnement de dev sans accès à un vrai serveur PXE : voir "Environnement de dev sous Windows (WSL + Nix)" dans le [README.md](README.md) -- `pxe-server` ne s'évalue qu'avec `--impure` **sur la machine réelle**, c'est normal ailleurs.
+
+## Sources -- pour vérifier au lieu de deviner
+
+En cas de doute sur le comportement réel d'une option ou d'un mécanisme, chercher ici avant de supposer :
+
+- NixOS manual : https://nixos.org/manual/nixos/stable/
+- Recherche d'options NixOS (n'importe quel module : `services.dnsmasq`, `services.caddy`, `system.autoUpgrade`, `programs.firefox`...) : https://search.nixos.org/options
+- Recherche de paquets nixpkgs : https://search.nixos.org/packages
+- Code source nixpkgs (la vérité de dernier recours sur le comportement réel d'un module) : https://github.com/NixOS/nixpkgs
+  - Module image ISO (`installer-iso`) : https://github.com/NixOS/nixpkgs/blob/master/nixos/modules/installer/cd-dvd/iso-image.nix
+  - Module image netboot (`installer-netboot`) : https://github.com/NixOS/nixpkgs/blob/master/nixos/modules/installer/netboot/netboot.nix
+- NixOS Wiki (officiel, `wiki.nixos.org` -- pas `nixos.wiki`, non-officiel et moins à jour) :
+  - Netboot : https://wiki.nixos.org/wiki/Netboot
+  - Creating a NixOS live CD : https://wiki.nixos.org/wiki/Creating_a_NixOS_live_CD
+- disko (partitionnement déclaratif) : https://github.com/nix-community/disko -- Quickstart : https://github.com/nix-community/disko/blob/master/docs/quickstart.md -- Référence : https://github.com/nix-community/disko/blob/master/docs/reference.md
+- home-manager : https://home-manager.dev/manual/
+- iPXE (premier étage du boot réseau, `undionly.kpxe`/`ipxe.efi`) : https://ipxe.org/
+- dnsmasq (DHCP/TFTP) : https://thekelleys.org.uk/dnsmasq/doc.html
+- Caddy (serveur HTTP) : https://caddyserver.com/docs/
+- systemd.timer (`pxe-publish.timer`) : https://www.freedesktop.org/software/systemd/man/systemd.timer.html
+- Policies Firefox (`RequestedLocales`, `FirefoxHome`...) : https://firefox-admin-docs.mozilla.org/reference/policies/

README.md

@@ -1,13 +1,70 @@
 # Nixos_Fleet
 
-Déploiement en masse (PXE ou USB) du profil générique `usagers`.
+Déploiement en masse (PXE ou USB) du profil générique `nixos`.
 
 Repo public. `git pull` sans mot de passe.
 
 Ne contient aucune donnée des utilisateurs nommés. Ça, c'est dans [Nixos_Users](../nixos_users), repo privé séparé.
 
+## Index
+
+- [Installer depuis un NixOS déjà installé](#installer-depuis-un-nixos-déjà-installé) -- appliquer cette config sans réinstaller, partitionnement existant préservé
+- [Installer un PC](#installer-un-pc) -- clé USB ou PXE, depuis zéro (reformate le disque)
+- [Installer le serveur PXE](#installer-le-serveur-pxe)
+- [Référence](#référence)
+- [Environnement de dev sous Windows (WSL + Nix)](#environnement-de-dev-sous-windows-wsl--nix)
+- [Travailler avec Git](#travailler-avec-git)
+
 ---
 
+# Installer depuis un NixOS déjà installé
+
+Pour appliquer cette config (flotte ou poste nommé) sur une machine où NixOS tourne déjà -- sans réinstaller, **sans toucher au partitionnement existant**. Utilise `nixos-existing` (flotte, ce repo) ou `<profil>-existing` (poste nommé, [Nixos_Users](../nixos_users)) : même profil logiciel que l'install normale, mais basé sur le `hardware-configuration.nix` réel de la machine plutôt que sur disko.
+
+Pour repartir de zéro (reformater le disque) à la place : voir "Installer un PC" plus bas.
+
+## Flotte
+
+```bash
+git clone https://gitea.miniclic.net/Damien/Nixos_Fleet.git /etc/nixos-fleet
+cd /etc/nixos-fleet
+sudo nixos-rebuild switch --flake .#nixos-existing --impure
+```
+
+`--impure` : nécessaire pour lire `/etc/nixos/hardware-configuration.nix`, hors du flake.
+
+## Poste nommé
+
+Repo privé -- voir "Token Gitea" dans [Nixos_Users](../nixos_users) pour en obtenir un, et la liste des profils disponibles (pas listée ici, repo public).
+
+```bash
+git clone https://<token>@gitea.miniclic.net/Damien/Nixos_Users.git /etc/nixos-users
+cd /etc/nixos-users
+sudo nixos-rebuild switch --flake .#<profil>-existing --impure
+```
+
+Pour que les mises à jour automatiques continuent de fonctionner ensuite (repo privé), créer le netrc à la main -- normalement écrit par `install.sh`, absent ici puisqu'on ne passe pas par l'installeur :
+
+```bash
+sudo mkdir -p /etc/nix
+{
+  echo "machine gitea.miniclic.net"
+  echo "login <token>"
+  echo "password x-oauth-basic"
+} | sudo tee /etc/nix/netrc
+sudo chmod 600 /etc/nix/netrc
+```
+
+## Maintenance
+
+Identique au reste du repo (voir "Mises à jour de la flotte" en Référence), avec `nixos-existing` (ou `<profil>-existing`) à la place de l'attribut normal :
+
+```bash
+cd /etc/nixos-fleet   # ou /etc/nixos-users
+sudo git pull
+sudo nixos-rebuild switch --flake .#nixos-existing --impure
+```
+
 # Installer un paquet sans le mettre "en dur"
 
 Pour tester un outil sans toucher à `configuration.nix`.
@@ -38,9 +95,45 @@ Aucune de ces méthodes ne survit à un reboot ni à un `nixos-rebuild`. Pour qu
 
 Une étape à la fois. Ne saute pas d'étape.
 
+## Étape 0 — Support d'installation
+
+Deux supports possibles, choisis-en un.
+
+**PXE (serveur déjà monté)** : rien à préparer ici. Va à l'étape 1.
+
+**Ce n'est pas l'ISO de nixos.org.** Celle-ci est construite depuis ce repo (`installer/iso.nix`) : paquets propres au parc (git, outils de partitionnement...), clavier/locale FR par défaut, et surtout `install.sh` qui se lance seul à l'ouverture de session -- l'ISO officielle démarre sur un shell nu, sans rien de tout ça, il faudrait tout faire à la main (partitionnement, `nixos-install`...).
+
+Le `nix build` ci-dessous est **long** (10 à 30+ minutes) et n'affiche presque rien pendant la majeure partie du temps -- l'étape la plus lente (`mksquashfs`, compression de tout le store Nix pour l'ISO) ne montre aucune progression. Normal, pas figé : vérifier avec `top`/`htop` qu'un processus consomme du CPU avant de penser à interrompre.
+
+**Clé USB, sur Linux :**
+
+```bash
+git clone https://gitea.miniclic.net/Damien/Nixos_Fleet.git
+cd Nixos_Fleet
+nix build .#nixosConfigurations.installer-iso.config.system.build.isoImage
+lsblk                                              # repérer la clé -- pas ton disque système
+sudo dd if=result/iso/*.iso of=/dev/sdX bs=4M status=progress conv=fsync
+```
+
+Vérifier `/dev/sdX` avant de lancer `dd`.
+
+**Clé USB, sur Windows** (dans un terminal WSL2 -- voir "Installer WSL2" plus bas si pas encore fait) :
+
+```bash
+cd "/mnt/c/Users/<toi>/Desktop"    # ou un autre dossier Windows de ton choix
+git clone https://gitea.miniclic.net/Damien/Nixos_Fleet.git
+cd Nixos_Fleet
+nix build .#nixosConfigurations.installer-iso.config.system.build.isoImage
+cp result/iso/*.iso ./nixos-installer.iso
+```
+
+`dd` ne fonctionne pas depuis WSL2 (pas d'accès à la clé USB par défaut, [source](https://learn.microsoft.com/en-us/windows/wsl/connect-usb)). `nixos-installer.iso` apparaît dans l'explorateur Windows, dans le dossier du repo -- le graver avec [Rufus](https://rufus.ie/) (ou balenaEtcher, Win32DiskImager).
+
+Une fois la clé prête (Linux ou Windows) : va à l'étape 1.
+
 ## Étape 1 — Brancher
 
-Branche le câble réseau.
+Branche le câble réseau (PXE) ou la clé USB gravée à l'étape 0 (USB).
 
 Branche le PC au secteur.
 
@@ -56,7 +149,7 @@ HP → F9
 
 Lenovo → F12
 
-Choisis : Network Boot.
+Choisis : Network Boot (PXE) ou Boot from USB (clé) -- le menu qui suit est identique dans les deux cas.
 
 ## Étape 3 — Attendre
 
@@ -70,7 +163,7 @@ Il y a deux cas. Choisis-en un seul.
 
 PC normal → va à l'étape 4A.
 
-PC pour thomas, clara, jade ou oreo → va à l'étape 4B.
+PC pour une personne (profil nommé) → va à l'étape 4B.
 
 ## Étape 4A — PC normal
 
@@ -90,7 +183,7 @@ Tape : `2`
 
 Appuie sur Entrée.
 
-Tape le prénom (thomas, clara, jade ou oreo).
+Tape le prénom du profil (liste donnée à part, pas dans ce guide public).
 
 Appuie sur Entrée.
 
@@ -122,17 +215,19 @@ N'y touche pas.
 
 PC normal :
 
-Utilisateur : `usagers`
+Utilisateur : `nixos`
 
 Mot de passe : `nixos`
 
+Utilisateur et mot de passe identiques, volontairement (un seul mot à retenir sur un poste partagé). Stable, ne change jamais tout seul et n'est jamais redemandé (voir "Réactiver un changement de mot de passe forcé" en référence si ça doit changer un jour).
+
 PC pour une personne :
 
 Utilisateur : le prénom tapé à l'étape 4B
 
 Mot de passe : `nixos`
 
-Un nouveau mot de passe est demandé tout de suite. Le choisir maintenant.
+Un nouveau mot de passe est demandé tout de suite (changement forcé au premier login, seulement sur les postes nominatifs -- voir [Nixos_Users](../nixos_users)). Le choisir maintenant.
 
 ## Étape 7 — Vérifier
 
@@ -238,13 +333,7 @@ Un reboot du serveur applique aussi ça correctement au démarrage suivant.
 
 ## Étape 8 — Tester sur 1 PC
 
-Démarrer un seul PC en PXE.
+Suivre "Installer un PC" (Network Boot au lieu de Boot from USB) sur une seule machine avant d'en lancer 20. Tester BIOS et UEFI séparément si le parc a les deux.
-
-Vérifier qu'il arrive sur l'écran de choix.
-
-Si le parc a du BIOS et de l'UEFI, tester les deux.
-
-Ne pas lancer 20 PC avant que cette étape fonctionne.
 
 ## Après l'installation
 
@@ -311,7 +400,7 @@ IP qui changent tout le temps → un autre DHCP tourne déjà, repasser `standal
 
 ## Contenu du repo
 
-`hosts/usagers/` → le seul profil du repo. Jamais chiffré.
+`hosts/nixos/` → le seul profil du repo. Jamais chiffré.
 
 `diskos/plain.nix` → layout disko (disque `main`, GPT+ESP+btrfs).
 
@@ -319,45 +408,115 @@ IP qui changent tout le temps → un autre DHCP tourne déjà, repasser `standal
 
 `pxe-server/` → le serveur PXE (dnsmasq + Caddy).
 
+## Personnaliser le bureau (dconf)
+
+`hosts/nixos/dconf.ini` contient les réglages Cinnamon (thème, fond d'écran, panneau...), chargés par home-manager à chaque rebuild.
+
+Pour changer un réglage : le faire en direct dans l'interface Cinnamon sur une machine, puis exporter :
+
+```bash
+dconf dump /org/cinnamon/ > dconf.ini
+```
+
+Remplacer `hosts/nixos/dconf.ini` par ce fichier, commit, push. Rien à changer dans le `.nix`.
+
+## Changer le nom d'utilisateur ou le mot de passe
+
+Deux fichiers à toucher, dans `hosts/nixos/configuration.nix` :
+
+```nix
+users.users.nixos = {
+  ...
+  initialPassword = "nixos";
+};
+```
+
+Renommer `nixos` (l'attribut `users.users.nixos`) change le compte système. Changer la valeur d'`initialPassword` change le mot de passe.
+
+Si le nom d'utilisateur change, mettre à jour aussi la référence dans `hosts/common/default.nix` (`home-manager.users.nixos = ...` doit cibler le même nom, sinon home-manager configure un compte qui n'existe plus).
+
+**`initialPassword` ne s'applique qu'à la création du compte.** Sur une machine déjà installée, changer cette valeur dans le repo + laisser l'auto-upgrade tourner ne change RIEN au mot de passe réel -- NixOS ne réécrit jamais un mot de passe déjà défini. Ça ne s'applique qu'aux **nouvelles installations** à partir de ce moment-là.
+
+Pour changer le mot de passe sur une machine déjà déployée : à la main, sur place ou à distance (SSH/console) :
+
+```bash
+sudo passwd nixos
+```
+
+Pareil pour renommer le compte sur une machine déjà installée : `usermod -l` ne suffit pas à tout migrer proprement (home directory, permissions) -- plus simple de considérer que le renommage ne s'applique qu'aux futures installations, pas de le faire à chaud sur le parc existant.
+
+## Réactiver un changement de mot de passe forcé
+
+Par défaut, le compte `nixos` garde `nixos` comme mot de passe stable, sans expiration (`hosts/nixos/configuration.nix`). Voulu : poste partagé, pas nominatif -- forcer un changement casserait le mot de passe commun affiché sur l'étiquette/le guide remis aux gens.
+
+`nixos_users` force ce changement au premier login pour les postes nominatifs, via un script d'activation one-shot (`hosts/common/accounts.nix` de ce repo-là) :
+
+```nix
+system.activationScripts.forcePasswordChangeOnce.text = ''
+  marker=/var/lib/nixos-force-pwchange-done
+  if [ ! -e "$marker" ]; then
+    ${pkgs.shadow}/bin/chage -d 0 nixos
+    mkdir -p /var/lib
+    touch "$marker"
+  fi
+'';
+```
+
+Pour réactiver la même chose sur `nixos`, reprendre ce bloc tel quel dans `hosts/nixos/configuration.nix` (ou `hosts/common/default.nix` si ça doit s'appliquer à un futur deuxième profil de flotte). Le marqueur est nécessaire : sans lui, `chage -d 0` s'appliquerait à nouveau à chaque `nixos-rebuild switch`, redemandant un mot de passe à chaque redémarrage.
+
 ## Pourquoi deux repos
 
 Une machine de la flotte pull uniquement ce repo.
 
-Les comptes thomas/clara/jade/oreo vivent dans un autre repo, privé.
+Les comptes nominatifs vivent dans un autre repo, privé.
 
 La flotte ne voit jamais ce second repo.
 
 ## Graver la clé USB
 
-Marche sans le serveur PXE. Utile pour tester avant de monter le PXE, ou en secours.
+Marche sans le serveur PXE. Utile pour tester avant de monter le PXE, ou en secours. Commandes : voir "Étape 0" au tout début de ce README.
 
 NixOS permet nativement de fabriquer une image d'installation sur mesure : un ISO avec nos propres paquets et notre propre script (`install.sh`) qui se lance seul au démarrage. C'est une fonctionnalité standard de NixOS, pas un bricolage — `installer/iso.nix` dans ce repo est la définition de cette image.
 
-C'est le même ISO pour la flotte et les postes nommés — pas deux images différentes. Le choix se fait à l'écran au démarrage (`1) flotte` / `2) poste nommé`), pas au moment de la gravure.
+C'est le même ISO pour la flotte et les postes nommés — pas deux images différentes, **pas de commande de build spécifique par profil nommé**. Le choix se fait à l'écran au démarrage, une fois la clé branchée sur le PC cible (voir étapes 4/4B).
 
-Le fichier `.iso` n'existe pas tant qu'on ne l'a pas construit :
+Depuis Windows : mêmes commandes, dans WSL -- voir "Étape 0", section Windows.
-
-```bash
-nix build .#nixosConfigurations.installer-iso.config.system.build.isoImage
-```
-
-Repérer la clé USB avant de graver — bien vérifier le chemin, pas ton disque système :
-
-```bash
-lsblk
-```
-
-```bash
-sudo dd if=result/iso/*.iso of=/dev/sdX bs=4M status=progress conv=fsync
-```
-
-Vérifier `/dev/sdX` avant de lancer `dd`.
 
 ## Mises à jour de la flotte
 
-Chaque PC tire ses mises à jour directement depuis ce repo, chaque semaine.
+Chaque PC tire ses mises à jour directement depuis ce repo, chaque semaine (`system.autoUpgrade`, `persistent = true` : se rattrape au boot suivant même si le PC était éteint au moment prévu).
 
-Pas de `git pull` manuel sur les PC. Juste `git push` ici.
+Pas de `git pull` manuel sur les PC en fonctionnement normal. Juste `git push` ici.
+
+### Appliquer un changement immédiatement (sans attendre la semaine)
+
+1. Pousser le changement depuis le poste de dev :
+
+```bash
+git add -A
+git commit -m "description"
+git push
+```
+
+2. Sur le PC cible, trois options, du plus lent au plus immédiat :
+
+**Rien faire** : le timer hebdomadaire s'en charge tout seul.
+
+**Forcer maintenant, sans y toucher physiquement** (ex. à distance via SSH) : lancer le même service que le timer, il fetch tout seul depuis l'URL du repo, pas besoin que `/etc/nixos` soit à jour :
+
+```bash
+sudo systemctl start nixos-upgrade.service
+```
+
+**Rebuild manuel sur place** (typique en test, devant la machine) :
+
+```bash
+cd /etc/nixos
+sudo git pull
+sudo nixos-rebuild switch --flake .#nixos
+```
+
+Le `git pull` est obligatoire ici : contrairement à `nixos-upgrade.service`, ce rebuild lit les fichiers locaux de `/etc/nixos`, pas l'URL distante.
 
 ## Avant la première vague de 100 PC
 
@@ -373,14 +532,19 @@ Boot BIOS et boot UEFI, sur le parc réel.
 
 Test sur 1-2 PC réels d'abord.
 
-PC à seulement 4 Go de RAM : le zram (`installer-base.nix`) doit suffire pour installer `usagers` (Cinnamon + Firefox + LibreOffice + VLC), mais pas testé en dessous de 12 Go pour l'instant. Si ça échoue encore sur du 4 Go réel : alléger la liste de paquets de `usagers` plutôt que d'insister sur le zram seul.
+PC à seulement 4 Go de RAM : le zram (`installer-base.nix`) doit suffire pour installer `nixos` (Cinnamon + Firefox + LibreOffice + VLC), mais pas testé en dessous de 12 Go pour l'instant. Si ça échoue encore sur du 4 Go réel : alléger la liste de paquets de `nixos` plutôt que d'insister sur le zram seul.
 
 ```bash
-nix flake check
+nix flake check --no-build          # évalue nixos/installer-netboot/installer-iso
-nix build .#nixosConfigurations.usagers.config.system.build.toplevel
+nix flake check --no-build --impure # inclut pxe-server (lit /etc/nixos, réel sur le serveur seulement)
-nix build .#nixosConfigurations.installer-iso
+nix build .#nixosConfigurations.nixos.config.system.build.toplevel --dry-run
+nix build .#nixosConfigurations.installer-iso.config.system.build.isoImage --dry-run
 ```
 
+Vérifié (WSL, testé le 2026-09-12) : `nixos` s'évalue et résout entièrement sa fermeture de paquets sans erreur. `pxe-server` échoue sans `--impure` en dehors du vrai serveur PXE (attendu, lit `/etc/nixos/hardware-configuration.nix`).
+
+**Ce que ces commandes ne couvrent pas** : elles vérifient que la config s'évalue et que les paquets existent, pas que le poste installé fonctionne réellement (Wi-Fi, wallpaper, LightDM, avatar...). Seul un test sur machine réelle (étape 8 plus haut) le confirme.
+
 ## Connexion Wi-Fi
 
 Pour un PC sans câble réseau (après l'installation, ou en dépannage).
@@ -426,7 +590,86 @@ Aucun paquet à installer manuellement : `enable = true` suffit dans les deux ca
 Après édition :
 
 ```bash
-sudo nixos-rebuild switch --flake .#usagers
+sudo nixos-rebuild switch --flake .#nixos
+```
+
+---
+
+# Environnement de dev sous Windows (WSL + Nix)
+
+Pour tester `nix flake check` / `nix build` depuis un poste Windows. Nix ne tourne pas nativement sur Windows : il faut un vrai noyau Linux, donc WSL2.
+
+## Installer WSL2
+
+PowerShell **en administrateur** :
+
+```powershell
+wsl --install
+```
+
+Installe WSL2 + Ubuntu par défaut. Redémarrer si demandé, puis laisser Ubuntu créer l'utilisateur Linux (indépendant du compte Windows).
+
+## Installer Nix
+
+Dans le terminal Ubuntu, commande officielle (nixos.org) :
+
+```bash
+curl --proto '=https' --tlsv1.2 -L https://nixos.org/nix/install | sh -s -- --daemon
+```
+
+Fermer/rouvrir le terminal ensuite. Vérifier :
+
+```bash
+nix --version
+```
+
+Les flakes sont activées par défaut sur les versions récentes de Nix (2.35+) — rien à configurer en plus. Si `nix flake check` répond une erreur `experimental-features`, ajouter dans `/etc/nix/nix.conf` :
+
+```
+experimental-features = nix-command flakes
+```
+
+## Utiliser les repos depuis WSL
+
+Les fichiers Windows sont accessibles depuis WSL sous `/mnt/c/...` — pas besoin de cloner une deuxième fois :
+
+```bash
+cd "/mnt/c/Users/<toi>/Desktop/Claude/Nixos/nixos_fleet"
+nix flake check --no-build
+```
+
+`pxe-server` échouera à `nix flake check` (sans `--impure`) : il lit `/etc/nixos/hardware-configuration.nix`, qui n'existe que sur le vrai serveur PXE. Normal, pas une régression.
+
+## Si "pas de réseau" dans WSL
+
+Symptôme typique : `ping 8.8.8.8` répond, mais `curl https://nixos.org` (ou tout domaine) time out à la résolution — le tunnel DNS de WSL2 est cassé (fréquent avec VPN/antivirus). Vérifier :
+
+```bash
+curl -m 5 https://1.1.1.1        # IP brute : doit marcher
+curl -m 5 https://nixos.org      # domaine : si ça time out, c'est le DNS
+```
+
+Correctif (côté Windows, PowerShell, pas besoin d'être admin) : créer `%USERPROFILE%\.wslconfig` avec :
+
+```
+[wsl2]
+networkingMode=mirrored
+```
+
+Puis `wsl --shutdown` et rouvrir Ubuntu. Ce mode partage directement la pile réseau de Windows à WSL, au lieu de passer par le NAT + proxy DNS interne.
+
+## Construire l'ISO et la graver, depuis Windows
+
+Commandes complètes : voir "Étape 0 — Support d'installation" tout en haut de ce README.
+
+Alternative avancée à Rufus (rattacher la clé USB à WSL et faire `dd` comme sur Linux) : [usbipd-win](https://github.com/dorssel/usbipd-win).
+
+## Appeler `nix` depuis un outil qui pilote WSL sans shell interactif
+
+`wsl.exe nix --version` échoue avec `nix: command not found` : une commande non-interactive ne source pas le profil qui ajoute `nix` au PATH. Forcer un shell de login :
+
+```bash
+wsl.exe -e bash -lc "nix --version"
 ```
 
 ---

flake.lock

@@ -20,6 +20,27 @@
         "type": "github"
       }
     },
+    "home-manager": {
+      "inputs": {
+        "nixpkgs": [
+          "nixpkgs"
+        ]
+      },
+      "locked": {
+        "lastModified": 1789182507,
+        "narHash": "sha256-9nt4W0HNNP84B+b37yRs9Zxat1ZR5guJxEZDEjAgex4=",
+        "owner": "nix-community",
+        "repo": "home-manager",
+        "rev": "b1d1b60084970f9d1e2b72662639dab6d039be71",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-community",
+        "ref": "release-26.05",
+        "repo": "home-manager",
+        "type": "github"
+      }
+    },
     "nixpkgs": {
       "locked": {
         "lastModified": 1788807765,
@@ -39,6 +60,7 @@
     "root": {
       "inputs": {
         "disko": "disko",
+        "home-manager": "home-manager",
         "nixpkgs": "nixpkgs"
       }
     }

flake.nix

@@ -7,17 +7,47 @@
       url = "github:nix-community/disko";
       inputs.nixpkgs.follows = "nixpkgs";
     };
+    # Même branche release-26.05 que nixpkgs (confirmé : la branche existe
+    # bien sur nix-community/home-manager). Gère les réglages Cinnamon par
+    # utilisateur (dconf, fichiers dans $HOME) à la place des scripts
+    # d'activation système à la main qu'on avait avant.
+    home-manager = {
+      url = "github:nix-community/home-manager/release-26.05";
+      inputs.nixpkgs.follows = "nixpkgs";
+    };
   };
 
   outputs =
-    { self, nixpkgs, disko, ... }:
+    { self, nixpkgs, disko, home-manager, ... }:
+    let
+      repoUrl = "git+https://gitea.miniclic.net/Damien/Nixos_Fleet.git";
+    in
     {
       nixosConfigurations = {
-        usagers = nixpkgs.lib.nixosSystem {
+        nixos = nixpkgs.lib.nixosSystem {
           system = "x86_64-linux";
           modules = [
             disko.nixosModules.disko
-            ./hosts/usagers/configuration.nix
+            home-manager.nixosModules.home-manager
+            ./hosts/nixos/configuration.nix
+            ./diskos/plain.nix
+            { system.autoUpgrade.flake = "${repoUrl}#nixos"; }
+          ];
+        };
+
+        # Même profil logiciel que "nixos", mais sans disko : pour une
+        # machine où NixOS est déjà installé (partitionnement existant,
+        # quel qu'il soit, à ne pas toucher) -- utilise le
+        # hardware-configuration.nix réel de cette machine à la place de
+        # diskos/plain.nix, comme pxe-server. --impure obligatoire au
+        # nixos-rebuild (lit un chemin hors du flake).
+        nixos-existing = nixpkgs.lib.nixosSystem {
+          system = "x86_64-linux";
+          modules = [
+            home-manager.nixosModules.home-manager
+            ./hosts/nixos/configuration.nix
+            /etc/nixos/hardware-configuration.nix
+            { system.autoUpgrade.flake = "${repoUrl}#nixos-existing"; }
           ];
         };
 

hosts/common/default.nix

@@ -168,11 +168,16 @@ in
   # (déjà la valeur par défaut de ce module -- explicité ici) : si la
   # machine est éteinte au moment prévu, la maj se lance dès le
   # prochain démarrage plutôt que d'attendre la semaine suivante.
+  # `flake` n'est PAS fixé ici : il dépend de l'attribut réellement
+  # utilisé pour cette machine (nixos vs nixos-existing, disko ou pas)
+  # -- injecté par flake.nix, comme dans nixos_users. Le fixer ici
+  # ferait basculer une machine "nixos-existing" vers l'attribut
+  # "nixos" (disko) à son prochain auto-upgrade, avec un layout disque
+  # potentiellement incompatible avec l'existant.
   system.autoUpgrade = {
     enable = true;
     persistent = true;
     dates = "weekly";
-    flake = "git+https://gitea.miniclic.net/Damien/Nixos_Fleet.git#usagers";
   };
 
   # Compte admin de la flotte : root, mot de passe "nixos" STABLE (pas
@@ -199,14 +204,35 @@ in
     warpinator
   ];
 
-  # Fond d'écran par défaut (logo NixOS, pas la galerie perso de
+  # dconf par utilisateur via home-manager, chargé depuis un fichier ini
-  # nixos_cinnamon). Suppose la config installée sur /etc/nixos (voir
+  # brut (hosts/nixos/dconf.ini) plutôt que du dconf.settings typé --
-  # installer/install.sh).
+  # même mécanisme que oreo (nixos_users), pour la même raison : ça se
-  environment.etc."dconf/db/local.d/00-background".text = ''
+  # met à jour par un simple `dconf dump /org/cinnamon/ > dconf.ini` +
-    [org/cinnamon/desktop/background]
+  # commit depuis une machine réelle, pas en retranscrivant chaque clé à
-    picture-uri='file:///etc/nixos/hosts/common/wallpaper/Nix/13977413.png'
+  # la main en Nix. Repris tel quel du dconf d'oreo (panneau, thèmes,
-  '';
+  # réglages GTK/Nemo...), sauf le chemin du fond d'écran (commun,
-  system.activationScripts.dconfUpdate.text = "${pkgs.dconf}/bin/dconf update";
+  # pas par-profil) et l'ID Warpinator (retiré : une valeur fixe
+  # partagée par tout le parc casserait l'appairage).
+  home-manager.useGlobalPkgs = true; # partage le pkgs du système, pas de deuxième évaluation (RAM)
+  home-manager.backupFileExtension = "hm-backup"; # évite un échec si un fichier existe déjà (migration)
+  home-manager.users.nixos =
+    { pkgs, lib, ... }:
+    {
+      home.stateVersion = "26.05";
+
+      # DBUS_SESSION_BUS_ADDRESS / dbus-run-session : même logique que le
+      # module home-manager dconf.nix officiel (dconf a besoin d'un bus
+      # D-Bus pour écrire, on en lance un temporaire s'il n'y en a pas
+      # déjà un actif).
+      home.activation.nixosDconf = lib.hm.dag.entryAfter [ "writeBoundary" ] ''
+        if [[ -v DBUS_SESSION_BUS_ADDRESS ]]; then
+          DCONF_DBUS_RUN_SESSION=""
+        else
+          DCONF_DBUS_RUN_SESSION="${pkgs.dbus}/bin/dbus-run-session --dbus-daemon=${pkgs.dbus}/bin/dbus-daemon"
+        fi
+        run $DCONF_DBUS_RUN_SESSION ${pkgs.dconf}/bin/dconf load / < ${../nixos/dconf.ini}
+      '';
+    };
 
   # Reprend la config Firefox d'oreo (nixos_users/hosts/oreo/configuration.nix)
   # -- c'est elle qui tue la page d'accueil/configuration au premier
@@ -312,6 +338,14 @@ in
     };
 
     policies = {
+      # Langpack fr téléchargé via languagePacks ci-dessus ; sans
+      # RequestedLocales, Firefox reste quand même en anglais (le
+      # langpack est juste installé, pas activé).
+      RequestedLocales = [
+        "fr"
+        "en-US"
+      ];
+
       DisableFirefoxStudies = true;
       DisableFirefoxAccounts = false;
       DisableFirefoxScreenshots = true;
@@ -340,6 +374,9 @@ in
         Highlights = false;
         Pocket = false;
         Snippets = false;
+        # Widget météo (demande la géolocalisation) -- ajouté à
+        # FirefoxHome en Firefox 152 / ESR 140.12.
+        Weather = false;
         Locked = true;
       };
 

hosts/nixos/configuration.nix

@@ -0,0 +1,22 @@
+# Profil générique "nixos" : poste non-nominatif de la flotte.
+# Le module disque (diskos/plain.nix pour une install neuve, ou le
+# hardware-configuration.nix réel d'une machine déjà installée) est
+# injecté par flake.nix, pas ici -- ce fichier ne connaît pas le
+# layout disque, comme dans nixos_users.
+{ ... }:
+
+{
+  imports = [
+    ../common
+  ];
+
+  # Compte de session non-nominatif, mot de passe "nixos" stable, sans
+  # expiration forcée (voir hosts/common). Nom d'utilisateur "nixos"
+  # aussi, pour unifier avec le mot de passe -- un seul mot à retenir.
+  users.users.nixos = {
+    isNormalUser = true;
+    description = "Nixos";
+    extraGroups = [ "networkmanager" ];
+    initialPassword = "nixos";
+  };
+}

hosts/nixos/dconf.ini

@@ -0,0 +1,199 @@
+[org/cinnamon]
+enabled-applets=['panel1:left:0:menu@cinnamon.org:0', 'panel1:left:1:separator@cinnamon.org:1', 'panel1:left:2:grouped-window-list@cinnamon.org:2', 'panel1:right:0:systray@cinnamon.org:3', 'panel1:right:1:xapp-status@cinnamon.org:4', 'panel1:right:2:notifications@cinnamon.org:5', 'panel1:right:3:printers@cinnamon.org:6', 'panel1:right:4:removable-drives@cinnamon.org:7', 'panel1:right:5:keyboard@cinnamon.org:8', 'panel1:right:6:favorites@cinnamon.org:9', 'panel1:right:7:network@cinnamon.org:10', 'panel1:right:8:sound@cinnamon.org:11', 'panel1:right:9:power@cinnamon.org:12', 'panel1:right:10:calendar@cinnamon.org:13', 'panel1:right:11:cornerbar@cinnamon.org:14']
+next-applet-id=15
+
+[org/cinnamon/desktop/background]
+picture-uri='file:///etc/nixos/hosts/common/wallpaper/Nix/13977413.png'
+
+[org/cinnamon/desktop/background/slideshow]
+delay=15
+image-source='directory:///etc/nixos/hosts/common/wallpaper/Nix'
+
+[org/cinnamon/desktop/input-sources]
+sources=[('xkb', 'fr')]
+
+[org/cinnamon/desktop/interface]
+cursor-size=24
+cursor-theme='Bibata-Modern-Classic'
+gtk-theme='Mint-Y-Dark-Blue'
+icon-theme='Mint-Y-Blue'
+toolkit-accessibility=false
+
+[org/cinnamon/desktop/peripherals/mouse]
+double-click=400
+drag-threshold=8
+speed=0.0
+
+[org/cinnamon/desktop/peripherals/touchpad]
+natural-scroll=false
+speed=0.0
+
+[org/cinnamon/desktop/screensaver]
+layout-group=0
+
+[org/cinnamon/desktop/sound]
+event-sounds=false
+
+[org/cinnamon/gestures]
+swipe-down-2='PUSH_TILE_DOWN::end'
+swipe-down-3='TOGGLE_OVERVIEW::end'
+swipe-down-4='VOLUME_DOWN::end'
+swipe-left-2='PUSH_TILE_LEFT::end'
+swipe-left-3='WORKSPACE_NEXT::end'
+swipe-left-4='WINDOW_WORKSPACE_PREVIOUS::end'
+swipe-right-2='PUSH_TILE_RIGHT::end'
+swipe-right-3='WORKSPACE_PREVIOUS::end'
+swipe-right-4='WINDOW_WORKSPACE_NEXT::end'
+swipe-up-2='PUSH_TILE_UP::end'
+swipe-up-3='TOGGLE_EXPO::end'
+swipe-up-4='VOLUME_UP::end'
+tap-3='MEDIA_PLAY_PAUSE::end'
+
+[org/cinnamon/settings-daemon/plugins/color]
+night-light-enabled=true
+night-light-last-coordinates=(48.866667, 2.3333330000000001)
+night-light-schedule-mode='always'
+night-light-temperature=uint32 5400
+
+[org/cinnamon/theme]
+name='Mint-Y-Dark-Blue'
+
+[org/gnome/desktop/a11y/applications]
+screen-reader-enabled=false
+
+[org/gnome/desktop/a11y/mouse]
+dwell-click-enabled=false
+dwell-threshold=10
+dwell-time=1.2
+secondary-click-enabled=false
+secondary-click-time=1.2
+
+[org/gnome/desktop/input-sources]
+sources=[('xkb', 'fr')]
+xkb-options=['terminate:ctrl_alt_bksp']
+
+[org/gnome/desktop/interface]
+can-change-accels=false
+clock-show-date=false
+clock-show-seconds=false
+cursor-blink=true
+cursor-blink-time=1200
+cursor-blink-timeout=10
+cursor-size=24
+cursor-theme='Bibata-Modern-Classic'
+enable-animations=true
+font-name='Ubuntu 10'
+gtk-color-palette='black:white:gray50:red:purple:blue:light blue:green:yellow:orange:lavender:brown:goldenrod4:dodger blue:pink:light green:gray10:gray30:gray75:gray90'
+gtk-color-scheme=''
+gtk-enable-primary-paste=true
+gtk-im-module=''
+gtk-im-preedit-style='callback'
+gtk-im-status-style='callback'
+gtk-key-theme='Default'
+gtk-theme='Mint-Y-Dark-Blue'
+gtk-timeout-initial=200
+gtk-timeout-repeat=20
+icon-theme='Mint-Y-Blue'
+menubar-accel='F10'
+menubar-detachable=false
+menus-have-tearoff=false
+scaling-factor=uint32 0
+text-scaling-factor=1.0
+toolbar-detachable=false
+toolbar-icons-size='large'
+toolbar-style='both-horiz'
+toolkit-accessibility=false
+
+[org/gnome/desktop/peripherals/mouse]
+accel-profile='default'
+double-click=400
+drag-threshold=8
+left-handed=false
+middle-click-emulation=false
+natural-scroll=false
+speed=0.0
+
+[org/gnome/desktop/privacy]
+disable-camera=false
+disable-microphone=false
+disable-sound-output=false
+old-files-age=uint32 30
+recent-files-max-age=7
+remember-recent-files=true
+remove-old-temp-files=false
+remove-old-trash-files=false
+
+[org/gnome/desktop/sound]
+event-sounds=false
+input-feedback-sounds=false
+theme-name='LinuxMint'
+
+[org/gnome/desktop/wm/preferences]
+action-double-click-titlebar='toggle-maximize'
+action-middle-click-titlebar='lower'
+action-right-click-titlebar='menu'
+audible-bell=false
+auto-raise=false
+auto-raise-delay=500
+button-layout=':minimize,maximize,close'
+disable-workarounds=false
+focus-mode='click'
+focus-new-windows='smart'
+mouse-button-modifier='<Alt>'
+num-workspaces=4
+raise-on-click=true
+resize-with-right-button=true
+theme='Mint-Y'
+titlebar-font='Ubuntu Medium 10'
+titlebar-uses-system-font=false
+visual-bell=false
+visual-bell-type='fullscreen-flash'
+workspace-names=@as []
+
+[org/gnome/file-roller/dialogs/extract]
+height=800
+recreate-folders=true
+skip-newer=false
+width=1000
+
+[org/gnome/file-roller/file-selector]
+show-hidden=false
+sidebar-size=300
+sort-method='name'
+sort-type='ascending'
+window-size=(-1, -1)
+
+[org/gnome/file-roller/listing]
+list-mode='as-folder'
+name-column-width=57
+show-path=false
+sort-method='name'
+sort-type='ascending'
+
+[org/gnome/file-roller/ui]
+sidebar-width=200
+window-height=480
+window-width=600
+
+[org/gtk/settings/file-chooser]
+date-format='regular'
+location-mode='path-bar'
+show-hidden=false
+show-size-column=true
+show-type-column=true
+sidebar-width=176
+sort-column='name'
+sort-directories-first=true
+sort-order='ascending'
+type-format='category'
+window-position=(202, 73)
+window-size=(1096, 822)
+
+[org/nemo/window-state]
+geometry='800x550+349+125'
+maximized=false
+sidebar-bookmark-breakpoint=3
+start-with-sidebar=true
+
+[org/x/apps/portal]
+color-scheme='prefer-dark'

hosts/usagers/configuration.nix

@@ -1,18 +0,0 @@
-# Profil générique "usagers" : poste non-nominatif de la flotte.
-{ ... }:
-
-{
-  imports = [
-    ../common
-    ../../diskos/plain.nix
-  ];
-
-  # Compte de session non-nominatif, mot de passe "nixos" stable, sans
-  # expiration forcée (voir hosts/common).
-  users.users.usagers = {
-    isNormalUser = true;
-    description = "Usagers";
-    extraGroups = [ "networkmanager" ];
-    initialPassword = "nixos";
-  };
-}

installer/install.sh

@@ -132,15 +132,15 @@ fi
 case "$CHOICE" in
   1)
     echo
-    echo "Installation du profil générique 'usagers' sur $DEVICE..."
+    echo "Installation du profil générique 'nixos' sur $DEVICE..."
-    do_install "$FLEET_REPO" "usagers" "diskos/plain.nix"
+    do_install "$FLEET_REPO" "nixos" "diskos/plain.nix"
     ;;
 
   2)
-    read -rp "Utilisateur (thomas/clara/jade/oreo) : " USER_PROFILE
+    read -rp "Utilisateur (thomas/clara/jade/oreo/oreo-i3) : " USER_PROFILE
     USER_PROFILE=$(echo "$USER_PROFILE" | tr '[:upper:]' '[:lower:]' | xargs)
     case "$USER_PROFILE" in
-      thomas|clara|jade|oreo) ;;
+      thomas|clara|jade|oreo|oreo-i3) ;;
       *)
         echo "Utilisateur inconnu : $USER_PROFILE" >&2
         exec bash