# NixOS Configuration

Configuration NixOS modulaire basée sur Flakes pour laptop.

## 📁 Structure

```
nixos-config/
├── flake.nix                    # Point d'entrée principal avec inputs et configurations
├── configuration.nix            # Configuration racine importée par le flake
├── hosts/
│   └── laptop/
│       └── configuration.nix    # Configuration matérielle spécifique au laptop
└── modules/
    ├── laptop/                  # Modules spécifiques au laptop
    │   ├── default.nix         # Secrets management (sops-nix) et config de base
    │   ├── users.nix           # Définition utilisateur et packages
    │   ├── gaming.nix          # Gaming (Steam, xpadneo) - avec options
    │   ├── virtualization.nix  # Docker & VirtualBox - avec options
    │   ├── printing.nix        # Imprimantes - avec options
    │   ├── power.nix           # Power management - avec options
    │   ├── bluetooth.nix       # Bluetooth - avec options
    │   └── zwift.nix           # Zwift cycling simulator - avec options
    └── nixos/                   # Modules système génériques
        ├── base.nix            # Configuration système de base (Nix, packages, fonts, locale)
      ├── yubikey.nix         # Authentification YubiKey globale (login/sudo)
        ├── desktop-i3.nix      # Window manager i3
        ├── net.nix             # Réseau (DNS chiffré, WiFi settings)
        ├── wireless-networks.nix # Configuration des réseaux WiFi (SSID, auth)
        └── parsec.nix          # Parsec Cloud client
```

## ⚙️ Configuration Centralisée

Tous les paramètres personnalisables se trouvent dans [config.nix](config.nix) :

```nix
{
  username = "alice";                        # Votre username
  userEmail = "amaury.joly";                # Email pour réseaux WPA-EAP
  configFlakePath = /etc/nixos;            # Chemin vers la config flake
  timezone = "Europe/Paris";               # Timezone
  locale = "fr_FR.UTF-8";                  # Locale
  hostname = "nixos";                      # Hostname du système
}
```

**À adapter lors de la première installation :**
1. Ouvrir [config.nix](config.nix)
2. Remplacer les valeurs par vos préférences (username, email, timezone, etc.)
3. Ces valeurs sont ensuite utilisées automatiquement dans tous les modules

## 🎛️ Système d'Options Modulaires

La configuration utilise le système d'options NixOS pour activer/désactiver des fonctionnalités. Toutes les options sont définies dans [configuration.nix](configuration.nix) :

### Gaming
```nix
custom.gaming.enable = true;           # Active Steam et support gaming
custom.gaming.enableXpadneo = true;    # Driver pour manettes Xbox
```

### Virtualisation
```nix
custom.virtualization.docker.enable = true;       # Active Docker
custom.virtualization.docker.dnsServers = [ "172.17.0.1" ];  # DNS pour containers
custom.virtualization.virtualbox.enable = true;   # Active VirtualBox
```

### Impression
```nix
custom.printing.enable = true;
custom.printing.printers = [          # Liste des imprimantes
  {
    name = "Mon_Imprimante";
    location = "Bureau";
    deviceUri = "http://192.168.1.100";
    model = "drv:///sample.drv/generic.ppd";
  }
];
custom.printing.defaultPrinter = "Mon_Imprimante";
```

### Power Management
```nix
custom.power.enable = true;
custom.power.cpuGovernor = "powersave";  # ou "performance", "ondemand"
```

### Bluetooth
```nix
custom.bluetooth.enable = true;
custom.bluetooth.powerOnBoot = true;     # Activer Bluetooth au démarrage
```

### Zwift
```nix
custom.zwift.enable = true;              # Zwift cycling simulator
```

**💡 Avantages :**
- ✅ **Activation conditionnelle** : Désactiver une fonctionnalité = `enable = false;`
- ✅ **Documentation intégrée** : `nixos-option custom.gaming.enable` affiche la doc
- ✅ **Pas de code mort** : Les modules désactivés ne sont pas évalués
- ✅ **Réutilisable** : Facile de créer une config pour une autre machine

## 🚀 Déploiement

### Build et test (sans activer)
```bash
cd ~/src/nixos-config
nixos-rebuild build --flake .#laptop
```

### Activer la configuration
```bash
sudo nixos-rebuild switch --flake .#laptop
```

### Mettre à jour les inputs
```bash
nix flake update
sudo nixos-rebuild switch --flake .#laptop
```

### Avec nh (helper recommandé)
```bash
nh os switch  # NH_OS_FLAKE est configuré automatiquement
```

## 🔐 Gestion des Secrets (sops-nix)

Cette configuration utilise [sops-nix](https://github.com/Mic92/sops-nix) pour gérer les secrets de manière sécurisée.

### Configuration initiale

1. **Générer une clé age** (si pas déjà fait) :
```bash
mkdir -p ~/.config/sops/age
age-keygen -o ~/.config/sops/age/keys.txt
```

2. **Configurer sops pour la clé publique** :
```bash
# Afficher votre clé publique
age-keygen -y ~/.config/sops/age/keys.txt

# Créer .sops.yaml à la racine si nécessaire
cat > .sops.yaml << EOF
keys:
  - &alice YOUR_PUBLIC_KEY_HERE
creation_rules:
  - path_regex: secrets/.*\.yaml$
    key_groups:
    - age:
      - *alice
EOF
```

3. **Créer et éditer les fichiers secrets** :
```bash
mkdir -p ~/.config/secrets/

# Pour les credentials WiFi (legacy - optionnel)
sops ~/.config/secrets/wireless.yaml

# Pour la configuration complète des réseaux WiFi (RECOMMANDÉ - tout chiffré)
sops ~/.config/secrets/wifi-networks.yaml

# Pour Zwift
sops ~/.config/secrets/zwift.yaml
```

### 📡 Configuration WiFi Sécurisée (Tout Chiffré)

**🔒 Nouveauté** : La configuration WiFi est maintenant **entièrement chiffrée** avec sops, incluant :
- ✅ Noms des réseaux (SSID)
- ✅ Identités/usernames
- ✅ Mots de passe
- ✅ Structure complète de configuration

**Avantages** :
- Aucune information sensible visible dans le code source
- Pas d'exposition des lieux (noms de réseaux maison/travail)
- Configuration complète dans un seul fichier chiffré

### Créer la configuration WiFi chiffrée

1. **Copier l'exemple de configuration** :
```bash
cp wifi-networks.yaml.example ~/.config/secrets/wifi-networks.yaml
```

2. **Éditer avec sops** :
```bash
sops ~/.config/secrets/wifi-networks.yaml
```

3. **Format du fichier** (syntaxe wpa_supplicant.conf) :
```yaml
# Réseau personnel (WPA-PSK)
network={
    ssid="Mon_WiFi_Maison"
    psk="mon_mot_de_passe_securise"
    priority=100
}

# Réseau entreprise (WPA-EAP)
network={
    ssid="Work_Network"
    key_mgmt=WPA-EAP
    eap=TTLS
    identity="username@company.com"
    password="password_entreprise"
    phase2="auth=PAP"
    priority=10
}

# Eduroam (université)
network={
    ssid="eduroam"
    key_mgmt=WPA-EAP
    eap=PEAP
    identity="etudiant@universite.fr"
    password="mot_de_passe_univ"
}

# Réseau caché
network={
    ssid="Hidden_Network"
    psk="password"
    scan_ssid=1
    priority=50
}
```

### Ajouter un nouveau réseau WiFi

**Tout se fait dans le fichier chiffré !**

```bash
# Éditer le fichier chiffré
sops ~/.config/secrets/wifi-networks.yaml

# Ajouter un nouveau bloc network={...}
# Sauvegarder et quitter

# Appliquer la configuration
sudo nixos-rebuild switch --flake .#laptop
```

**Exemples de configuration selon le type de réseau** :

**WiFi personnel (WPA2)** :
```
network={
    ssid="MonReseau"
    psk="MotDePasse123"
    priority=100
}
```

**WiFi entreprise (802.1X)** :
```
network={
    ssid="CorpWiFi"
    key_mgmt=WPA-EAP
    eap=TTLS
    identity="user@company.com"
    password="my_password"
    phase2="auth=PAP"
}
```

**Hotspot mobile** :
```
network={
    ssid="iPhone_Alice"
    psk="hotspot_pass"
    scan_ssid=1
}
```

### Migration depuis l'ancienne configuration

Si vous aviez des réseaux définis en Nix (ancienne méthode), migrez-les vers le fichier chiffré :

1. Copier les configs depuis [modules/nixos/wireless-networks.nix](modules/nixos/wireless-networks.nix)
2. Convertir au format wpa_supplicant.conf
3. Ajouter dans `~/.config/secrets/wifi-networks.yaml`
4. Chiffrer avec sops
5. Les anciennes définitions seront ignorées

### Format du fichier zwift.yaml
```yaml
# Configuration Zwift ici
```

## 📦 Modules et Fonctionnalités

### 🖥️ Système de Base

**Base System** ([modules/nixos/base.nix](modules/nixos/base.nix))
- Configuration Nix avec flakes et nix-command
- Packages système essentiels (wget, jq, element-desktop, etc.)
- Fonts Nerd Fonts (DejaVu, Droid Sans Mono)
- Locale française (Europe/Paris - configurable)
- Shell Fish par défaut

**YubiKey Authentication** ([modules/nixos/yubikey.nix](modules/nixos/yubikey.nix))
- Active l'authentification YubiKey (U2F) pour `login` et `sudo`
- S'applique à tous les systèmes qui importent ce module

**Fingerprint (Laptop)** ([modules/laptop/fingerprint.nix](modules/laptop/fingerprint.nix))
- Active `fprintd` sur le laptop
- Ajoute l'authentification empreinte pour `login` et `sudo`
- Sur laptop, l'authentification peut se faire avec **YubiKey ou empreinte** selon la méthode disponible

**Networking** ([modules/nixos/net.nix](modules/nixos/net.nix))
- **DNS chiffré** : dnscrypt-proxy (primaire + backup dns0-eu)
- **WiFi** : wpa_supplicant avec multi-réseaux
- **Hostname** : Configurable via [config.nix](config.nix)

**Desktop** ([modules/nixos/desktop-i3.nix](modules/nixos/desktop-i3.nix))
- Window manager **i3**
- Terminal : **alacritty**
- Launcher : **rofi**
- Panel : **tint2**
- Notifications : **dunst**

### 🎮 Fonctionnalités Optionnelles (avec options)

**Gaming** ([modules/laptop/gaming.nix](modules/laptop/gaming.nix))
- Steam avec steam-hardware
- Driver xpadneo pour manettes Xbox (optionnel)
- Option : `custom.gaming.enable`

**Virtualization** ([modules/laptop/virtualization.nix](modules/laptop/virtualization.nix))
- Docker avec DNS personnalisé
- VirtualBox avec extension pack
- Options : `custom.virtualization.docker.enable`, `custom.virtualization.virtualbox.enable`

**Printing** ([modules/laptop/printing.nix](modules/laptop/printing.nix))
- CUPS avec configuration d'imprimantes
- Option : `custom.printing.enable`

**Power Management** ([modules/laptop/power.nix](modules/laptop/power.nix))
- CPU frequency governor configurable
- Option : `custom.power.enable`

**Bluetooth** ([modules/laptop/bluetooth.nix](modules/laptop/bluetooth.nix))
- Bluetooth avec blueman GUI
- Mode dual controller + experimental features
- Option : `custom.bluetooth.enable`

**Zwift** ([modules/laptop/zwift.nix](modules/laptop/zwift.nix))
- Zwift cycling simulator via Docker
- Ports réseau configurés automatiquement
- Option : `custom.zwift.enable`

### 👤 Utilisateur & Applications

**User Configuration** ([modules/laptop/users.nix](modules/laptop/users.nix))

Packages par catégorie :
- **Browsers** : Firefox
- **Office** : LibreOffice, OnlyOffice, Obsidian, TickTick, Nextcloud
- **Development** : VSCode, Git, Neovim, Zotero, tcpdump, Pandoc
- **Communication** : Slack, Thunderbird, Discord
- **Media** : VLC, Spotify, Mixxx, Pympress
- **Gaming** : Prismlauncher (Minecraft), Widelands, Moonlight
- **System** : Rclone, Fuse3, Pavucontrol

## 🔧 Flake Inputs

- **nixpkgs** : nixos-unstable channel
- **sops-nix** : Secrets management
- **parsec-cloud-nix** : Parsec Cloud client
- **claude-desktop** : Claude AI desktop app
- **zwift** : Zwift cycling simulator

## � Personnalisation

### Configuration de base

1. **Timezone et Locale** : Éditer [config.nix](config.nix)
   ```nix
   timezone = "Europe/Paris";
   locale = "fr_FR.UTF-8";
   ```

2. **Username et email** : Éditer [config.nix](config.nix)
   ```nix
   username = "alice";
   userEmail = "votre.email";
   ```

3. **Hostname** : Éditer [config.nix](config.nix)
   ```nix
   hostname = "nixos";
   ```

### Activer/Désactiver des fonctionnalités

Dans [configuration.nix](configuration.nix), modifier les options `custom.*` :

```nix
# Désactiver le gaming
custom.gaming.enable = false;

# Activer uniquement Docker (pas VirtualBox)
custom.virtualization.docker.enable = true;
custom.virtualization.virtualbox.enable = false;

# Changer le CPU governor
custom.power.cpuGovernor = "performance";  # pour laptop branché
```

### Ajouter des packages utilisateur

Éditer [modules/laptop/users.nix](modules/laptop/users.nix) et ajouter dans la liste appropriée :

```nix
packages = with pkgs; [
  # Development
  python3
  nodejs
  # ... vos packages
];
```

### Ajouter une nouvelle fonctionnalité avec options

1. Créer `modules/laptop/ma-feature.nix` :
```nix
{ config, lib, pkgs, ... }:
{
  options.custom.maFeature.enable = lib.mkEnableOption "ma fonctionnalité";
  
  config = lib.mkIf config.custom.maFeature.enable {
    # votre configuration
  };
}
```

2. Importer dans [configuration.nix](configuration.nix)
3. Activer : `custom.maFeature.enable = true;`

## 🐛 Dépannage

### Lister les options disponibles
```bash
# Voir toutes les options custom.*
nixos-option custom

# Voir une option spécifique avec sa documentation
nixos-option custom.gaming.enable
```

### Erreurs de build
```bash
# Vérifier la syntaxe Nix
nix flake check

# Build avec logs détaillés
nixos-rebuild build --flake .#laptop --show-trace
```

### Secrets non déchiffrables
Vérifier que :
- La clé age existe : `~/.config/sops/age/keys.txt`
- Les fichiers secrets existent : `~/.config/secrets/*.yaml`
- Les permissions sont correctes (0400 recommandé)

### Problèmes DNS
```bash
# Vérifier dnscrypt-proxy
systemctl status dnscrypt-proxy
systemctl status dnscrypt-proxy-backup

# Tester la résolution
dig @127.0.0.1 example.com
```

## 📚 Ressources

- [NixOS Manual](https://nixos.org/manual/nixos/stable/)
- [Nix Flakes Guide](https://nixos.wiki/wiki/Flakes)
- [sops-nix Documentation](https://github.com/Mic92/sops-nix)
- [Home Manager](https://github.com/nix-community/home-manager) (à considérer pour config utilisateur)

## 📝 Notes

- **stateVersion** : Actuellement `24.05` - **NE PAS MODIFIER** après installation
- **Auto-upgrade** : Désactivé pour éviter les mises à jour imprévues
- **Unfree packages** : Activé globalement pour Steam, Slack, etc.

## 🔄 Maintenance

### Nettoyage du store Nix
```bash
# Via nh (automatique toutes les 4 jours, garde 3 générations)
nh clean all --keep-since 4d --keep 3

# Ou manuellement
nix-collect-garbage -d
sudo nix-collect-garbage -d
```

### Lister les générations
```bash
nixos-rebuild list-generations
```

### Rollback
```bash
sudo nixos-rebuild switch --rollback
# Ou au boot via GRUB
```