secubox-openwrt/.claude/module-implementation-guide.md

🔧 Guide d'Implémentation de Nouveaux Modules SecuBox

Ce guide fournit un framework structuré pour implémenter de nouveaux modules SecuBox avec suivi complet du développement.

---

📋 Template de Prompt d'Implémentation

Utilise ce template pour demander l'implémentation d'un nouveau module:

## Nouveau Module SecuBox: {NOM_MODULE}

### 🎯 Contexte et Objectif

**Nom du module**: luci-app-{nom-module}
**Catégorie**: [Security / Network / System / Performance / Services]
**Description courte**: {Description en 1-2 phrases}
**Cas d'utilisation**: {Qui utilisera ce module et pourquoi}

### 📊 Fonctionnalités Requises

Liste numérotée des fonctionnalités principales:

1. **{Fonctionnalité 1}**: {Description détaillée}
   - Sous-fonctionnalité A
   - Sous-fonctionnalité B

2. **{Fonctionnalité 2}**: {Description détaillée}
   - Sous-fonctionnalité A
   - Sous-fonctionnalité B

3. **{Fonctionnalité 3}**: {Description détaillée}

### 🔌 Intégration Système

**Service système**: {nom du daemon/service}
**Commandes CLI**:
- `{commande1}` - {description}
- `{commande2}` - {description}

**Fichiers de configuration**:
- `/etc/{config-file}` - {description}
- `/var/run/{runtime-file}` - {description}

**Dépendances packages**:
- `{package1}` - {description}
- `{package2}` - {description}

### 🎨 Méthodes RPCD

Script: `/usr/libexec/rpcd/luci.{nom-module}`

#### Méthodes de Base
1. **status**: État du service
   - Retour: `{ "running": bool, "enabled": bool, "version": string, ... }`

2. **get_info**: Informations système
   - Retour: `{ ... }`

#### Méthodes de Gestion
3. **list_{ressource}**: Liste des ressources
   - Retour: `{ "{ressources}": [...] }`

4. **get_{ressource}**: Détails d'une ressource
   - Params: `id`
   - Retour: `{ ... }`

5. **add_{ressource}**: Créer une ressource
   - Params: `{ param1, param2, ... }`
   - Retour: `{ "success": bool, "id": string }`

6. **update_{ressource}**: Modifier une ressource
   - Params: `{ id, param1, param2, ... }`
   - Retour: `{ "success": bool }`

7. **delete_{ressource}**: Supprimer une ressource
   - Params: `id`
   - Retour: `{ "success": bool }`

#### Méthodes Spécifiques
8. **{methode_specifique_1}**: {Description}
9. **{methode_specifique_2}**: {Description}

### 🗄️ Configuration UCI

Fichier: `/etc/config/{nom-module}`

```uci
config global 'main'
    option enabled '1'
    option {param1} '{valeur}'
    option {param2} '{valeur}'

config {type_section} '{id_section}'
    option {param1} '{valeur}'
    option {param2} '{valeur}'
    list {param_list} '{valeur1}'
    list {param_list} '{valeur2}'

🎨 Interface Utilisateur (Views)

Vue 1: Overview/Dashboard

Fichier: htdocs/luci-static/resources/view/{module}/overview.js

Éléments:

• Status cards (service running, stats)
• Graphiques/visualisations
• Actions rapides
• Liens vers autres vues

Auto-refresh: Oui (5s pour status, 10s pour stats)

Vue 2: {Nom Vue 2}

Fichier: htdocs/luci-static/resources/view/{module}/{vue2}.js

Éléments:

• Tableau CRUD avec form.GridSection
• Modals pour création/édition
• Validation des inputs
• Confirmations de suppression

Vue 3: {Nom Vue 3}

Fichier: htdocs/luci-static/resources/view/{module}/{vue3}.js

Éléments:

• ...

🎯 Spécifications Techniques

Parsing de Sortie CLI

# Exemple de commande et parsing attendu
{commande} | {parsing}

# Output format attendu
{...}

Gestion d'Erreurs

• Erreur si service non installé: { "error": "Service not installed" }
• Erreur si permission refusée: { "error": "Permission denied" }
• Erreur si ressource inexistante: { "error": "Not found" }

Sécurité

• Validation des inputs: {regex/validation}
• Sanitization des chaînes: Oui/Non
• Permissions requises: {root/user/...}

📦 Livrables Attendus

IMPORTANT: Génère TOUS les fichiers complets suivants:

1. Makefile avec dépendances correctes
2. RPCD Backend (/root/usr/libexec/rpcd/luci.{module})
   • Toutes les méthodes implémentées
   • Gestion d'erreurs complète
   • JSON valide pour chaque retour
3. API Client (/htdocs/luci-static/resources/{module}/api.js)
   • Déclarations RPC pour toutes les méthodes
   • Fonctions utilitaires (formatage, etc.)
4. Views JavaScript (tous les fichiers .js nécessaires)
   • Code complet, pas de placeholders
   • Gestion d'erreurs UI
   • Auto-refresh où approprié
5. Menu JSON (/root/usr/share/luci/menu.d/luci-app-{module}.json)
6. ACL JSON (/root/usr/share/rpcd/acl.d/luci-app-{module}.json)
7. UCI Config Template (optionnel si besoin)
8. README.md avec:
   • Installation
   • Configuration
   • Usage
   • Dépendances
   • Troubleshooting

✅ Checklist de Validation

Avant de marquer comme terminé, vérifier:

• Tous les fichiers générés
• RPCD script exécutable (chmod +x)
• Nom RPCD = luci.{module} (convention obligatoire)
• Tous les appels RPC matchent les méthodes RPCD
• Paths menu matchent les fichiers view
• JavaScript syntaxe valide (node -c)
• JSON files valides (jsonlint)
• ACL inclut toutes les méthodes RPCD
• Dépendances Makefile complètes
• Gestion d'erreurs implémentée partout
• Documentation README complète

🔄 Workflow d'Implémentation

1. Phase 1: Backend

   • Implémenter RPCD avec toutes les méthodes
   • Tester chaque méthode individuellement avec ubus call

2. Phase 2: API Client

   • Créer api.js avec déclarations RPC
   • Ajouter fonctions utilitaires

3. Phase 3: Views

   • Implémenter vue overview (dashboard)
   • Implémenter vues CRUD
   • Implémenter vues spécifiques

4. Phase 4: Configuration

   • Menu JSON
   • ACL JSON
   • UCI template si nécessaire

5. Phase 5: Validation

   • Run ./secubox-tools/validate-modules.sh
   • Vérifier syntaxe JavaScript
   • Tester sur router si possible

📝 Notes d'Implémentation

{Notes spécifiques, contraintes, choix d'architecture, etc.}

---

Instructions Finales

Implémente ce module en suivant EXACTEMENT les patterns des 14 modules existants:

• Structure des fichiers identique
• Conventions de nommage cohérentes
• Style de code similaire
• Validation complète avant livraison

Génère tous les fichiers complets. Ne laisse AUCUN placeholder ou TODO.

---

## 🔐 Exemple Concret: Module KSM (Key Storage Manager)

Voici un exemple d'utilisation du template pour un module de gestion de clés avec support Nitrokey:

```markdown
## Nouveau Module SecuBox: Key Storage Manager

### 🎯 Contexte et Objectif

**Nom du module**: luci-app-ksm-manager
**Catégorie**: Security
**Description courte**: Gestionnaire centralisé de clés cryptographiques avec support hardware (Nitrokey, YubiKey) et stockage sécurisé.
**Cas d'utilisation**: Administrateurs système gérant des certificats SSL, clés SSH, secrets d'application, et tokens avec support HSM/USB.

### 📊 Fonctionnalités Requises

1. **Gestion des Clés Cryptographiques**
   - Génération de clés (RSA, ECDSA, Ed25519)
   - Import/export de clés (PEM, DER, P12)
   - Listing avec métadonnées (type, taille, usage, expiration)
   - Suppression sécurisée (shred)

2. **Support Hardware Security Modules**
   - Détection automatique Nitrokey/YubiKey (USB)
   - Initialisation/PIN management
   - Génération de clés on-chip
   - Opérations cryptographiques (sign, encrypt)
   - Backup/restore de tokens

3. **Stockage Sécurisé de Secrets**
   - Keystore chiffré (AES-256-GCM)
   - Secrets applicatifs (API keys, passwords)
   - Rotation automatique de secrets
   - Historique d'accès (audit log)

4. **Intégration Certificats**
   - Génération CSR (Certificate Signing Request)
   - Import certificats (Let's Encrypt, CA interne)
   - Vérification chaîne de confiance
   - Alertes expiration (< 30 jours)

5. **SSH Key Management**
   - Génération de paires SSH
   - Déploiement vers authorized_keys
   - Agent SSH avec forward (ssh-agent)
   - Support certificats SSH

### 🔌 Intégration Système

**Services système**:
- `nitropy` - CLI Nitrokey
- `ykman` - CLI YubiKey
- `gnupg2` - GPG/OpenPGP
- `opensc` - Smart card framework

**Commandes CLI**:
- `nitropy nk3 list` - Liste Nitrokey connectées
- `ykman list` - Liste YubiKey connectées
- `gpg --card-status` - Status carte OpenPGP
- `pkcs11-tool --list-tokens` - Liste tokens PKCS#11
- `openssl` - Génération clés/CSR

**Fichiers de configuration**:
- `/etc/ksm/keystore.db` - Base SQLite chiffrée
- `/etc/ksm/config.json` - Configuration module
- `/var/log/ksm-audit.log` - Logs d'accès

**Dépendances packages**:
- `nitropy` - Nitrokey tools
- `yubikey-manager` - YubiKey management
- `gnupg2` - GPG support
- `opensc` - Smart card support
- `openssl` - Crypto operations
- `libccid` - USB CCID driver
- `pcscd` - PC/SC daemon

### 🎨 Méthodes RPCD

Script: `/usr/libexec/rpcd/luci.ksm-manager`

#### Méthodes de Base
1. **status**: État du service
   - Retour: `{ "running": bool, "keystore_unlocked": bool, "keys_count": int, "hsm_connected": bool }`

2. **get_info**: Informations système
   - Retour: `{ "openssl_version": string, "gpg_version": string, "hsm_support": bool }`

#### Méthodes HSM/Hardware
3. **list_hsm_devices**: Liste devices USB
   - Retour: `{ "devices": [{ "type": "nitrokey", "serial": "...", "version": "..." }] }`

4. **get_hsm_status**: Status d'un device
   - Params: `serial`
   - Retour: `{ "initialized": bool, "pin_retries": int, "keys_count": int }`

5. **init_hsm**: Initialiser un HSM
   - Params: `serial, admin_pin, user_pin`
   - Retour: `{ "success": bool }`

6. **generate_hsm_key**: Générer clé on-chip
   - Params: `serial, key_type, key_size, label`
   - Retour: `{ "success": bool, "key_id": string }`

#### Méthodes Gestion de Clés
7. **list_keys**: Liste toutes les clés
   - Retour: `{ "keys": [{ "id": string, "label": string, "type": string, "size": int, "created": timestamp }] }`

8. **generate_key**: Générer une clé logicielle
   - Params: `type, size, label, passphrase`
   - Retour: `{ "success": bool, "id": string, "public_key": string }`

9. **import_key**: Importer une clé
   - Params: `label, key_data, format, passphrase`
   - Retour: `{ "success": bool, "id": string }`

10. **export_key**: Exporter une clé
    - Params: `id, format, include_private, passphrase`
    - Retour: `{ "success": bool, "key_data": string }`

11. **delete_key**: Supprimer une clé
    - Params: `id, secure_erase`
    - Retour: `{ "success": bool }`

#### Méthodes Certificats
12. **generate_csr**: Générer CSR
    - Params: `key_id, subject_dn, san_list`
    - Retour: `{ "success": bool, "csr": string }`

13. **import_certificate**: Importer certificat
    - Params: `key_id, cert_data, chain`
    - Retour: `{ "success": bool, "cert_id": string }`

14. **list_certificates**: Liste certificats
    - Retour: `{ "certificates": [{ "id": string, "subject": string, "issuer": string, "valid_until": timestamp }] }`

15. **verify_certificate**: Vérifier certificat
    - Params: `cert_id`
    - Retour: `{ "valid": bool, "chain_valid": bool, "expires_in_days": int }`

#### Méthodes Secrets
16. **store_secret**: Stocker un secret
    - Params: `label, secret_data, category, auto_rotate`
    - Retour: `{ "success": bool, "secret_id": string }`

17. **retrieve_secret**: Récupérer un secret
    - Params: `secret_id`
    - Retour: `{ "success": bool, "secret_data": string, "accessed_at": timestamp }`

18. **list_secrets**: Liste secrets
    - Retour: `{ "secrets": [{ "id": string, "label": string, "category": string, "created": timestamp }] }`

19. **rotate_secret**: Rotation de secret
    - Params: `secret_id, new_secret_data`
    - Retour: `{ "success": bool, "version": int }`

#### Méthodes SSH
20. **generate_ssh_key**: Générer paire SSH
    - Params: `label, key_type, comment`
    - Retour: `{ "success": bool, "key_id": string, "public_key": string }`

21. **deploy_ssh_key**: Déployer vers authorized_keys
    - Params: `key_id, target_host, target_user`
    - Retour: `{ "success": bool }`

#### Méthodes Audit
22. **get_audit_logs**: Logs d'accès
    - Params: `limit, offset, filter_type`
    - Retour: `{ "logs": [{ "timestamp": timestamp, "action": string, "user": string, "key_id": string }] }`

### 🗄️ Configuration UCI

Fichier: `/etc/config/ksm`

```uci
config global 'main'
    option enabled '1'
    option keystore_path '/etc/ksm/keystore.db'
    option audit_enabled '1'
    option audit_retention '90'
    option auto_backup '1'

config hsm_device 'device_123'
    option serial 'NK3-ABC123'
    option type 'nitrokey'
    option label 'Production HSM'
    option enabled '1'

config key 'key_456'
    option label 'SSL Certificate Key'
    option type 'rsa'
    option size '4096'
    option usage 'ssl'
    option storage 'hsm'
    option hsm_serial 'NK3-ABC123'
    option created '2025-01-15T10:00:00Z'

config secret 'secret_789'
    option label 'API Key GitHub'
    option category 'api_key'
    option auto_rotate '1'
    option rotation_days '90'
    option created '2025-01-15T10:00:00Z'

config certificate 'cert_101'
    option key_id 'key_456'
    option subject 'CN=example.com'
    option issuer 'CN=Let's Encrypt'
    option valid_from '2025-01-01T00:00:00Z'
    option valid_until '2025-04-01T00:00:00Z'
    option alert_days '30'

🎨 Interface Utilisateur (Views)

Vue 1: Overview/Dashboard

Fichier: htdocs/luci-static/resources/view/ksm-manager/overview.js

Éléments:

• Status cards: Keystore locked/unlocked, HSM connected, Keys count, Expiring certs
• HSM Devices: Cards avec serial, type, status (connected/disconnected), PIN retries
• Quick Stats: Pie chart types de clés (RSA/ECDSA/Ed25519)
• Expiring Certificates: Timeline avec alertes < 30 jours
• Recent Activity: 10 dernières actions d'audit
• Actions rapides: Unlock keystore, Generate key, Import certificate

Auto-refresh: 10s pour HSM status, 30s pour stats

Vue 2: Keys Management

Fichier: htdocs/luci-static/resources/view/ksm-manager/keys.js

Éléments:

• Tableau GridSection avec:
  • Colonnes: Label, Type, Size, Storage (software/hsm), Created, Actions
  • Filtres: Type, Storage location
  • Tri par date/label
• Modal Generate Key:
  • Type (RSA/ECDSA/Ed25519)
  • Size (dropdown: 2048/3072/4096 pour RSA, 256/384/521 pour ECDSA)
  • Storage (software/hsm selector)
  • Label, Passphrase
  • Button "Generate" → progress → success
• Modal Import Key:
  • Format (PEM/DER/P12)
  • File upload ou paste textarea
  • Passphrase si encrypted
  • Label
• Actions inline:
  • View public key (modal avec copy button)
  • Export (format selector)
  • Delete (confirmation avec secure erase option)

Vue 3: HSM Devices

Fichier: htdocs/luci-static/resources/view/ksm-manager/hsm.js

Éléments:

• Auto-detect: Button scan USB devices
• Device Cards pour chaque HSM:
  • Header: Type icon (Nitrokey/YubiKey) + Serial + Label
  • Status: Initialized, PIN retries (progress bar), Keys count
  • Actions: Initialize, Change PIN, Generate key on-chip, Backup, Factory reset
• Modal Initialize HSM:
  • Admin PIN (strength meter)
  • User PIN (strength meter)
  • Label
  • Warning: Factory reset si déjà initialisé
• Modal Generate HSM Key:
  • Key type, size, label
  • Requires user PIN
  • Progress indicator
• Key list per HSM: Expandable section showing keys stored on chip

Vue 4: Certificates

Fichier: htdocs/luci-static/resources/view/ksm-manager/certificates.js

Éléments:

• Tableau certificates:
  • Colonnes: Subject CN, Issuer, Valid from/until, Days remaining, Status
  • Color coding: Green (>30d), Orange (7-30d), Red (<7d), Gray (expired)
  • Actions: View details, Export PEM, Revoke, Delete
• Modal Generate CSR:
  • Select key (dropdown)
  • Subject DN fields (CN, O, OU, C, ST, L)
  • SAN list (domains, IPs)
  • Generate button → CSR textarea avec copy
  • Download .csr button
• Modal Import Certificate:
  • Select key to associate
  • Certificate PEM (textarea or file upload)
  • Certificate chain (optional)
  • Validate button → shows cert info before import
• Certificate Details Modal:
  • Full subject/issuer DN
  • Serial number
  • Validity dates
  • Public key info
  • Extensions (Key Usage, Extended Key Usage, SAN)
  • Certificate chain visualization
  • Verify chain button

Vue 5: Secrets

Fichier: htdocs/luci-static/resources/view/ksm-manager/secrets.js

Éléments:

• Tableau secrets:
  • Colonnes: Label, Category, Created, Last accessed, Auto-rotate, Actions
  • Categories: API Key, Password, Token, Database, Other
  • Masked secrets (show button reveals for 10s)
• Modal Add Secret:
  • Label
  • Category (dropdown)
  • Secret value (textarea, masked)
  • Auto-rotate toggle + rotation days
  • Expiration date (optional)
• Modal View Secret:
  • Shows secret with copy button
  • Warning: "This access will be logged"
  • Auto-hide after 30 seconds
  • Access history table
• Actions:
  • View/copy (logs access)
  • Rotate (enter new value)
  • Delete (confirmation)

Vue 6: SSH Keys

Fichier: htdocs/luci-static/resources/view/ksm-manager/ssh.js

Éléments:

• Tableau SSH keys:
  • Colonnes: Label, Type, Fingerprint, Created, Deployed to, Actions
• Modal Generate SSH Key:
  • Type (RSA/ECDSA/Ed25519)
  • Size (for RSA)
  • Comment
  • Passphrase (optional)
• Modal Deploy Key:
  • Select key
  • Target host
  • Target user
  • Port
  • Test connection button
  • Deploy button
• Public key display: Copy to clipboard button

Vue 7: Audit Logs

Fichier: htdocs/luci-static/resources/view/ksm-manager/audit.js

Éléments:

• Timeline logs:
  • Timestamp, User, Action, Resource (key/secret/cert), Status
  • Color coding par action type
  • Filtres: Date range, Action type, User, Resource
• Export logs: CSV/JSON download
• Auto-refresh: 15s

Vue 8: Settings

Fichier: htdocs/luci-static/resources/view/ksm-manager/settings.js

Éléments:

• Keystore Settings:
  • Change master password
  • Keystore path
  • Auto-lock timeout
  • Backup schedule
• Audit Settings:
  • Enable/disable audit
  • Retention period (days)
  • Log level
• Alerts Settings:
  • Certificate expiration threshold (days)
  • Secret rotation reminder
  • HSM disconnect alerts
• Backup/Restore:
  • Create backup (encrypted archive)
  • Restore from backup
  • Auto-backup toggle + schedule

🎯 Spécifications Techniques

Parsing de Sortie CLI

Nitrokey List:

nitropy nk3 list --json | jq -c '.[]'
# Output: {"path": "/dev/hidraw0", "serial_number": "NK3-ABC123", "firmware_version": "1.2.0"}

YubiKey List:

ykman list --serials
# Output: NK3-ABC123

OpenSSL Key Generation:

openssl genpkey -algorithm RSA -pkeyopt rsa_keygen_bits:4096 -out /tmp/key.pem
openssl rsa -in /tmp/key.pem -pubout -out /tmp/key.pub

Certificate Info:

openssl x509 -in cert.pem -noout -subject -issuer -dates -serial

Gestion d'Erreurs

• HSM non détecté: { "error": "HSM not found", "code": "HSM_NOT_FOUND" }
• PIN incorrect: { "error": "Invalid PIN", "retries_left": 2, "code": "INVALID_PIN" }
• Keystore locked: { "error": "Keystore locked", "code": "KEYSTORE_LOCKED" }
• Clé inexistante: { "error": "Key not found", "code": "KEY_NOT_FOUND" }
• Certificate expiré: { "error": "Certificate expired", "code": "CERT_EXPIRED" }

Sécurité

• Validation inputs:
  • Serial: ^[A-Z0-9-]+$
  • Label: ^[a-zA-Z0-9 _-]{1,64}$
  • PIN: 6-32 caractères
• Sanitization: Toutes les entrées utilisateur passées à openssl/gpg
• Permissions: Root requis pour accès /dev/hidraw*
• Audit: Tous les accès aux secrets loggés
• Encryption: Keystore chiffré AES-256-GCM avec KDF (PBKDF2)

📦 Livrables Attendus

Génère TOUS les fichiers complets:

1. ✅ Makefile avec dépendances (nitropy, yubikey-manager, gnupg2, opensc, openssl, libccid, pcscd)
2. ✅ RPCD Backend avec 22 méthodes complètes
3. ✅ API Client avec toutes les déclarations RPC + utilitaires
4. ✅ 8 Views JavaScript (overview, keys, hsm, certificates, secrets, ssh, audit, settings)
5. ✅ Menu JSON avec 8 entrées
6. ✅ ACL JSON avec toutes les permissions
7. ✅ README.md complet avec:
   • Guide installation Nitrokey/YubiKey drivers
   • Configuration initiale du keystore
   • Exemples d'utilisation
   • Troubleshooting USB permissions
   • Best practices sécurité

✅ Checklist de Validation

• RPCD backend complet avec 22 méthodes
• Gestion HSM (Nitrokey + YubiKey)
• Génération/import/export de clés
• Gestion certificats avec CSR
• Stockage secrets chiffrés
• SSH key management
• Audit logs complets
• 8 views fonctionnelles
• Auto-refresh approprié
• Validation inputs partout
• Gestion erreurs complète
• Nom RPCD = luci.ksm-manager
• Syntaxe JavaScript valide
• Documentation README

🔄 Workflow d'Implémentation

Phase 1: Backend Core

1. Implémenter détection HSM (nitropy/ykman)
2. Créer keystore SQLite chiffré
3. Implémenter méthodes de base (status, info, list)

Phase 2: Key Management 4. Génération clés software (openssl) 5. Import/export clés 6. Génération clés HSM (PKCS#11)

Phase 3: Certificates 7. Génération CSR 8. Import/validation certificats 9. Alertes expiration

Phase 4: Secrets & SSH 10. Stockage secrets chiffrés 11. Rotation automatique 12. SSH key management

Phase 5: Audit & UI 13. Système d'audit logs 14. Toutes les views 15. Auto-refresh et polling

Phase 6: Testing 16. Validation complète 17. Tests avec vrai HSM 18. Documentation

📝 Notes d'Implémentation

Architecture:

• Backend SQLite pour metadata + fichiers PEM pour clés
• Keystore master password → KDF → AES key pour chiffrement
• HSM operations via PKCS#11 (libccid + opensc)
• Audit logs append-only avec rotation

Performance:

• Cache status HSM (TTL 5s) pour éviter USB polling constant
• Index SQLite sur labels, created, expires
• Lazy loading de clés privées

Sécurité:

• Keystore auto-lock après timeout
• PIN retries limités (3 max avant lock)
• Secure memory (mlock) pour clés en RAM
• Shred files avant delete
• Audit tous les accès

---

Instructions Finales

Implémente le module KSM Manager en suivant exactement le template ci-dessus.

• Structure identique aux 14 modules SecuBox existants
• Code complet, zéro placeholders
• Validation complète avant livraison
• Documentation exhaustive

Génère TOUS les fichiers listés. Commence par le backend RPCD, puis API, puis views.

---

## 🎯 Utilisation du Template

### Pour implémenter un nouveau module:

1. **Copie le template** de ce fichier
2. **Remplis chaque section** avec les specs de ton module
3. **Soumets le prompt complet** à Claude
4. **Valide** avec `./secubox-tools/validate-modules.sh`
5. **Teste** sur router ou émulateur

### Exemples d'autres modules possibles:

- **luci-app-iot-hub**: Gestion centralisée dispositifs IoT (MQTT, Zigbee, Z-Wave)
- **luci-app-backup-manager**: Backups automatiques (rsync, rclone, cloud)
- **luci-app-dns-manager**: DNS local avancé (Pi-hole style, DoH, DoT)
- **luci-app-container-manager**: Docker/Podman management
- **luci-app-monitoring-alerts**: Alerting system (Prometheus, Grafana, webhooks)

Adapte le template selon tes besoins spécifiques!