Cours Vibe coding avec Claude Code · Module 13: Clone de Twitch
Le pont avec une caméra : lecteur et chat, le test d'abord
Dans cette leçon9
Ohé ! Le capitaine veut diffuser ses traversées en direct : l'équipage resté à terre doit voir le pont et discuter avec lui pendant le quart. Dans cette location, tu construis Live from the Deck, un clone de Twitch, c'est-à-dire d'un service de diffusion en direct. Le spectateur qui arrive sur une chaîne attend deux choses à la fois : l'image et le chat. L'image doit pouvoir se mettre en pause, se couper et passer en plein écran. Le chat défile vite, et sa logique, par exemple la transformation des codes d'émotes en images, casse à des endroits qu'on ne voit pas au premier clic.
Ce que tu vas apprendre
- commander un lecteur et un chat en mode plan, avec un test comme critère de fin ;
- écrire avec Claude le test de l'analyseur d'émotes avant que l'analyseur existe, et voir comment il attrape le tri sur place ;
- lire un chat avec mise à jour fonctionnelle de l'état, des identifiants uniques et
onKeyDownà la place de l'évènement obsolète ; - vérifier dans un vrai navigateur le plein écran, qu'aucun test du terminal ne vérifiera.
Nouveau port : le projet live-from-the-deck
Le clone est une application à part : tu la crées donc avec la commande de la leçon 1_2, en changeant seulement le nom :
npx create-next-app@latest live-from-the-deck --ts --eslint --tailwind --app --no-src-dir --no-cache-components --agents-md --no-agent-feedback --use-npmEnsuite, la boucle habituelle : une session claude dans le nouveau dossier, un CLAUDE.md qui importe @AGENTS.md (leçon 1_7), Vitest avec le correctif @types/node de la leçon 4_1 et un premier commit.
Il faut dire honnêtement une chose dès le départ. Une vraie diffusion en direct demande que l'image de la caméra du streamer arrive sur un serveur qui la distribue aux spectateurs dans un format lisible par les navigateurs. MDN explique que cela exige un logiciel spécial sur le serveur ou un service externe, et que les protocoles hors HTTP, comme RTMP, ne fonctionnent pas dans l'élément <video> sans extension. C'est un sujet pour un cours à part. Notre clone joue un fichier local en boucle et fait semblant de diffuser. Claude fabriquera le fichier de test si le programme ffmpeg est installé chez toi :
ffmpeg -f lavfi -i testsrc2=size=640x360:rate=30 -f lavfi -i sine=frequency=440 -t 60 -c:v libx264 -pix_fmt yuv420p -c:a aac -movflags +faststart public/streams/traversee.mp4lavfi désigne les sources d'image et de son artificiels intégrées à ffmpeg : une mire colorée avec une horloge et un son de 440 Hz. -t 60 coupe le tout à une minute, libx264 et aac sont des codecs que les navigateurs savent lire, et +faststart place la table des matières du fichier au début, pour que la vidéo démarre avant d'être entièrement téléchargée. Sans ffmpeg, dépose dans public/streams/ n'importe quel court MP4 à toi.
Demande pour Claude Code
Cette étape touche des types, deux fonctions, deux composants et une page : tu commences donc par un plan, comme dans la leçon 1_6. La phrase la plus importante de la demande dit quelle est la preuve : le test de l'analyseur, écrit avant l'analyseur, comme dans les leçons 4_1 et 10_4.
Demande pour Claude Code :
/plan Ajoute la page de chaîne /channel/[handle] avec un lecteur et
un chat. Les données de la chaîne dans lib/channels.ts, la diffusion
est le fichier /streams/traversee.mp4 joué en boucle, muet au départ.
Le lecteur components/StreamPlayer.tsx : des boutons à nous Lecture,
Couper le son, Plein écran ; le plein écran couvre tout le conteneur
avec les boutons, pas seulement l'élément video. Le chat
components/LiveChat.tsx, local pour l'instant, sans serveur. Un
message a ses émotes sous forme de plages de caractères ; sors le
découpage du texte en morceaux dans lib/chat/parseMessageWithEmotes.ts.
D'abord le test de cette fonction : aucune émote, émote au début,
deux émotes côte à côte, émote à la fin, plages dans un ordre
quelconque. Lance-le et montre l'échec, puis écris la fonction.
Ce sera fini quand npm run test -- --run, npm run lint et
npx tsc --noEmit passent sans erreur.Dans le plan, vérifie que le test naît avant l'analyseur et que le plein écran concerne le conteneur. Si le plan n'en dit rien, corrige-le avec Ctrl+G avant de l'approuver.
Ce que Claude a écrit : le test avant l'analyseur
Une émote est un court code dans le texte, par exemple :ancre:, que le chat affiche comme une image. Le serveur du chat peut envoyer le message avec une liste de plages : où commence et où finit chaque code. Ouvre lib/chat/types.ts dans Cursor :
// lib/chat/types.ts
export interface EmoteRange {
name: string; // "ancre"
start: number; // indice du premier caractère du code de l'émote
end: number; // indice après le dernier caractère, comme dans slice
}end désigne le caractère qui suit le code, comme le second argument de slice : text.slice(start, end) renvoie donc exactement :ancre:. Ouvre maintenant le test que Claude a écrit en premier. Le dernier cas est le plus intéressant :
// lib/chat/parseMessageWithEmotes.test.ts
test("plages dans un ordre quelconque, tableau d'émotes inchangé", () => {
const emotes = Object.freeze([ancre(9), { name: "rum", start: 0, end: 5 }]);
const parts = parseMessageWithEmotes(":rum: et :ancre:", emotes);
expect(parts.map((p) => p.kind)).toEqual(["emote", "text", "emote"]);
});Les plages arrivent dans l'ordre inverse, et Object.freeze fige le tableau : toute tentative de le modifier se termine par une erreur. ancre(9) est une fonction d'aide en haut du fichier qui construit la plage de l'ancre à partir du neuvième caractère. Le premier lancement, avant que l'analyseur existe, a donné chez nous ceci :
Error: Failed to resolve import "./parseMessageWithEmotes" from "lib/chat/parseMessageWithEmotes.test.ts". Does the file exist?C'est un bon échec : le test cherche une fonction qui n'existe pas encore.
Ce que Claude a écrit : l'analyseur
Ouvre lib/chat/parseMessageWithEmotes.ts. La première version de l'agent triait les plages ainsi :
// lib/chat/parseMessageWithEmotes.ts (version de l'agent)
const sorted = emotes.sort((a, b) => a.start - b.start);sort modifie le tableau sur place, et ce tableau appartient au message, pas à l'analyseur. Quatre tests ont réussi, le cinquième a échoué avec le message TypeError: Cannot assign to read only property '0' of object '[object Array]'. La version corrigée :
// lib/chat/parseMessageWithEmotes.ts
export function parseMessageWithEmotes(text: string, emotes: readonly EmoteRange[]): MessagePart[] {
const sorted = [...emotes].sort((a, b) => a.start - b.start);
const parts: MessagePart[] = [];
let pos = 0;
for (const emote of sorted) {
if (emote.start < pos || emote.end > text.length) continue;
if (emote.start > pos) parts.push({ kind: "text", start: pos, text: text.slice(pos, emote.start) });
parts.push({ kind: "emote", start: emote.start, name: emote.name, code: text.slice(emote.start, emote.end) });
pos = emote.end;
}
if (pos < text.length) parts.push({ kind: "text", start: pos, text: text.slice(pos) });
return parts;
}[...emotes] copie la liste avant le tri, comme dans la leçon 11_2. pos marque l'endroit jusqu'où le texte est déjà découpé ; une plage qui chevauche la précédente ou qui sort du texte est ignorée par la fonction, au lieu de la faire planter. Le mot readonly dans le type du paramètre est le second garde-fou : avec lui, npx tsc --noEmit rejette la version de l'agent avec le message Property 'sort' does not exist on type 'readonly EmoteRange[]'. Après le correctif : Tests 5 passed (5).
Ce que Claude a écrit : le chat
Les messages saisis par le spectateur n'ont pas de plages ; findEmotes, dans lib/chat/emotes.ts, cherche donc dans le texte les codes du dictionnaire EMOTES et les renvoie regroupés par émote, pas par position. C'est pour cela que l'analyseur doit trier. Ouvre components/LiveChat.tsx :
// components/LiveChat.tsx
function send() {
const text = draft.trim();
if (!text) return;
const message: ChatMessage = { id: crypto.randomUUID(), author: viewerName, text, emotes: findEmotes(text) };
setMessages((prev) => [...prev, message].slice(-MAX_MESSAGES));
setDraft("");
}crypto.randomUUID() donne à chaque message son propre identifiant, comme aux blocs de la chronique dans la leçon 11_1. prev => ... est une fonction de mise à jour qui voit la liste la plus récente. slice(-MAX_MESSAGES) garde les 150 derniers messages, pour que la page ne gonfle pas pendant toute la diffusion. L'envoi est déclenché par une touche :
// components/LiveChat.tsx
onKeyDown={(e) => {
if (e.key === "Enter") send();
}}MDN marque l'évènement keypress comme obsolète et recommande keydown ou beforeinput. Les types de React marquent aussi onKeyPress avec @deprecated, mais la version de l'agent avec onKeyPress a passé chez nous lint et tsc. Seul le test du composant, qui envoie un message avec Entrée, l'a attrapée : Unable to find an element with the text: <b>ohé</b>. Ce même test surveille un second point : les balises dans le contenu restent du texte, car les morceaux vont dans <span>{part.text}</span> et React les transforme en simples caractères. La liste défile toute seule vers le bas :
// components/LiveChat.tsx
useEffect(() => {
const list = listRef.current;
if (list && stickToBottom.current) list.scrollTop = list.scrollHeight;
}, [messages]);stickToBottom est un useRef qui, à chaque défilement, vérifie la condition de MDN : Math.abs(el.scrollHeight - el.clientHeight - el.scrollTop) <= 1. Le spectateur qui relit d'anciens messages n'est pas brusquement renvoyé en bas.
Ce que Claude a écrit : le lecteur et le plein écran
Ouvre components/StreamPlayer.tsx. L'état des boutons lit les évènements de l'élément, comme dans la leçon 10_1 : onPlay, onPause et onVolumeChange. Le démarrage muet avec autoPlay, tu le connais depuis la leçon 9_1. Le plein écran est nouveau :
// components/StreamPlayer.tsx
useEffect(() => {
function sync() {
setFullscreen(document.fullscreenElement === boxRef.current);
}
document.addEventListener("fullscreenchange", sync);
return () => document.removeEventListener("fullscreenchange", sync);
}, []);Selon MDN, document.fullscreenElement est l'élément affiché en plein écran ou null, et fullscreenchange arrive à l'entrée comme à la sortie. Le guide MDN rappelle que le navigateur ferme aussi le plein écran tout seul, en général avec la touche Échap. C'est pourquoi l'étiquette du bouton interroge le navigateur au lieu de deviner. Le bouton appelle boxRef.current?.requestFullscreen() sur le conteneur. MDN ajoute que cette méthode renvoie une promesse et ne marche qu'après un geste de l'utilisateur ; elle a donc un .catch avec un message.
La revue du capitaine
- Tri. Cherche dans le projet (Cmd+Shift+F)
.sort(: chaque occurrence est précédée de[.... - Du texte, pas du HTML. Cherche
dangerouslySetInnerHTML: il n'apparaît pas du tout dans le chat. - Clés. Les messages ont
key={m.id}, pas l'indice. - Plein écran dans le navigateur. Vitest ne le vérifiera pas : dans jsdom, le faux navigateur de la leçon 4_1,
requestFullscreenn'existe tout simplement pas. Lancenpm run dev, ouvre/channel/captain-redbeard, passe en plein écran, appuie sur Échap et lis l'étiquette du bouton. Ou demande-le à Claude in Chrome de la leçon 3_8. Chez nous, la version de l'agent appelaitrequestFullscreen()sur<video>et changeait l'état à la main. En plein écran, le badge EN DIRECT et nos boutons ont disparu, et Chrome a affiché ses propres contrôles avec la barre0:02 / 1:00, qui trahit qu'il s'agit d'un enregistrement. Après la sortie du plein écran sans passer par notre bouton, l'étiquette disait toujours "Quitter le plein écran". La version corrigée est revenue à "Plein écran".
L'erreur typique d'un agent face à un test, c'est de changer la valeur attendue pour que le test passe. Dans le diff, on la voit tout de suite : le fichier de test modifié dans la même étape que l'analyseur. Demande pourquoi.
Étape suivante
Quand les tests et le navigateur sont d'accord, demande un commit "Lecteur et chat avec test de l'analyseur". Puis une petite étape, encore avec le test d'abord : "Ajoute un mode lent : un message de spectateur toutes les 5 secondes, avec un compte à rebours près du bouton". Le vrai chat, où tout le monde voit les messages, tu le construiras avec le schéma de la leçon 6_4 : envoi par une simple requête POST et Server-Sent Events pour distribuer les messages. Dans l'éditeur ci-dessous t'attend un chat en miniature : écris un message avec :ancre: et <b>, bascule sur la version de l'agent et regarde ce que fait le tri sur place.
Retiens ceci : le capitaine qui se fie à sa longue-vue sans la vérifier ne voit le récif que lorsqu'il est dessus ; le test est la longue-vue que tu règles avant d'appareiller.
Code de cette leçon : App.tsx
// Chat de bord en miniature : analyseur d'émotes, Entrée via onKeyDown et défilement vers le bas
import { useEffect, useRef, useState } from 'react';
interface EmoteRange {
name: string;
start: number;
end: number;
}
interface ChatMessage {
id: string;
author: string;
text: string;
emotes: readonly EmoteRange[];
}
type MessagePart =
| { kind: 'text'; start: number; text: string }
| { kind: 'emote'; start: number; name: string; code: string };
const EMOTES: Record<string, string> = { ancre: '⚓', perroquet: '🦜', tresor: '💰', rum: '🥃' };
const MAX_MESSAGES = 150;
const CREW_LINES = ['Terre en vue :perroquet:', 'Qui a le quart ? :ancre:', ':rum: pour le timonier', 'Coffre plein de :tresor: :tresor:'];
// Codes cherchés d'après le dictionnaire, donc les plages arrivent groupées par émote, pas par position
function findEmotes(text: string): readonly EmoteRange[] {
const ranges: EmoteRange[] = [];
for (const name of Object.keys(EMOTES)) {
const code = ':' + name + ':';
for (let i = text.indexOf(code); i !== -1; i = text.indexOf(code, i + code.length)) {
ranges.push({ name, start: i, end: i + code.length });
}
}
return Object.freeze(ranges); // les données du message sont en lecture seule, comme si elles venaient du serveur
}
function parseMessageWithEmotes(text: string, emotes: readonly EmoteRange[], agentBug: boolean): MessagePart[] {
// La version de l'agent trie le tableau du message sur place ; un tableau figé lève alors une TypeError
const sorted = agentBug ? (emotes as EmoteRange[]).sort((a, b) => a.start - b.start) : [...emotes].sort((a, b) => a.start - b.start);
const parts: MessagePart[] = [];
let pos = 0;
for (const emote of sorted) {
if (emote.start < pos || emote.end > text.length) continue;
if (emote.start > pos) parts.push({ kind: 'text', start: pos, text: text.slice(pos, emote.start) });
parts.push({ kind: 'emote', start: emote.start, name: emote.name, code: text.slice(emote.start, emote.end) });
pos = emote.end;
}
if (pos < text.length) parts.push({ kind: 'text', start: pos, text: text.slice(pos) });
return parts;
}
// Dans le projet l'id vient de crypto.randomUUID() ; ici un compteur suffit
let nextId = 1;
function newMessage(author: string, text: string): ChatMessage {
return { id: 'm' + nextId++, author, text, emotes: findEmotes(text) };
}
// L'erreur de l'analyseur est attrapée hors du JSX : try/catch autour du JSX n'attrape pas les erreurs de rendu
function safeParse(message: ChatMessage, agentBug: boolean): { parts: MessagePart[] } | { error: string } {
try {
return { parts: parseMessageWithEmotes(message.text, message.emotes, agentBug) };
} catch (error) {
return { error: (error as Error).message };
}
}
function MessageText({ message, agentBug }: { message: ChatMessage; agentBug: boolean }) {
const result = safeParse(message, agentBug);
if ('error' in result) return <span className="text-red-400">Erreur de l'analyseur : {result.error}</span>;
return result.parts.map((part) =>
part.kind === 'emote' ? (
<span key={part.start} role="img" aria-label={part.name} title={part.code}>
{EMOTES[part.name]}
</span>
) : (
<span key={part.start}>{part.text}</span>
),
);
}
export default function App() {
const [messages, setMessages] = useState<ChatMessage[]>(() => [
newMessage('Timonier', "Ohé l'équipage :ancre:"),
newMessage('Perroquet_Pola', ":perroquet: :tresor: l'île est en vue !"),
]);
const [draft, setDraft] = useState('');
const [agentBug, setAgentBug] = useState(false);
const [crewTalking, setCrewTalking] = useState(false);
const listRef = useRef<HTMLOListElement>(null);
const stickToBottom = useRef(true);
useEffect(() => {
const list = listRef.current;
if (list && stickToBottom.current) list.scrollTop = list.scrollHeight;
}, [messages]);
useEffect(() => {
if (!crewTalking) return;
let n = 0;
const id = setInterval(() => {
const line = CREW_LINES[n % CREW_LINES.length];
n += 1;
setMessages((prev) => [...prev, newMessage('Équipage', line)].slice(-MAX_MESSAGES));
}, 1000);
return () => clearInterval(id);
}, [crewTalking]);
function send() {
const text = draft.trim();
if (!text) return;
setMessages((prev) => [...prev, newMessage('Mousse', text)].slice(-MAX_MESSAGES));
setDraft('');
}
return (
<div className="min-h-screen bg-zinc-950 p-4 text-zinc-100">
<div className="mx-auto flex h-96 max-w-md flex-col rounded-lg border border-zinc-800 bg-zinc-900">
<h1 className="border-b border-zinc-800 p-3 font-semibold">Chat de bord</h1>
<ol
ref={listRef}
onScroll={(e) => {
const el = e.currentTarget;
stickToBottom.current = Math.abs(el.scrollHeight - el.clientHeight - el.scrollTop) <= 1;
}}
className="flex-1 space-y-1 overflow-y-auto p-3 text-sm"
>
{messages.map((m) => (
<li key={m.id}>
<strong className="text-amber-400">{m.author}:</strong> <MessageText message={m} agentBug={agentBug} />
</li>
))}
</ol>
<div className="flex gap-2 border-t border-zinc-800 p-3">
<input
value={draft}
onChange={(e) => setDraft(e.target.value)}
onKeyDown={(e) => {
if (e.key === 'Enter') send();
}}
maxLength={300}
aria-label="Message du chat"
placeholder="Essaie : <b>ohé</b> :rum: et :ancre:"
className="min-w-0 flex-1 rounded bg-zinc-800 px-3 py-2"
/>
<button type="button" onClick={send} className="rounded bg-purple-600 px-3 py-2 font-semibold">
Envoyer
</button>
</div>
</div>
<div className="mx-auto mt-3 max-w-md space-y-2 text-sm">
<label className="flex items-center gap-2">
<input type="checkbox" checked={crewTalking} onChange={(e) => setCrewTalking(e.target.checked)} />
L'équipage écrit chaque seconde (remonte : le chat ne te secouera pas)
</label>
<label className="flex items-center gap-2">
<input type="checkbox" checked={agentBug} onChange={(e) => setAgentBug(e.target.checked)} />
Version de l'agent : emotes.sort(...) sur place
</label>
<p className="text-zinc-400">Messages : {messages.length} (le chat en garde au plus {MAX_MESSAGES})</p>
</div>
</div>
);
}Tu as repéré une erreur dans cette leçon ?
Teste tes connaissances
Réponds aux questions de cette leçon. Choisis une réponse pour voir tout de suite si elle est correcte.
1. Comment Live from the Deck montre-t-il la diffusion en direct ?
2. Pourquoi StreamPlayer fixe-t-il l'étiquette du bouton plein écran dans l'évènement fullscreenchange, d'après document.fullscreenElement, au lieu de basculer l'état dans onClick ?
Voici 2 des 6 questions de cette leçon. Réponds aux autres dans le jeu.
Tâches pratiques dans le jeu
- Clique dans l'ordre
Construis la ligne de l'analyseur qui trie les plages d'émotes sans modifier le tableau du message
- Tri horizontal
Compose la ligne de la fonction send qui ajoute le message et garde les 150 derniers (une seule ligne) :
- Clique dans l'ordre
Construis la condition de onKeyDown du champ de chat qui envoie le message avec la touche Entrée
- Éditeur de code
Construis un lecteur de stream avec des contrôles vidéo
- Tri vertical
Ordonne les étapes par lesquelles Claude a construit l'analyseur d'émotes :
- Éditeur de code
Crée une interface de chat en temps réel
- Tri vertical
Ordonne les étapes de la fonction send dans LiveChat :
- Clique dans l'ordre
Construis la ligne qui, dans StreamPlayer, commence à écouter les changements de plein écran
Exercices après cette leçon
- QuestionQuiz : la diffusion dans le clone
- QuestionQuiz : l'état du plein écran
- QuestionQuiz : la fin de la plage d'une émote
- Clique dans l'ordreConstruction : trier une copie
- Remets dans l'ordreTri : ajouter un message
- Clique dans l'ordreConstruction : envoi avec Entrée
- Exercice de codePratique : Lecteur de stream
- QuestionQuiz : ce qu'a attrapé onKeyPress
- QuestionQuiz : les balises dans un message
- Remets dans l'ordreTri : le test d'abord
- Exercice de codePratique : Chat en direct
- Remets dans l'ordreTri : les étapes de la fonction send
- Clique dans l'ordreConstruction : écouter le plein écran
- QuestionQuiz : le défilement du chat