Kurs vibe coding z Claude Code · Moduł 13: Klon Twitcha

Pokład z kamerą: odtwarzacz i czat, najpierw test

8 min czytania
W tej lekcji9

Ahoj! Kapitan chce nadawać rejsy na żywo: załoga na lądzie ma widzieć pokład i rozmawiać z nim w trakcie wachty. W tej lokacji budujesz Live from the Deck, klon Twitcha, czyli serwisu z transmisjami na żywo. Widz, który wchodzi na kanał, oczekuje dwóch rzeczy naraz: obrazu i czatu. Obraz musi dać się zatrzymać, wyciszyć i powiększyć na cały ekran. Czat płynie szybko, a jego logika, na przykład zamiana kodów emotek na obrazki, psuje się w miejscach, których nie widać przy pierwszym kliknięciu.

Czego się nauczysz

  • zamówić odtwarzacz i czat w trybie planowania, z testem jako kryterium ukończenia;
  • napisać z Claude test parsera emotek, zanim powstanie parser, i zobaczyć, jak łapie sortowanie w miejscu;
  • przeczytać czat z funkcyjną aktualizacją stanu, unikalnymi identyfikatorami i onKeyDown w miejsce przestarzałego zdarzenia;
  • sprawdzić w prawdziwej przeglądarce pełny ekran, którego nie sprawdzi żaden test w terminalu.

Nowy port: projekt live-from-the-deck

Klon to osobna aplikacja, więc zakładasz ją poleceniem z lekcji 1_2, zmieniając tylko nazwę:

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-npm

Dalej znana pętla: sesja claude w nowym folderze, CLAUDE.md z importem @AGENTS.md (lekcja 1_7), Vitest z poprawką @types/node z lekcji 4_1 i pierwszy commit.

Jedno trzeba powiedzieć uczciwie na starcie. Prawdziwa transmisja na żywo wymaga, żeby obraz z kamery streamera trafił na serwer, który rozsyła go widzom w formacie dla przeglądarek. MDN pisze, że do tego potrzebne jest specjalne oprogramowanie na serwerze albo zewnętrzna usługa, a protokoły spoza HTTP, takie jak RTMP, nie działają w elemencie <video> bez wtyczek. To temat na osobny kurs. Nasz klon gra lokalny plik w pętli i udaje transmisję. Plik testowy zrobi Claude, jeśli masz zainstalowany program ffmpeg:

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/rejs.mp4

lavfi to wbudowane w ffmpeg źródła sztucznego obrazu i dźwięku: kolorowa plansza z zegarem i ton 440 Hz. -t 60 tnie całość do minuty, libx264 i aac to kodeki, które przeglądarki odtwarzają, a +faststart przenosi spis zawartości pliku na początek, żeby film ruszył przed pobraniem całości. Bez ffmpeg wrzuć do public/streams/ dowolny własny krótki MP4.

Polecenie dla Claude Code

Krok dotyka typów, dwóch funkcji, dwóch komponentów i strony, więc zaczynasz od planu, jak w lekcji 1_6. Najważniejsze zdanie polecenia mówi, co jest dowodem: test parsera, napisany przed parserem, jak w lekcjach 4_1 i 10_4.

Polecenie dla Claude Code:

/plan Dodaj stronę kanału /channel/[handle] z odtwarzaczem i czatem.
Dane kanału w lib/channels.ts, transmisja to plik /streams/rejs.mp4
grany w pętli, wyciszony na starcie. Odtwarzacz components/StreamPlayer.tsx:
własne przyciski Odtwórz, Wycisz, Pełny ekran; pełny ekran obejmuje
cały kontener z przyciskami, nie sam element video. Czat
components/LiveChat.tsx, na razie lokalny, bez serwera. Wiadomość ma
emotki jako zakresy znaków; zamianę tekstu na kawałki wydziel do
lib/chat/parseMessageWithEmotes.ts. Najpierw test tej funkcji: brak
emotek, emotka na początku, dwie obok siebie, emotka na końcu, zakresy
w dowolnej kolejności. Uruchom go i pokaż porażkę, potem napisz funkcję.
Gotowe, gdy npm run test -- --run, npm run lint i npx tsc --noEmit
przejdą bez błędów.

W planie sprawdź, czy test powstaje przed parserem i czy pełny ekran dotyczy kontenera. Jeśli plan o tym milczy, popraw go przez Ctrl+G przed akceptacją.

Co napisał Claude: test przed parserem

Emotka to krótki kod w tekście, na przykład :kotwica:, który czat pokazuje jako obrazek. Serwer czatu może przysłać wiadomość razem z listą zakresów: gdzie zaczyna się i kończy każdy kod. Otwórz w Cursorze lib/chat/types.ts:

// lib/chat/types.ts
export interface EmoteRange {
  name: string; // "kotwica"
  start: number; // indeks pierwszego znaku kodu emotki
  end: number; // indeks za ostatnim znakiem, jak w slice
}

end wskazuje znak za kodem, tak jak drugi argument slice, więc text.slice(start, end) zwraca dokładnie :kotwica:. Teraz otwórz test, który Claude napisał jako pierwszy. Najciekawszy jest ostatni przypadek:

// lib/chat/parseMessageWithEmotes.test.ts
test("zakresy w dowolnej kolejności, tablica emotek bez zmian", () => {
  const emotes = Object.freeze([kotwica(8), { name: "rum", start: 0, end: 5 }]);
  const parts = parseMessageWithEmotes(":rum: i :kotwica:", emotes);
  expect(parts.map((p) => p.kind)).toEqual(["emote", "text", "emote"]);
});

Zakresy przychodzą w odwrotnej kolejności, a Object.freeze zamraża tablicę: każda próba jej zmiany kończy się błędem. kotwica(8) to pomocnicza funkcja z góry pliku, która buduje zakres kotwicy od ósmego znaku. Pierwsze uruchomienie, zanim parser istniał, skończyło się u nas tak:

Error: Failed to resolve import "./parseMessageWithEmotes" from "lib/chat/parseMessageWithEmotes.test.ts". Does the file exist?

To dobra porażka: test szuka funkcji, której jeszcze nie ma.

Co napisał Claude: parser

Otwórz lib/chat/parseMessageWithEmotes.ts. Pierwsza wersja agenta sortowała zakresy tak:

// lib/chat/parseMessageWithEmotes.ts (wersja agenta)
const sorted = emotes.sort((a, b) => a.start - b.start);

sort zmienia tablicę w miejscu, a ta tablica należy do wiadomości, nie do parsera. Cztery testy przeszły, piąty oblał z komunikatem TypeError: Cannot assign to read only property '0' of object '[object Array]'. Poprawiona wersja:

// 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] kopiuje listę przed sortowaniem, jak w lekcji 11_2. pos to miejsce, do którego tekst jest już pocięty; zakres, który nachodzi na poprzedni albo wychodzi poza tekst, funkcja pomija, zamiast się wywrócić. Słowo readonly w typie parametru to druga zapora: z nim npx tsc --noEmit odrzuca wersję agenta komunikatem Property 'sort' does not exist on type 'readonly EmoteRange[]'. Po poprawce: Tests 5 passed (5).

Co napisał Claude: czat

Wiadomości wpisane przez widza nie mają zakresów, więc findEmotes z lib/chat/emotes.ts szuka w tekście kodów ze słownika EMOTES i zwraca je pogrupowane według emotki, a nie według miejsca. Dlatego parser musi sortować. Otwórz 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() daje każdej wiadomości własny identyfikator, jak blokom kroniki w lekcji 11_1. prev => ... to funkcja aktualizująca, która widzi najświeższą listę. slice(-MAX_MESSAGES) zostawia 150 ostatnich wiadomości, żeby strona nie puchła przez całą transmisję. Wysyłkę uruchamia klawisz:

// components/LiveChat.tsx
onKeyDown={(e) => {
  if (e.key === "Enter") send();
}}

MDN oznacza zdarzenie keypress jako przestarzałe i każe używać keydown albo beforeinput. Typy Reacta też oznaczają onKeyPress jako @deprecated, ale wersja agenta z onKeyPress przeszła u nas lint i tsc. Złapał ją dopiero test komponentu, który wysyła wiadomość Enterem: Unable to find an element with the text: <b>ahoj</b>. Ten sam test pilnuje drugiej rzeczy: znaczniki w treści zostają tekstem, bo kawałki trafiają do <span>{part.text}</span>, a React zamienia je na zwykłe znaki. Lista sama przewija się w dół:

// components/LiveChat.tsx
useEffect(() => {
  const list = listRef.current;
  if (list && stickToBottom.current) list.scrollTop = list.scrollHeight;
}, [messages]);

stickToBottom to useRef, który przy każdym przewinięciu sprawdza warunek z MDN: Math.abs(el.scrollHeight - el.clientHeight - el.scrollTop) <= 1. Widz, który czyta starsze wiadomości, nie zostaje szarpnięty na dół.

Co napisał Claude: odtwarzacz i pełny ekran

Otwórz components/StreamPlayer.tsx. Stan przycisków czyta zdarzenia elementu, jak w lekcji 10_1: onPlay, onPause i onVolumeChange. Start wyciszony z autoPlay znasz z lekcji 9_1. Nowy jest pełny ekran:

// components/StreamPlayer.tsx
useEffect(() => {
  function sync() {
    setFullscreen(document.fullscreenElement === boxRef.current);
  }
  document.addEventListener("fullscreenchange", sync);
  return () => document.removeEventListener("fullscreenchange", sync);
}, []);

Według MDN document.fullscreenElement to element pokazany na pełnym ekranie albo null, a fullscreenchange przychodzi przy wejściu i przy wyjściu. Przewodnik MDN przypomina, że przeglądarka zamyka pełny ekran także sama, zwykle klawiszem Esc. Dlatego etykieta przycisku pyta przeglądarkę, a nie zgaduje. Przycisk woła boxRef.current?.requestFullscreen() na kontenerze. MDN dodaje, że ta metoda zwraca obietnicę i działa tylko po geście użytkownika, więc ma .catch z komunikatem.

Przegląd kapitana

  1. Sortowanie. Wyszukaj w projekcie (Cmd+Shift+F) .sort(: przed każdym stoi [....
  2. Tekst, nie HTML. Wyszukaj dangerouslySetInnerHTML: w czacie nie ma go wcale.
  3. Klucze. Wiadomości mają key={m.id}, nie indeks.
  4. Pełny ekran w przeglądarce. Tego nie sprawdzi Vitest: w jsdom, udawanej przeglądarce z lekcji 4_1, requestFullscreen w ogóle nie istnieje. Uruchom npm run dev, wejdź na /channel/kapitan-redbeard, włącz pełny ekran, naciśnij Esc i przeczytaj etykietę przycisku. Albo poproś o to Claude in Chrome z lekcji 3_8. U nas wersja agenta wołała requestFullscreen() na <video> i przestawiała stan ręcznie. Na pełnym ekranie zniknęły plakietka NA ŻYWO i nasze przyciski, a Chrome pokazał swoje kontrolki z paskiem 0:02 / 1:00, który zdradza, że to nagranie. Po wyjściu z pełnego ekranu bez naszego przycisku etykieta dalej brzmiała "Zamknij pełny ekran". Poprawiona wersja wróciła do "Pełny ekran".

Typowy błąd agenta przy teście to zmiana oczekiwanej wartości, żeby test przeszedł. W diffie widzisz to od razu: plik testu zmieniony w tym samym kroku co parser. Zapytaj, dlaczego.

Następny krok

Gdy testy i przeglądarka się zgadzają, poproś o commit "Odtwarzacz i czat z testem parsera". Potem mały krok, znowu test pierwszy: "Dodaj tryb wolny: jedna wiadomość widza na 5 sekund, z odliczaniem przy przycisku". Prawdziwy czat, w którym wiadomości widzą wszyscy, zbudujesz wzorcem z lekcji 6_4: wysyłka zwykłym żądaniem POST i Server-Sent Events do rozwożenia wiadomości. W edytorze poniżej czeka czat w miniaturze: wpisz wiadomość z :kotwica: i <b>, przełącz wersję agenta i zobacz, co robi sortowanie w miejscu.

Zapamiętaj: kapitan, który ufa lunecie bez sprawdzenia, widzi rafę dopiero wtedy, gdy na niej stoi; test to luneta, którą ustawiasz, zanim wypłyniesz.

Kod do tej lekcji: App.tsx
// Czat pokładowy w miniaturze: parser emotek, Enter przez onKeyDown i przewijanie w dół
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> = { kotwica: '⚓', papuga: '🦜', skarb: '💰', rum: '🥃' };
const MAX_MESSAGES = 150;
const CREW_LINES = ['Widać ląd :papuga:', 'Kto ma wachtę? :kotwica:', ':rum: dla sternika', 'Skrzynia pełna :skarb: :skarb:'];

// Kody szukane według słownika, więc zakresy przychodzą pogrupowane po emotce, nie po miejscu
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); // dane wiadomości są tylko do odczytu, jak z serwera
}

function parseMessageWithEmotes(text: string, emotes: readonly EmoteRange[], agentBug: boolean): MessagePart[] {
  // Wersja agenta sortuje tablicę wiadomości w miejscu; zamrożona tablica rzuca wtedy 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;
}

// W projekcie id daje crypto.randomUUID(); tu wystarczy licznik
let nextId = 1;

function newMessage(author: string, text: string): ChatMessage {
  return { id: 'm' + nextId++, author, text, emotes: findEmotes(text) };
}

// Błąd parsera łapiemy poza JSX: try/catch wokół JSX nie łapie błędów renderu
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">Błąd parsera: {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('Sternik', 'Ahoj załogo :kotwica:'),
    newMessage('Papuga_Pola', ':papuga: :skarb: widać już wyspę!'),
  ]);
  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('Załoga', line)].slice(-MAX_MESSAGES));
    }, 1000);
    return () => clearInterval(id);
  }, [crewTalking]);

  function send() {
    const text = draft.trim();
    if (!text) return;
    setMessages((prev) => [...prev, newMessage('Majtek', 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">Czat pokładowy</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="Wiadomość na czacie"
            placeholder="Spróbuj: <b>ahoj</b> :rum: i :kotwica:"
            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">
            Wyślij
          </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)} />
          Załoga pisze co sekundę (przewiń w górę: czat Cię nie szarpnie)
        </label>
        <label className="flex items-center gap-2">
          <input type="checkbox" checked={agentBug} onChange={(e) => setAgentBug(e.target.checked)} />
          Wersja agenta: emotes.sort(...) w miejscu
        </label>
        <p className="text-zinc-400">Wiadomości: {messages.length} (czat trzyma najwyżej {MAX_MESSAGES})</p>
      </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. 1. Jak Live from the Deck pokazuje transmisję na żywo?

  2. 2. Dlaczego StreamPlayer ustawia etykietę przycisku pełnego ekranu w zdarzeniu fullscreenchange na podstawie document.fullscreenElement, zamiast przełączać stan w onClick?

To 2 z 6 pytań do tej lekcji. Pozostałe rozwiążesz w grze.

Zadania praktyczne w grze

  • Klikanie w kolejności

    Zbuduj linię parsera, która sortuje zakresy emotek bez zmiany tablicy wiadomości

  • Układanie w poziomie

    Ułóż linię z funkcji send, która dopisuje wiadomość i zostawia 150 ostatnich (jedna linia):

  • Klikanie w kolejności

    Zbuduj warunek z onKeyDown pola czatu, który wysyła wiadomość klawiszem Enter

  • Edytor kodu

    Zbuduj stream player z kontrolkami video

  • Układanie w pionie

    Uporządkuj kroki, w których Claude budował parser emotek:

  • Edytor kodu

    Stwórz real-time chat interface

  • Układanie w pionie

    Uporządkuj kroki funkcji send w LiveChat:

  • Klikanie w kolejności

    Zbuduj linię, która w StreamPlayer zaczyna nasłuchiwać zmian pełnego ekranu

  1. PytanieQuiz: transmisja w klonie
  2. PytanieQuiz: stan pełnego ekranu
  3. PytanieQuiz: koniec zakresu emotki
  4. Kliknij w kolejnościBudowanie: sortowanie kopii
  5. Ułóż w kolejnościSortowanie: dopisanie wiadomości
  6. Kliknij w kolejnościBudowanie: wysyłka Enterem
  7. Zadanie z kodemPraktyka: Stream player
  8. PytanieQuiz: co złapało onKeyPress
  9. PytanieQuiz: znaczniki w wiadomości
  10. Ułóż w kolejnościSortowanie: najpierw test
  11. Zadanie z kodemPraktyka: Live chat
  12. Ułóż w kolejnościSortowanie: kroki funkcji send
  13. Kliknij w kolejnościBudowanie: nasłuch pełnego ekranu
  14. PytanieQuiz: przewijanie czatu

Przydatne artykuły