Créer un agent vocal IA qui rejoint les appels Google Meet (ElevenLabs + Selenium + PulseAudio)

#!/bin/bash
set -e
 
echo "=== Installation de l'agent vocal ==="
 
# Paquets système principaux
apt-get update -q
apt-get install -y -q \
    wget curl unzip \
    xvfb pulseaudio \
    libsndfile1 libportaudio2 ffmpeg portaudio19-dev \
    fonts-liberation libappindicator3-1 libasound2 \
    libatk-bridge2.0-0 libatk1.0-0 libcups2 libdbus-1-3 \
    libgdk-pixbuf2.0-0 libnspr4 libnss3 libx11-xcb1 \
    libxcomposite1 libxdamage1 libxrandr2 xdg-utils
 
# Installer Google Chrome
wget -q https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb
dpkg -i google-chrome-stable_current_amd64.deb || apt-get -f install -y
rm google-chrome-stable_current_amd64.deb
 
# Installer ChromeDriver (correspondant à votre version de Chrome)
CHROME_VERSION=$(google-chrome --version | grep -oP '\d+\.\d+\.\d+')
DRIVER_URL="https://storage.googleapis.com/chrome-for-testing-public/${CHROME_VERSION}.0/linux64/chromedriver-linux64.zip"
wget -q "$DRIVER_URL" -O /tmp/chromedriver.zip
unzip -o /tmp/chromedriver.zip -d /tmp/
mv /tmp/chromedriver-linux64/chromedriver /usr/local/bin/
chmod +x /usr/local/bin/chromedriver
 
# Dépendances Python
pip install -q \
    selenium \
    websockets \
    elevenlabs
 
echo "=== Installation terminée ==="

chmod +x setup.sh && ./setup.sh

# Démarrer l'affichage virtuel
Xvfb :99 -screen 0 1280x720x24 &
export DISPLAY=:99
 
# Démarrer PulseAudio en mode système
pulseaudio --start --exit-idle-time=-1

# 1. meet_capture — La sortie audio de Chrome va ici
#    Nous lirons depuis meet_capture.monitor pour entendre ce que disent les participants
pactl load-module module-null-sink \
    sink_name=meet_capture \
    sink_properties=device.description=MeetCapture
 
# 2. atlas_out — Les réponses de l'IA sont jouées ici
#    atlas_mic lit depuis atlas_out.monitor et agit comme entrée micro de Chrome
pactl load-module module-null-sink \
    sink_name=atlas_out \
    sink_properties=device.description=AtlasOutput
 
# 3. atlas_mic — Source microphone virtuelle alimentée par atlas_out
pactl load-module module-virtual-source \
    source_name=atlas_mic \
    master=atlas_out.monitor \
    source_properties=device.description=AtlasMic
 
# Définir les valeurs par défaut pour que Chrome les utilise
pactl set-default-source atlas_mic    # Micro de Chrome = sortie IA
pactl set-default-sink meet_capture   # Haut-parleurs de Chrome = notre point de capture

# Vérifier les sinks (devrait afficher meet_capture et atlas_out)
pactl list short sinks
 
# Vérifier les sources (devrait afficher atlas_mic et meet_capture.monitor)
pactl list short sources

#!/usr/bin/env python3
"""meet_bot.py — Rejoint un appel Google Meet en tant qu'invité via Selenium."""
 
import os
import sys
import time
from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.common.by import By
from selenium.common.exceptions import NoSuchElementException
 
MEET_URL = sys.argv[1] if len(sys.argv) > 1 else "https://meet.google.com/abc-defg-hij"
DISPLAY = os.environ.get("DISPLAY", ":99")
BOT_NAME = "Atlas"
 
 
def make_driver():
    opts = Options()
    opts.binary_location = "/usr/bin/google-chrome"
    opts.add_argument("--no-sandbox")
    opts.add_argument("--disable-dev-shm-usage")
    opts.add_argument("--disable-gpu")
    opts.add_argument("--use-fake-ui-for-media-stream")   # auto-allow mic/cam
    # Important : NE PAS utiliser --use-fake-device-for-media-stream
    # Nous voulons que Chrome utilise les vrais périphériques PulseAudio
    opts.add_argument("--disable-blink-features=AutomationControlled")
    opts.add_argument("--window-size=1280,720")
    opts.add_argument("--autoplay-policy=no-user-gesture-required")
    opts.add_experimental_option("excludeSwitches", ["enable-automation"])
 
    svc = Service("/usr/local/bin/chromedriver")
    driver = webdriver.Chrome(service=svc, options=opts)
    driver.execute_script(
        "Object.defineProperty(navigator, 'webdriver', {get: () => undefined})"
    )
    return driver
 
 
def find_any(driver, xpaths, timeout=10):
    """Essaie plusieurs sélecteurs XPath, retourne la première correspondance visible."""
    deadline = time.time() + timeout
    while time.time() < deadline:
        for xpath in xpaths:
            try:
                el = driver.find_element(By.XPATH, xpath)
                if el.is_displayed():
                    return el
            except NoSuchElementException:
                pass
        time.sleep(0.5)
    return None
 
 
def join_meet(driver, url):
    print(f"Ouverture de {url}")
    driver.get(url)
    time.sleep(4)
 
    # Étape 1 : Choisir le mode invité (sans compte Google)
    guest = find_any(driver, [
        "//span[contains(text(),'Use without an account')]",
        "//button[contains(text(),'Use without')]",
        "//span[contains(text(),'Continue without')]",
    ], timeout=8)
    if guest:
        guest.click()
        print("  Mode invité sélectionné")
        time.sleep(3)
 
    # Étape 2 : Entrer le nom du bot
    name_el = find_any(driver, [
        "//input[contains(@aria-label,'name') or contains(@aria-label,'Name')]",
        "//input[@placeholder='Your name']",
        "//input[@type='text']",
    ], timeout=8)
    if name_el:
        name_el.clear()
        name_el.send_keys(BOT_NAME)
        print(f"  Nom saisi : {BOT_NAME}")
        time.sleep(1)
 
    # Étape 3 : Cliquer sur rejoindre
    join_btn = find_any(driver, [
        "//span[contains(text(),'Ask to join')]",
        "//span[contains(text(),'Join now')]",
        "//button[contains(text(),'Ask to join')]",
        "//button[contains(text(),'Join now')]",
    ], timeout=15)
    if join_btn:
        join_btn.click()
        print("  Demande de participation envoyée — en attente d'admission...")
    else:
        print("  ERREUR : Bouton de participation non trouvé")
        driver.save_screenshot("/tmp/meet_debug.png")
        return False
 
    # Étape 4 : Attendre l'admission (jusqu'à 5 minutes)
    for i in range(60):
        mute_btns = driver.find_elements(By.XPATH,
            "//button[contains(@aria-label,'microphone') or contains(@aria-label,'mic')]"
        )
        if mute_btns:
            print(f"  DANS L'APPEL !")
            return True
        time.sleep(5)
 
    print("  Délai d'attente dépassé pour l'admission")
    return False
 
 
if __name__ == "__main__":
    driver = make_driver()
    try:
        if join_meet(driver, MEET_URL):
            print("\nLe bot est dans l'appel. Appuyez sur Ctrl+C pour quitter.")
            while True:
                time.sleep(10)
    except KeyboardInterrupt:
        print("\nDéconnexion de l'appel...")
    finally:
        driver.quit()

#!/usr/bin/env python3
"""
meet_elevenlabs_bridge.py — Pont ElevenLabs ConvAI <-> Google Meet via PulseAudio.
 
Flux audio :
  Audio sortant Meet -> meet_capture.monitor -> Agent ElevenLabs
  Agent ElevenLabs -> atlas_out -> atlas_out.monitor -> atlas_mic -> Micro Meet
"""
 
import argparse
import queue
import subprocess
import sys
import threading
import signal
import time
from typing import Callable
 
from elevenlabs.client import ElevenLabs
from elevenlabs.conversational_ai.conversation import (
    AudioInterface,
    Conversation,
)
 
# ── Configuration ─────────────────────────────────────────────────
API_KEY = "votre_clé_api_elevenlabs_ici"
 
INPUT_SOURCE  = "meet_capture.monitor"   # ce que Meet joue
OUTPUT_SINK   = "atlas_out"              # alimente atlas_mic -> micro Meet
 
SAMPLE_RATE   = 16000
CHANNELS      = 1
FORMAT        = "s16le"          # PCM 16-bit signé little-endian
CHUNK_SAMPLES = 4000             # chunks de 250ms (recommandé par le SDK)
CHUNK_BYTES   = CHUNK_SAMPLES * CHANNELS * 2
 
 
# ── Interface audio PulseAudio personnalisée ─────────────────────
class PulseAudioInterface(AudioInterface):
    """Route l'audio via PulseAudio en utilisant des sous-processus parec/pacat."""
 
    def start(self, input_callback: Callable[[bytes], None]):
        self.input_callback = input_callback
        self.output_queue: queue.Queue[bytes] = queue.Queue()
        self.should_stop = threading.Event()
 
        # Capture depuis la sortie audio de Meet
        self._rec_proc = subprocess.Popen(
            [
                "parec",
                f"--device={INPUT_SOURCE}",
                f"--format={FORMAT}",
                f"--rate={SAMPLE_RATE}",
                f"--channels={CHANNELS}",
                "--latency-msec=50",
            ],
            stdout=subprocess.PIPE,
            stderr=subprocess.DEVNULL,
        )
 
        # Jouer les réponses de l'IA dans atlas_out -> micro de Meet
        self._play_proc = subprocess.Popen(
            [
                "pacat",
                "--playback",
                f"--device={OUTPUT_SINK}",
                f"--format={FORMAT}",
                f"--rate={SAMPLE_RATE}",
                f"--channels={CHANNELS}",
                "--latency-msec=50",
            ],
            stdin=subprocess.PIPE,
            stderr=subprocess.DEVNULL,
        )
 
        self._input_thread = threading.Thread(
            target=self._read_input, daemon=True
        )
        self._output_thread = threading.Thread(
            target=self._write_output, daemon=True
        )
        self._input_thread.start()
        self._output_thread.start()
 
        print(f"[audio] capture depuis {INPUT_SOURCE}")
        print(f"[audio] lecture vers {OUTPUT_SINK}")
 
    def stop(self):
        self.should_stop.set()
        if self._rec_proc:
            self._rec_proc.terminate()
        if self._play_proc:
            try:
                self._play_proc.stdin.close()
            except Exception:
                pass
            self._play_proc.terminate()
 
    def output(self, audio: bytes):
        self.output_queue.put(audio)
 
    def interrupt(self):
        # Vider la file d'attente quand l'utilisateur interrompt l'IA
        try:
            while True:
                self.output_queue.get_nowait()
        except queue.Empty:
            pass
 
    def _read_input(self):
        while not self.should_stop.is_set():
            chunk = self._rec_proc.stdout.read(CHUNK_BYTES)
            if not chunk:
                break
            self.input_callback(chunk)
 
    def _write_output(self):
        while not self.should_stop.is_set():
            try:
                audio = self.output_queue.get(timeout=0.25)
                self._play_proc.stdin.write(audio)
                self._play_proc.stdin.flush()
            except queue.Empty:
                pass
            except BrokenPipeError:
                break
 
 
# ── Principal ─────────────────────────────────────────────────────
def run_bridge(client: ElevenLabs, agent_id: str):
    print(f"\n[pont] Démarrage du pont ElevenLabs ConvAI")
    print(f"[pont] Agent : {agent_id}")
    print(f"[pont] Appuyez sur Ctrl+C pour arrêter\n")
 
    quit_event = threading.Event()
    signal.signal(signal.SIGTERM, lambda s, f: quit_event.set())
    signal.signal(signal.SIGINT, lambda s, f: quit_event.set())
 
    while not quit_event.is_set():
        print("[pont] Démarrage d'une nouvelle session...")
        try:
            conversation = Conversation(
                client=client,
                agent_id=agent_id,
                requires_auth=False,
                audio_interface=PulseAudioInterface(),
                callback_agent_response=lambda t: print(f"[agent] {t}"),
                callback_user_transcript=lambda t: print(f"[user]  {t}"),
                callback_latency_measurement=lambda ms: print(
                    f"[latence] {ms}ms"
                ),
            )
            conversation.start_session()
            conversation.wait_for_session_end()
        except Exception as e:
            print(f"[pont] Erreur de session : {e}")
 
        if not quit_event.is_set():
            print("[pont] Session terminée, redémarrage dans 2s...")
            time.sleep(2)
 
    print("[pont] Terminé.")
 
 
def main():
    parser = argparse.ArgumentParser(
        description="Pont ElevenLabs ConvAI <-> Google Meet"
    )
    parser.add_argument("--agent-id", required=True, help="ID de l'agent ElevenLabs")
    parser.add_argument(
        "--api-key",
        default=API_KEY,
        help="Clé API ElevenLabs",
    )
    args = parser.parse_args()
 
    client = ElevenLabs(api_key=args.api_key)
    run_bridge(client, args.agent_id)
 
 
if __name__ == "__main__":
    main()

# Démarrer Xvfb
Xvfb :99 -screen 0 1280x720x24 &
export DISPLAY=:99
 
# Démarrer PulseAudio
pulseaudio --start --exit-idle-time=-1
 
# Créer les périphériques audio virtuels
pactl load-module module-null-sink sink_name=meet_capture \
    sink_properties=device.description=MeetCapture
pactl load-module module-null-sink sink_name=atlas_out \
    sink_properties=device.description=AtlasOutput
pactl load-module module-virtual-source source_name=atlas_mic \
    master=atlas_out.monitor \
    source_properties=device.description=AtlasMic
pactl set-default-source atlas_mic
pactl set-default-sink meet_capture

export DISPLAY=:99
python3 meet_bot.py "https://meet.google.com/votre-code-reunion"

python3 meet_elevenlabs_bridge.py --agent-id VOTRE_ID_AGENT --api-key VOTRE_CLE_API

# Lister les flux audio de Chrome
pactl list short sink-inputs
 
# Déplacer chaque flux vers meet_capture (remplacez INDEX par le numéro réel)
pactl move-sink-input INDEX meet_capture

def move_chrome_audio():
    """Déplace tous les flux audio Chrome vers le sink meet_capture."""
    import time
    time.sleep(6)  # attendre que Chrome commence à jouer de l'audio
    result = subprocess.run(
        ["pactl", "list", "short", "sink-inputs"],
        capture_output=True, text=True,
    )
    for line in result.stdout.strip().splitlines():
        parts = line.split()
        if parts:
            subprocess.run(
                ["pactl", "move-sink-input", parts[0], "meet_capture"],
                capture_output=True,
            )
            print(f"Flux audio {parts[0]} déplacé vers meet_capture")

#!/usr/bin/env python3
"""voice_meet_bot.py — Agent vocal IA complet pour Google Meet."""
 
import os
import subprocess
import sys
import threading
import time
 
# ... (combiner meet_bot.py + meet_elevenlabs_bridge.py)
# Voir le script combiné complet dans le dépôt du projet
 
def main():
    # 1. Configurer les périphériques audio
    setup_audio()
 
    # 2. Démarrer Chrome et rejoindre Meet
    driver = make_driver()
    join_thread = threading.Thread(target=join_meet, args=(driver, MEET_URL))
    join_thread.start()
 
    # 3. Déplacer l'audio de Chrome après qu'il a rejoint
    time.sleep(10)
    move_chrome_audio()
 
    # 4. Démarrer le pont ElevenLabs
    client = ElevenLabs(api_key=API_KEY)
    run_bridge(client, AGENT_ID)