Kurs vibe coding z Claude Code · Moduł 7: Klon LinkedIna
Lina między statkami: czat na żywo i serwer w tle
W tej lekcji9
Rekruter z Czarnej Perły pisze do Anne Bonny: "Masz czas na rozmowę o stanowisku oficera?". Anne ma stronę otwartą, ale nic się nie dzieje, dopóki jej nie odświeży. W lekcji 5_5 dzwonek pytał serwer co 30 sekund. W rozmowie to wieczność, a większość pytań wraca z niczym. Potrzebujesz liny rozpiętej między statkami: połączenia, którym serwer sam wyśle wiadomość, gdy tylko się pojawi.
Server-Sent Events: lina w jedną stronę
Server-Sent Events (SSE) to stałe połączenie HTTP, którym serwer wysyła przeglądarce kolejne zdarzenia w formacie text/event-stream. Przeglądarka słucha przez wbudowany obiekt EventSource. W przeciwieństwie do WebSocketu ta lina działa w jedną stronę, od serwera do przeglądarki. Do czatu to wystarczy: wiadomość wysyłasz zwykłym żądaniem POST, a strumień tylko rozwozi ją do otwartych kart. Nie potrzebujesz osobnego serwera ani biblioteki, bo dokumentacja Next.js wymienia Route Handler jako miejsce na strumień SSE.
To kilka plików i nowy rodzaj połączenia, więc zaczynasz od planu, a sprawdzian zlecasz od razu:
Polecenie dla Claude Code:
/plan Dodaj czat 1 do 1: strona /messages/[handle], a przycisk
Wiadomość na karcie kontaktu prowadzi do rozmowy. Nowe wiadomości
przychodzą bez odświeżania przez Server-Sent Events: Route Handler
app/api/messages/[handle]/route.ts, GET zwraca strumień
text/event-stream, POST przyjmuje { content } jako JSON. Nadawcę
ustala serwer z getCurrentUser(). Zapis przez lib/store.ts, historię
pokazuje strona. Bez nowych bibliotek, testy dla czystych funkcji.
Potem uruchom serwer deweloperski w tle i sprawdź czat sam: curl
słuchający strumienia i drugi curl z POST. Pokaż, co dostał pierwszy.W planie szukasz trzech rzeczy: nadawcy z sesji, a nie z treści żądania, sprzątania połączenia po obu stronach i sprawdzianu, który Claude zrobi, zanim odda Ci pracę.
Co napisał Claude: zdarzenie w strumieniu
Otwórz w Cursorze lib/chat.ts. Typ ChatMessage z types/message.ts ma id, from, to, treść i sentAt, a zdarzenie SSE to kilka linii tekstu zakończonych pustą linią:
// Ta sama rozmowa dla obu stron: "anne:redbeard", kto by nie pisał.
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 sortuje dwa handle, więc rozmowa redbearda z Anne i Anne z redbeardem ma jeden identyfikator. Pusta linia na końcu zdarzenia nie jest ozdobą: dopiero ona mówi przeglądarce, że wiadomość jest cała. JSON.stringify zamienia znak nowej linii w treści na \n, więc wiadomość z dwoma akapitami mieści się w jednej linii data. Obu rzeczy pilnują testy w lib/chat.test.ts.
Co napisał Claude: strumień na serwerze
lib/chat-hub.ts trzyma w pamięci mapę rozmów i ich słuchaczy, czyli funkcji, które dopiszą wiadomość do otwartego strumienia. subscribe dodaje słuchacza i zwraca funkcję, która go usuwa, a publish woła wszystkich słuchaczy jednej rozmowy. Odpowiedzią na GET w app/api/messages/[handle]/route.ts jest ReadableStream, strumień z Web API, który oddaje odpowiedź kawałkami:
const stream = new ReadableStream<Uint8Array>({
start(controller) {
controller.enqueue(encoder.encode(": połączono\n\n"));
unsubscribe = subscribe(conversationId(user.handle, partner.handle), (message) => {
controller.enqueue(encoder.encode(toEvent(message)));
});
},
cancel() {
unsubscribe(); // karta zamknięta: nie wysyłaj już do tego strumienia
},
});
return new Response(stream, { headers: { "Content-Type": "text/event-stream", "Cache-Control": "no-cache" } });start rusza raz, przy otwarciu, a controller.enqueue wypycha kolejny kawałek. encoder to wbudowany TextEncoder, który zamienia tekst na bajty, bo strumień przenosi bajty. cancel przychodzi, gdy przeglądarka się rozłączy. Linia zaczynająca się dwukropkiem to komentarz, który przeglądarka pomija; po co tu jest, zobaczysz w przeglądzie. Rozmowę wyznacza zalogowany pirat i handle z adresu, więc nikt nie podsłucha cudzej rozmowy, wpisując jej nazwę do parametru.
Co napisał Claude: wysyłka
POST w tym samym pliku sprawdza treść schematem Zod (od 1 do 1000 znaków po trim()), a resztę wiadomości składa sam:
const message: ChatMessage = {
id: randomUUID(),
from: user.handle,
to: partner.handle,
content: result.data.content,
sentAt: new Date().toISOString(),
};
await addMessage(message);addMessage z lib/messages.ts zapisuje wiadomość do data/messages.json i woła publish, więc trafia ona do każdej otwartej karty tej rozmowy, także do karty nadawcy. Formularz w ChatWindow niczego więc nie dopisuje sam, tylko czeka, aż wiadomość wróci strumieniem. Pole from przysłane w żądaniu serwer pomija.
Co napisał Claude: karta słucha
Otwórz components/messages/useChat.ts. Hook startuje z historią, którą strona przeczytała na serwerze, i dopisuje to, co przyjdzie:
useEffect(() => {
const source = new EventSource(`/api/messages/${handle}`);
source.onopen = () => setConnected(true);
source.onerror = () => setConnected(false); // przeglądarka sama spróbuje połączyć się ponownie
source.onmessage = (event) => {
const message: ChatMessage = JSON.parse(event.data);
setMessages((current) => [...current, message]);
};
return () => source.close();
}, [handle]);Stan zmienia się tylko w funkcjach zwrotnych, nie w samym ciele efektu, więc reguła react-hooks/set-state-in-effect przechodzi. Gdy połączenie się zerwie, przeglądarka sama łączy się ponownie. source.close() zwija linę, gdy karta zmienia rozmowę albo znika. Strona renderuje ChatWindow z key={partner.handle}, żeby przejście do innej rozmowy nie zostawiło w stanie starych wiadomości.
Serwer w tle, Claude testuje
Po budowie Claude uruchamia npm run dev. Serwer deweloperski nigdy sam nie kończy pracy, więc jeśli Claude odpali go zwykłą komendą, sesja stoi i czeka. Naciśnij wtedy Ctrl+B: Claude Code przeniesie działającą komendę w tło (w tmux naciśnij dwa razy), a jej wyjście zapisze do pliku, który Claude przeczyta, gdy będzie potrzebował. Możesz też od razu napisać "uruchom w tle", jak w poleceniu. Dokumentacja podaje serwery deweloperskie jako typowy przykład pracy w tle.
Teraz Claude ma wolne ręce. Pierwszy curl też trwa bez końca, bo słucha strumienia, więc również idzie w tło, a drugi wysyła wiadomość z podrobionym nadawcą:
curl -N http://localhost:3000/api/messages/anne
curl -X POST http://localhost:3000/api/messages/anne -H "Content-Type: application/json" -d '{"content":"Ahoj, Anne!","from":"anne"}'Flaga -N wyłącza buforowanie curla, żeby zdarzenia pokazywały się od razu. Drugi curl dostaje status 201 i wiadomość, w której from to redbeard, choć żądanie podawało anne. Claude czyta plik z wyjściem pierwszego:
: połączono
id: e8705818-17b3-4c9b-80f9-68ec0fef6ff8
data: {"id":"e8705818-17b3-4c9b-80f9-68ec0fef6ff8","from":"redbeard","to":"anne","content":"Ahoj, Anne!","sentAt":"2026-11-14T18:46:35.931Z"}Wpisz w sesji /tasks: zobaczysz pracę w tle, czyli serwer i słuchający curl, i każde z nich możesz tam zatrzymać. Ta komenda działa od razu, nawet gdy Claude jeszcze pisze. Nie myl jej z Ctrl+T, który pokazuje listę zadań Claude, a nie procesy. Wszystko, co działa w tle, Claude Code sprząta przy wyjściu z sesji.
Ostatnia próba jest Twoja: na /network kliknij Wiadomość przy Anne Bonny i otwórz ten sam adres w drugiej karcie. Napisz w pierwszej, a wiadomość pojawi się w obu bez odświeżania, nad rozmową zaś napis "Na żywo". Logowania jeszcze nie ma, więc obie karty to Ty; rozmowę dwóch osób sprawdzisz, gdy załoga dostanie konta.
Przegląd kapitana
- Brak sprzątania w przeglądarce. Typowy błąd agenta to efekt bez
return () => source.close(). Sprawdziliśmy: w trybie deweloperskim React celowo uruchamia efekt dwa razy: montuje, sprząta i montuje ponownie (Strict Mode jest w App Routerze domyślnie włączony), więc powstały dwa strumienie, każda wiadomość pojawiła się dwa razy, a konsola zgłosiła "Encountered two children with the same key". Na produkcji ten sam błąd zostawia otwarte połączenie po każdym przejściu do innej rozmowy. - Brak sprzątania na serwerze. Usuń na próbę
canceli zamknij kartę z rozmową. U nas następna wiadomość dostała błąd 500, a terminal pokazałTypeError: Invalid state: Controller is already closed:publishpisał do strumienia, którego nikt już nie czytał. Wiadomość zdążyła się zapisać, więc nadawca widział błąd przy czymś, co się udało. - "Łączenie..." bez końca. Bez komentarza
: połączonona starcie napis nad rozmową wisiał, dopóki ktoś czegoś nie napisał. Next.js wysłał nagłówki dopiero z pierwszym kawałkiem odpowiedzi, więconopenteż czekał. - Stan ustawiany w ciele efektu. Gdy agent wstawi
setConnected(false)na początek efektu,npm run lintzgłaszareact-hooks/set-state-in-effect. Wystarczy stan początkowyfalse, który zmieniają tylkoonopenionerror.
Na produkcji: Supabase Realtime
Mapa słuchaczy żyje w pamięci jednego procesu Node. Na jednym serwerze to działa, ale hosting, który uruchamia kilka kopii aplikacji, ma kilka osobnych map: wiadomość wysłana do jednej kopii nie dotrze do karty podłączonej do drugiej. Do tego bez HTTP/2 przeglądarka utrzyma najwyżej 6 połączeń SSE z jedną domeną, licząc wszystkie karty (MDN). Wtedy zamiast własnej mapy bierze się usługę czasu rzeczywistego. Tej części nie sprawdzaliśmy w praktyce; to fakty z dokumentacji Supabase, stan na listopad 2026:
- Supabase Realtime ma trzy funkcje: Broadcast (wiadomości między klientami, na przykład czat), Presence (kto jest online) i Postgres Changes (nasłuch zmian w tabelach). Do większości zastosowań dokumentacja poleca Broadcast, a Postgres Changes opisuje jako dobre do testów i małej liczby użytkowników.
- Klient z paczki
@supabase/supabase-jsdołącza do kanału, czyli pokoju o nazwie, zconfig: { private: true }. W efekcie Reacta sprząta go przezsupabase.removeChannel(channel): ta sama zasada cosource.close(). - Kto może słuchać i nadawać na kanale prywatnym, decydują reguły dostępu do wierszy w bazie (Row Level Security, RLS) na tabeli
realtime.messages. Dokumentacja każe na produkcji używać tylko kanałów prywatnych. - Plan darmowy pozwala na 200 jednoczesnych połączeń i 2 mln wiadomości miesięcznie.
Następny krok
Gdy przegląd przejdzie, poproś o commit, na przykład "Czat na żywo przez Server-Sent Events". Sprawdziliśmy jeszcze jedno: po restarcie serwera przeglądarka połączyła się sama i odesłała w nagłówku Last-Event-ID identyfikator ostatniej wiadomości. Wiadomości z przerwy jednak przepadają, więc kolejny mały krok:
Po zerwaniu połączenia EventSource łączy się sam i odsyła nagłówek
Last-Event-ID. Dociągnij na serwerze wiadomości z tej rozmowy, które
przyszły po tym id, zanim zaczniesz słuchać nowych. Najpierw test
czystej funkcji, która je wybiera.W edytorze poniżej czekają dwie karty tej samej rozmowy i licznik otwartych strumieni. Zamknij drugą kartę i otwórz ją z powrotem, potem włącz i wyłącz "Bez sprzątania", wyślij wiadomość i patrz, jak licznik rośnie, a wiadomości się dublują.
Pamiętaj: lina między statkami trzyma, póki obie strony pilnują węzłów, a kto ją rozpiął, ten ją zwija, gdy odpływa.
Kod do tej lekcji: App.jsx
// Czat na żywo w miniaturze: dwie karty tej samej rozmowy i "serwer" w pamięci.
// W projekcie serwerem jest Route Handler z text/event-stream, a karta słucha przez EventSource.
// Tutaj openStream udaje new EventSource(...), a sendToServer udaje POST /api/messages/anne.
import { useActionState, useEffect, useState, useSyncExternalStore } from 'react';
const ME = 'redbeard';
const saved = []; // zapisane wiadomości, jak data/messages.json
const streams = new Set(); // otwarte strumienie, jak słuchacze w 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;
}
// Serwer nadaje id i nadawcę, zapisuje wiadomość i rozsyła ją do każdego otwartego strumienia.
function sendToServer(content) {
const text = content.trim();
if (!text) return { ok: false, error: 'Napisz coś, zanim wyślesz.' };
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 czyta licznik otwartych strumieni z magazynu spoza komponentów.
function useOpenStreams() {
return useSyncExternalStore(
(watch) => {
watchers.add(watch);
return () => watchers.delete(watch);
},
() => streams.size
);
}
function useChat(leaky) {
const [messages, setMessages] = useState(() => [...saved]); // historia, jak z serwera
useEffect(() => {
const source = openStream();
source.onmessage = (event) => {
const message = JSON.parse(event.data);
setMessages((current) => [...current, message]);
};
if (leaky) return; // typowy błąd agenta: brak sprzątania
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">Wiadomość</label>
<input
id={inputId}
name="content"
defaultValue={state.content}
autoComplete="off"
placeholder="Napisz wiadomość"
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">
Wyślij
</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">Otwarte strumienie: {open}</span>
<button
onClick={() => setSecondOpen(!secondOpen)}
className="rounded-full border border-blue-600 px-3 py-1 font-semibold text-blue-700"
>
{secondOpen ? 'Zamknij kartę 2' : 'Otwórz kartę 2'}
</button>
<label className="flex items-center gap-2">
<input type="checkbox" checked={leaky} onChange={(e) => setLeaky(e.target.checked)} />
Bez sprzątania (typowy błąd)
</label>
</div>
<div className="grid gap-3 sm:grid-cols-2">
<ChatWindow title="Karta 1: rozmowa z Anne Bonny" inputId="message-1" leaky={leaky} />
{secondOpen && <ChatWindow title="Karta 2: ta sama rozmowa" inputId="message-2" leaky={leaky} />}
</div>
</div>
</div>
);
}
Widzisz błąd w tej lekcji?
Sprawdź się
Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.
1. Czym Server-Sent Events różnią się od WebSocketu?
2. Co robi karta w source.onmessage, gdy ze strumienia przyjdzie zdarzenie?
Zadania praktyczne w grze
- Klikanie w kolejności
Ułóż otwarcie strumienia w useChat: new EventSource(
/api/messages/${handle}) - Układanie w pionie
Uporządkuj drogę wiadomości od kliknięcia Wyślij do drugiej karty: