fix: application du buffer d'accumulation aux backends Linux (PipeWire/JACK)

- Ajout buffer d'accumulation dans PipeWireBackend (même pattern que CoreAudio) - Ajout buffer d'accumulation dans JACKBackend - pw-cat et jack_rec émettent aussi des chunks de taille variable - Garantit frames fixes (960 samples) sur tous les backends - Prévient audio haché/robotique sous Linux
fix: audio haché depuis carte son par chunks sox de taille variable
2026-06-02 21:19:45 +02:00 · 2026-06-02 01:14:49 +02:00 · 2026-06-02 00:45:41 +02:00 · 2026-06-02 00:33:26 +02:00 · 2026-06-01 23:51:01 +02:00 · 2026-06-01 23:24:38 +02:00
36 changed files with 2762 additions and 972 deletions
@@ -8,10 +8,18 @@ pnpm-lock.yaml
 .env
 .env.local
 .env.*.local
+server/.env
+client/.env
+
+# Keep .env.example files (templates)
+!.env.example
+!client/.env.example
+!server/.env.example

 # Build outputs
 dist/
 build/
+dev-dist/
 *.log

 # OS files
@@ -43,3 +51,7 @@ yarn-debug.log*
 yarn-error.log*
 pnpm-debug.log*
 lerna-debug.log*
+server.log
+
+# Runtime files
+/tmp/ptt-live.pid
@@ -204,24 +204,48 @@ PTT Live/
 ## Commandes de développement

 ```bash
-# Installation initiale
-./install/macos.sh
+# Installation automatique (recommandé)
+./install.sh  # Détecte OS, configure tout automatiquement

-# Serveur (dev)
+# Démarrage rapide
+./start.sh --dev  # Mode développement
+./start.sh        # Mode production
+
+# OU manuellement (deux terminaux)
+# Serveur
 cd server
 npm install
 npm run dev

-# Client (dev)
+# Client
 cd client
 npm install
 npm run dev
-
-# Production
-cd server
-npm start
 ```

+## Fonctionnalités de portabilité (v0.2.1)
+
+### Installation zéro-config
+- **Script multi-OS** : `install.sh` détecte automatiquement macOS/Linux
+- **Auto-détection IP** : Génère les `.env` avec l'IP réseau du serveur
+- **Devices audio** : API `/admin/devices/list` pour énumérer devices disponibles
+- **Templates** : `.env.example` pour serveur et client
+
+### QR Code terminal
+- **Affichage automatique** au démarrage du serveur
+- **Scan rapide** depuis smartphone (connexion en 5s)
+- **URL adaptative** : dev (5173) ou prod (3000) selon build client
+
+### HTTPS automatique
+- **Vite dev server** : HTTPS par défaut (certificat self-signed)
+- **Redirection HTTP → HTTPS** en mode développement
+- **Production** : utiliser reverse proxy (nginx/Caddy) pour HTTPS
+
+### Configuration dynamique
+- **LIVEKIT_URL: AUTO** dans config.yaml → détection IP runtime
+- **Vite loadEnv()** pour variables d'environnement dynamiques
+- **Serveur statique** : Express sert `client/dist/` en production
+
 ## Tests et validation

 ### Métriques critiques
@@ -307,7 +331,8 @@ test: description
 2. **Après chaque tâche complétée** :
   - ✅ Valider la tâche dans [TODO.md](TODO.md)
   - 🔄 Commiter avec message descriptif en français
-   - 📝 Mettre à jour CLAUDE.md si nécessaire
+   - 📝 Mettre à jour CLAUDE.md si nécessaire sans écrire "🤖 Generated with Claude Code Co-Authored-By: Claude noreply@anthropic.com"
+   - Ne pas créer de fichiers récapitulatifs markdown.

 **Exemple workflow** :
 ```bash
@@ -326,5 +351,5 @@ Voir [TODO.md](TODO.md) pour le plan détaillé.

 ---

-**Dernière mise à jour** : 2026-05-21
-**Version** : 0.1.0 (Phase 1 en cours)
+**Dernière mise à jour** : 2026-05-27
+**Version** : 0.2.1 (Portable + QR Code)
@@ -0,0 +1,408 @@
+# PTT Live - Guide de Déploiement Portable
+
+Ce guide explique comment déployer **PTT Live** sur n'importe quelle machine macOS ou Linux, sans configuration manuelle d'IP ou de devices audio.
+
+---
+
+## 🚀 Installation Rapide
+
+### Prérequis
+
+- **macOS** : Homebrew installé ([brew.sh](https://brew.sh))
+- **Linux** : Ubuntu 22.04+, Debian 11+, Arch Linux ou Fedora
+- **Node.js** : Version 20+ (installé automatiquement si absent)
+- **Connexion Internet** : Pour télécharger les dépendances
+
+### Commandes
+
+```bash
+# Cloner ou télécharger le projet
+cd ptt-live
+
+# Lancer l'installation (détection automatique OS)
+./install.sh
+
+# Ou manuellement selon votre système :
+./install/macos.sh   # macOS
+./install/linux.sh   # Linux
+```
+
+### Ce que l'installeur fait automatiquement
+
+✅ Détecte votre système d'exploitation  
+✅ Installe Node.js 20+ (si absent)  
+✅ Installe LiveKit Server (binaire local)  
+✅ Installe les backends audio (sox/PipeWire/JACK)  
+✅ Détecte votre IP réseau locale  
+✅ Génère les fichiers `.env` avec la bonne configuration  
+✅ Installe toutes les dépendances npm  
+
+---
+
+## 🎬 Démarrage
+
+### Méthode 1 : Script unifié (recommandé)
+
+```bash
+# Mode développement (serveur + client avec hot-reload)
+./start.sh --dev
+
+# Mode production (build client + serveur optimisé)
+./start.sh
+```
+
+L'IP réseau est **détectée automatiquement** et affichée au démarrage.
+
+### Méthode 2 : Manuel (deux terminaux)
+
+**Terminal 1 : Serveur**
+```bash
+cd server
+npm run dev
+```
+
+**Terminal 2 : Client**
+```bash
+cd client
+npm run dev
+```
+
+---
+
+## 🌐 Accès depuis d'autres appareils
+
+### Sur le même réseau WiFi
+
+Après le démarrage, notez l'**IP affichée** (exemple : `192.168.1.100`).
+
+#### Depuis un smartphone/tablette
+
+1. **Connectez l'appareil au même WiFi** que le serveur
+2. Ouvrez le navigateur
+3. Allez sur : `https://IP_SERVEUR:5173` (dev) ou `http://IP_SERVEUR:3000` (prod)
+4. **iOS** : Installez la PWA sur l'écran d'accueil pour activer les notifications
+
+#### Depuis un autre ordinateur
+
+Même procédure : `https://IP_SERVEUR:5173`
+
+---
+
+## ⚙️ Configuration Avancée
+
+### Changer l'IP du serveur manuellement
+
+Si l'auto-détection ne fonctionne pas (VPN, Docker, etc.) :
+
+**1. Modifier `server/.env`**
+
+```bash
+# Remplacer AUTO par l'IP voulue
+LIVEKIT_URL=ws://192.168.1.100:7880
+```
+
+**2. Pour le client (accès réseau)**
+
+Modifier `client/.env` :
+
+```bash
+# Décommenter et mettre l'IP du serveur
+VITE_API_URL=http://192.168.1.100:3000
+```
+
+**3. Redémarrer**
+
+```bash
+./start.sh --dev
+```
+
+### Lister les devices audio disponibles
+
+```bash
+# Via API (serveur doit tourner)
+curl http://localhost:3000/admin/devices/list
+
+# Retourne JSON :
+{
+  "inputs": [
+    { "id": 0, "name": "Microphone MacBook Pro" },
+    { "id": 4, "name": "USB Audio Interface" }
+  ],
+  "outputs": [...],
+  "platform": "darwin"
+}
+```
+
+Utilisez ensuite l'interface admin (`/admin`) pour sélectionner les devices.
+
+### Changer les ports
+
+**API serveur (port 3000 par défaut)**
+
+Modifier `server/.env` :
+
+```bash
+PORT=3001
+```
+
+**Client dev (port 5173 par défaut)**
+
+Modifier `client/vite.config.js` :
+
+```javascript
+server: {
+  port: 5174,
+  // ...
+}
+```
+
+---
+
+## 📦 Mode Production (événement en conditions réelles)
+
+### Build optimisé
+
+```bash
+# Build du client statique
+cd client
+npm run build
+
+# Le dossier dist/ contient le build optimisé
+```
+
+### Servir en production
+
+```bash
+# Méthode 1 : Script start.sh (recommandé)
+./start.sh
+
+# Méthode 2 : npm start direct
+cd server
+npm start
+
+# Le serveur Express sert automatiquement client/dist/
+```
+
+### Reverse proxy Nginx (optionnel)
+
+Pour un domaine personnalisé avec HTTPS :
+
+```nginx
+server {
+    listen 443 ssl http2;
+    server_name ptt.example.com;
+
+    ssl_certificate /path/to/cert.pem;
+    ssl_certificate_key /path/to/key.pem;
+
+    # Client PWA
+    location / {
+        proxy_pass http://localhost:3000;
+        proxy_http_version 1.1;
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection 'upgrade';
+        proxy_set_header Host $host;
+        proxy_cache_bypass $http_upgrade;
+    }
+
+    # WebSocket LiveKit
+    location /livekit {
+        proxy_pass http://localhost:7880;
+        proxy_http_version 1.1;
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection "Upgrade";
+        proxy_set_header Host $host;
+    }
+}
+```
+
+---
+
+## 🐛 Dépannage
+
+### Erreur "Port déjà utilisé"
+
+**Port 3000 (API)**
+```bash
+# Trouver le processus
+lsof -i :3000
+# Tuer ou changer PORT dans .env
+```
+
+**Port 7880 (LiveKit)**
+```bash
+lsof -i :7880
+# Arrêter LiveKit ou changer dans config.yaml
+```
+
+### IP détectée incorrecte
+
+**Lister toutes les interfaces réseau :**
+
+```bash
+# macOS
+ifconfig | grep "inet "
+
+# Linux
+ip addr show
+```
+
+Puis modifier `server/.env` avec la bonne IP.
+
+### Clients ne peuvent pas se connecter
+
+**1. Vérifier le serveur**
+```bash
+curl http://IP_SERVEUR:3000/health
+```
+
+**2. Vérifier LiveKit**
+```bash
+curl http://IP_SERVEUR:7880
+```
+
+**3. Firewall**
+
+macOS/Linux : autoriser ports 3000, 7880, 7882 (UDP)
+
+```bash
+# macOS
+sudo /usr/libexec/ApplicationFirewall/socketfilterfw --add /path/to/node
+sudo /usr/libexec/ApplicationFirewall/socketfilterfw --unblock /path/to/livekit-server
+
+# Linux (ufw)
+sudo ufw allow 3000/tcp
+sudo ufw allow 7880/tcp
+sudo ufw allow 7882/udp
+```
+
+### Pas d'audio (macOS)
+
+**Permissions microphone :**
+
+1. **Navigateur** : Autoriser le micro dans les préférences Safari/Chrome
+2. **Terminal** : `Réglages Système > Confidentialité > Microphone` → autoriser Terminal
+
+**Carte son externe :**
+
+```bash
+# Lister devices
+curl http://localhost:3000/admin/devices/list
+
+# Sélectionner via interface admin
+open http://localhost:3000/admin
+```
+
+### Pas d'audio (Linux)
+
+**Vérifier PipeWire :**
+
+```bash
+systemctl --user status pipewire
+pw-cli info 0
+```
+
+**Démarrer si inactif :**
+
+```bash
+systemctl --user start pipewire pipewire-pulse
+```
+
+**Lister devices PulseAudio :**
+
+```bash
+pactl list short sources  # Inputs
+pactl list short sinks    # Outputs
+```
+
+---
+
+## 📚 Architecture Portable
+
+### Structure des fichiers de configuration
+
+```
+PTT Live/
+├── server/
+│   ├── .env                 # Généré par install (IP auto)
+│   └── config/
+│       └── config.yaml      # LIVEKIT_URL = AUTO
+├── client/
+│   ├── .env                 # Généré par install
+│   └── .env.example         # Template
+└── install/
+    ├── macos.sh             # Détection IP + génération .env
+    └── linux.sh             # Idem
+```
+
+### Flux de configuration automatique
+
+```
+1. install.sh
+   └─> Détecte OS (macOS/Linux)
+   └─> Lance install/{os}.sh
+       └─> Détecte IP réseau (ifconfig/hostname)
+       └─> Génère server/.env avec LIVEKIT_URL=AUTO
+       └─> Génère client/.env avec IP dans commentaires
+
+2. npm run dev (serveur)
+   └─> Lit server/.env
+   └─> Si LIVEKIT_URL=AUTO → détecte IP au runtime (index.js:75)
+   └─> Lance LiveKit sur 0.0.0.0:7880
+   └─> Retourne ws://IP_DETECTÉE:7880 aux clients via /token
+
+3. Client se connecte
+   └─> Appelle POST /token avec username + groupId
+   └─> Reçoit { token, url: "ws://192.168.x.x:7880" }
+   └─> Se connecte automatiquement à la bonne URL
+```
+
+**Résultat** : **Zéro configuration manuelle** d'IP pour l'utilisateur final.
+
+---
+
+## 🔒 Sécurité en Production
+
+### Bonnes pratiques
+
+1. **Changer les clés LiveKit** (par défaut : `devkey/secret`)
+
+   Modifier `server/.env` :
+   ```bash
+   LIVEKIT_API_KEY=$(openssl rand -hex 32)
+   LIVEKIT_API_SECRET=$(openssl rand -hex 64)
+   ```
+
+2. **Activer HTTPS/WSS** (avec certificats Let's Encrypt ou mkcert)
+
+3. **Firewall strict** : Autoriser seulement les ports nécessaires
+
+4. **Authentification admin** : Ajouter un mot de passe sur `/admin` (Phase 2.3)
+
+5. **VLAN dédié** : Isoler le réseau PTT Live du reste du LAN (événements)
+
+---
+
+## ✨ Fonctionnalités Portables
+
+✅ **Auto-détection IP réseau** (macOS/Linux)  
+✅ **Auto-détection devices audio** (API `/admin/devices/list`)  
+✅ **Génération .env automatique** lors de l'installation  
+✅ **Scripts start.sh multi-OS** (dev/prod)  
+✅ **Configuration dynamique Vite** (loadEnv)  
+✅ **Support JACK, PipeWire, CoreAudio**  
+✅ **PWA installable** (iOS/Android)  
+
+---
+
+## 📖 Documentation Complémentaire
+
+- [README.md](README.md) — Guide utilisateur complet
+- [NETWORK_SETUP.md](NETWORK_SETUP.md) — Configuration réseau détaillée
+- [CLAUDE.md](CLAUDE.md) — Documentation développement
+- [docs/](docs/) — Guides techniques (JACK, Dante, AES67)
+
+---
+
+**Dernière mise à jour** : 2026-05-27  
+**Version** : 0.2.0 (Portable)
@@ -8,20 +8,43 @@ Communiquez via smartphone (PWA) en WiFi, le serveur fait le pont avec l'install

 ## 🚀 Démarrage rapide

-### Prérequis
+### Installation Automatique (Recommandé)

- Node.js 20+ ([télécharger](https://nodejs.org))
- Compte LiveKit Cloud gratuit ([créer ici](https://cloud.livekit.io))
+**Un seul script pour tout installer** (détection automatique macOS/Linux) :

-### Installation (5 minutes)
+```bash
+# Lancer l'installation portable
+./install.sh

-1. **Installer les dépendances**
+# Démarrer le système
+./start.sh --dev
+```
+
+✨ **L'installeur configure automatiquement** :
+- LiveKit Server local (pas besoin de compte cloud)
+- Détection et configuration IP réseau
+- Backends audio (sox/PipeWire/JACK selon OS)
+- Toutes les dépendances
+
+📖 **Guide portable complet** : [README-PORTABLE.md](README-PORTABLE.md)
+
+---
+
+### Installation Manuelle (avec LiveKit Cloud)
+
+**Alternative si vous préférez utiliser LiveKit Cloud**
+
+1. **Prérequis**
+   - Node.js 20+ ([télécharger](https://nodejs.org))
+   - Compte LiveKit Cloud gratuit ([créer ici](https://cloud.livekit.io))
+
+2. **Installer les dépendances**
   ```bash
   cd server && npm install
   cd ../client && npm install
   ```

-2. **Configurer LiveKit Cloud**
+3. **Configurer LiveKit Cloud**

   - Créer compte sur https://cloud.livekit.io
   - Créer un projet
@@ -35,7 +58,7 @@ Communiquez via smartphone (PWA) en WiFi, le serveur fait le pont avec l'install
   USE_LOCAL_LIVEKIT=false
   ```

-3. **Démarrer**
+4. **Démarrer**

   Terminal 1 :
   ```bash
@@ -47,13 +70,13 @@ Communiquez via smartphone (PWA) en WiFi, le serveur fait le pont avec l'install
   cd client && npm run dev
   ```

-4. **Tester** : http://localhost:5173
+5. **Tester** : https://localhost:5173

   - Se connecter avec votre nom
   - Ouvrir second onglet avec autre nom
   - Maintenir bouton PTT pour parler !

-📖 **Guide complet** : [docs/SETUP_LIVEKIT.md](docs/SETUP_LIVEKIT.md)
+📖 **Guide LiveKit Cloud** : [docs/SETUP_LIVEKIT.md](docs/SETUP_LIVEKIT.md)

 ---

@@ -84,6 +107,8 @@ Voir le guide complet : [docs/SETUP_LIVEKIT.md](docs/SETUP_LIVEKIT.md)

 ## 📚 Documentation

+- **[README-PORTABLE.md](README-PORTABLE.md)** - 🆕 **Guide déploiement portable** (zéro config)
+- **[NETWORK_SETUP.md](NETWORK_SETUP.md)** - Configuration réseau multi-appareils
 - **[docs/SETUP_LIVEKIT.md](docs/SETUP_LIVEKIT.md)** - Configuration LiveKit (Cloud + Local)
 - **[CLAUDE.md](CLAUDE.md)** - Documentation développement complète
 - **[TODO.md](TODO.md)** - Progression des phases
@@ -92,13 +117,12 @@ Voir le guide complet : [docs/SETUP_LIVEKIT.md](docs/SETUP_LIVEKIT.md)

 ## 🎯 État du projet

- ✅ **Phase 1.1** : Infrastructure
- ✅ **Phase 1.2** : Serveur + API REST
- ⏳ **Phase 1.3** : Bridge audio macOS
- ✅ **Phase 1.4** : Client PWA React
- ⏳ **Phase 1.5** : Tests validation
+- ✅ **Phase 1** : MVP fonctionnel (WebRTC + PTT)
+- ✅ **Phase 2** : Fonctionnalités avancées (groupes, routing, admin)
+- 🆕 **Portable** : Installation zéro-config macOS/Linux
+- ⏳ **Phase 3** : Intégrations audio pro (Dante, AES67)

-**Version actuelle** : 0.1.0 (Phase 1 MVP en cours)
+**Version actuelle** : 0.2.0 (Portable - production-ready)

 ---

@@ -1,7 +1,15 @@
-# PTT Live Client - Configuration environnement
+# Configuration Client PTT Live
+# Copiez ce fichier en .env et adaptez selon votre environnement

-# URL API serveur (en dev, utilise le proxy Vite)
+# URL de l'API serveur
+# En développement : laissez /api pour utiliser le proxy Vite
+# En production : spécifiez l'URL complète du serveur
+# Exemples :
+#   VITE_API_URL=/api                          # Dev local (via proxy Vite)
+#   VITE_API_URL=http://192.168.1.100:3000     # Serveur sur réseau local
+#   VITE_API_URL=https://ptt.example.com       # Production avec domaine
 VITE_API_URL=/api

-# Pour production, pointer vers le serveur
-# VITE_API_URL=https://your-server.com
+# URL LiveKit WebSocket (optionnel, normalement auto-détectée)
+# Ne définir que si vous voulez forcer une URL spécifique
+# VITE_LIVEKIT_URL=ws://192.168.1.100:7880
@@ -0,0 +1,5 @@
+# Configuration PTT Live Client - Production
+# Le client est servi depuis le même domaine que l'API
+
+# URLs relatives directes (pas de proxy /api)
+VITE_API_URL=.
@@ -81,7 +81,7 @@ define(['./workbox-290dd570'], (function (workbox) { 'use strict';
    "revision": "3ca0b8505b4bec776b69afdba2768812"
  }, {
    "url": "index.html",
-    "revision": "0.oebo7b1mt4g"
+    "revision": "0.t6h2k1g9avg"
  }], {});
  workbox.cleanupOutdatedCaches();
  workbox.registerRoute(new workbox.NavigationRoute(workbox.createHandlerBoundToURL("index.html"), {
@@ -1,11 +1,17 @@
-import { useState, useEffect } from 'react';
+import { useState, useEffect, useRef } from 'react';
 import './Admin.css';
 import AudioRoutingMatrix from './components/AudioRoutingMatrix';

 const API_URL = import.meta.env.VITE_API_URL || '/api';

 function Admin() {
-  const [activeTab, setActiveTab] = useState('groups');
+  // Lire l'onglet depuis l'URL hash (ex: #audio) ou utiliser 'groups' par défaut
+  const getInitialTab = () => {
+    const hash = window.location.hash.slice(1); // Enlever le #
+    return ['groups', 'audio', 'users', 'stats', 'logs'].includes(hash) ? hash : 'groups';
+  };
+
+  const [activeTab, setActiveTab] = useState(getInitialTab());
  const [groups, setGroups] = useState([]);
  const [users, setUsers] = useState([]);
  const [stats, setStats] = useState(null);
@@ -15,25 +21,36 @@ function Admin() {

  // Audio devices (Phase 2.5)
  const [audioDevices, setAudioDevices] = useState([]);
-  const [currentDevice, setCurrentDevice] = useState(null);
+  const [currentDevice, setCurrentDevice] = useState({ inputChannels: 8, outputChannels: 8 });
  const [selectedInputDevice, setSelectedInputDevice] = useState(null);
  const [selectedOutputDevice, setSelectedOutputDevice] = useState(null);
  const [selectedSampleRate, setSelectedSampleRate] = useState(48000);
-  const [isEditingAudio, setIsEditingAudio] = useState(false);
+  const isEditingAudioRef = useRef(false);

  // Channel names (Phase 2.5)
  const [channelNames, setChannelNames] = useState({ inputs: {}, outputs: {} });
-  const [editingChannelNames, setEditingChannelNames] = useState(false);

  // Gestion formulaire nouveau groupe
  const [showGroupForm, setShowGroupForm] = useState(false);
  const [editingGroup, setEditingGroup] = useState(null);
  const [groupForm, setGroupForm] = useState({
    name: '',
-    audioBitrate: 96,
-    channels: []
+    audioBitrate: 96
  });

+  // Synchroniser l'onglet avec l'URL hash
+  useEffect(() => {
+    const handleHashChange = () => {
+      const hash = window.location.hash.slice(1);
+      if (['groups', 'audio', 'users', 'stats', 'logs'].includes(hash)) {
+        setActiveTab(hash);
+      }
+    };
+
+    window.addEventListener('hashchange', handleHashChange);
+    return () => window.removeEventListener('hashchange', handleHashChange);
+  }, []);
+
  // Rafraîchissement automatique
  useEffect(() => {
    loadData();
@@ -91,25 +108,30 @@ function Admin() {
  };

  const loadAudioDevices = async () => {
-    const [devicesRes, currentDeviceRes, channelNamesRes] = await Promise.all([
+    const [devicesRes, currentDeviceRes, channelNamesRes, groupsRes] = await Promise.all([
      fetch(`${API_URL}/admin/audio/devices`),
      fetch(`${API_URL}/admin/audio/device`),
-      fetch(`${API_URL}/admin/audio/channels/names`)
+      fetch(`${API_URL}/admin/audio/channels/names`),
+      fetch(`${API_URL}/admin/groups`)
    ]);

    const devicesData = await devicesRes.json();
    const currentData = await currentDeviceRes.json();
    const channelNamesData = await channelNamesRes.json();
+    const groupsData = await groupsRes.json();

    setAudioDevices(devicesData.devices || []);
-    setCurrentDevice(currentData.device || {});
+    setGroups(groupsData.groups || []);
+
+    const device = currentData.device || { inputChannels: 8, outputChannels: 8 };
+    setCurrentDevice(device);
    setChannelNames(channelNamesData.channelNames || { inputs: {}, outputs: {} });

-    // Ne réinitialiser les sélections que si l'utilisateur n'est pas en train d'éditer
-    if (!isEditingAudio) {
-      setSelectedInputDevice(currentData.device?.inputDeviceId ?? null);
-      setSelectedOutputDevice(currentData.device?.outputDeviceId ?? null);
-      setSelectedSampleRate(currentData.device?.sampleRate || 48000);
+    // Ne réinitialiser les sélections que lors du chargement initial (pas en train d'éditer)
+    if (!isEditingAudioRef.current) {
+      setSelectedInputDevice(device.inputDeviceId ?? null);
+      setSelectedOutputDevice(device.outputDeviceId ?? null);
+      setSelectedSampleRate(device.sampleRate || 48000);
    }
  };

@@ -189,8 +211,7 @@ function Admin() {
    setEditingGroup(group.id);
    setGroupForm({
      name: group.name,
-      audioBitrate: group.audioBitrate || 96,
-      channels: group.channels || []
+      audioBitrate: group.audioBitrate || 96
    });
    setShowGroupForm(true);
  };
@@ -198,38 +219,12 @@ function Admin() {
  const resetGroupForm = () => {
    setGroupForm({
      name: '',
-      audioBitrate: 96,
-      channels: []
+      audioBitrate: 96
    });
    setShowGroupForm(false);
    setEditingGroup(null);
  };

-  const addChannel = () => {
-    setGroupForm({
-      ...groupForm,
-      channels: [
-        ...groupForm.channels,
-        { name: '', audioInput: 0, audioOutput: 0 }
-      ]
-    });
-  };
-
-  const updateChannel = (index, field, value) => {
-    const newChannels = [...groupForm.channels];
-    newChannels[index] = {
-      ...newChannels[index],
-      [field]: field === 'audioInput' || field === 'audioOutput' ? parseInt(value) : value
-    };
-    setGroupForm({ ...groupForm, channels: newChannels });
-  };
-
-  const removeChannel = (index) => {
-    const newChannels = [...groupForm.channels];
-    newChannels.splice(index, 1);
-    setGroupForm({ ...groupForm, channels: newChannels });
-  };
-
  // ========== Gestion audio devices (Phase 2.5) ==========

  const handleSaveChannelNames = async () => {
@@ -242,7 +237,6 @@ function Admin() {

      if (res.ok) {
        alert('Noms de canaux sauvegardés avec succès!');
-        setEditingChannelNames(false);
        await loadAudioDevices();
      } else {
        const error = await res.json();
@@ -270,14 +264,14 @@ function Admin() {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
-          inputDeviceId: selectedInputDevice !== null ? parseInt(selectedInputDevice) : undefined,
-          outputDeviceId: selectedOutputDevice !== null ? parseInt(selectedOutputDevice) : undefined,
+          inputDeviceId: selectedInputDevice || undefined,
+          outputDeviceId: selectedOutputDevice || undefined,
          sampleRate: parseInt(selectedSampleRate)
        })
      });

      if (res.ok) {
-        setIsEditingAudio(false); // Désactiver le mode édition
+        isEditingAudioRef.current = false; // Désactiver le mode édition
        alert('Configuration audio sauvegardée avec succès!');
        await loadAudioDevices();
      } else {
@@ -337,31 +331,31 @@ function Admin() {
      <nav className="admin-tabs">
        <button
          className={activeTab === 'groups' ? 'active' : ''}
-          onClick={() => setActiveTab('groups')}
+          onClick={() => { window.location.hash = 'groups'; setActiveTab('groups'); }}
        >
          Groupes
        </button>
        <button
          className={activeTab === 'audio' ? 'active' : ''}
-          onClick={() => setActiveTab('audio')}
+          onClick={() => { window.location.hash = 'audio'; setActiveTab('audio'); }}
        >
          Audio
        </button>
        <button
          className={activeTab === 'users' ? 'active' : ''}
-          onClick={() => setActiveTab('users')}
+          onClick={() => { window.location.hash = 'users'; setActiveTab('users'); }}
        >
          Utilisateurs ({users.length})
        </button>
        <button
          className={activeTab === 'stats' ? 'active' : ''}
-          onClick={() => setActiveTab('stats')}
+          onClick={() => { window.location.hash = 'stats'; setActiveTab('stats'); }}
        >
          Statistiques
        </button>
        <button
          className={activeTab === 'logs' ? 'active' : ''}
-          onClick={() => setActiveTab('logs')}
+          onClick={() => { window.location.hash = 'logs'; setActiveTab('logs'); }}
        >
          Logs
        </button>
@@ -415,43 +409,9 @@ function Admin() {
                    </label>
                  </div>

-                  <div className="channels-section">
-                    <div className="channels-header">
-                      <h4>Canaux audio</h4>
-                      <button type="button" onClick={addChannel} className="btn-small">
-                        + Canal
-                      </button>
-                    </div>
-
-                    {groupForm.channels.map((channel, index) => (
-                      <div key={index} className="channel-item">
-                        <input
-                          type="text"
-                          placeholder="Nom canal (ex: Principal, Backup...)"
-                          value={channel.name}
-                          onChange={(e) => updateChannel(index, 'name', e.target.value)}
-                          required
-                        />
-                        <input
-                          type="number"
-                          placeholder="Input"
-                          value={channel.audioInput}
-                          onChange={(e) => updateChannel(index, 'audioInput', e.target.value)}
-                          min="0"
-                        />
-                        <input
-                          type="number"
-                          placeholder="Output"
-                          value={channel.audioOutput}
-                          onChange={(e) => updateChannel(index, 'audioOutput', e.target.value)}
-                          min="0"
-                        />
-                        <button type="button" onClick={() => removeChannel(index)} className="btn-danger">
-                          ×
-                        </button>
-                      </div>
-                    ))}
-                  </div>
+                  <p style={{color: 'var(--color-text-secondary)', fontSize: '0.9rem', marginTop: 'var(--spacing-md)'}}>
+                    Le routing audio se configure dans l'onglet "Audio" via la matrice de routing.
+                  </p>

                  <div className="form-actions">
                    <button type="submit" className="btn-primary">
@@ -482,18 +442,7 @@ function Admin() {

                  <div className="group-info">
                    <span>Bitrate: {group.audioBitrate || 96} kbps</span>
-                    <span>Canaux: {group.channels?.length || 0}</span>
                  </div>
-
-                  {group.channels && group.channels.length > 0 && (
-                    <div className="channels-list">
-                      {group.channels.map(channel => (
-                        <div key={channel.id} className="channel-badge">
-                          {channel.name} (I/O: {channel.audioInput}/{channel.audioOutput})
-                        </div>
-                      ))}
-                    </div>
-                  )}
                </div>
              ))}
            </div>
@@ -509,63 +458,73 @@ function Admin() {

            <div className="audio-config-container">
              <div className="audio-section">
-                <h3>Carte son d'entrée (Input)</h3>
+                <h3>Configuration des cartes son</h3>
+
+                <div style={{display: 'grid', gap: 'var(--spacing-lg)', marginTop: 'var(--spacing-md)'}}>
+                  <div>
+                    <label style={{display: 'block', marginBottom: 'var(--spacing-xs)', fontSize: '0.9rem', fontWeight: 600, color: 'var(--color-text-secondary)'}}>
+                      Carte son d'entrée (Input)
+                    </label>
                    <select
                      value={selectedInputDevice ?? ''}
                      onChange={(e) => {
-                    setIsEditingAudio(true);
-                    setSelectedInputDevice(e.target.value === '' ? null : parseInt(e.target.value));
+                        isEditingAudioRef.current = true;
+                        setSelectedInputDevice(e.target.value === '' ? null : e.target.value);
                      }}
                      className="device-select"
                    >
                      <option value="">-- Sélectionner une carte --</option>
                      {audioDevices
                        .filter(d => d.maxInputChannels > 0)
-                    .map(device => (
-                      <option key={device.id} value={device.id}>
+                        .map((device, index) => (
+                          <option key={`input-${device.id}-${index}`} value={device.id}>
                            {device.name} - {device.maxInputChannels} canaux - {device.defaultSampleRate}Hz
                          </option>
                        ))}
                    </select>
-                {selectedInputDevice !== null && (
-                  <p style={{marginTop: 'var(--spacing-sm)', color: 'var(--color-text-secondary)', fontSize: '0.85rem'}}>
-                    Device ID {selectedInputDevice} sélectionné
+                    {selectedInputDevice !== null && selectedInputDevice !== '' && (
+                      <p style={{marginTop: 'var(--spacing-sm)', color: 'var(--color-text-secondary)', fontSize: '0.85rem', wordBreak: 'break-all'}}>
+                        Device ID: {selectedInputDevice}
                      </p>
                    )}
                  </div>

-              <div className="audio-section">
-                <h3>Carte son de sortie (Output)</h3>
+                  <div>
+                    <label style={{display: 'block', marginBottom: 'var(--spacing-xs)', fontSize: '0.9rem', fontWeight: 600, color: 'var(--color-text-secondary)'}}>
+                      Carte son de sortie (Output)
+                    </label>
                    <select
                      value={selectedOutputDevice ?? ''}
                      onChange={(e) => {
-                    setIsEditingAudio(true);
-                    setSelectedOutputDevice(e.target.value === '' ? null : parseInt(e.target.value));
+                        isEditingAudioRef.current = true;
+                        setSelectedOutputDevice(e.target.value === '' ? null : e.target.value);
                      }}
                      className="device-select"
                    >
                      <option value="">-- Sélectionner une carte --</option>
                      {audioDevices
                        .filter(d => d.maxOutputChannels > 0)
-                    .map(device => (
-                      <option key={device.id} value={device.id}>
+                        .map((device, index) => (
+                          <option key={`output-${device.id}-${index}`} value={device.id}>
                            {device.name} - {device.maxOutputChannels} canaux - {device.defaultSampleRate}Hz
                          </option>
                        ))}
                    </select>
-                {selectedOutputDevice !== null && (
-                  <p style={{marginTop: 'var(--spacing-sm)', color: 'var(--color-text-secondary)', fontSize: '0.85rem'}}>
-                    Device ID {selectedOutputDevice} sélectionné
+                    {selectedOutputDevice !== null && selectedOutputDevice !== '' && (
+                      <p style={{marginTop: 'var(--spacing-sm)', color: 'var(--color-text-secondary)', fontSize: '0.85rem', wordBreak: 'break-all'}}>
+                        Device ID: {selectedOutputDevice}
                      </p>
                    )}
                  </div>

-              <div className="audio-section">
-                <h3>Sample Rate</h3>
+                  <div>
+                    <label style={{display: 'block', marginBottom: 'var(--spacing-xs)', fontSize: '0.9rem', fontWeight: 600, color: 'var(--color-text-secondary)'}}>
+                      Sample Rate
+                    </label>
                    <select
                      value={selectedSampleRate}
                      onChange={(e) => {
-                    setIsEditingAudio(true);
+                        isEditingAudioRef.current = true;
                        setSelectedSampleRate(parseInt(e.target.value));
                      }}
                      className="device-select"
@@ -575,37 +534,25 @@ function Admin() {
                      <option value={96000}>96000 Hz (High quality)</option>
                    </select>
                  </div>
+                </div>

                <div className="audio-actions">
                  <button onClick={handleSaveAudioDevice} className="btn-primary">
-                  Sauvegarder la configuration
+                    Sauvegarder la configuration audio
                  </button>
                </div>
+              </div>

              <div className="audio-section">
-                <div style={{display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: 'var(--spacing-md)'}}>
                <h3>Nommage des canaux physiques</h3>
-                  {!editingChannelNames ? (
-                    <button onClick={() => setEditingChannelNames(true)} className="btn-secondary">
-                      Modifier les noms
-                    </button>
-                  ) : (
-                    <div style={{display: 'flex', gap: 'var(--spacing-sm)'}}>
-                      <button onClick={handleSaveChannelNames} className="btn-primary">
-                        Sauvegarder
-                      </button>
-                      <button onClick={() => { setEditingChannelNames(false); loadAudioDevices(); }} className="btn-secondary">
-                        Annuler
-                      </button>
-                    </div>
-                  )}
-                </div>

-                <div style={{display: 'grid', gridTemplateColumns: '1fr 1fr', gap: 'var(--spacing-xl)'}}>
+                <div style={{display: 'grid', gridTemplateColumns: '1fr 1fr', gap: 'var(--spacing-xl)', marginTop: 'var(--spacing-md)'}}>
                  <div>
-                    <h4 style={{marginBottom: 'var(--spacing-md)', color: 'var(--color-text-secondary)'}}>Entrées (Inputs)</h4>
+                    <h4 style={{marginBottom: 'var(--spacing-md)', color: 'var(--color-text-secondary)'}}>
+                      Entrées (Inputs) - {currentDevice.inputChannels || 0} canaux disponibles
+                    </h4>
                    <div style={{display: 'grid', gap: 'var(--spacing-sm)'}}>
-                      {Array.from({length: 8}, (_, i) => (
+                      {Array.from({length: currentDevice.inputChannels || 8}, (_, i) => (
                        <div key={`input-${i}`} style={{display: 'grid', gridTemplateColumns: '40px 1fr', gap: 'var(--spacing-sm)', alignItems: 'center'}}>
                          <span style={{color: 'var(--color-text-secondary)', fontSize: '0.85rem'}}>{i}</span>
                          <input
@@ -613,10 +560,9 @@ function Admin() {
                            value={channelNames.inputs?.[i] || ''}
                            onChange={(e) => updateChannelName('inputs', i, e.target.value)}
                            placeholder={`Input ${i}`}
-                            disabled={!editingChannelNames}
                            style={{
                              padding: 'var(--spacing-sm)',
-                              background: editingChannelNames ? 'var(--color-bg)' : 'var(--color-surface-hover)',
+                              background: 'var(--color-bg)',
                              border: '1px solid var(--color-border)',
                              borderRadius: '6px',
                              color: 'var(--color-text)',
@@ -629,9 +575,11 @@ function Admin() {
                  </div>

                  <div>
-                    <h4 style={{marginBottom: 'var(--spacing-md)', color: 'var(--color-text-secondary)'}}>Sorties (Outputs)</h4>
+                    <h4 style={{marginBottom: 'var(--spacing-md)', color: 'var(--color-text-secondary)'}}>
+                      Sorties (Outputs) - {currentDevice.outputChannels || 0} canaux disponibles
+                    </h4>
                    <div style={{display: 'grid', gap: 'var(--spacing-sm)'}}>
-                      {Array.from({length: 8}, (_, i) => (
+                      {Array.from({length: currentDevice.outputChannels || 8}, (_, i) => (
                        <div key={`output-${i}`} style={{display: 'grid', gridTemplateColumns: '40px 1fr', gap: 'var(--spacing-sm)', alignItems: 'center'}}>
                          <span style={{color: 'var(--color-text-secondary)', fontSize: '0.85rem'}}>{i}</span>
                          <input
@@ -639,10 +587,9 @@ function Admin() {
                            value={channelNames.outputs?.[i] || ''}
                            onChange={(e) => updateChannelName('outputs', i, e.target.value)}
                            placeholder={`Output ${i}`}
-                            disabled={!editingChannelNames}
                            style={{
                              padding: 'var(--spacing-sm)',
-                              background: editingChannelNames ? 'var(--color-bg)' : 'var(--color-surface-hover)',
+                              background: 'var(--color-bg)',
                              border: '1px solid var(--color-border)',
                              borderRadius: '6px',
                              color: 'var(--color-text)',
@@ -654,17 +601,24 @@ function Admin() {
                    </div>
                  </div>
                </div>
+
+                <div className="audio-actions">
+                  <button onClick={handleSaveChannelNames} className="btn-primary">
+                    Sauvegarder les noms des canaux
+                  </button>
+                </div>
              </div>

              <AudioRoutingMatrix groups={groups} channelNames={channelNames} />

-              {currentDevice && Object.keys(currentDevice).length > 0 && (
+              {currentDevice && currentDevice.inputDeviceId && (
                <div className="current-config">
                  <h3>Configuration actuelle</h3>
                  <div className="config-info">
-                    <p><strong>Input Device ID:</strong> {currentDevice.inputDeviceId ?? 'Non configuré'}</p>
-                    <p><strong>Output Device ID:</strong> {currentDevice.outputDeviceId ?? 'Non configuré'}</p>
+                    <p><strong>Input Device:</strong> {currentDevice.inputDeviceName || currentDevice.inputDeviceId}</p>
+                    <p><strong>Output Device:</strong> {currentDevice.outputDeviceName || currentDevice.outputDeviceId}</p>
                    <p><strong>Sample Rate:</strong> {currentDevice.sampleRate ?? 48000} Hz</p>
+                    <p><strong>Canaux:</strong> {currentDevice.inputChannels} entrées / {currentDevice.outputChannels} sorties</p>
                  </div>
                </div>
              )}
@@ -683,9 +637,9 @@ function Admin() {
                    </tr>
                  </thead>
                  <tbody>
-                    {audioDevices.map(device => (
-                      <tr key={device.id}>
-                        <td>{device.id}</td>
+                    {audioDevices.map((device, index) => (
+                      <tr key={`${device.id}-${index}`}>
+                        <td style={{fontSize: '0.75rem', wordBreak: 'break-all', maxWidth: '200px'}}>{device.id}</td>
                        <td>{device.name}</td>
                        <td>{device.maxInputChannels}</td>
                        <td>{device.maxOutputChannels}</td>
@@ -100,14 +100,17 @@ function App() {

      const data = await response.json();

-      // Adapter l'URL LiveKit selon le protocole de la page
+      // En mode dev (HTTPS via Vite), utiliser le proxy WebSocket
+      // En mode prod (HTTP direct), utiliser l'URL LiveKit directement
      let livekitUrl = data.url;
-      if (window.location.protocol === 'https:') {
-        // En HTTPS, utiliser le proxy WSS local via Vite
+
+      if (import.meta.env.DEV && window.location.protocol === 'https:') {
+        // Mode dev avec Vite : utiliser le proxy WSS
        livekitUrl = `${window.location.protocol}//${window.location.host}/livekit`;
      }

      console.log('🔗 Connexion LiveKit:', livekitUrl);
+      console.log('📝 Mode:', import.meta.env.DEV ? 'dev' : 'prod');

      // Se connecter à LiveKit avec les canaux virtuels
      await connect(livekitUrl, data.token, data.virtualChannels || []);
@@ -6,6 +6,13 @@
  margin-top: var(--spacing-lg);
 }

+.routing-actions {
+  margin-top: var(--spacing-xl);
+  display: flex;
+  justify-content: flex-start;
+  gap: var(--spacing-sm);
+}
+
 .routing-matrix-header {
  display: flex;
  justify-content: space-between;
@@ -169,9 +176,9 @@
  width: 100%;
  padding: 4px 8px;
  font-size: 0.75rem;
-  background: rgba(255, 255, 255, 0.9);
-  color: var(--color-text);
-  border: 1px solid rgba(255, 255, 255, 0.3);
+  background: rgba(59, 130, 246, 0.2);
+  color: #ffffff;
+  border: 1px solid rgba(255, 255, 255, 1);
  border-radius: 4px;
  cursor: pointer;
  font-weight: 600;
@@ -180,8 +187,9 @@

 .gain-select:focus {
  outline: none;
-  border-color: rgba(255, 255, 255, 0.6);
-  box-shadow: 0 0 0 2px rgba(255, 255, 255, 0.2);
+  background: rgba(59, 130, 246, 0.3);
+  border-color: rgba(255, 255, 255, 1);
+  box-shadow: 0 0 0 2px rgba(59, 130, 246, 0.2);
 }

@media (max-width: 1024px) {
@@ -10,9 +10,11 @@ function AudioRoutingMatrix({ groups, channelNames }) {
  const [routing, setRouting] = useState({ inputToGroup: {}, groupToOutput: {}, gains: {} });
  const [loading, setLoading] = useState(true);
  const [showOnlyNamedChannels, setShowOnlyNamedChannels] = useState(false);
+  const [audioDevice, setAudioDevice] = useState({ inputChannels: 8, outputChannels: 8 });

  useEffect(() => {
    loadRouting();
+    loadAudioDevice();
  }, []);

  const loadRouting = async () => {
@@ -30,6 +32,21 @@ function AudioRoutingMatrix({ groups, channelNames }) {
    }
  };

+  const loadAudioDevice = async () => {
+    try {
+      const res = await fetch(`${API_URL}/admin/audio/device`);
+      if (res.ok) {
+        const data = await res.json();
+        setAudioDevice({
+          inputChannels: data.device?.inputChannels || 8,
+          outputChannels: data.device?.outputChannels || 8
+        });
+      }
+    } catch (error) {
+      console.error('Erreur chargement audio device:', error);
+    }
+  };
+
  const saveRouting = async () => {
    try {
      const res = await fetch(`${API_URL}/admin/audio/routing`, {
@@ -146,7 +163,7 @@ function AudioRoutingMatrix({ groups, channelNames }) {
  };

  const getVisibleInputChannels = () => {
-    const allInputs = Array.from({length: 8}, (_, i) => i);
+    const allInputs = Array.from({length: audioDevice.inputChannels}, (_, i) => i);
    if (showOnlyNamedChannels) {
      return allInputs.filter(i => hasCustomName('inputs', i));
    }
@@ -154,7 +171,7 @@ function AudioRoutingMatrix({ groups, channelNames }) {
  };

  const getVisibleOutputChannels = () => {
-    const allOutputs = Array.from({length: 8}, (_, i) => i);
+    const allOutputs = Array.from({length: audioDevice.outputChannels}, (_, i) => i);
    if (showOnlyNamedChannels) {
      return allOutputs.filter(i => hasCustomName('outputs', i));
    }
@@ -177,7 +194,6 @@ function AudioRoutingMatrix({ groups, channelNames }) {
            {wsConnected ? '● Live' : '○ Offline'}
          </span>
        </div>
-        <div style={{ display: 'flex', gap: '1rem', alignItems: 'center' }}>
        <label style={{ display: 'flex', alignItems: 'center', gap: '0.5rem', cursor: 'pointer' }}>
          <input
            type="checkbox"
@@ -186,10 +202,6 @@ function AudioRoutingMatrix({ groups, channelNames }) {
          />
          <span>Afficher uniquement les canaux nommés</span>
        </label>
-          <button onClick={saveRouting} className="btn-primary">
-            Sauvegarder le routing
-          </button>
-        </div>
      </div>

      <div className="routing-section">
@@ -324,6 +336,12 @@ function AudioRoutingMatrix({ groups, channelNames }) {
          ))}
        </div>
      </div>
+
+      <div className="routing-actions">
+        <button onClick={saveRouting} className="btn-primary">
+          Sauvegarder le routing audio
+        </button>
+      </div>
    </div>
  );
 }
@@ -22,16 +22,6 @@ export default function PTTButton({ isTalking, onPressStart, onPressEnd, audioLe
  const currentYRef = useRef(null);
  const [dragOffset, setDragOffset] = useState(0); // Offset visuel du drag (en pixels)

-  // Initialiser le mode selon les préférences au démarrage
-  useEffect(() => {
-    const currentSettings = loadSettings();
-    if (currentSettings.defaultPTTMode === 'continuous') {
-      setIsLockMode(true);
-      isLockModeRef.current = true;
-      console.log('Mode continu activé par défaut (préférences)');
-    }
-  }, []);
-
  useEffect(() => {
    const button = buttonRef.current;
    if (!button) return;
@@ -3,8 +3,22 @@
  bottom: 0;
  left: 0;
  right: 0;
+  top: 0;
  z-index: 1001;
-  animation: slideUp 0.3s ease;
+  background: rgba(0, 0, 0, 0.6);
+  backdrop-filter: blur(4px);
+  display: flex;
+  align-items: flex-end;
+  animation: fadeIn 0.3s ease;
+}
+
+@keyframes fadeIn {
+  from {
+    opacity: 0;
+  }
+  to {
+    opacity: 1;
+  }
 }

@keyframes slideUp {
@@ -17,12 +31,14 @@
 }

 .pwa-prompt {
-  background: var(--bg-secondary);
+  width: 100%;
+  background: #1a1a1a;
  border-top-left-radius: 16px;
  border-top-right-radius: 16px;
  box-shadow: 0 -4px 20px rgba(0, 0, 0, 0.3);
  max-height: 80vh;
  overflow-y: auto;
+  animation: slideUp 0.3s ease;
 }

 .pwa-prompt-header {
@@ -36,13 +52,13 @@
 .pwa-prompt-header h3 {
  margin: 0;
  font-size: 1.2rem;
-  color: var(--text-primary);
+  color: #ffffff;
 }

 .pwa-prompt-close {
  background: none;
  border: none;
-  color: var(--text-secondary);
+  color: #9ca3af;
  cursor: pointer;
  padding: 0.5rem;
  border-radius: 8px;
@@ -50,8 +66,8 @@
 }

 .pwa-prompt-close:hover {
-  background: var(--bg-hover);
-  color: var(--text-primary);
+  background: rgba(255, 255, 255, 0.1);
+  color: #ffffff;
 }

 .pwa-prompt-content {
@@ -59,8 +75,8 @@
 }

 .pwa-prompt-content > p {
-  margin: 0 0 var(--spacing-lg) 0;
-  color: var(--text-secondary);
+  margin: 0 0 1.5rem 0;
+  color: #d1d5db;
  line-height: 1.6;
 }

@@ -73,9 +89,9 @@
 .pwa-prompt-step {
  display: flex;
  align-items: center;
-  gap: var(--spacing-md);
-  padding: var(--spacing-md);
-  background: var(--bg-hover);
+  gap: 1rem;
+  padding: 1rem;
+  background: rgba(255, 255, 255, 0.05);
  border-radius: 8px;
 }

@@ -85,7 +101,7 @@
  justify-content: center;
  width: 32px;
  height: 32px;
-  background: var(--primary-color);
+  background: #3b82f6;
  color: white;
  border-radius: 50%;
  font-weight: 600;
@@ -95,13 +111,13 @@
 .pwa-prompt-step p {
  flex: 1;
  margin: 0;
-  color: var(--text-primary);
+  color: #ffffff;
  font-size: 0.95rem;
 }

 .pwa-prompt-step svg {
  flex-shrink: 0;
-  color: var(--primary-color);
+  color: #3b82f6;
 }

 .pwa-prompt-footer {
@@ -4,9 +4,7 @@ import './Settings.css';
 const STORAGE_KEY = 'ptt-live-settings';

 const defaultSettings = {
-  defaultPTTMode: 'normal', // 'normal' ou 'continuous'
-  vibrationEnabled: true,
-  audioFeedbackEnabled: true
+  vibrationEnabled: true
 };

 /**
@@ -68,39 +66,6 @@ export default function Settings({ isOpen, onClose }) {
        </div>

        <div className="settings-content">
-          <div className="setting-section">
-            <h3>Mode PTT</h3>
-            <p className="setting-description">
-              Choisissez le mode de fonctionnement par défaut du bouton PTT
-            </p>
-
-            <label className="radio-option">
-              <input
-                type="radio"
-                name="pttMode"
-                checked={settings.defaultPTTMode === 'normal'}
-                onChange={() => handleChange('defaultPTTMode', 'normal')}
-              />
-              <div>
-                <strong>Mode normal (Push-To-Talk)</strong>
-                <p>Maintenir le bouton pour parler, relâcher pour arrêter</p>
-              </div>
-            </label>
-
-            <label className="radio-option">
-              <input
-                type="radio"
-                name="pttMode"
-                checked={settings.defaultPTTMode === 'continuous'}
-                onChange={() => handleChange('defaultPTTMode', 'continuous')}
-              />
-              <div>
-                <strong>Mode continu (verrouillé)</strong>
-                <p>Un appui active le micro en continu, un second appui le désactive</p>
-              </div>
-            </label>
-          </div>
-
          <div className="setting-section">
            <h3>Feedback</h3>

@@ -112,19 +77,7 @@ export default function Settings({ isOpen, onClose }) {
              />
              <div>
                <strong>Vibrations</strong>
-                <p>Activer le retour haptique (si disponible)</p>
-              </div>
-            </label>
-
-            <label className="checkbox-option">
-              <input
-                type="checkbox"
-                checked={settings.audioFeedbackEnabled}
-                onChange={(e) => handleChange('audioFeedbackEnabled', e.target.checked)}
-              />
-              <div>
-                <strong>Feedback audio</strong>
-                <p>Sons de confirmation pour les actions</p>
+                <p>Activer le retour haptique lors du verrouillage PTT</p>
              </div>
            </label>
          </div>
@@ -1,9 +1,17 @@
-import { defineConfig } from 'vite';
+import { defineConfig, loadEnv } from 'vite';
 import react from '@vitejs/plugin-react';
 import { VitePWA } from 'vite-plugin-pwa';
 import fs from 'fs';

-export default defineConfig({
+export default defineConfig(({ mode }) => {
+  // Charger les variables d'environnement
+  const env = loadEnv(mode, process.cwd(), '');
+
+  // Déterminer l'URL de l'API (utilise variable d'environnement ou fallback localhost)
+  const apiUrl = env.VITE_API_URL || 'http://localhost:3000';
+  const livekitUrl = env.VITE_LIVEKIT_URL || 'ws://localhost:7880';
+
+  return {
  plugins: [
    react(),
    VitePWA({
@@ -68,12 +76,12 @@ export default defineConfig({
    },
    proxy: {
      '/api': {
-        target: 'http://localhost:3000',
+        target: apiUrl.startsWith('/') ? 'http://localhost:3000' : apiUrl,
        changeOrigin: true,
        rewrite: (path) => path.replace(/^\/api/, '')
      },
      '/livekit': {
-        target: 'ws://192.168.0.146:7880',
+        target: livekitUrl,
        ws: true,
        changeOrigin: true,
        rewrite: (path) => path.replace(/^\/livekit/, '')
@@ -84,4 +92,5 @@ export default defineConfig({
    outDir: 'dist',
    sourcemap: true
  }
+  };
 });
@@ -0,0 +1,47 @@
+#!/bin/bash
+
+# PTT Live - Script d'installation multi-OS
+# Détecte automatiquement le système et lance l'installeur approprié
+
+set -e
+
+# Couleurs
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+RED='\033[0;31m'
+BLUE='\033[0;34m'
+NC='\033[0m'
+
+echo -e "${BLUE}=================================="
+echo "🚀 PTT Live - Installation"
+echo "==================================${NC}"
+echo ""
+
+# Détection du système d'exploitation
+if [[ "$OSTYPE" == "darwin"* ]]; then
+  echo -e "${GREEN}📱 Système détecté : macOS${NC}"
+  echo ""
+  exec ./install/macos.sh
+elif [[ "$OSTYPE" == "linux-gnu"* ]]; then
+  echo -e "${GREEN}🐧 Système détecté : Linux${NC}"
+  echo ""
+  exec ./install/linux.sh
+elif [[ "$OSTYPE" == "msys" ]] || [[ "$OSTYPE" == "cygwin" ]] || [[ "$OSTYPE" == "win32" ]]; then
+  echo -e "${YELLOW}🪟 Système détecté : Windows${NC}"
+  echo ""
+  echo -e "${RED}❌ Windows n'est pas encore supporté (Phase 3)${NC}"
+  echo ""
+  echo "Plateformes supportées :"
+  echo "  • macOS (via Homebrew)"
+  echo "  • Linux (Debian/Ubuntu/Fedora)"
+  echo ""
+  exit 1
+else
+  echo -e "${RED}❌ Système non reconnu : $OSTYPE${NC}"
+  echo ""
+  echo "Plateformes supportées :"
+  echo "  • macOS"
+  echo "  • Linux"
+  echo ""
+  exit 1
+fi
@@ -71,7 +71,8 @@ install_system_deps() {
                # Outils PipeWire
                sudo apt install -y \
                    pipewire-bin \
-                    libspa-0.2-jack
+                    libspa-0.2-jack \
+                    pulseaudio-utils

                # Démarrage automatique
                systemctl --user enable --now pipewire pipewire-pulse wireplumber
@@ -168,7 +169,8 @@ install_livekit_server() {
    echo ""
    echo "Téléchargement de LiveKit Server..."

-    LIVEKIT_VERSION="v1.5.2"
+    LIVEKIT_VERSION="v1.12.0"
+    LIVEKIT_VERSION_NUM="${LIVEKIT_VERSION#v}"  # Retire le 'v' pour le nom du fichier
    LIVEKIT_DIR="$PROJECT_ROOT/server/bin"
    LIVEKIT_BINARY="$LIVEKIT_DIR/livekit-server"

@@ -189,7 +191,7 @@ install_livekit_server() {
            ;;
    esac

-    LIVEKIT_URL="https://github.com/livekit/livekit/releases/download/${LIVEKIT_VERSION}/livekit_${LIVEKIT_VERSION}_linux_${LIVEKIT_ARCH}.tar.gz"
+    LIVEKIT_URL="https://github.com/livekit/livekit/releases/download/${LIVEKIT_VERSION}/livekit_${LIVEKIT_VERSION_NUM}_linux_${LIVEKIT_ARCH}.tar.gz"

    echo "Téléchargement depuis : $LIVEKIT_URL"

@@ -222,6 +224,61 @@ install_node_deps() {
    echo "Dépendances Node.js installées !"
 }

+# Configuration réseau et génération .env
+configure_network() {
+    echo ""
+    echo "Configuration réseau..."
+
+    # Détection IP réseau
+    NETWORK_IP=$(hostname -I | awk '{print $1}')
+
+    if [ -z "$NETWORK_IP" ]; then
+        echo "⚠️  IP réseau non détectée, utilisation localhost"
+        NETWORK_IP="localhost"
+    else
+        echo "✓ IP réseau détectée : ${NETWORK_IP}"
+    fi
+
+    # Générer .env serveur
+    echo "Génération configuration serveur..."
+
+    cat > "$PROJECT_ROOT/server/.env" << EOF
+# Configuration PTT Live Server
+# Généré automatiquement par install/linux.sh
+
+USE_LOCAL_LIVEKIT=true
+
+# LiveKit Configuration
+# AUTO = détection automatique IP réseau au démarrage
+LIVEKIT_URL=AUTO
+# En mode --dev, LiveKit utilise ces clés par défaut
+LIVEKIT_API_KEY=devkey
+LIVEKIT_API_SECRET=secret
+
+# Server Configuration
+PORT=3000
+NODE_ENV=development
+EOF
+
+    echo "✓ Configuration serveur générée (server/.env)"
+
+    # Générer .env client
+    echo "Génération configuration client..."
+
+    cat > "$PROJECT_ROOT/client/.env" << EOF
+# Configuration PTT Live Client
+# Généré automatiquement par install/linux.sh
+
+# En développement local, utilise le proxy Vite
+VITE_API_URL=/api
+
+# Pour accès réseau (autres devices), décommentez et mettez l'IP du serveur :
+# VITE_API_URL=http://${NETWORK_IP}:3000
+EOF
+
+    echo "✓ Configuration client générée (client/.env)"
+}
+
 # Configuration audio
 configure_audio() {
    echo ""
@@ -259,23 +316,35 @@ configure_audio() {
 print_summary() {
    echo ""
    echo "========================================"
-    echo "  Installation terminée !"
+    echo "  ✅ Installation terminée !"
    echo "========================================"
    echo ""
-    echo "Prochaines étapes :"
+    echo "🚀 Démarrage rapide :"
    echo ""
-    echo "1. Démarrer le serveur :"
-    echo "   cd $PROJECT_ROOT/server"
-    echo "   npm run dev"
+    echo "   # Mode développement (recommandé)"
+    echo "   ./start.sh --dev"
    echo ""
-    echo "2. Démarrer le client (autre terminal) :"
-    echo "   cd $PROJECT_ROOT/client"
-    echo "   npm run dev"
+    echo "   # Mode production"
+    echo "   ./start.sh"
    echo ""
-    echo "3. Accéder à l'interface :"
-    echo "   http://localhost:5173"
+    echo "📝 OU manuellement (deux terminaux) :"
+    echo ""
+    echo "   Terminal 1 : cd $PROJECT_ROOT/server && npm run dev"
+    echo "   Terminal 2 : cd $PROJECT_ROOT/client && npm run dev"
+    echo ""
+    echo "🌐 Accès après démarrage :"
+    echo "   • Développement local : https://localhost:5173"
+    echo "   • Depuis smartphone (WiFi) : https://${NETWORK_IP}:5173"
+    echo "   • Admin : https://${NETWORK_IP}:5173/admin"
+    echo ""
+    echo "💡 Configuration réseau :"
+    echo "   IP serveur détectée : ${NETWORK_IP}"
+    echo "   LiveKit URL : AUTO (détection dynamique)"
+    echo ""
+    echo "📖 Documentation :"
+    echo "   • README.md - Guide complet"
+    echo "   • README-PORTABLE.md - Déploiement portable"
    echo ""
-    echo "Documentation : $PROJECT_ROOT/README.md"
    echo "========================================"
    echo ""
 }
@@ -286,6 +355,7 @@ main() {
    install_system_deps
    install_livekit_server
    install_node_deps
+    configure_network
    configure_audio
    print_summary
 }
@@ -82,7 +82,7 @@ echo ""

 # Installer dépendances serveur
 echo "📦 Installation dépendances serveur..."
-cd ../server
+cd ./server
 npm install
 echo -e "${GREEN}✅ Dépendances serveur installées${NC}"
 echo ""
@@ -96,14 +96,30 @@ echo ""

 cd ..

-# Créer fichier .env
-echo "🔑 Génération configuration LiveKit..."
+# Détecter l'IP réseau locale
+echo "🌐 Détection configuration réseau..."
+NETWORK_IP=$(ifconfig | grep "inet " | grep -v 127.0.0.1 | awk '{print $2}' | head -n 1)
+
+if [ -z "$NETWORK_IP" ]; then
+    echo -e "${YELLOW}⚠️  IP réseau non détectée, utilisation localhost${NC}"
+    NETWORK_IP="localhost"
+else
+    echo -e "${GREEN}✅ IP réseau détectée : ${NETWORK_IP}${NC}"
+fi
+echo ""
+
+# Créer fichier .env serveur
+echo "🔑 Génération configuration serveur..."

 cat > server/.env << EOF
+# Configuration PTT Live Server
+# Généré automatiquement par install/macos.sh
+
 USE_LOCAL_LIVEKIT=true

 # LiveKit Configuration
-LIVEKIT_URL=ws://localhost:7880
+# AUTO = détection automatique IP réseau au démarrage
+LIVEKIT_URL=AUTO
 # En mode --dev, LiveKit utilise ces clés par défaut
 LIVEKIT_API_KEY=devkey
 LIVEKIT_API_SECRET=secret
@@ -113,22 +129,52 @@ PORT=3000
 NODE_ENV=development
 EOF

-echo -e "${GREEN}✅ Clés API générées (server/.env)${NC}"
+echo -e "${GREEN}✅ Configuration serveur générée (server/.env)${NC}"
+
+# Créer fichier .env client
+echo "🔑 Génération configuration client..."
+
+cat > client/.env << EOF
+# Configuration PTT Live Client
+# Généré automatiquement par install/macos.sh
+
+# En développement local, utilise le proxy Vite
+VITE_API_URL=/api
+
+# Pour accès réseau (autres devices), décommentez et mettez l'IP du serveur :
+# VITE_API_URL=http://${NETWORK_IP}:3000
+EOF
+
+echo -e "${GREEN}✅ Configuration client générée (client/.env)${NC}"
 echo ""

 # Message final
 echo "=================================="
 echo -e "${GREEN}✅ Installation terminée !${NC}"
 echo ""
-echo "📝 Prochaines étapes :"
+echo "🚀 Démarrage rapide :"
 echo ""
-echo "   1. Démarrer le serveur :"
-echo "      cd server && npm run dev"
+echo "   # Mode développement (recommandé)"
+echo "   ./start.sh --dev"
 echo ""
-echo "   2. Démarrer le client (nouveau terminal) :"
-echo "      cd client && npm run dev"
+echo "   # Mode production"
+echo "   ./start.sh"
 echo ""
-echo "   3. Ouvrir https://localhost:5173 dans votre navigateur"
+echo "📝 OU manuellement (deux terminaux) :"
 echo ""
-echo "📖 Documentation : README.md"
+echo "   Terminal 1 : cd server && npm run dev"
+echo "   Terminal 2 : cd client && npm run dev"
+echo ""
+echo "🌐 Accès après démarrage :"
+echo "   • Développement local : https://localhost:5173"
+echo "   • Depuis smartphone (WiFi) : https://${NETWORK_IP}:5173"
+echo "   • Admin : https://${NETWORK_IP}:5173/admin"
+echo ""
+echo "💡 Configuration réseau :"
+echo "   IP serveur détectée : ${NETWORK_IP}"
+echo "   LiveKit URL : AUTO (détection dynamique)"
+echo ""
+echo "📖 Documentation :"
+echo "   • README.md - Guide complet"
+echo "   • README-PORTABLE.md - Déploiement portable"
 echo ""
@@ -1,17 +1,23 @@
-# PTT Live - Configuration environnement serveur
+# Configuration PTT Live Server
+# Copiez ce fichier en .env et adaptez selon votre environnement

-# LiveKit API Keys
-# En dev, utilise les valeurs par défaut si non définies
+# Mode LiveKit
+USE_LOCAL_LIVEKIT=true  # true = LiveKit local, false = LiveKit Cloud
+
+# LiveKit Configuration
+# Mode local : AUTO détecte automatiquement l'IP réseau
+# Mode cloud : URL complète wss://votre-projet.livekit.cloud
+LIVEKIT_URL=AUTO
+
+# Clés API LiveKit
+# Mode local --dev : devkey/secret (par défaut)
+# Mode cloud : récupérez vos clés sur https://cloud.livekit.io
 LIVEKIT_API_KEY=devkey
 LIVEKIT_API_SECRET=secret

-# URL LiveKit pour les clients
-# Pour permettre les connexions réseau, utilisez l'IP locale du serveur
-# Exemples :
-#   - Local uniquement : ws://localhost:7880
-#   - Réseau local : ws://192.168.1.100:7880 (remplacer par votre IP)
-#   - Utiliser AUTO pour détecter automatiquement l'IP réseau
-LIVEKIT_URL=AUTO
+# Configuration serveur
+PORT=3000
+NODE_ENV=development

-# Mode LiveKit local (démarre livekit-server automatiquement)
-USE_LOCAL_LIVEKIT=true
+# Logging (optionnel)
+# LOG_LEVEL=debug
@@ -4,9 +4,6 @@
 */

 import { Router } from 'express';
-import { readFileSync, writeFileSync } from 'fs';
-import { join } from 'path';
-import YAML from 'yaml';
 import { fileURLToPath } from 'url';
 import { dirname } from 'path';
 import { CoreAudioBackend } from '../bridge/backends/CoreAudioBackend.js';
@@ -41,47 +38,6 @@ const stats = {
  logs: []
 };

-// Configuration file path
-const configPath = join(__dirname, '..', 'config', 'config.yaml');
-
-/**
- * Charge la configuration depuis le fichier YAML
- * et génère les IDs à partir des noms
- */
-function loadConfig() {
-  const configFile = readFileSync(configPath, 'utf8');
-  const config = YAML.parse(configFile);
-
-  // Générer les IDs pour les groupes
-  config.groups = config.groups.map(group => {
-    const groupId = slugify(group.name);
-    return {
-      ...group,
-      id: groupId
-    };
-  });
-
-  return config;
-}
-
-/**
- * Sauvegarde la configuration dans le fichier YAML
- * Ne sauvegarde PAS les IDs (ils sont générés dynamiquement)
- */
-function saveConfig(config) {
-  // Nettoyer les IDs avant de sauvegarder
-  const cleanConfig = {
-    ...config,
-    groups: config.groups.map(group => {
-      const { id, ...groupWithoutId } = group;
-      return groupWithoutId;
-    })
-  };
-
-  const yamlContent = YAML.stringify(cleanConfig);
-  writeFileSync(configPath, yamlContent, 'utf8');
-}
-
 /**
 * Ajoute un log au système
 */
@@ -166,7 +122,7 @@ export function addAudioStats(data) {
 */
 router.get('/groups', (req, res) => {
  try {
-    const config = loadConfig();
+    const config = configManager.get();
    res.json({
      groups: config.groups
    });
@@ -179,7 +135,7 @@ router.get('/groups', (req, res) => {
 /**
 * POST /admin/groups
 * Crée un nouveau groupe
- * Body: { name, audioBitrate?, channels }
+ * Body: { name, audioBitrate? }
 * L'ID est généré automatiquement à partir du nom
 */
 router.post('/groups', (req, res) => {
@@ -192,7 +148,7 @@ router.post('/groups', (req, res) => {
      });
    }

-    const config = loadConfig();
+    const config = configManager.get();

    // Générer l'ID à partir du nom
    const id = slugify(name);
@@ -204,14 +160,14 @@ router.post('/groups', (req, res) => {
      });
    }

-    // Créer le nouveau groupe (sans channels)
+    // Créer le nouveau groupe
    const newGroup = {
      name,
      ...(audioBitrate && { audioBitrate })
    };

    config.groups.push(newGroup);
-    saveConfig(config);
+    configManager.save(config);

    addLog('info', `Group created: ${name}`, { id });

@@ -237,7 +193,7 @@ router.put('/groups/:id', (req, res) => {
    const { id } = req.params;
    const { name, audioBitrate } = req.body;

-    const config = loadConfig();
+    const config = configManager.get();

    // Chercher le groupe par son nom (qui correspond à l'ID slugifié)
    const groupIndex = config.groups.findIndex(g => slugify(g.name) === id);
@@ -252,12 +208,12 @@ router.put('/groups/:id', (req, res) => {
    if (name !== undefined) config.groups[groupIndex].name = name;
    if (audioBitrate !== undefined) config.groups[groupIndex].audioBitrate = audioBitrate;

-    saveConfig(config);
+    configManager.save(config);

    addLog('info', `Group updated: ${config.groups[groupIndex].name}`, { id });

-    // Recharger pour obtenir les IDs générés
-    const updatedConfig = loadConfig();
+    // Récupérer la config à jour avec les IDs générés
+    const updatedConfig = configManager.get();
    const updatedGroupIndex = updatedConfig.groups.findIndex(g => slugify(g.name) === id || slugify(g.name) === slugify(name));
    const updatedGroup = updatedGroupIndex !== -1 ? updatedConfig.groups[updatedGroupIndex] : null;

@@ -281,7 +237,7 @@ router.delete('/groups/:id', (req, res) => {
  try {
    const { id } = req.params;

-    const config = loadConfig();
+    const config = configManager.get();
    const groupIndex = config.groups.findIndex(g => slugify(g.name) === id);

    if (groupIndex === -1) {
@@ -292,7 +248,7 @@ router.delete('/groups/:id', (req, res) => {

    const groupName = config.groups[groupIndex].name;
    config.groups.splice(groupIndex, 1);
-    saveConfig(config);
+    configManager.save(config);

    addLog('info', `Group deleted: ${groupName}`, { id });

@@ -412,7 +368,7 @@ router.get('/logs', (req, res) => {
 */
 router.get('/config', (req, res) => {
  try {
-    const config = loadConfig();
+    const config = configManager.get();
    res.json(config);
  } catch (error) {
    console.error('Erreur GET /admin/config:', error);
@@ -429,13 +385,13 @@ router.put('/config/audio', (req, res) => {
  try {
    const { sampleRate, defaultBitrate, jitterBufferMs } = req.body;

-    const config = loadConfig();
+    const config = configManager.get();

    if (sampleRate !== undefined) config.audio.sampleRate = sampleRate;
    if (defaultBitrate !== undefined) config.audio.defaultBitrate = defaultBitrate;
    if (jitterBufferMs !== undefined) config.audio.jitterBufferMs = jitterBufferMs;

-    saveConfig(config);
+    configManager.save(config);

    addLog('info', 'Audio config updated', { sampleRate, defaultBitrate, jitterBufferMs });

@@ -482,8 +438,28 @@ router.get('/audio/device', (req, res) => {
    const config = configManager.get();
    const audioDevice = config.audio?.device || {};

+    // Enrichir avec les infos réelles de la carte si configurée
+    const devices = CoreAudioBackend.getDevices();
+    let deviceInfo = { ...audioDevice };
+
+    if (audioDevice.inputDeviceId) {
+      const inputDev = devices.find(d => d.id === audioDevice.inputDeviceId);
+      if (inputDev) {
+        deviceInfo.inputChannels = inputDev.maxInputChannels;
+        deviceInfo.inputDeviceName = inputDev.name;
+      }
+    }
+
+    if (audioDevice.outputDeviceId) {
+      const outputDev = devices.find(d => d.id === audioDevice.outputDeviceId);
+      if (outputDev) {
+        deviceInfo.outputChannels = outputDev.maxOutputChannels;
+        deviceInfo.outputDeviceName = outputDev.name;
+      }
+    }
+
    res.json({
-      device: audioDevice
+      device: deviceInfo
    });
  } catch (error) {
    console.error('Erreur GET /admin/audio/device:', error);
@@ -644,4 +620,151 @@ router.post('/audio/device', (req, res) => {
  }
 });

+/**
+ * GET /admin/devices/list
+ * Liste tous les devices audio disponibles (auto-détection)
+ * Supporte macOS (CoreAudio), Linux (JACK/PipeWire), Windows (WASAPI)
+ */
+router.get('/devices/list', async (req, res) => {
+  try {
+    const devices = {
+      inputs: [],
+      outputs: [],
+      platform: process.platform
+    };
+
+    // Détection selon la plateforme
+    if (process.platform === 'darwin') {
+      // macOS : utiliser CoreAudioBackend.getDevices()
+      try {
+        const coreAudioDevices = CoreAudioBackend.getDevices();
+
+        // Séparer inputs et outputs
+        coreAudioDevices.forEach(device => {
+          if (device.maxInputChannels > 0) {
+            devices.inputs.push({
+              id: device.name, // Utiliser le nom comme ID (compatible avec inputDeviceName)
+              name: device.name,
+              channels: device.maxInputChannels,
+              sampleRate: device.defaultSampleRate,
+              isDefault: device.isDefault?.input || false
+            });
+          }
+
+          if (device.maxOutputChannels > 0) {
+            devices.outputs.push({
+              id: device.name, // Utiliser le nom comme ID (compatible avec outputDeviceName)
+              name: device.name,
+              channels: device.maxOutputChannels,
+              sampleRate: device.defaultSampleRate,
+              isDefault: device.isDefault?.output || false
+            });
+          }
+        });
+
+        // Fallback si aucun device trouvé
+        if (devices.inputs.length === 0) {
+          devices.inputs.push({ id: 'builtin-mic', name: 'Built-in Microphone', isDefault: true });
+        }
+        if (devices.outputs.length === 0) {
+          devices.outputs.push({ id: 'builtin-output', name: 'Built-in Output', isDefault: true });
+        }
+      } catch (error) {
+        console.warn('⚠️  Détection CoreAudio échouée:', error.message);
+
+        // Fallback : devices par défaut macOS
+        devices.inputs.push({ id: 'builtin-mic', name: 'Built-in Microphone', isDefault: true });
+        devices.outputs.push({ id: 'builtin-output', name: 'Built-in Output', isDefault: true });
+      }
+
+    } else if (process.platform === 'linux') {
+      // Linux : JACK ou PipeWire
+      const { exec } = await import('child_process');
+      const { promisify } = await import('util');
+      const execPromise = promisify(exec);
+
+      try {
+        // Essayer JACK d'abord
+        const { stdout: jackPorts } = await execPromise('jack_lsp 2>/dev/null || echo ""');
+
+        if (jackPorts.trim()) {
+          // Parser les ports JACK
+          const ports = jackPorts.split('\n').filter(Boolean);
+
+          ports.forEach(port => {
+            if (port.includes('capture')) {
+              devices.inputs.push({ id: port, name: port });
+            } else if (port.includes('playback')) {
+              devices.outputs.push({ id: port, name: port });
+            }
+          });
+        } else {
+          // Fallback : PipeWire/PulseAudio via pactl
+          const { stdout: paDevices } = await execPromise('pactl list short sources 2>/dev/null || echo ""');
+          const { stdout: paSinks } = await execPromise('pactl list short sinks 2>/dev/null || echo ""');
+
+          // Helper pour obtenir une description lisible
+          const getDeviceDescription = (deviceId) => {
+            // Extraire une description plus lisible du nom technique
+            if (deviceId.includes('alsa_input')) return deviceId.replace('alsa_input.', 'Input: ');
+            if (deviceId.includes('alsa_output')) return deviceId.replace('alsa_output.', 'Output: ');
+            return deviceId;
+          };
+
+          if (paDevices.trim()) {
+            paDevices.split('\n').filter(Boolean).forEach((line) => {
+              const parts = line.split('\t');
+              const deviceId = parts[1]; // Nom du device (ex: alsa_input.pci-...)
+              if (deviceId && !deviceId.includes('.monitor')) { // Ignorer les monitors
+                devices.inputs.push({
+                  id: deviceId,
+                  name: getDeviceDescription(deviceId)
+                });
+              }
+            });
+          }
+
+          if (paSinks.trim()) {
+            paSinks.split('\n').filter(Boolean).forEach((line) => {
+              const parts = line.split('\t');
+              const deviceId = parts[1]; // Nom du device (ex: alsa_output.pci-...)
+              if (deviceId) {
+                devices.outputs.push({
+                  id: deviceId,
+                  name: getDeviceDescription(deviceId)
+                });
+              }
+            });
+          }
+        }
+      } catch (linuxError) {
+        console.warn('⚠️  Détection devices Linux échouée:', linuxError.message);
+        devices.inputs.push({ id: 0, name: 'Default Input', isDefault: true });
+        devices.outputs.push({ id: 0, name: 'Default Output', isDefault: true });
+      }
+
+    } else if (process.platform === 'win32') {
+      // Windows : WASAPI (Phase 3)
+      // TODO: implémenter détection WASAPI
+      devices.inputs.push({ id: 0, name: 'Default Input (Windows)', isDefault: true });
+      devices.outputs.push({ id: 0, name: 'Default Output (Windows)', isDefault: true });
+    }
+
+    addLog('info', 'Audio devices listed', {
+      inputsCount: devices.inputs.length,
+      outputsCount: devices.outputs.length
+    });
+
+    res.json(devices);
+
+  } catch (error) {
+    console.error('Erreur GET /admin/devices/list:', error);
+    res.status(500).json({
+      error: 'Failed to list audio devices',
+      message: error.message,
+      platform: process.platform
+    });
+  }
+});
+
 export default router;
@@ -54,7 +54,7 @@ export class AudioBridge extends EventEmitter {
    this.opusEncoder = null;
    this.opusDecoder = null;
    this.jitterBuffer = null;
-    this.liveKitClient = null;
+    this.liveKitClients = new Map(); // Map<groupName, LiveKitClient> - un client par groupe
    this.groupAudioRouter = null;

    // État
@@ -65,6 +65,16 @@ export class AudioBridge extends EventEmitter {
    this.inputChannelBuffers = new Map(); // Map<channelId, Float32Array>
    this.groupBuffersFromLiveKit = new Map(); // Map<groupName, Float32Array>

+    // Frame accumulators pour LiveKit (240 samples → 960 samples)
+    this.liveKitFrameAccumulators = new Map(); // Map<groupName, { buffer: Float32Array, offset: number }>
+
+    // Pool de buffers pré-alloués pour éviter allocations répétées
+    this.bufferPool = {
+      float32: [], // Pool de Float32Array réutilisables
+      pcm: []      // Pool de Buffer PCM réutilisables
+    };
+    this.maxPoolSize = 50; // Limite du pool (adapté pour 30+ clients)
+
    // Statistiques
    this.stats = {
      startTime: null,
@@ -189,16 +199,45 @@ export class AudioBridge extends EventEmitter {
      throw new Error(`Plateforme non supportée : ${os}`);
    }

+    // Résoudre les device IDs vers les noms pour CoreAudio/sox
+    let inputDeviceName = null;
+    let outputDeviceName = null;
+
+    if (this.options.inputDeviceId) {
+      const inputDevice = BackendClass.getDevices().find(d => d.id === this.options.inputDeviceId);
+      inputDeviceName = inputDevice ? inputDevice.name : this.options.inputDeviceId;
+      console.log(`📥 Input device: "${inputDeviceName}" (ID: ${this.options.inputDeviceId})`);
+    }
+
+    if (this.options.outputDeviceId) {
+      const outputDevice = BackendClass.getDevices().find(d => d.id === this.options.outputDeviceId);
+      outputDeviceName = outputDevice ? outputDevice.name : this.options.outputDeviceId;
+      console.log(`📤 Output device: "${outputDeviceName}" (ID: ${this.options.outputDeviceId})`);
+    }
+
    // Initialisation du backend sélectionné
-    this.audioBackend = new BackendClass({
+    const backendOptions = {
      sampleRate: this.options.sampleRate,
      channels: this.options.channels,
      framesPerBuffer: this.options.frameSize,
-      inputDeviceId: this.options.inputDeviceId,
-      outputDeviceId: this.options.outputDeviceId,
-      // Options spécifiques PipeWire
      latency: this.options.latency || 20
-    });
+    };
+
+    // PipeWire utilise targetDevice, CoreAudio utilise inputDeviceName/outputDeviceName
+    if (this.backendType === 'PipeWire') {
+      // Pour PipeWire, on utilise inputDeviceId directement comme targetDevice
+      // (startCapture et startPlayback peuvent avoir des targets différents)
+      backendOptions.inputTargetDevice = this.options.inputDeviceId;
+      backendOptions.outputTargetDevice = this.options.outputDeviceId;
+    } else {
+      // CoreAudio et autres backends
+      backendOptions.inputDeviceId = this.options.inputDeviceId;
+      backendOptions.inputDeviceName = inputDeviceName;
+      backendOptions.outputDeviceId = this.options.outputDeviceId;
+      backendOptions.outputDeviceName = outputDeviceName;
+    }
+
+    this.audioBackend = new BackendClass(backendOptions);

    // Liste des devices disponibles
    devices = BackendClass.getDevices();
@@ -288,45 +327,63 @@ export class AudioBridge extends EventEmitter {
  }

  /**
-   * Initialise la connexion LiveKit
+   * Initialise les connexions LiveKit (une par groupe)
   * @private
   */
  async _initLiveKit() {
-    if (!this.options.liveKitToken) {
-      throw new Error('Token LiveKit requis');
+    if (!this.options.liveKitTokens || !Array.isArray(this.options.liveKitTokens)) {
+      throw new Error('liveKitTokens requis (tableau d\'objets { groupName, groupId, token })');
    }

-    this.liveKitClient = new LiveKitClient({
+    console.log(`🔌 Initialisation ${this.options.liveKitTokens.length} connexions LiveKit (une par groupe)...`);
+
+    // Créer un LiveKitClient pour chaque groupe
+    for (const { groupName, groupId, token } of this.options.liveKitTokens) {
+      const roomName = groupId; // La room porte le nom du groupId (slugifié)
+
+      const client = new LiveKitClient({
        url: this.options.liveKitUrl,
-      token: this.options.liveKitToken,
-      roomName: this.options.roomName,
-      participantName: 'AudioBridge',
+        token,
+        roomName,
+        participantName: `AudioBridge-${groupId}`,
        sampleRate: this.options.sampleRate,
        channels: this.options.channels,
        audioBitrate: this.opusEncoder.options.bitrate
      });

-    // Events LiveKit
-    this.liveKitClient.on('connected', () => {
-      console.log('✓ LiveKit connecté');
+      // Events LiveKit pour ce groupe
+      client.on('connected', () => {
+        console.log(`✓ LiveKit connecté pour groupe "${groupName}" (room: ${roomName})`);
      });

-    this.liveKitClient.on('disconnected', (data) => {
+      client.on('disconnected', (data) => {
        const reason = data?.reason || 'unknown';
-      console.warn('⚠️  LiveKit déconnecté:', reason);
+        console.warn(`⚠️  LiveKit déconnecté pour groupe "${groupName}":`, reason);
        this.stats.errors.network++;
      });

-    this.liveKitClient.on('reconnecting', () => {
-      console.log('🔄 LiveKit reconnexion...');
+      client.on('reconnecting', () => {
+        console.log(`🔄 LiveKit reconnexion pour groupe "${groupName}"...`);
      });

-    this.liveKitClient.on('audioTrackSubscribed', ({ track, participant }) => {
-      console.log(`🎵 Nouveau track audio : ${participant.identity}`);
-      this._handleRemoteAudioTrack(track);
+      client.on('audioTrackSubscribed', ({ track, participant }) => {
+        console.log(`🎵 Nouveau track audio dans groupe "${groupName}": ${participant.identity}`);
      });

-    await this.liveKitClient.connect();
+      // Réception audio depuis les clients LiveKit de ce groupe
+      client.on('audioData', ({ participantName, pcmData, sampleRate, channels }) => {
+        // Router vers le bon groupe
+        this.emit('groupAudioIn', { groupName: groupId, pcmBuffer: pcmData });
+      });
+
+      // Connexion
+      await client.connect();
+
+      // Stocker le client par groupId
+      this.liveKitClients.set(groupId, client);
+    }
+
+    console.log(`✓ ${this.liveKitClients.size} connexions LiveKit établies`);
  }

  /**
@@ -342,37 +399,156 @@ export class AudioBridge extends EventEmitter {
        // Convertir PCM Buffer → Float32Array (pour GroupAudioRouter)
        const float32Data = this._bufferToFloat32(pcmData);

-        // Pour l'instant, on assume que l'audio vient du canal 0
-        // TODO: Supporter multi-canaux depuis la carte son
+        // Séparer les canaux si audio multi-canaux (entrelacé)
+        const numChannels = this.options.channels || 1;
+
+        if (numChannels === 1) {
+          // Mono : un seul canal
          const channelId = this.options.inputDeviceChannel || 0;
          this.inputChannelBuffers.set(channelId, float32Data);
+        } else {
+          // Multi-canaux : dé-entrelacer les samples
+          // Format entrelacé : [L0, R0, L1, R1, ...] → [L0, L1, ...] et [R0, R1, ...]
+          const samplesPerChannel = float32Data.length / numChannels;
+
+          for (let ch = 0; ch < numChannels; ch++) {
+            const channelBuffer = new Float32Array(samplesPerChannel);
+
+            for (let i = 0; i < samplesPerChannel; i++) {
+              channelBuffer[i] = float32Data[i * numChannels + ch];
+            }
+
+            // Mapper canal hardware → canal logique (peut être configuré)
+            const logicalChannelId = this.options.channelMapping?.[ch] ?? ch;
+            this.inputChannelBuffers.set(logicalChannelId, channelBuffer);
+          }
+        }

        // ÉTAPE 1 : Inputs physiques → Groupes (via GroupAudioRouter)
        const groupBuffers = this.groupAudioRouter.processInputsToGroups(
          this.inputChannelBuffers
        );

-        // ÉTAPE 2 : Pour chaque groupe, envoyer vers LiveKit
-        groupBuffers.forEach((groupBuffer, groupName) => {
-          // Convertir Float32Array → PCM Buffer
-          const pcmBuffer = this._float32ToBuffer(groupBuffer);
-
-          // Encoder en Opus
-          const opusData = this.opusEncoder.encode(pcmBuffer);
-
-          if (opusData) {
-            this.stats.framesCapture++;
-            this.stats.bytesEncoded += opusData.length;
-
-            // TODO: Envoyer opusData à LiveKit pour ce groupe spécifique
-            // this.liveKitClient.sendAudioToGroup(groupName, opusData);
-
-            // Pour Phase 3, on émet un événement que le système d'intégration LiveKit écoutera
-            this.emit('groupAudioOut', { groupName, opusData, pcmBuffer });
+        if (this.stats.framesCapture % 100 === 0) {
+          // Détecter si l'audio est du silence (toutes les samples < 0.001)
+          let totalEnergy = 0;
+          this.inputChannelBuffers.forEach((buffer) => {
+            for (let i = 0; i < buffer.length; i++) {
+              totalEnergy += Math.abs(buffer[i]);
            }
          });
+          const avgEnergy = totalEnergy / (this.inputChannelBuffers.size * (this.options.frameSize || 960));
+          console.log(`[AudioBridge] Frame ${this.stats.framesCapture}: ${this.inputChannelBuffers.size} inputs → ${groupBuffers.size} groupes | Énergie audio: ${avgEnergy.toFixed(6)}`);
+        }
+
+        // ÉTAPE 2 : Pour chaque groupe, envoyer vers le LiveKitClient correspondant
+        groupBuffers.forEach((groupBuffer, groupName) => {
+          // Les groupes sont MONO (Float32Array de N samples)
+          // Mais la config globale peut être STÉRÉO (channels=2)
+          // → Adapter selon la configuration
+
+          let pcmBuffer;
+          const configChannels = this.options.channels || 1;
+
+          if (configChannels === 1) {
+            // Config MONO : envoyer directement
+            pcmBuffer = this._float32ToBuffer(groupBuffer);
+          } else if (configChannels === 2) {
+            // Config STÉRÉO : dupliquer le canal mono
+            const samplesPerChannel = groupBuffer.length;
+            const stereoBuffer = new Float32Array(samplesPerChannel * 2);
+
+            // Entrelacer : [M0, M1, M2, ...] → [M0, M0, M1, M1, M2, M2, ...]
+            for (let i = 0; i < samplesPerChannel; i++) {
+              stereoBuffer[i * 2] = groupBuffer[i];     // Canal gauche
+              stereoBuffer[i * 2 + 1] = groupBuffer[i]; // Canal droit (dupliqué)
+            }
+
+            pcmBuffer = this._float32ToBuffer(stereoBuffer);
+          } else {
+            console.error(`❌ Nombre de canaux non supporté: ${configChannels}`);
+            return;
+          }
+
+          // Récupérer le client LiveKit pour ce groupe
+          const client = this.liveKitClients.get(groupName);
+
+          // Envoi vers LiveKit via sendAudioData (prend du PCM 16-bit)
+          // Note: LiveKit gère lui-même l'encodage Opus en interne
+          if (client && client.isConnected) {
+            client.sendAudioData(pcmBuffer);
+            if (this.stats.framesCapture % 100 === 0) {
+              const channelLabel = configChannels === 1 ? 'mono' : `${configChannels}ch`;
+              console.log(`[AudioBridge] → LiveKit groupe "${groupName}": ${pcmBuffer.length} bytes (${channelLabel})`);
+            }
+          } else {
+            if (this.stats.framesCapture % 100 === 0) {
+              console.log(`[AudioBridge] ⚠️  LiveKit non connecté pour groupe "${groupName}", audio non envoyé`);
+            }
+          }
+
+          // Émettre aussi pour monitoring/debug
+          this.emit('groupAudioOut', { groupName, pcmBuffer });
+        });
+
+        // ÉTAPE 3 : Loopback local - Groupes → Outputs physiques (sans passer par LiveKit)
+        const outputBuffers = this.groupAudioRouter.processGroupsToOutputs(groupBuffers);
+
+        if (this.stats.framesCapture % 100 === 0) {
+          console.log(`[AudioBridge] Loopback local: ${groupBuffers.size} groupes → ${outputBuffers.size} outputs`);
+        }
+
+        // ÉTAPE 4 : Envoyer chaque output à la carte son
+        const numOutputChannels = this.options.channels || 1;
+
+        if (numOutputChannels === 1) {
+          // Mono : un seul output
+          if (outputBuffers.size > 0) {
+            const [firstChannelId, outputBuffer] = outputBuffers.entries().next().value;
+            const pcmBuffer = this._float32ToBuffer(outputBuffer);
+            this.audioBackend.queueAudio(pcmBuffer);
+
+            if (this.stats.framesCapture % 100 === 0) {
+              console.log(`[AudioBridge] → Output mono (canal ${firstChannelId}): ${pcmBuffer.length} bytes`);
+            }
+          }
+        } else {
+          // Multi-canaux : entrelacer les samples
+          // Récupérer les buffers dans l'ordre des canaux hardware
+          const channelBuffers = [];
+          const samplesPerChannel = this.options.frameSize;
+
+          for (let ch = 0; ch < numOutputChannels; ch++) {
+            const logicalChannelId = this.options.channelMapping?.[ch] ?? ch;
+            const buffer = outputBuffers.get(logicalChannelId);
+
+            if (buffer && buffer.length === samplesPerChannel) {
+              channelBuffers.push(buffer);
+            } else {
+              // Canal absent ou taille incorrecte : silence
+              channelBuffers.push(new Float32Array(samplesPerChannel));
+            }
+          }
+
+          // Entrelacer : [L0, L1, ...] et [R0, R1, ...] → [L0, R0, L1, R1, ...]
+          const interleavedBuffer = new Float32Array(samplesPerChannel * numOutputChannels);
+
+          for (let i = 0; i < samplesPerChannel; i++) {
+            for (let ch = 0; ch < numOutputChannels; ch++) {
+              interleavedBuffer[i * numOutputChannels + ch] = channelBuffers[ch][i];
+            }
+          }
+
+          const pcmBuffer = this._float32ToBuffer(interleavedBuffer);
+          this.audioBackend.queueAudio(pcmBuffer);
+
+          if (this.stats.framesCapture % 100 === 0) {
+            console.log(`[AudioBridge] → Output multi-canaux (${numOutputChannels}ch): ${pcmBuffer.length} bytes`);
+          }
+        }

        this.stats.framesCapture++;
+        this.stats.framesPlayback++;
      } catch (error) {
        console.error('Erreur routing capture:', error);
        this.stats.errors.capture++;
@@ -384,9 +560,39 @@ export class AudioBridge extends EventEmitter {
    // Écouter l'audio entrant de LiveKit (sera connecté par LiveKitServerBridge)
    this.on('groupAudioIn', ({ groupName, pcmBuffer }) => {
      try {
-        // Stocker le buffer du groupe pour le routing
+        // Convertir PCM Buffer → Float32Array
        const float32Data = this._bufferToFloat32(pcmBuffer);
-        this.groupBuffersFromLiveKit.set(groupName, float32Data);
+        const samplesReceived = float32Data.length;
+
+        // Initialiser l'accumulateur pour ce groupe si nécessaire
+        if (!this.liveKitFrameAccumulators.has(groupName)) {
+          this.liveKitFrameAccumulators.set(groupName, {
+            buffer: new Float32Array(960), // Frame size attendu par GroupRouter
+            offset: 0
+          });
+        }
+
+        const accumulator = this.liveKitFrameAccumulators.get(groupName);
+
+        // Vérifier que le buffer ne débordera pas
+        const availableSpace = 960 - accumulator.offset;
+        const samplesToCopy = Math.min(samplesReceived, availableSpace);
+
+        // Copier les samples dans l'accumulateur
+        if (samplesToCopy > 0) {
+          accumulator.buffer.set(float32Data.subarray(0, samplesToCopy), accumulator.offset);
+          accumulator.offset += samplesToCopy;
+        }
+
+        // Si on a accumulé assez de samples (960), router vers les outputs
+        if (accumulator.offset >= 960) {
+          // Vérifier que le backend est toujours actif (évite crash pendant shutdown)
+          if (!this.audioBackend) {
+            return;
+          }
+
+          // Stocker le buffer complet pour le routing
+          this.groupBuffersFromLiveKit.set(groupName, accumulator.buffer);

          // ÉTAPE 3 : Groupes → Outputs physiques (via GroupAudioRouter)
          const outputBuffers = this.groupAudioRouter.processGroupsToOutputs(
@@ -396,12 +602,15 @@ export class AudioBridge extends EventEmitter {
          // ÉTAPE 4 : Envoyer chaque output à la carte son
          outputBuffers.forEach((outputBuffer, channelId) => {
            const pcmBuffer = this._float32ToBuffer(outputBuffer);
-
-          // Envoyer à la carte son
            this.audioBackend.queueAudio(pcmBuffer);
          });

+          // Réinitialiser l'accumulateur
+          accumulator.offset = 0;
+          accumulator.buffer.fill(0);
+
          this.stats.framesPlayback++;
+        }
      } catch (error) {
        console.error('Erreur routing lecture:', error);
        this.stats.errors.playback++;
@@ -418,37 +627,85 @@ export class AudioBridge extends EventEmitter {
  }

  /**
-   * Gère l'arrivée d'un track audio distant
-   * @param {RemoteAudioTrack} track - Track LiveKit
+   * Acquiert un Float32Array depuis le pool ou en crée un nouveau
+   * @param {number} size - Taille du buffer
+   * @returns {Float32Array}
   * @private
   */
-  _handleRemoteAudioTrack(track) {
-    // Récupération du MediaStream du track
-    const mediaStream = new MediaStream([track.mediaStreamTrack]);
-
-    // Note: Pour décoder Opus côté serveur, on aurait besoin d'accéder
-    // aux données brutes via DataChannel ou API bas niveau
-    // LiveKit gère nativement le décodage WebRTC → PCM dans le navigateur
-
-    // Pour un vrai bridge serveur, il faudrait :
-    // 1. Recevoir les paquets Opus via DataChannel ou API custom
-    // 2. Décoder avec opusDecoder
-    // 3. Envoyer au jitterBuffer
-    // 4. Lire depuis jitterBuffer vers CoreAudio
-
-    // TODO: Implémenter réception bas niveau Opus depuis LiveKit
-    console.warn('Réception track distant : implémentation complète en cours');
+  _acquireFloat32Buffer(size) {
+    const pooled = this.bufferPool.float32.find(b => b.length === size);
+    if (pooled) {
+      this.bufferPool.float32.splice(this.bufferPool.float32.indexOf(pooled), 1);
+      return pooled;
+    }
+    return new Float32Array(size);
  }

  /**
-   * Convertit Buffer PCM 16-bit → Float32Array [-1.0, 1.0]
-   * @param {Buffer} buffer - Buffer PCM 16-bit signed
+   * Retourne un Float32Array au pool pour réutilisation
+   * @param {Float32Array} buffer
+   * @private
+   */
+  _releaseFloat32Buffer(buffer) {
+    if (this.bufferPool.float32.length < this.maxPoolSize) {
+      this.bufferPool.float32.push(buffer);
+    }
+  }
+
+  /**
+   * Acquiert un Buffer PCM depuis le pool ou en crée un nouveau
+   * @param {number} size - Taille du buffer
+   * @returns {Buffer}
+   * @private
+   */
+  _acquirePcmBuffer(size) {
+    const pooled = this.bufferPool.pcm.find(b => b.length === size);
+    if (pooled) {
+      this.bufferPool.pcm.splice(this.bufferPool.pcm.indexOf(pooled), 1);
+      return pooled;
+    }
+    return Buffer.alloc(size);
+  }
+
+  /**
+   * Retourne un Buffer PCM au pool pour réutilisation
+   * @param {Buffer} buffer
+   * @private
+   */
+  _releasePcmBuffer(buffer) {
+    if (this.bufferPool.pcm.length < this.maxPoolSize) {
+      this.bufferPool.pcm.push(buffer);
+    }
+  }
+
+  /**
+   * Convertit Buffer/Int16Array PCM 16-bit → Float32Array [-1.0, 1.0]
+   * @param {Buffer|Int16Array|Uint8Array} buffer - Buffer PCM 16-bit signed
   * @returns {Float32Array}
   * @private
   */
  _bufferToFloat32(buffer) {
-    const samples = buffer.length / 2; // 2 bytes per sample (16-bit)
-    const float32 = new Float32Array(samples);
+    let samples;
+    let float32;
+
+    // Cas 1 : Int16Array (LiveKit Node SDK format)
+    if (buffer instanceof Int16Array) {
+      samples = buffer.length;
+      float32 = this._acquireFloat32Buffer(samples);
+
+      for (let i = 0; i < samples; i++) {
+        float32[i] = buffer[i] / 32768.0;
+      }
+      return float32;
+    }
+
+    // Cas 2 : Buffer/Uint8Array (format classique)
+    if (!(buffer instanceof Buffer)) {
+      buffer = Buffer.from(buffer);
+    }
+
+    samples = buffer.length / 2; // 2 bytes per sample (16-bit)
+    float32 = this._acquireFloat32Buffer(samples);

    for (let i = 0; i < samples; i++) {
      // Lire 16-bit signed little-endian
@@ -467,7 +724,7 @@ export class AudioBridge extends EventEmitter {
   * @private
   */
  _float32ToBuffer(float32) {
-    const buffer = Buffer.alloc(float32.length * 2); // 2 bytes per sample
+    const buffer = this._acquirePcmBuffer(float32.length * 2); // 2 bytes per sample

    for (let i = 0; i < float32.length; i++) {
      // Clamping [-1.0, 1.0]
@@ -496,10 +753,12 @@ export class AudioBridge extends EventEmitter {
      this.audioBackend = null;
    }

-    if (this.liveKitClient) {
-      await this.liveKitClient.destroy();
-      this.liveKitClient = null;
+    // Déconnecter tous les clients LiveKit
+    for (const [groupName, client] of this.liveKitClients.entries()) {
+      console.log(`🔌 Déconnexion LiveKit groupe "${groupName}"...`);
+      await client.destroy();
    }
+    this.liveKitClients.clear();

    if (this.groupAudioRouter) {
      this.groupAudioRouter.destroy();
@@ -525,6 +784,10 @@ export class AudioBridge extends EventEmitter {
    this.inputChannelBuffers.clear();
    this.groupBuffersFromLiveKit.clear();

+    // Nettoyer le pool de buffers
+    this.bufferPool.float32 = [];
+    this.bufferPool.pcm = [];
+
    this.isRunning = false;

    console.log('✓ AudioBridge arrêté');
@@ -21,8 +21,10 @@ class AudioBridgeManager extends EventEmitter {

  /**
   * Démarre le bridge audio avec la configuration actuelle
+   * @param {Object} options - Options de démarrage
+   * @param {string} options.liveKitUrl - URL LiveKit résolue (déjà avec IP si AUTO)
   */
-  async start() {
+  async start(options = {}) {
    if (this.isRunning) {
      console.warn('⚠️  AudioBridge déjà démarré');
      return;
@@ -32,31 +34,60 @@ class AudioBridgeManager extends EventEmitter {
      const config = configManager.get();
      console.log('🎵 Démarrage AudioBridge avec configuration:', config.audio);

-      // Génération du token JWT pour le participant serveur
+      // Générer un token JWT par groupe
+      const liveKitTokens = [];
+
+      // Fonction pour slugifier le nom (identique à admin.js)
+      const slugify = (text) => {
+        return text
+          .toString()
+          .normalize('NFD')
+          .replace(/[\u0300-\u036f]/g, '')
+          .toLowerCase()
+          .trim()
+          .replace(/\s+/g, '-')
+          .replace(/[^\w-]+/g, '')
+          .replace(/--+/g, '-');
+      };
+
+      for (const group of config.groups || []) {
+        const groupId = slugify(group.name);
+        const groupName = group.name;
+
        const token = new AccessToken(
          config.server?.livekit?.apiKey || 'devkey',
          config.server?.livekit?.apiSecret || 'secret',
          {
-          identity: 'AudioBridge',
-          name: 'Audio Bridge Server',
+            identity: `AudioBridge-${groupId}`,
+            name: `Audio Bridge - ${groupName}`,
            metadata: JSON.stringify({
              role: 'bridge',
+              group: groupId,
              capabilities: ['audio-routing', 'monitoring']
            })
          }
        );

-      // Permissions complètes pour le bridge serveur
+        // Permissions complètes pour ce groupe
        token.addGrant({
-        room: 'main',
+          room: groupId, // Chaque groupe a sa propre room
          roomJoin: true,
          canPublish: true,
          canSubscribe: true,
          canPublishData: true
        });

-      const liveKitToken = await token.toJwt();
-      console.log('✓ Token JWT généré pour AudioBridge');
+        const jwt = await token.toJwt();
+        liveKitTokens.push({ groupName, groupId, token: jwt });
+
+        console.log(`✓ Token JWT généré pour groupe "${groupName}" (room: ${groupId})`);
+      }
+
+      if (liveKitTokens.length === 0) {
+        console.warn('⚠️  Aucun groupe configuré, AudioBridge ne pourra pas démarrer');
+        this.isRunning = false;
+        return;
+      }

      // Import dynamique du AudioBridge
      const { AudioBridge } = await import('./AudioBridge.js');
@@ -79,18 +110,27 @@ class AudioBridgeManager extends EventEmitter {
      if (audioConfig.defaultBitrate) audioConfig.defaultBitrate = parseInt(audioConfig.defaultBitrate, 10);
      if (audioConfig.customOpusBitrate) audioConfig.customOpusBitrate = parseInt(audioConfig.customOpusBitrate, 10);

+      // Extraire les device IDs depuis le sous-objet device
+      const inputDeviceId = audioConfig.device?.inputDeviceId || null;
+      const outputDeviceId = audioConfig.device?.outputDeviceId || null;
+
+      // Utiliser l'URL résolue passée en option, sinon fallback config
+      const liveKitUrl = options.liveKitUrl || config.server?.livekit?.url || 'ws://localhost:7880';
+
      // Créer l'instance avec la config
      this.bridge = new AudioBridge({
        ...audioConfig,
-        // Options LiveKit
-        liveKitUrl: config.server?.livekit?.url || 'ws://localhost:7880',
-        liveKitToken,
-        roomName: 'main',
+        // Options LiveKit (multi-rooms)
+        liveKitUrl,
+        liveKitTokens, // Tableau de { groupName, groupId, token }
        // Options de routing
        routing: config.audio?.routing || {},
        groups: config.groups || [],
        maxInputChannels: 32,
-        maxOutputChannels: 32
+        maxOutputChannels: 32,
+        // Device IDs extraits
+        inputDeviceId,
+        outputDeviceId
      });

      // Démarrer le bridge
@@ -10,6 +10,9 @@
 */

 import { EventEmitter } from 'events';
+import { getLogger } from '../utils/Logger.js';
+
+const logger = getLogger('Routing');

 /**
 * Représente une route audio avec gain
@@ -76,7 +79,10 @@ export class GroupAudioRouter extends EventEmitter {
   * Configure le routing depuis la config YAML
   */
  configure(routingConfig) {
-    console.log('Configuration du routing audio...');
+    logger.info('Configuration du routing audio...');
+    logger.debug('  Groupes disponibles:', this.config.groups.map(g => `${g.name || g} (id: ${g.id || g})`).join(', '));
+    logger.debug('  inputToGroup:', JSON.stringify(routingConfig.inputToGroup || {}));
+    logger.debug('  groupToOutput:', JSON.stringify(routingConfig.groupToOutput || {}));

    // Réinitialise les routes
    this.inputToGroupRoutes.clear();
@@ -104,7 +110,7 @@ export class GroupAudioRouter extends EventEmitter {
    }

    this._updateStatsActiveRoutes();
-    console.log(`Routing configuré : ${this.stats.routesActive} routes actives`);
+    logger.success(`Routing configuré : ${this.stats.routesActive} routes actives`);
    this.emit('configured', this.stats);
  }

@@ -128,7 +134,7 @@ export class GroupAudioRouter extends EventEmitter {
    const route = new AudioRoute(inputChannel, groupName, gainDb);
    this.inputToGroupRoutes.get(key).push(route);

-    console.log(`Route ajoutée : Input ${inputChannel} -> Group "${groupName}" (${gainDb}dB)`);
+    logger.info(`Input ${inputChannel} → Group "${groupName}" (${gainDb}dB)`);
    this._updateStatsActiveRoutes();
  }

@@ -145,7 +151,7 @@ export class GroupAudioRouter extends EventEmitter {
    const route = new AudioRoute(groupName, outputChannel, gainDb);
    this.groupToOutputRoutes.get(key).push(route);

-    console.log(`Route ajoutée : Group "${groupName}" -> Output ${outputChannel} (${gainDb}dB)`);
+    logger.info(`Group "${groupName}" → Output ${outputChannel} (${gainDb}dB)`);
    this._updateStatsActiveRoutes();
  }

@@ -205,7 +211,24 @@ export class GroupAudioRouter extends EventEmitter {
    // Réinitialise les buffers de groupe
    this.groupBuffers.clear();
    this.config.groups.forEach(group => {
-      this.groupBuffers.set(group.name, new Float32Array(this.config.frameSize));
+      // Utiliser l'ID (slugifié) plutôt que le nom pour correspondre au routing
+      const groupId = group.id || group.name || group;
+      this.groupBuffers.set(groupId, new Float32Array(this.config.frameSize));
+    });
+
+    // Compter le nombre de sources par groupe pour normalisation
+    const groupSourceCount = new Map();
+    inputChannelsData.forEach((_, channelId) => {
+      const key = `in_${channelId}`;
+      const routes = this.inputToGroupRoutes.get(key);
+      if (routes) {
+        routes.forEach(route => {
+          groupSourceCount.set(
+            route.destination,
+            (groupSourceCount.get(route.destination) || 0) + 1
+          );
+        });
+      }
    });

    // Pour chaque canal d'entrée
@@ -221,11 +244,17 @@ export class GroupAudioRouter extends EventEmitter {
      // Applique chaque route (mixage additif vers les groupes)
      routes.forEach(route => {
        const groupBuffer = this.groupBuffers.get(route.destination);
-        if (!groupBuffer) return;
+        if (!groupBuffer) {
+          logger.warn(`Buffer groupe "${route.destination}" introuvable pour routing depuis Input ${channelId}`);
+          return;
+        }
+
+        // Mixage avec gain + atténuation par nombre de sources
+        const sourceCount = groupSourceCount.get(route.destination) || 1;
+        const mixGain = route.linearGain / sourceCount;

-        // Mixage avec gain
        for (let i = 0; i < pcmData.length && i < groupBuffer.length; i++) {
-          groupBuffer[i] += pcmData[i] * route.linearGain;
+          groupBuffer[i] += pcmData[i] * mixGain;
        }
      });
    });
@@ -235,6 +264,9 @@ export class GroupAudioRouter extends EventEmitter {
      for (let i = 0; i < buffer.length; i++) {
        if (Math.abs(buffer[i]) > 1.0) {
          this.stats.clippingEvents++;
+          if (this.stats.clippingEvents % 1000 === 1) {
+            logger.warn(`Clipping détecté sur groupe "${groupName}" (${this.stats.clippingEvents} événements)`);
+          }
          buffer[i] = Math.sign(buffer[i]) * 1.0; // Hard clipping
        }
      }
@@ -260,7 +292,9 @@ export class GroupAudioRouter extends EventEmitter {
    groupBuffersData.forEach((pcmData, groupName) => {
      const routes = this.groupToOutputRoutes.get(groupName);

-      if (!routes || routes.length === 0) return;
+      if (!routes || routes.length === 0) {
+        return;
+      }

      // Applique chaque route vers les sorties
      routes.forEach(route => {
@@ -376,7 +410,7 @@ export class GroupAudioRouter extends EventEmitter {
    this.groupBuffers.clear();
    this.outputBuffers.clear();
    this.removeAllListeners();
-    console.log('GroupAudioRouter détruit');
+    logger.info('GroupAudioRouter détruit');
  }
 }

@@ -10,7 +10,7 @@
 * - Reconnexion automatique
 */

-import { Room, RoomEvent, AudioSource, AudioFrame, LocalAudioTrack, TrackSource } from '@livekit/rtc-node';
+import { Room, RoomEvent, AudioSource, AudioFrame, LocalAudioTrack, TrackSource, AudioStream, TrackKind } from '@livekit/rtc-node';
 import { EventEmitter } from 'events';

 export class LiveKitClient extends EventEmitter {
@@ -86,35 +86,21 @@ export class LiveKitClient extends EventEmitter {
   */
  async _createAudioSource() {
    try {
-      // Debug: afficher les valeurs avant conversion
+      // Conversion explicite en int32 pour l'API LiveKit
      const sampleRate = parseInt(this.options.sampleRate, 10);
      const channels = parseInt(this.options.channels, 10);

-      console.log('🔍 DEBUG AudioSource:', {
-        sampleRateOriginal: this.options.sampleRate,
-        sampleRateType: typeof this.options.sampleRate,
-        sampleRateConverted: sampleRate,
-        sampleRateConvertedType: typeof sampleRate,
-        channelsOriginal: this.options.channels,
-        channelsType: typeof this.options.channels,
-        channelsConverted: channels,
-        channelsConvertedType: typeof channels
-      });
-
-      // Création de l'AudioSource (conversion en int32 explicite)
+      // Création de l'AudioSource
      this.audioSource = new AudioSource(sampleRate, channels);
-      console.log('✓ AudioSource créée:', this.audioSource);

      // Création du LocalAudioTrack depuis l'AudioSource
      const localTrack = LocalAudioTrack.createAudioTrack('bridge-audio', this.audioSource);
-      console.log('✓ LocalAudioTrack créé:', localTrack);

      // Publication du track
      const options = {
        source: TrackSource.SOURCE_MICROPHONE // Simule un microphone pour les clients
      };

-      console.log('🔍 DEBUG publishTrack options:', options);
      this.localAudioTrack = await this.room.localParticipant.publishTrack(
        localTrack,
        options
@@ -150,8 +136,19 @@ export class LiveKitClient extends EventEmitter {
    });

    // Participants
-    this.room.on(RoomEvent.ParticipantConnected, (participant) => {
+    this.room.on(RoomEvent.ParticipantConnected, async (participant) => {
      console.log(`➕ Participant connecté: ${participant.identity}`);
+
+      // Parcourir les tracks publiés par ce participant et s'y abonner manuellement
+      for (const [trackSid, publication] of participant.trackPublications) {
+        console.log(`  📝 Track disponible: ${publication.kind} (${trackSid}), muted: ${publication.muted}`);
+
+        if (publication.kind === TrackKind.KIND_AUDIO && publication.track) {
+          console.log(`  ⚡ Souscription manuelle au track audio ${trackSid}...`);
+          await this._handleAudioTrack(publication.track, publication, participant);
+        }
+      }
+
      this.emit('participantConnected', participant);
    });

@@ -161,13 +158,47 @@ export class LiveKitClient extends EventEmitter {
      this.emit('participantDisconnected', participant);
    });

-    // Tracks
-    this.room.on(RoomEvent.TrackSubscribed, (track, publication, participant) => {
-      if (track.kind === 'audio') {
-        console.log(`🎵 Track audio souscrit de ${participant.identity}`);
+    // Tracks - Debug tous les événements
+    this.room.on(RoomEvent.TrackPublished, async (publication, participant) => {
+      console.log(`📢 Track publié par ${participant.identity}: ${publication.kind} (${publication.sid}), muted: ${publication.muted}`);
+
+      // Si c'est un track audio, s'y abonner immédiatement
+      if (publication.kind === TrackKind.KIND_AUDIO && publication.track) {
+        console.log(`  ⚡ Track audio détecté, souscription...`);
+        await this._handleAudioTrack(publication.track, publication, participant);
+      } else if (publication.kind === TrackKind.KIND_AUDIO && !publication.track) {
+        console.log(`  ⚠️  Track audio publié mais track object non disponible encore`);
+      }
+    });
+
+    this.room.on(RoomEvent.TrackSubscribed, async (track, publication, participant) => {
+      console.log(`🎵 Track souscrit de ${participant.identity}: ${track.kind} (${publication.sid})`);
+
+      if (track.kind === TrackKind.KIND_AUDIO) {
+        console.log(`🎵 Track AUDIO souscrit de ${participant.identity} (événement TrackSubscribed)`);
+        await this._handleAudioTrack(track, publication, participant);
+      }
+    });
+
+    this.room.on(RoomEvent.TrackUnsubscribed, (track, publication, participant) => {
+      if (track.kind === TrackKind.KIND_AUDIO) {
+        console.log(`🔇 Track audio désouscrit de ${participant.identity}`);
+        this.remoteParticipants.delete(participant.sid);
+        this.emit('audioTrackUnsubscribed', { track, participant });
+      }
+    });
+  }
+
+  /**
+   * Gère un track audio (création AudioStream et lecture)
+   * @private
+   */
+  async _handleAudioTrack(track, publication, participant) {
+    console.log(`🎧 Création AudioStream pour ${participant.identity}...`);

    // Création d'un AudioStream pour recevoir les données PCM
-        const stream = new track.AudioStream(
+    const stream = new AudioStream(
+      track,
      this.options.sampleRate,
      this.options.channels
    );
@@ -184,16 +215,6 @@ export class LiveKitClient extends EventEmitter {

    this.emit('audioTrackSubscribed', { track, participant });
  }
-    });
-
-    this.room.on(RoomEvent.TrackUnsubscribed, (track, publication, participant) => {
-      if (track.kind === 'audio') {
-        console.log(`🔇 Track audio désouscrit de ${participant.identity}`);
-        this.remoteParticipants.delete(participant.sid);
-        this.emit('audioTrackUnsubscribed', { track, participant });
-      }
-    });
-  }

  /**
   * Démarre la réception audio d'un participant
@@ -237,12 +258,24 @@ export class LiveKitClient extends EventEmitter {
      return;
    }

+    if (!this.isConnected || !this.localAudioTrack) {
+      // Silently drop frames si pas encore connecté
+      return;
+    }
+
    try {
-      // Création d'un AudioFrame (conversion en int32 explicite)
-      const samplesPerChannel = Math.floor(pcmData.length / 2 / this.options.channels);
+      // AudioFrame attend Int16Array, pas Buffer
+      // Convertir Buffer → Int16Array (éviter .slice, utiliser .subarray selon doc)
+      const int16Array = new Int16Array(
+        pcmData.buffer,
+        pcmData.byteOffset,
+        pcmData.length / 2  // length en samples, pas en bytes
+      );
+
+      const samplesPerChannel = Math.floor(int16Array.length / this.options.channels);

      const frame = new AudioFrame(
-        pcmData,
+        int16Array,
        parseInt(this.options.sampleRate, 10),
        parseInt(this.options.channels, 10),
        samplesPerChannel
@@ -252,9 +285,12 @@ export class LiveKitClient extends EventEmitter {
      await this.audioSource.captureFrame(frame);

    } catch (error) {
+      // Ne logger que les erreurs non-InvalidState pour éviter le spam
+      if (!error.message.includes('InvalidState')) {
        console.error('Erreur envoi audio:', error);
      }
    }
+  }

  /**
   * Récupère tous les tracks audio distants actifs
@@ -320,7 +356,14 @@ export class LiveKitClient extends EventEmitter {
    if (this.room) {
      // Unpublish track
      if (this.localAudioTrack) {
+        try {
          await this.room.localParticipant.unpublishTrack(this.localAudioTrack.sid);
+        } catch (error) {
+          // Ignorer l'erreur si le track n'existe plus (shutdown rapide)
+          if (!error.message?.includes('track not found')) {
+            console.warn('⚠️  Erreur unpublish track:', error.message);
+          }
+        }
        this.localAudioTrack = null;
      }

@@ -1,237 +0,0 @@
-/**
- * LiveKitServerBridge.js
- * Pont entre AudioBridge (cartes son) et LiveKit (clients WebRTC)
- *
- * Agit comme un participant virtuel qui :
- * - Publie l'audio des cartes son vers les clients WebRTC
- * - Reçoit l'audio des clients et le renvoie vers les cartes son
- *
- * Architecture :
- * [Carte Son] → AudioBridge → LiveKitServerBridge → LiveKit SFU → [Clients WebRTC]
- *                                      ↑
- *                            Gère le routing par groupe
- */
-
-import { RoomServiceClient, AccessToken, TrackSource } from 'livekit-server-sdk';
-import { EventEmitter } from 'events';
-
-export class LiveKitServerBridge extends EventEmitter {
-  constructor(audioBridge, options = {}) {
-    super();
-
-    this.audioBridge = audioBridge;
-
-    this.options = {
-      url: options.url || 'ws://localhost:7880',
-      apiKey: options.apiKey || process.env.LIVEKIT_API_KEY,
-      apiSecret: options.apiSecret || process.env.LIVEKIT_API_SECRET,
-      roomName: options.roomName || 'main',
-      participantName: options.participantName || 'AudioBridge',
-      ...options
-    };
-
-    this.roomServiceClient = null;
-    this.activeGroups = new Map(); // Map<groupName, { participants, audioData }>
-    this.isConnected = false;
-  }
-
-  /**
-   * Initialise la connexion au serveur LiveKit
-   */
-  async connect() {
-    try {
-      // Créer le client pour l'API LiveKit
-      this.roomServiceClient = new RoomServiceClient(
-        this.options.url.replace('ws://', 'http://').replace('wss://', 'https://'),
-        this.options.apiKey,
-        this.options.apiSecret
-      );
-
-      console.log('✓ LiveKitServerBridge : Connexion API établie');
-
-      // Configurer les événements AudioBridge
-      this._setupAudioBridgeListeners();
-
-      this.isConnected = true;
-      this.emit('connected');
-    } catch (error) {
-      console.error('Erreur connexion LiveKitServerBridge:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * Configure les listeners pour l'AudioBridge
-   * @private
-   */
-  _setupAudioBridgeListeners() {
-    // FLUX SORTANT : Carte son → Groupes → LiveKit
-    this.audioBridge.on('groupAudioOut', ({ groupName, opusData, pcmBuffer }) => {
-      this._handleGroupAudioOut(groupName, opusData, pcmBuffer);
-    });
-
-    console.log('✓ LiveKitServerBridge : Listeners AudioBridge configurés');
-  }
-
-  /**
-   * Gère l'audio sortant d'un groupe vers LiveKit
-   * @param {string} groupName - Nom du groupe
-   * @param {Buffer} opusData - Données Opus encodées
-   * @param {Buffer} pcmBuffer - Données PCM (pour debug)
-   * @private
-   */
-  async _handleGroupAudioOut(groupName, opusData, pcmBuffer) {
-    try {
-      // Pour l'instant, on stocke les données pour les envoyer via DataChannel
-      // ou via un participant virtuel par groupe
-
-      // IMPLÉMENTATION PHASE 3+ :
-      // Option A : Utiliser @livekit/rtc-node pour créer un AudioSource par groupe
-      // Option B : Utiliser DataChannel pour envoyer Opus directement
-      // Option C : Utiliser un participant virtuel par groupe (simple mais plus de ressources)
-
-      // Pour Phase actuelle, on émet un événement pour debug/monitoring
-      this.emit('groupAudioProcessed', {
-        groupName,
-        opusSize: opusData.length,
-        pcmSize: pcmBuffer.length
-      });
-
-      // TODO: Implémenter l'envoi réel vers LiveKit
-      // Voir docs/LIVEKIT_AUDIO_BRIDGE.md pour les 3 approches possibles
-
-    } catch (error) {
-      console.error(`Erreur envoi audio groupe ${groupName}:`, error);
-      this.emit('error', { groupName, error });
-    }
-  }
-
-  /**
-   * Méthode pour simuler la réception d'audio depuis LiveKit
-   * (À connecter avec le vrai système LiveKit via webhook ou polling)
-   *
-   * @param {string} groupName - Nom du groupe
-   * @param {Buffer} pcmBuffer - Audio PCM depuis un client
-   */
-  injectGroupAudioIn(groupName, pcmBuffer) {
-    // Envoyer vers AudioBridge pour routing vers la carte son
-    this.audioBridge.emit('groupAudioIn', { groupName, pcmBuffer });
-  }
-
-  /**
-   * Génère un token d'accès pour un client
-   * @param {string} identity - Identité du participant (ex: "user123")
-   * @param {string} groupName - Groupe à rejoindre
-   * @returns {string} JWT token
-   */
-  async generateClientToken(identity, groupName) {
-    const at = new AccessToken(
-      this.options.apiKey,
-      this.options.apiSecret,
-      {
-        identity,
-        name: identity,
-        ttl: '24h'
-      }
-    );
-
-    at.addGrant({
-      room: groupName, // Chaque groupe = une room LiveKit
-      roomJoin: true,
-      canPublish: true,
-      canSubscribe: true,
-      canPublishData: true
-    });
-
-    return at.toJwt();
-  }
-
-  /**
-   * Liste tous les participants actifs dans une room/groupe
-   * @param {string} groupName - Nom du groupe
-   * @returns {Promise<Array>} Liste des participants
-   */
-  async listParticipants(groupName) {
-    try {
-      const participants = await this.roomServiceClient.listParticipants(groupName);
-      return participants;
-    } catch (error) {
-      console.error(`Erreur listing participants ${groupName}:`, error);
-      return [];
-    }
-  }
-
-  /**
-   * Vérifie si une room/groupe existe
-   * @param {string} groupName - Nom du groupe
-   * @returns {Promise<boolean>}
-   */
-  async roomExists(groupName) {
-    try {
-      const rooms = await this.roomServiceClient.listRooms();
-      return rooms.some(room => room.name === groupName);
-    } catch (error) {
-      console.error('Erreur vérification room:', error);
-      return false;
-    }
-  }
-
-  /**
-   * Crée une room/groupe si elle n'existe pas
-   * @param {string} groupName - Nom du groupe
-   */
-  async ensureRoomExists(groupName) {
-    const exists = await this.roomExists(groupName);
-
-    if (!exists) {
-      try {
-        await this.roomServiceClient.createRoom({
-          name: groupName,
-          emptyTimeout: 300, // 5 minutes timeout si vide
-          maxParticipants: 50
-        });
-        console.log(`✓ Room créée : ${groupName}`);
-      } catch (error) {
-        console.error(`Erreur création room ${groupName}:`, error);
-      }
-    }
-  }
-
-  /**
-   * Obtient les statistiques du bridge
-   */
-  getStats() {
-    return {
-      connected: this.isConnected,
-      activeGroups: this.activeGroups.size,
-      apiUrl: this.options.url,
-      roomName: this.options.roomName
-    };
-  }
-
-  /**
-   * Déconnexion
-   */
-  async disconnect() {
-    if (this.audioBridge) {
-      this.audioBridge.removeAllListeners('groupAudioOut');
-    }
-
-    this.activeGroups.clear();
-    this.isConnected = false;
-
-    console.log('✓ LiveKitServerBridge déconnecté');
-    this.emit('disconnected');
-  }
-
-  /**
-   * Détruit le bridge et libère les ressources
-   */
-  async destroy() {
-    await this.disconnect();
-    this.removeAllListeners();
-    console.log('✓ LiveKitServerBridge détruit');
-  }
-}
-
-export default LiveKitServerBridge;
@@ -32,6 +32,11 @@ export class CoreAudioBackend extends EventEmitter {
    this.playbackProcess = null;
    this.isCapturing = false;
    this.isPlaying = false;
+    this.shuttingDown = false;
+
+    // Buffer d'accumulation pour la capture (sox envoie des chunks de taille variable)
+    this.captureAccumulator = Buffer.alloc(0);
+    this.targetCaptureBytes = this.options.framesPerBuffer * 2 * this.options.channels; // 2 bytes per sample

    // Buffer circulaire pour la lecture
    this.playbackBuffer = [];
@@ -48,7 +53,6 @@ export class CoreAudioBackend extends EventEmitter {
      const data = JSON.parse(output);

      const devices = [];
-      let id = 0;

      // Parse audio devices
      if (data.SPAudioDataType) {
@@ -62,13 +66,16 @@ export class CoreAudioBackend extends EventEmitter {
              const outputChannels = parseInt(device.coreaudio_device_output) || 0;
              const sampleRate = parseInt(device.coreaudio_device_srate) || 48000;

+              // Utiliser le UID CoreAudio comme ID (unique et stable)
+              const deviceUID = device._uniqueID || device.coreaudio_device_uid || name;
+
              // Ignorer les devices sans input ni output
              if (inputChannels === 0 && outputChannels === 0) {
                return;
              }

              devices.push({
-                id: id++,
+                id: deviceUID,
                name: name,
                maxInputChannels: inputChannels,
                maxOutputChannels: outputChannels,
@@ -90,7 +97,7 @@ export class CoreAudioBackend extends EventEmitter {
      if (devices.length === 0) {
        devices.push(
          {
-            id: 0,
+            id: 'builtin-mic',
            name: 'Built-in Microphone',
            maxInputChannels: 1,
            maxOutputChannels: 0,
@@ -98,7 +105,7 @@ export class CoreAudioBackend extends EventEmitter {
            hostAPIName: 'Core Audio'
          },
          {
-            id: 1,
+            id: 'builtin-output',
            name: 'Built-in Output',
            maxInputChannels: 0,
            maxOutputChannels: 2,
@@ -116,7 +123,7 @@ export class CoreAudioBackend extends EventEmitter {
      // Fallback : devices par défaut
      return [
        {
-          id: 0,
+          id: 'builtin-mic',
          name: 'Built-in Microphone',
          maxInputChannels: 1,
          maxOutputChannels: 0,
@@ -124,7 +131,7 @@ export class CoreAudioBackend extends EventEmitter {
          hostAPIName: 'Core Audio'
        },
        {
-          id: 1,
+          id: 'builtin-output',
          name: 'Built-in Output',
          maxInputChannels: 0,
          maxOutputChannels: 2,
@@ -182,35 +189,45 @@ export class CoreAudioBackend extends EventEmitter {
    }

    try {
-      // Commande sox pour capturer audio
-      // rec : enregistrer depuis input par défaut
-      // -t raw : format raw PCM
-      // -b 16 : 16-bit
-      // -e signed-integer : signed PCM
-      // -c 1 : mono (ou nombre de canaux)
-      // -r 48000 : sample rate
-      // - : sortie vers stdout
-      const args = [
-        '-t', 'coreaudio',  // Driver CoreAudio
-        'default',          // Device par défaut (ou spécifier nom)
-        '-t', 'raw',
-        '-b', '16',
-        '-e', 'signed-integer',
-        `-c`, String(this.options.channels),
-        `-r`, String(this.options.sampleRate),
-        '-'  // Stdout
-      ];
+      // Commande sox pour capturer audio sur macOS
+      // Sur macOS, sox utilise CoreAudio par défaut via 'rec' (alias de sox -d)
+      // Format: sox -d [options] output
+      // -d = default input device OU -t coreaudio "Device Name"

-      // Si device spécifié
+      const args = [];
+
+      // Spécifier le device d'entrée (CoreAudio capture en 32-bit natif)
      if (this.options.inputDeviceName) {
-        args[1] = this.options.inputDeviceName;
+        args.push('-t', 'coreaudio', this.options.inputDeviceName);
+      } else {
+        args.push('-d');
      }

+      // Format de sortie (stdout) - convertir 32→16 bit
+      args.push(
+        '-t', 'raw',      // Format sortie raw PCM
+        '-b', '16',       // Convertir vers 16-bit
+        '-e', 'signed-integer',
+        '-c', String(this.options.channels),
+        '-r', String(this.options.sampleRate),
+        '-'  // Stdout
+      );
+
+      console.log(`🎤 Démarrage capture sox: ${args.join(' ')}`);
      this.captureProcess = spawn('sox', args);

      this.captureProcess.stdout.on('data', (audioData) => {
-        // Émet les données audio capturées (Buffer PCM 16-bit)
-        this.emit('audioData', audioData);
+        // Accumuler les données jusqu'à avoir un frame complet
+        this.captureAccumulator = Buffer.concat([this.captureAccumulator, audioData]);
+
+        // Émettre des frames de taille fixe
+        while (this.captureAccumulator.length >= this.targetCaptureBytes) {
+          const frame = this.captureAccumulator.subarray(0, this.targetCaptureBytes);
+          this.emit('audioData', Buffer.from(frame)); // Copier pour éviter les références
+
+          // Garder le reste pour la prochaine frame
+          this.captureAccumulator = this.captureAccumulator.subarray(this.targetCaptureBytes);
+        }
      });

      this.captureProcess.stderr.on('data', (data) => {
@@ -246,6 +263,7 @@ export class CoreAudioBackend extends EventEmitter {
      this.captureProcess.kill('SIGTERM');
      this.captureProcess = null;
      this.isCapturing = false;
+      this.captureAccumulator = Buffer.alloc(0); // Reset accumulator
      console.log('✓ Capture audio arrêtée');
    }
  }
@@ -255,32 +273,42 @@ export class CoreAudioBackend extends EventEmitter {
   * @returns {Promise<void>}
   */
  async startPlayback() {
+    console.log('🔊 Démarrage playback sox...');
+
    if (this.isPlaying) {
-      console.warn('Lecture déjà active');
+      console.warn('⚠️  Lecture déjà active');
      return;
    }

    try {
-      // Commande sox pour lecture audio
-      // play : lire vers output par défaut
-      // -t raw : format raw PCM depuis stdin
+      // Commande sox pour lecture audio sur macOS
+      // Format: sox [options] input output
+      // Input = stdin (-)
+      // Output = -d (default) OU -t coreaudio "Device Name"
+
      const args = [
+        '--buffer', '65536',  // Buffer 64k (évite EOF prématuré)
        '-t', 'raw',
        '-b', '16',
        '-e', 'signed-integer',
-        `-c`, String(this.options.channels),
-        `-r`, String(this.options.sampleRate),
-        '-',  // Stdin
-        '-t', 'coreaudio',
-        'default'  // Device par défaut
+        '-c', String(this.options.channels),
+        '-r', String(this.options.sampleRate),
+        '-'  // Input = stdin
      ];

-      // Si device spécifié
+      // Spécifier le device de sortie
      if (this.options.outputDeviceName) {
-        args[args.length - 1] = this.options.outputDeviceName;
+        // Utiliser le device spécifié par son nom
+        args.push('-t', 'coreaudio', this.options.outputDeviceName);
+      } else {
+        // Device par défaut
+        args.push('-d');
      }

-      this.playbackProcess = spawn('sox', args);
+      console.log(`🔊 Démarrage playback sox: ${args.join(' ')}`);
+      this.playbackProcess = spawn('sox', args, {
+        stdio: ['pipe', 'ignore', 'pipe']  // stdin=pipe, stdout=ignore, stderr=pipe
+      });

      // Gérer l'erreur EPIPE sur stdin (si processus se ferme)
      this.playbackProcess.stdin.on('error', (error) => {
@@ -305,13 +333,35 @@ export class CoreAudioBackend extends EventEmitter {
      });

      this.playbackProcess.on('close', (code) => {
-        console.log(`Sox playback fermé (code ${code})`);
+        const uptime = ((Date.now() - this.playbackStartTime) / 1000).toFixed(1);
+        console.log(`⚠️  Sox playback fermé (code ${code}) après ${uptime}s`);
        this.isPlaying = false;
+
+        // Redémarrer automatiquement (sox se ferme quand le buffer stdin se vide)
+        if (!this.shuttingDown) {
+          console.log('🔄 Redémarrage automatique du playback...');
+          setTimeout(() => {
+            if (!this.shuttingDown) {
+              this.startPlayback().catch(err => {
+                console.error('Erreur redémarrage playback:', err);
+              });
+            }
+          }, 100);
+        }
      });

+      this.playbackStartTime = Date.now();
      this.isPlaying = true;
      this._startPlaybackLoop();

+      // Envoyer immédiatement du silence pour démarrer sox
+      const silenceBuffer = Buffer.alloc(this.options.framesPerBuffer * 2 * this.options.channels);
+      for (let i = 0; i < 10; i++) {
+        if (this.playbackProcess.stdin.writable) {
+          this.playbackProcess.stdin.write(silenceBuffer);
+        }
+      }
+
      console.log(`✓ Lecture audio démarrée : ${this.options.sampleRate}Hz, ${this.options.channels}ch`);
    } catch (error) {
      console.error('Erreur démarrage lecture:', error);
@@ -323,6 +373,11 @@ export class CoreAudioBackend extends EventEmitter {
   * Arrête la lecture audio
   */
  stopPlayback() {
+    if (this.playbackInterval) {
+      clearInterval(this.playbackInterval);
+      this.playbackInterval = null;
+    }
+
    if (this.playbackProcess && this.isPlaying) {
      this.playbackProcess.kill('SIGTERM');
      this.playbackProcess = null;
@@ -338,10 +393,16 @@ export class CoreAudioBackend extends EventEmitter {
   */
  queueAudio(audioData) {
    if (!this.isPlaying) {
-      console.warn('Tentative ajout audio alors que lecture inactive');
+      // Ne logger qu'une fois pour éviter le spam
+      if (!this.playbackInactiveWarned) {
+        console.warn('⚠️  Tentative ajout audio alors que lecture inactive (message unique)');
+        this.playbackInactiveWarned = true;
+      }
      return;
    }

+    this.playbackInactiveWarned = false;
+
    // Limite la taille du buffer pour éviter la latence excessive
    if (this.playbackBuffer.length < this.maxBufferSize) {
      this.playbackBuffer.push(audioData);
@@ -356,48 +417,55 @@ export class CoreAudioBackend extends EventEmitter {
   * @private
   */
  _startPlaybackLoop() {
-    const playNextChunk = () => {
+    // Calculer l'intervalle en ms (ex: 960 frames à 48kHz = 20ms)
+    const intervalMs = (this.options.framesPerBuffer / this.options.sampleRate) * 1000;
+
+    console.log(`🔁 Boucle playback démarrée (intervalle: ${intervalMs}ms)`);
+
+    // Utiliser setInterval pour garantir un flux continu
+    this.playbackInterval = setInterval(() => {
      if (!this.isPlaying || !this.playbackProcess || !this.playbackProcess.stdin) {
+        if (this.playbackInterval) {
+          clearInterval(this.playbackInterval);
+          this.playbackInterval = null;
+        }
        return;
      }

+      let chunk;
      if (this.playbackBuffer.length > 0) {
-        const chunk = this.playbackBuffer.shift();
+        chunk = this.playbackBuffer.shift();
+      } else {
+        // Buffer vide : underrun (envoyer du silence)
+        chunk = Buffer.alloc(this.options.framesPerBuffer * 2 * this.options.channels);
+      }
+
+      // Toujours écrire quelque chose pour garder sox actif
      try {
        if (this.playbackProcess.stdin.writable) {
          this.playbackProcess.stdin.write(chunk);
-          }
-        } catch (error) {
-          console.error('Erreur écriture stdin sox:', error);
-          this.isPlaying = false;
-          return;
-        }
        } else {
-        // Buffer vide : underrun (silence)
-        const silenceBuffer = Buffer.alloc(this.options.framesPerBuffer * 2 * this.options.channels);
-        try {
-          if (this.playbackProcess.stdin.writable) {
-            this.playbackProcess.stdin.write(silenceBuffer);
+          console.warn('⚠️  Sox stdin non writable, arrêt boucle');
+          this.isPlaying = false;
+          clearInterval(this.playbackInterval);
+          this.playbackInterval = null;
        }
      } catch (error) {
-          // Ignore si process fermé
+        if (error.code !== 'EPIPE') {
+          console.error('Erreur écriture stdin sox:', error);
+        }
        this.isPlaying = false;
-          return;
+        clearInterval(this.playbackInterval);
+        this.playbackInterval = null;
      }
-        this.emit('bufferUnderrun');
-      }
-
-      const intervalMs = (this.options.framesPerBuffer / this.options.sampleRate) * 1000;
-      setTimeout(playNextChunk, intervalMs);
-    };
-
-    playNextChunk();
+    }, intervalMs);
  }

  /**
   * Arrête tous les streams
   */
  destroy() {
+    this.shuttingDown = true;
    this.stopCapture();
    this.stopPlayback();
    this.removeAllListeners();
@@ -30,6 +30,12 @@ export class JACKBackend extends EventEmitter {
    this.jackProcess = null;
    this.isCapturing = false;
    this.isPlaying = false;
+    this.shuttingDown = false;
+
+    // Buffer d'accumulation pour la capture (JACK peut envoyer des chunks de taille variable)
+    this.captureAccumulator = Buffer.alloc(0);
+    this.targetCaptureBytes = this.options.framesPerBuffer * 2 * this.options.channels; // 2 bytes per sample
+
    this.playbackBuffer = [];
    this.maxBufferSize = 10;

@@ -213,8 +219,17 @@ export class JACKBackend extends EventEmitter {
      ]);

      this.jackProcess.stdout.on('data', (audioData) => {
-        // Émet les données audio capturées (Buffer PCM 16-bit)
-        this.emit('audioData', audioData);
+        // Accumuler les données jusqu'à avoir un frame complet
+        this.captureAccumulator = Buffer.concat([this.captureAccumulator, audioData]);
+
+        // Émettre des frames de taille fixe
+        while (this.captureAccumulator.length >= this.targetCaptureBytes) {
+          const frame = this.captureAccumulator.subarray(0, this.targetCaptureBytes);
+          this.emit('audioData', Buffer.from(frame)); // Copier pour éviter les références
+
+          // Garder le reste pour la prochaine frame
+          this.captureAccumulator = this.captureAccumulator.subarray(this.targetCaptureBytes);
+        }
      });

      this.jackProcess.stderr.on('data', (data) => {
@@ -248,6 +263,7 @@ export class JACKBackend extends EventEmitter {
      this.jackProcess.kill('SIGTERM');
      this.jackProcess = null;
      this.isCapturing = false;
+      this.captureAccumulator = Buffer.alloc(0); // Reset accumulator
      console.log('✓ Capture JACK arrêtée');
    }
  }
@@ -359,6 +375,7 @@ export class JACKBackend extends EventEmitter {
   * Arrête tous les streams
   */
  destroy() {
+    this.shuttingDown = true;
    this.stopCapture();
    this.stopPlayback();
    this.removeAllListeners();
@@ -23,7 +23,8 @@ export class PipeWireBackend extends EventEmitter {
      sampleRate: options.sampleRate || 48000,
      channels: options.channels || 1,
      framesPerBuffer: options.framesPerBuffer || 960,
-      targetDevice: options.targetDevice || null,
+      inputTargetDevice: options.inputTargetDevice || null,
+      outputTargetDevice: options.outputTargetDevice || null,
      latency: options.latency || 20, // ms
      ...options
    };
@@ -32,6 +33,12 @@ export class PipeWireBackend extends EventEmitter {
    this.playbackProcess = null;
    this.isCapturing = false;
    this.isPlaying = false;
+    this.shuttingDown = false;
+
+    // Buffer d'accumulation pour la capture (pw-cat envoie des chunks de taille variable)
+    this.captureAccumulator = Buffer.alloc(0);
+    this.targetCaptureBytes = this.options.framesPerBuffer * 2 * this.options.channels; // 2 bytes per sample
+
    this.playbackBuffer = [];
    this.maxBufferSize = 10;
  }
@@ -74,8 +81,10 @@ export class PipeWireBackend extends EventEmitter {

    try {
      // Utilise pactl (compatible PipeWire) pour lister les devices
-      const sourcesOutput = execSync('pactl list sources short', { encoding: 'utf8' });
-      const sinksOutput = execSync('pactl list sinks short', { encoding: 'utf8' });
+      // Chemin absolu pour éviter les problèmes de PATH avec /bin/sh
+      const pactlCmd = '/usr/bin/pactl';
+      const sourcesOutput = execSync(`${pactlCmd} list sources short`, { encoding: 'utf8' });
+      const sinksOutput = execSync(`${pactlCmd} list sinks short`, { encoding: 'utf8' });

      const devices = [];

@@ -126,7 +135,8 @@ export class PipeWireBackend extends EventEmitter {
   */
  static getDefaultInputDevice() {
    try {
-      const output = execSync('pactl get-default-source', { encoding: 'utf8' });
+      const pactlCmd = '/usr/bin/pactl';
+      const output = execSync(`${pactlCmd} get-default-source`, { encoding: 'utf8' });
      const defaultName = output.trim();

      const devices = this.getDevices();
@@ -144,7 +154,8 @@ export class PipeWireBackend extends EventEmitter {
   */
  static getDefaultOutputDevice() {
    try {
-      const output = execSync('pactl get-default-sink', { encoding: 'utf8' });
+      const pactlCmd = '/usr/bin/pactl';
+      const output = execSync(`${pactlCmd} get-default-sink`, { encoding: 'utf8' });
      const defaultName = output.trim();

      const devices = this.getDevices();
@@ -182,14 +193,24 @@ export class PipeWireBackend extends EventEmitter {
      ];

      // Ajoute le device cible si spécifié
-      if (this.options.targetDevice) {
-        args.push(`--target=${this.options.targetDevice}`);
+      if (this.options.inputTargetDevice) {
+        args.push(`--target=${this.options.inputTargetDevice}`);
      }

      this.captureProcess = spawn('pw-cat', args);

      this.captureProcess.stdout.on('data', (audioData) => {
-        this.emit('audioData', audioData);
+        // Accumuler les données jusqu'à avoir un frame complet
+        this.captureAccumulator = Buffer.concat([this.captureAccumulator, audioData]);
+
+        // Émettre des frames de taille fixe
+        while (this.captureAccumulator.length >= this.targetCaptureBytes) {
+          const frame = this.captureAccumulator.subarray(0, this.targetCaptureBytes);
+          this.emit('audioData', Buffer.from(frame)); // Copier pour éviter les références
+
+          // Garder le reste pour la prochaine frame
+          this.captureAccumulator = this.captureAccumulator.subarray(this.targetCaptureBytes);
+        }
      });

      this.captureProcess.stderr.on('data', (data) => {
@@ -226,6 +247,7 @@ export class PipeWireBackend extends EventEmitter {
      this.captureProcess.kill('SIGTERM');
      this.captureProcess = null;
      this.isCapturing = false;
+      this.captureAccumulator = Buffer.alloc(0); // Reset accumulator
      console.log('✓ Capture PipeWire arrêtée');
    }
  }
@@ -254,8 +276,8 @@ export class PipeWireBackend extends EventEmitter {
        '-' // Lecture depuis stdin
      ];

-      if (this.options.targetDevice) {
-        args.push(`--target=${this.options.targetDevice}`);
+      if (this.options.outputTargetDevice) {
+        args.push(`--target=${this.options.outputTargetDevice}`);
      }

      this.playbackProcess = spawn('pw-cat', args);
@@ -355,6 +377,7 @@ export class PipeWireBackend extends EventEmitter {
   * Arrête tous les streams
   */
  destroy() {
+    this.shuttingDown = true;
    this.stopCapture();
    this.stopPlayback();
    this.removeAllListeners();
@@ -1,51 +1,60 @@
 audio:
  sampleRate: 48000
+  channels: 2
  frameSize: 20
  defaultBitrate: 96
  jitterBufferMs: 40
  device:
-    inputDeviceId: 1
-    outputDeviceId: 0
+    inputDeviceId: Loopback Audio 4
+    outputDeviceId: Haut-parleurs MacBook Pro
    sampleRate: 48000
  routing:
    inputToGroup:
-      "1":
-        - technique
-      "2":
-        - technique
+      "0":
+        - default
+      "1": []
+      "2": []
      "4":
        - technique
      "5":
        - technique
-    groupToOutput: {}
+    groupToOutput:
+      technique:
+        - "1"
+      production:
+        - "0"
+        - "1"
+      default:
+        - "0"
    gains: {}
  channelNames:
    inputs:
-      "0": Micro Régisseur
+      "0": Mac
      "1": Talkback FOH
      "2": Retour Console
      "3": Liaison Scène
      "4": Monitor Mix
      "5": Spare 1
    outputs:
-      "0": Sortie Principale
-      "1": Retour Scène
+      "0": L
+      "1": R
      "2": Talkback Console
 groups:
+  - name: Default
+    audioBitrate: 96
+    channels: []
  - name: Production
    audioBitrate: 96
    channels: []
  - name: Technique
-    channels: []
-  - name: Sonorisation
-    audioBitrate: 128
+    audioBitrate: 96
    channels: []
 server:
  host: 0.0.0.0
  port: 3000
  livekit:
-    url: ws://localhost:7880
+    url: AUTO
 logging:
  level: debug
-  logLatency: true
-  logAudioStats: true
+  logLatency: false
+  logAudioStats: false
@@ -2,8 +2,10 @@

 import 'dotenv/config';
 import express from 'express';
+import https from 'https';
+import http from 'http';
 import { spawn } from 'child_process';
-import { readFileSync } from 'fs';
+import { readFileSync, existsSync } from 'fs';
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
 import { networkInterfaces } from 'os';
@@ -13,12 +15,18 @@ import adminRouter, { registerUser, addLog } from './api/admin.js';
 import configManager from './config/ConfigManager.js';
 import audioBridgeManager from './bridge/AudioBridgeManager.js';
 import AudioLevelsServer from './websocket/AudioLevelsServer.js';
+import { setGlobalLogLevel } from './utils/Logger.js';

 const __dirname = dirname(fileURLToPath(import.meta.url));

 // Chargement configuration via ConfigManager
 const config = configManager.get();

+// Configure le niveau de log
+const logLevel = config.logging?.level?.toUpperCase() || 'INFO';
+setGlobalLogLevel(logLevel);
+console.log(`📊 Niveau de log: ${logLevel}`);
+
 // Note: Les IDs sont maintenant générés automatiquement par le ConfigManager

 /**
@@ -61,6 +69,7 @@ const LIVEKIT_API_SECRET = process.env.LIVEKIT_API_SECRET || 'secret';
 const USE_LOCAL_LIVEKIT = process.env.USE_LOCAL_LIVEKIT === 'true';
 const SERVER_PORT = parseInt(process.env.PORT || config.server.port, 10);
 const SERVER_HOST = config.server.host;
+const ENABLE_HTTPS = process.env.ENABLE_HTTPS === 'true';

 // Configuration URL LiveKit
 let LIVEKIT_URL = process.env.LIVEKIT_URL || config.server.livekit.url;
@@ -99,8 +108,11 @@ let livekitProcess = null;

 function startLiveKitServer() {
  return new Promise((resolve, reject) => {
-    // Utiliser le binaire Homebrew (dans PATH)
-    const livekitBinary = 'livekit-server';
+    // Détection du binaire LiveKit :
+    // 1. Binaire local (Linux après install.sh) : server/bin/livekit-server
+    // 2. Binaire Homebrew (macOS) : livekit-server dans PATH
+    const localBinary = join(__dirname, 'bin', 'livekit-server');
+    const livekitBinary = existsSync(localBinary) ? localBinary : 'livekit-server';

    log('info', 'Démarrage LiveKit Server...');
    log('debug', 'Commande:', livekitBinary);
@@ -117,16 +129,27 @@ function startLiveKitServer() {

    livekitProcess = spawn(livekitBinary, args, {
      stdio: ['ignore', 'pipe', 'pipe'],
-      env: { ...process.env },
+      env: {
+        ...process.env,
+        LIVEKIT_LOG_LEVEL: 'info'  // Réduit les logs LiveKit (debug → info)
+      },
      shell: true  // Permet de trouver le binaire dans PATH
    });

    livekitProcess.stdout.on('data', (data) => {
      const output = data.toString().trim();
-      if (output) {
-        log('debug', '[LiveKit]', output);
+      if (!output) return;
+
+      // Filtrer les logs trop verbeux
+      if (output.includes('DEBUG') ||
+          output.includes('received signal request') ||
+          output.includes('sending signal response') ||
+          output.includes('handling signal request')) {
+        return; // Ignorer ces logs
      }

+      log('debug', '[LiveKit]', output);
+
      // Détection démarrage réussi
      if (output.includes('starting server') || output.includes('rtc server')) {
        resolve();
@@ -135,9 +158,14 @@ function startLiveKitServer() {

    livekitProcess.stderr.on('data', (data) => {
      const output = data.toString().trim();
-      if (output) {
-        log('warn', '[LiveKit Error]', output);
+      if (!output) return;
+
+      // Filtrer les logs DEBUG de stderr aussi
+      if (output.includes('DEBUG')) {
+        return;
      }
+
+      log('warn', '[LiveKit Error]', output);
    });

    livekitProcess.on('error', (error) => {
@@ -175,12 +203,36 @@ app.use((req, res, next) => {
  next();
 });

+// Middleware redirection HTTP → HTTPS (si activé)
+app.use((req, res, next) => {
+  // Si HTTPS activé et requête en HTTP, rediriger
+  if (ENABLE_HTTPS && req.protocol === 'http' && req.hostname !== 'localhost') {
+    const httpsUrl = `https://${req.hostname}:${SERVER_PORT}${req.url}`;
+    log('debug', `↪️  Redirection HTTPS: ${httpsUrl}`);
+    return res.redirect(301, httpsUrl);
+  }
+
+  next();
+});
+
 // Middleware logging
 app.use((req, res, next) => {
  log('debug', `${req.method} ${req.path}`);
  next();
 });

+// ========== Servir fichiers statiques client (production) ==========
+
+// En production, servir le build client depuis ../client/dist
+const clientDistPath = join(__dirname, '..', 'client', 'dist');
+
+if (existsSync(clientDistPath)) {
+  log('info', `📦 Serveur statique activé : ${clientDistPath}`);
+  app.use(express.static(clientDistPath));
+} else {
+  log('debug', '📦 Pas de build client (mode dev)');
+}
+
 // ========== Routes Admin ==========

 // Monter les routes admin sous /admin
@@ -188,11 +240,14 @@ app.use('/admin', adminRouter);

 // ========== Routes API ==========

+// Créer un router pour les routes API
+const apiRouter = express.Router();
+
 /**
 * GET /config
 * Retourne la configuration des groupes
 */
-app.get('/config', (req, res) => {
+apiRouter.get('/config', (req, res) => {
  try {
    const clientConfig = {
      groups: config.groups.map(g => ({
@@ -216,7 +271,7 @@ app.get('/config', (req, res) => {
 * GET /groups
 * Retourne la liste des groupes disponibles (simplifié)
 */
-app.get('/groups', (req, res) => {
+apiRouter.get('/groups', (req, res) => {
  try {
    const groups = config.groups.map(g => ({
      id: g.id,
@@ -235,7 +290,7 @@ app.get('/groups', (req, res) => {
 * Génère un token LiveKit pour un client
 * Body: { username: string, groupId: string }
 */
-app.post('/token', async (req, res) => {
+apiRouter.post('/token', async (req, res) => {
  try {
    const { username, groupId } = req.body;

@@ -314,7 +369,7 @@ app.post('/token', async (req, res) => {
 * GET /health
 * Health check
 */
-app.get('/health', (req, res) => {
+apiRouter.get('/health', (req, res) => {
  const isLivekitRunning = livekitProcess !== null;
  res.json({
    status: isLivekitRunning ? 'ok' : 'degraded',
@@ -323,22 +378,34 @@ app.get('/health', (req, res) => {
  });
 });

+// Monter le router API sous /api ET à la racine (rétrocompatibilité)
+app.use('/api', apiRouter);
+app.use(apiRouter); // Routes accessibles aussi sans préfixe /api
+
 /**
 * GET /
- * Info serveur
+ * Info serveur OU client PWA (si build existe)
 */
 app.get('/', (req, res) => {
+  // Si build client existe, servir index.html
+  const indexPath = join(clientDistPath, 'index.html');
+  if (existsSync(indexPath)) {
+    res.sendFile(indexPath);
+  } else {
+    // Sinon, afficher info API
    res.json({
      name: 'PTT Live Server',
-    version: '0.1.0',
-    phase: 'Phase 1 - MVP',
+      version: '0.2.0',
+      mode: 'development',
      endpoints: [
        'GET  /config - Configuration groupes',
        'GET  /groups - Liste des groupes',
        'POST /token  - Générer token client',
-      'GET  /health - Health check'
+        'GET  /health - Health check',
+        'GET  /admin - Interface administration'
      ]
    });
+  }
 });

 // ========== Démarrage ==========
@@ -366,23 +433,67 @@ async function start() {
      log('warn', '⚠️  Pour utiliser LiveKit local, définir USE_LOCAL_LIVEKIT=true dans .env');
    }

-    // 2. Démarrer API REST
-    const server = app.listen(SERVER_PORT, SERVER_HOST, () => {
+    // 2. Démarrer API REST (HTTP ou HTTPS selon config)
+    let server;
+
+    if (ENABLE_HTTPS) {
+      // Charger certificats SSL (mêmes que Vite)
+      const certPath = join(__dirname, '..', 'client');
+      const httpsOptions = {
+        key: readFileSync(join(certPath, 'localhost+3-key.pem')),
+        cert: readFileSync(join(certPath, 'localhost+3.pem'))
+      };
+
+      server = https.createServer(httpsOptions, app);
+      server.listen(SERVER_PORT, SERVER_HOST, () => {
+        log('info', `✓ API REST démarrée sur https://${SERVER_HOST}:${SERVER_PORT}`);
+        log('info', '');
+        log('info', 'Serveur prêt !');
+        log('info', `Groupes configurés: ${config.groups.map(g => g.name).join(', ')}`);
+        log('info', '');
+
+        // Afficher URLs d'accès
+        if (networkIP && networkIP !== 'localhost') {
+          const prodUrl = `https://${networkIP}:${SERVER_PORT}`;
+          log('info', '📱 Accès réseau WiFi :');
+          log('info', '');
+          log('info', `   Prod : ${prodUrl}`);
+          log('info', '');
+        }
+      });
+    } else {
+      server = http.createServer(app);
+      server.listen(SERVER_PORT, SERVER_HOST, () => {
        log('info', `✓ API REST démarrée sur http://${SERVER_HOST}:${SERVER_PORT}`);
        log('info', '');
        log('info', 'Serveur prêt !');
        log('info', `Groupes configurés: ${config.groups.map(g => g.name).join(', ')}`);
+        log('info', '');
+
+        // Afficher URLs d'accès
+        if (networkIP && networkIP !== 'localhost') {
+          const clientUrl = `https://${networkIP}:5173`; // Dev mode
+          const prodUrl = `http://${networkIP}:${SERVER_PORT}`; // Prod mode HTTP
+
+          log('info', '📱 Accès réseau WiFi :');
+          log('info', '');
+          log('info', `   Dev  : ${clientUrl}`);
+          log('info', `   Prod : ${prodUrl}`);
+          log('info', '');
+        }
      });
+    }

    // 2.5 Démarrer WebSocket Audio Levels (même port que l'API)
    const audioLevelsServer = new AudioLevelsServer({ server });
    audioLevelsServer.start();
-    log('info', `✓ WebSocket Audio Levels démarré sur ws://${SERVER_HOST}:${SERVER_PORT}`);
+    const wsProtocol = ENABLE_HTTPS ? 'wss' : 'ws';
+    log('info', `✓ WebSocket Audio Levels démarré sur ${wsProtocol}://${SERVER_HOST}:${SERVER_PORT}`);

    // 3. Démarrer Audio Bridge Manager (Phase 2.5)
    log('info', '');
    log('info', '🎵 Démarrage Audio Bridge Manager...');
-    await audioBridgeManager.start();
+    await audioBridgeManager.start({ liveKitUrl: LIVEKIT_URL });
    log('info', '✓ Audio Bridge Manager prêt (mode placeholder)');

    // Gérer erreur port déjà utilisé
@@ -24,6 +24,7 @@
    "express": "^4.19.2",
    "livekit-server-sdk": "^2.6.0",
    "opusscript": "^0.1.1",
+    "qrcode-terminal": "^0.12.0",
    "ws": "^8.17.0",
    "yaml": "^2.4.2"
  },
@@ -0,0 +1,78 @@
+/**
+ * Logger.js
+ * Système de logging centralisé avec niveaux configurables
+ */
+
+const LOG_LEVELS = {
+  ERROR: 0,
+  WARN: 1,
+  INFO: 2,
+  DEBUG: 3,
+  TRACE: 4
+};
+
+class Logger {
+  constructor(category = 'default', level = 'INFO') {
+    this.category = category;
+    this.level = LOG_LEVELS[level] ?? LOG_LEVELS.INFO;
+  }
+
+  setLevel(level) {
+    this.level = LOG_LEVELS[level] ?? LOG_LEVELS.INFO;
+  }
+
+  error(message, ...args) {
+    if (this.level >= LOG_LEVELS.ERROR) {
+      console.error(`[${this.category}] ❌`, message, ...args);
+    }
+  }
+
+  warn(message, ...args) {
+    if (this.level >= LOG_LEVELS.WARN) {
+      console.warn(`[${this.category}] ⚠️ `, message, ...args);
+    }
+  }
+
+  info(message, ...args) {
+    if (this.level >= LOG_LEVELS.INFO) {
+      console.log(`[${this.category}] ℹ️ `, message, ...args);
+    }
+  }
+
+  success(message, ...args) {
+    if (this.level >= LOG_LEVELS.INFO) {
+      console.log(`[${this.category}] ✓`, message, ...args);
+    }
+  }
+
+  debug(message, ...args) {
+    if (this.level >= LOG_LEVELS.DEBUG) {
+      console.log(`[${this.category}] 🔍`, message, ...args);
+    }
+  }
+
+  trace(message, ...args) {
+    if (this.level >= LOG_LEVELS.TRACE) {
+      console.log(`[${this.category}] 🔬`, message, ...args);
+    }
+  }
+}
+
+// Configuration globale depuis env ou config
+const globalLevel = process.env.LOG_LEVEL || 'INFO';
+
+// Loggers par catégorie
+const loggers = new Map();
+
+export function getLogger(category) {
+  if (!loggers.has(category)) {
+    loggers.set(category, new Logger(category, globalLevel));
+  }
+  return loggers.get(category);
+}
+
+export function setGlobalLogLevel(level) {
+  loggers.forEach(logger => logger.setLevel(level));
+}
+
+export default { getLogger, setGlobalLogLevel };
@@ -0,0 +1,56 @@
+#!/bin/bash
+
+# PTT Live - Affichage QR Code
+# Génère et affiche le QR code pour connexion smartphone
+
+set -e
+
+# Couleurs
+GREEN='\033[0;32m'
+BLUE='\033[0;34m'
+NC='\033[0m'
+
+# Détection IP réseau
+get_network_ip() {
+  if [[ "$OSTYPE" == "darwin"* ]]; then
+    # macOS
+    ifconfig | grep "inet " | grep -v 127.0.0.1 | awk '{print $2}' | head -n 1
+  elif [[ "$OSTYPE" == "linux-gnu"* ]]; then
+    # Linux
+    hostname -I | awk '{print $1}'
+  else
+    echo "localhost"
+  fi
+}
+
+NETWORK_IP=$(get_network_ip)
+
+# Déterminer l'URL selon mode dev ou prod
+if [ -d "client/dist" ] && [ "$1" != "--dev" ]; then
+  # Mode production (HTTPS)
+  URL="https://${NETWORK_IP}:3000"
+  MODE="production"
+else
+  # Mode dev (HTTPS)
+  URL="https://${NETWORK_IP}:5173"
+  MODE="dev"
+fi
+
+echo ""
+echo -e "${BLUE}=================================="
+echo "📱 QR Code PTT Live ($MODE)"
+echo "==================================${NC}"
+echo ""
+
+# Générer le QR code avec le package installé dans server/
+(cd server && node -e "
+const qrcode = require('qrcode-terminal');
+qrcode.generate('$URL', { small: true });
+")
+
+echo ""
+echo -e "${GREEN}🔗 URL : $URL${NC}"
+echo ""
+echo "📱 Scannez ce QR code depuis votre smartphone"
+echo "   pour vous connecter instantanément"
+echo ""
@@ -0,0 +1,204 @@
+#!/bin/bash
+
+# PTT Live - Script de démarrage unifié
+# Lance le serveur et le client en mode production
+
+set -e
+
+# Couleurs
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+RED='\033[0;31m'
+BLUE='\033[0;34m'
+NC='\033[0m'
+
+# Détection IP réseau
+get_network_ip() {
+  if [[ "$OSTYPE" == "darwin"* ]]; then
+    # macOS
+    ifconfig | grep "inet " | grep -v 127.0.0.1 | awk '{print $2}' | head -n 1
+  elif [[ "$OSTYPE" == "linux-gnu"* ]]; then
+    # Linux
+    hostname -I | awk '{print $1}'
+  else
+    echo "localhost"
+  fi
+}
+
+NETWORK_IP=$(get_network_ip)
+
+echo -e "${BLUE}=================================="
+echo "🚀 PTT Live - Démarrage"
+echo "==================================${NC}"
+echo ""
+
+echo -e "${GREEN}📡 IP réseau détectée : ${NETWORK_IP}${NC}"
+echo ""
+
+# Vérifier que les dépendances sont installées
+if [ ! -d "server/node_modules" ]; then
+  echo -e "${RED}❌ Dépendances serveur manquantes${NC}"
+  echo "   Exécutez d'abord : ./install/macos.sh (ou linux.sh)"
+  exit 1
+fi
+
+if [ ! -d "client/node_modules" ]; then
+  echo -e "${RED}❌ Dépendances client manquantes${NC}"
+  echo "   Exécutez d'abord : ./install/macos.sh (ou linux.sh)"
+  exit 1
+fi
+
+# Créer fichier PID pour cleanup
+PID_FILE="/tmp/ptt-live.pid"
+
+# Fonction cleanup
+cleanup() {
+  echo ""
+  echo -e "${YELLOW}⏹  Arrêt PTT Live...${NC}"
+
+  if [ -f "$PID_FILE" ]; then
+    while read -r pid; do
+      if ps -p "$pid" > /dev/null 2>&1; then
+        kill "$pid" 2>/dev/null || true
+      fi
+    done < "$PID_FILE"
+    rm -f "$PID_FILE"
+  fi
+
+  echo -e "${GREEN}✓ Arrêté${NC}"
+  exit 0
+}
+
+trap cleanup SIGINT SIGTERM EXIT
+
+# Afficher le QR code AVANT de lancer le serveur
+if [ "$1" == "--dev" ]; then
+  ./show-qr.sh --dev
+else
+  ./show-qr.sh
+fi
+
+# Démarrer le serveur (silencieux, logs dans fichier)
+echo -e "${BLUE}🔧 Démarrage serveur...${NC}"
+echo ""
+
+cd server
+
+# En mode production (pas --dev), activer HTTPS
+if [ "$1" != "--dev" ]; then
+  export ENABLE_HTTPS=true
+fi
+
+# Lancer le serveur en background silencieux
+npm start > ../server.log 2>&1 &
+SERVER_PID=$!
+echo "$SERVER_PID" > "$PID_FILE"
+cd ..
+
+
+
+
+
+
+
+
+
+
+# Attendre que le serveur soit prêt
+echo ""
+echo -e "${YELLOW}⏳ Attente démarrage serveur...${NC}"
+
+# Déterminer le protocole selon le mode
+if [ "$1" != "--dev" ]; then
+  HEALTH_URL="https://localhost:3000/health"
+else
+  HEALTH_URL="http://localhost:3000/health"
+fi
+
+for i in {1..30}; do
+  if curl -kssf "$HEALTH_URL" > /dev/null 2>&1; then
+    echo -e "${GREEN}✓ Serveur prêt${NC}"
+    break
+  fi
+
+  if [ $i -eq 30 ]; then
+    echo -e "${RED}❌ Timeout : le serveur n'a pas démarré${NC}"
+    echo "   Consultez server.log pour plus de détails"
+    exit 1
+  fi
+
+  sleep 1
+done
+
+echo ""
+
+# Build client si pas déjà fait ou mode dev
+if [ "$1" == "--dev" ]; then
+  echo -e "${BLUE}🎨 Démarrage client (dev)...${NC}"
+  cd client
+  npm run dev &
+  CLIENT_PID=$!
+  echo "$CLIENT_PID" >> "$PID_FILE"
+  cd ..
+
+  echo -e "${GREEN}✓ Client dev démarré${NC}"
+  echo ""
+  echo -e "${GREEN}=================================="
+  echo "✅ PTT Live démarré (mode dev)"
+  echo "==================================${NC}"
+  echo ""
+  echo -e "${BLUE}🌐 ACCÈS CLIENT (HTTPS) :${NC}"
+  echo -e "${GREEN}   👉 Local   : https://localhost:5173${NC}"
+  echo -e "${GREEN}   👉 Réseau  : https://${NETWORK_IP}:5173${NC}"
+  echo ""
+  echo -e "${YELLOW}⚠️  Acceptez le certificat auto-signé dans votre navigateur${NC}"
+  echo -e "${YELLOW}   (Cliquez sur 'Avancé' puis 'Continuer')${NC}"
+  echo ""
+  echo "📊 API serveur (HTTP uniquement) : http://localhost:3000"
+  echo "🎛️  Interface admin : https://localhost:5173/admin"
+  echo ""
+  echo "📝 Logs serveur : tail -f server.log"
+  echo ""
+  echo -e "${YELLOW}Appuyez sur Ctrl+C pour arrêter${NC}"
+  echo ""
+
+  # Attendre indéfiniment
+  wait
+
+else
+  # Mode production : build et serve
+  echo -e "${BLUE}🎨 Build client production...${NC}"
+  cd client
+
+  if [ ! -d "dist" ] || [ "$1" == "--rebuild" ]; then
+    npm run build
+    echo -e "${GREEN}✓ Client buildé${NC}"
+  else
+    echo -e "${YELLOW}⚠️  Build existant utilisé (--rebuild pour forcer)${NC}"
+  fi
+
+  cd ..
+
+  echo ""
+  echo -e "${GREEN}=================================="
+  echo "✅ PTT Live démarré (production)"
+  echo "==================================${NC}"
+  echo ""
+  echo -e "${BLUE}🌐 ACCÈS CLIENT (HTTPS) :${NC}"
+  echo -e "${GREEN}   👉 Local   : https://localhost:3000${NC}"
+  echo -e "${GREEN}   👉 Réseau  : https://${NETWORK_IP}:3000${NC}"
+  echo ""
+  echo -e "${YELLOW}⚠️  Acceptez le certificat auto-signé dans votre navigateur${NC}"
+  echo -e "${YELLOW}   (Cliquez sur 'Avancé' puis 'Continuer')${NC}"
+  echo ""
+  echo "🎛️  Interface admin : https://localhost:3000/admin"
+  echo "📊 API serveur : https://localhost:3000/api"
+  echo ""
+  echo "📝 Logs serveur : tail -f server.log"
+  echo ""
+  echo -e "${YELLOW}Appuyez sur Ctrl+C pour arrêter${NC}"
+  echo ""
+
+  # Attendre indéfiniment
+  wait
+fi