Cours Vibe coding avec Claude Code · Module 7: Clone de LinkedIn
Un cordage entre les navires : chat en direct et serveur en arrière-plan
Dans cette leçon9
Le recruteur de la Black Pearl écrit à Anne Bonny : "Tu as le temps de parler du poste d'officier ?". Anne a la page ouverte, mais rien ne bouge tant qu'elle ne la recharge pas. Dans la leçon 5_5, la cloche interrogeait le serveur toutes les 30 secondes. Dans une conversation, c'est une éternité, et la plupart des questions reviennent vides. Il te faut un cordage tendu entre les navires : une connexion par laquelle le serveur envoie lui-même un message dès qu'il arrive.
Server-Sent Events : un cordage à sens unique
Les Server-Sent Events (SSE) sont une connexion HTTP permanente par laquelle le serveur envoie au navigateur des événements successifs au format text/event-stream. Le navigateur écoute via l'objet intégré EventSource. Contrairement à un WebSocket, ce cordage ne marche que dans un sens, du serveur vers le navigateur. Pour un chat, cela suffit : tu envoies le message par une simple requête POST, et le flux ne fait que le distribuer aux onglets ouverts. Pas besoin d'un serveur séparé ni d'une bibliothèque, car la documentation de Next.js cite le Route Handler comme l'endroit où placer un flux SSE.
Cela fait plusieurs fichiers et un nouveau type de connexion, donc tu commences par un plan, et tu demandes tout de suite une vérification :
Demande pour Claude Code :
/plan Ajoute un chat 1 à 1 : une page /messages/[handle], et le bouton
Message sur la carte de contact mène à la conversation. Les nouveaux
messages arrivent sans rechargement via Server-Sent Events : Route
Handler app/api/messages/[handle]/route.ts, GET renvoie un flux
text/event-stream, POST reçoit { content } en JSON. L'expéditeur est
déterminé par le serveur avec getCurrentUser(). Enregistrement via
lib/store.ts, l'historique est affiché par la page. Pas de nouvelle
bibliothèque, des tests pour les fonctions pures. Ensuite lance le
serveur de développement en arrière-plan et vérifie le chat toi-même :
un curl qui écoute le flux et un second curl avec POST. Montre ce que
le premier a reçu.Dans le plan, tu cherches trois choses : l'expéditeur tiré de la session et non du contenu de la requête, le nettoyage de la connexion des deux côtés, et la vérification que Claude fera avant de te rendre le travail.
Ce que Claude a écrit : l'événement dans le flux
Ouvre lib/chat.ts dans Cursor. Le type ChatMessage de types/message.ts a id, from, to, le contenu et sentAt, et un événement SSE, c'est quelques lignes de texte terminées par une ligne vide :
// La même conversation pour les deux côtés : "anne:redbeard", quel que soit celui qui écrit.
export function conversationId(a: string, b: string): string {
return [a, b].sort().join(":");
}
export function toEvent(message: ChatMessage): string {
return `id: ${message.id}\ndata: ${JSON.stringify(message)}\n\n`;
}conversationId trie les deux handles, donc la conversation de redbeard avec Anne et celle d'Anne avec redbeard ont un seul identifiant. La ligne vide à la fin de l'événement n'est pas un ornement : c'est elle qui dit au navigateur que le message est complet. JSON.stringify transforme un saut de ligne dans le contenu en \n, donc un message de deux paragraphes tient sur une seule ligne data. Les tests de lib/chat.test.ts veillent sur ces deux points.
Ce que Claude a écrit : le flux côté serveur
lib/chat-hub.ts garde en mémoire une carte des conversations et de leurs auditeurs, c'est-à-dire des fonctions qui ajoutent un message au flux ouvert. subscribe ajoute un auditeur et renvoie une fonction qui le retire, et publish appelle tous les auditeurs d'une conversation. La réponse au GET dans app/api/messages/[handle]/route.ts est un ReadableStream, un flux de l'API Web qui livre la réponse par morceaux :
const stream = new ReadableStream<Uint8Array>({
start(controller) {
controller.enqueue(encoder.encode(": connecté\n\n"));
unsubscribe = subscribe(conversationId(user.handle, partner.handle), (message) => {
controller.enqueue(encoder.encode(toEvent(message)));
});
},
cancel() {
unsubscribe(); // onglet fermé : n'envoie plus rien à ce flux
},
});
return new Response(stream, { headers: { "Content-Type": "text/event-stream", "Cache-Control": "no-cache" } });start s'exécute une fois, à l'ouverture, et controller.enqueue pousse le morceau suivant. encoder est le TextEncoder intégré, qui transforme le texte en octets, parce qu'un flux transporte des octets. cancel arrive quand le navigateur se déconnecte. La ligne qui commence par deux-points est un commentaire que le navigateur ignore ; à quoi elle sert, tu le verras dans la revue. La conversation est déterminée par le pirate connecté et par le handle de l'adresse, donc personne n'écoute la conversation d'un autre en tapant son nom dans un paramètre.
Ce que Claude a écrit : l'envoi
Le POST du même fichier vérifie le contenu avec un schéma Zod (de 1 à 1000 caractères après trim()) et assemble lui-même le reste du message :
const message: ChatMessage = {
id: randomUUID(),
from: user.handle,
to: partner.handle,
content: result.data.content,
sentAt: new Date().toISOString(),
};
await addMessage(message);addMessage de lib/messages.ts enregistre le message dans data/messages.json et appelle publish, donc il arrive dans chaque onglet ouvert de cette conversation, y compris celui de l'expéditeur. Le formulaire de ChatWindow n'ajoute donc rien lui-même : il attend que le message revienne par le flux. Le champ from envoyé dans la requête est ignoré par le serveur.
Ce que Claude a écrit : l'onglet écoute
Ouvre components/messages/useChat.ts. Le hook démarre avec l'historique que la page a lu sur le serveur, et ajoute ce qui arrive :
useEffect(() => {
const source = new EventSource(`/api/messages/${handle}`);
source.onopen = () => setConnected(true);
source.onerror = () => setConnected(false); // le navigateur essaie de se reconnecter tout seul
source.onmessage = (event) => {
const message: ChatMessage = JSON.parse(event.data);
setMessages((current) => [...current, message]);
};
return () => source.close();
}, [handle]);L'état ne change que dans des fonctions de rappel, pas dans le corps de l'effet, donc la règle react-hooks/set-state-in-effect passe. Quand la connexion se coupe, le navigateur se reconnecte tout seul. source.close() enroule le cordage quand l'onglet change de conversation ou disparaît. La page rend ChatWindow avec key={partner.handle}, pour que le passage à une autre conversation ne laisse pas d'anciens messages dans l'état.
Serveur en arrière-plan, Claude teste
Après la construction, Claude lance npm run dev. Le serveur de développement ne s'arrête jamais de lui-même, donc si Claude le lance avec une commande ordinaire, la session reste bloquée à attendre. Appuie alors sur Ctrl+B : Claude Code met la commande en cours en arrière-plan (dans tmux, appuie deux fois) et écrit sa sortie dans un fichier que Claude lira quand il en aura besoin. Tu peux aussi écrire d'emblée "lance en arrière-plan", comme dans la demande. La documentation cite les serveurs de développement comme exemple typique du travail en arrière-plan.
Claude a maintenant les mains libres. Le premier curl dure lui aussi sans fin, parce qu'il écoute le flux, donc il part aussi en arrière-plan, et le second envoie un message avec un expéditeur falsifié :
curl -N http://localhost:3000/api/messages/anne
curl -X POST http://localhost:3000/api/messages/anne -H "Content-Type: application/json" -d '{"content":"Ohé, Anne !","from":"anne"}'L'option -N désactive la mise en mémoire tampon de curl, pour que les événements s'affichent tout de suite. Le second curl reçoit le statut 201 et un message dont from vaut redbeard, bien que la requête ait indiqué anne. Claude lit le fichier avec la sortie du premier :
: connecté
id: e8705818-17b3-4c9b-80f9-68ec0fef6ff8
data: {"id":"e8705818-17b3-4c9b-80f9-68ec0fef6ff8","from":"redbeard","to":"anne","content":"Ohé, Anne !","sentAt":"2026-11-14T18:46:35.931Z"}Tape /tasks dans la session : tu verras le travail en arrière-plan, c'est-à-dire le serveur et le curl qui écoute, et tu peux arrêter chacun d'eux ici. Cette commande marche tout de suite, même quand Claude est encore en train d'écrire. Ne la confonds pas avec Ctrl+T, qui affiche la liste des tâches de Claude, pas les processus. Tout ce qui tourne en arrière-plan est nettoyé par Claude Code à la fermeture de la session.
Le dernier essai est pour toi : sur /network, clique sur Message chez Anne Bonny et ouvre la même adresse dans un second onglet. Écris dans le premier, et le message apparaît dans les deux sans rechargement, avec l'inscription "En direct" au-dessus de la conversation. La connexion n'existe pas encore, donc les deux onglets, c'est toi ; tu vérifieras la conversation de deux personnes quand l'équipage aura des comptes.
La revue du capitaine
- Pas de nettoyage dans le navigateur. L'erreur typique d'un agent est un effet sans
return () => source.close(). Nous l'avons vérifié : en mode développement, React lance volontairement l'effet deux fois : il monte, nettoie et remonte (le Strict Mode est activé par défaut dans l'App Router), donc deux flux se sont créés, chaque message est apparu deux fois et la console a signalé "Encountered two children with the same key". En production, la même erreur laisse une connexion ouverte après chaque passage à une autre conversation. - Pas de nettoyage côté serveur. Supprime
cancelpour essayer et ferme l'onglet de la conversation. Chez nous, le message suivant a reçu une erreur 500, et le terminal a affichéTypeError: Invalid state: Controller is already closed:publishécrivait dans un flux que plus personne ne lisait. Le message avait eu le temps d'être enregistré, donc l'expéditeur voyait une erreur sur quelque chose qui avait réussi. - "Connexion..." sans fin. Sans le commentaire
: connectéau démarrage, l'inscription au-dessus de la conversation restait affichée jusqu'à ce que quelqu'un écrive quelque chose. Next.js n'a envoyé les en-têtes qu'avec le premier morceau de la réponse, donconopenattendait aussi. - État défini dans le corps de l'effet. Quand l'agent met
setConnected(false)au début de l'effet,npm run lintsignalereact-hooks/set-state-in-effect. Il suffit d'un état initialfalseque seulsonopenetonerrormodifient.
En production : Supabase Realtime
La carte des auditeurs vit dans la mémoire d'un seul processus Node. Sur un seul serveur, cela marche, mais un hébergeur qui lance plusieurs copies de l'application a plusieurs cartes séparées : un message envoyé à une copie n'atteindra pas l'onglet connecté à l'autre. De plus, sans HTTP/2, le navigateur ne garde au plus que 6 connexions SSE vers un même domaine, tous onglets confondus (MDN). On prend alors un service de temps réel au lieu de sa propre carte. Cette partie, nous ne l'avons pas vérifiée en pratique ; ce sont des faits de la documentation de Supabase, état de novembre 2026 :
- Supabase Realtime a trois fonctions : Broadcast (messages entre clients, par exemple un chat), Presence (qui est en ligne) et Postgres Changes (écoute des changements dans les tables). Pour la plupart des usages, la documentation recommande Broadcast, et elle décrit Postgres Changes comme adapté aux tests et à un petit nombre d'utilisateurs.
- Le client du paquet
@supabase/supabase-jsrejoint un canal, c'est-à-dire une salle portant un nom, avecconfig: { private: true }. Dans un effet React, il le nettoie avecsupabase.removeChannel(channel): le même principe quesource.close(). - Qui peut écouter et émettre sur un canal privé, ce sont les règles d'accès aux lignes de la base (Row Level Security, RLS) sur la table
realtime.messagesqui le décident. La documentation demande de n'utiliser que des canaux privés en production. - Le plan gratuit permet 200 connexions simultanées et 2 millions de messages par mois.
Étape suivante
Quand la revue est passée, demande un commit, par exemple "Chat en direct via Server-Sent Events". Nous avons vérifié encore une chose : après un redémarrage du serveur, le navigateur s'est reconnecté tout seul et a renvoyé dans l'en-tête Last-Event-ID l'identifiant du dernier message. Les messages de l'interruption sont pourtant perdus, d'où un petit pas suivant :
Après une coupure, EventSource se reconnecte tout seul et renvoie
l'en-tête Last-Event-ID. Côté serveur, récupère les messages de cette
conversation arrivés après cet id, avant de commencer à écouter les
nouveaux. D'abord un test de la fonction pure qui les sélectionne.Dans l'éditeur ci-dessous t'attendent deux onglets de la même conversation et un compteur de flux ouverts. Ferme le deuxième onglet et rouvre-le, puis active et désactive "Sans nettoyage", envoie un message et regarde le compteur grimper et les messages se doubler.
Souviens-toi : le cordage entre les navires tient tant que les deux côtés surveillent leurs nœuds, et celui qui l'a détendu l'enroule en appareillant.
Code de cette leçon : App.jsx
// Chat en direct en miniature : deux onglets de la même conversation et un « serveur » en mémoire.
// Dans le projet, le serveur est un Route Handler avec text/event-stream, et l’onglet écoute via EventSource.
// Ici, openStream imite new EventSource(...) et sendToServer imite POST /api/messages/anne.
import { useActionState, useEffect, useState, useSyncExternalStore } from 'react';
const ME = 'redbeard';
const saved = []; // messages enregistrés, comme data/messages.json
const streams = new Set(); // flux ouverts, comme les auditeurs de lib/chat-hub.ts
const watchers = new Set();
let nextId = 1;
const notify = () => watchers.forEach((watch) => watch());
function openStream() {
const source = {
onmessage: null,
close() {
streams.delete(source);
notify();
},
};
streams.add(source);
notify();
return source;
}
// Le serveur attribue l’id et l’expéditeur, enregistre le message et le diffuse à chaque flux ouvert.
function sendToServer(content) {
const text = content.trim();
if (!text) return { ok: false, error: 'Écris quelque chose avant d’envoyer.' };
const message = { id: 'm' + nextId++, from: ME, to: 'anne', content: text };
setTimeout(() => {
saved.push(message);
streams.forEach((source) => source.onmessage?.({ data: JSON.stringify(message) }));
}, 200);
return { ok: true };
}
// React lit le compteur de flux ouverts dans un magasin extérieur aux composants.
function useOpenStreams() {
return useSyncExternalStore(
(watch) => {
watchers.add(watch);
return () => watchers.delete(watch);
},
() => streams.size
);
}
function useChat(leaky) {
const [messages, setMessages] = useState(() => [...saved]); // historique, comme venu du serveur
useEffect(() => {
const source = openStream();
source.onmessage = (event) => {
const message = JSON.parse(event.data);
setMessages((current) => [...current, message]);
};
if (leaky) return; // erreur typique d’un agent : pas de nettoyage
return () => source.close();
}, [leaky]);
return messages;
}
function ChatWindow({ title, inputId, leaky }) {
const messages = useChat(leaky);
const [state, formAction, pending] = useActionState(
async (_prev, formData) => {
const content = String(formData.get('content') ?? '');
const result = sendToServer(content);
return result.ok ? { content: '', error: '' } : { content, error: result.error };
},
{ content: '', error: '' }
);
return (
<section className="flex h-80 flex-col rounded-lg border border-gray-200 bg-white">
<p className="border-b border-gray-200 px-3 py-2 text-xs font-semibold text-gray-500">{title}</p>
<ol className="flex-1 space-y-2 overflow-y-auto p-3">
{messages.map((message) => (
<li key={message.id} className="text-right">
<span className="inline-block rounded-2xl bg-blue-600 px-3 py-2 text-left text-sm text-white">{message.content}</span>
</li>
))}
</ol>
<form action={formAction} className="flex gap-2 border-t border-gray-200 p-2">
<label htmlFor={inputId} className="sr-only">Message</label>
<input
id={inputId}
name="content"
defaultValue={state.content}
autoComplete="off"
placeholder="Écris un message"
className="min-w-0 flex-1 rounded-full border border-gray-300 px-3 py-1.5 text-sm"
/>
<button disabled={pending} className="rounded-full bg-blue-600 px-3 text-sm font-semibold text-white">
Envoyer
</button>
</form>
{state.error && <p className="px-3 pb-2 text-xs text-red-600">{state.error}</p>}
</section>
);
}
export default function App() {
const [secondOpen, setSecondOpen] = useState(true);
const [leaky, setLeaky] = useState(false);
const open = useOpenStreams();
return (
<div className="min-h-screen bg-gray-100 p-4 text-gray-900">
<div className="mx-auto max-w-3xl space-y-3">
<div className="flex flex-wrap items-center gap-3 rounded-lg border border-gray-200 bg-white p-3 text-sm">
<span className="font-semibold">Flux ouverts : {open}</span>
<button
onClick={() => setSecondOpen(!secondOpen)}
className="rounded-full border border-blue-600 px-3 py-1 font-semibold text-blue-700"
>
{secondOpen ? 'Fermer l’onglet 2' : 'Ouvrir l’onglet 2'}
</button>
<label className="flex items-center gap-2">
<input type="checkbox" checked={leaky} onChange={(e) => setLeaky(e.target.checked)} />
Sans nettoyage (erreur typique)
</label>
</div>
<div className="grid gap-3 sm:grid-cols-2">
<ChatWindow title="Onglet 1 : conversation avec Anne Bonny" inputId="message-1" leaky={leaky} />
{secondOpen && <ChatWindow title="Onglet 2 : la même conversation" inputId="message-2" leaky={leaky} />}
</div>
</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. En quoi les Server-Sent Events diffèrent-ils d'un WebSocket ?
2. Que fait l'onglet dans source.onmessage quand un événement arrive du flux ?
Tâches pratiques dans le jeu
- Clique dans l'ordre
Ordonne l'ouverture du flux dans useChat : new EventSource(
/api/messages/${handle}) - Tri vertical
Ordonne le chemin du message, du clic sur Envoyer jusqu'au second onglet :