---
title: Kaloko v CI: každý náhled pull requestu prověřený a okomentovaný
description: Jeden příkaz napíše workflow: počká na náhled na Vercelu, Netlify nebo Cloudflare, projde kroky, kterých se změna týká, a okomentuje PR.
seo_title: Kaloko v CI: prověřte každý náhled pull requestu
query: akceptační průchody náhledů pull requestů v CI
kind: agent
order: 12
demo: true
---
Každý pull request má svůj náhled a v review stojí „vypadá to dobře“ dřív, než ho někdo otevřel na telefonu. Kaloko náhled projde za vás, jen obrazovky, kterých se změna týká, a odkaz na plachtu vloží do pull requestu.

## Co nás pálí

Screenshoty z CI končí jako artefakty, které nikdo nestáhne. Projít všechny flow při každém pushi trvá tak dlouho, že s tím týmy přestanou, a na odkaz na náhled v PR se klikne jednou, na notebooku, v jednom jazyce.

## Co se změní s Kalokem

`npx kaloko ci github` napíše workflow. Když se náhled nasadí, CI na něm projde kroky, kterých se pull request týká, a ke každému scénáři napíše jeden komentář. Verdikty dávají lidé na plachtě, agent nebo další úloha si je přečte přes `kaloko feedback`.

## Jak to funguje

1. **Vygenerujte workflow**: `npx kaloko ci github` (nebo `npx kaloko ci gitlab`) zapíše `.github/workflows/kaloko.yml` a do `kaloko.config.yml` přidá prostředí `preview`, jehož `base_url` je `${KALOKO_PREVIEW_URL}`.
2. **Přidejte jeden secret**: `KALOKO_TOKEN`, token s rolí tester a rozsahem pro nahrávání (Nastavení → API tokeny; na Enterprise token servisního účtu, který nepatří žádnému člověku). `TYPESAFE_API_KEY` jen tehdy, když chcete vlastní klíč k vyhodnocení.
3. **Najděte náhled**: Vercel, Netlify i Cloudflare Pages hlásí náhledy jako GitHub deployments. `kaloko ci preview-url` z nich přečte adresu, pull request a jeho cílovou větev; jiná review aplikace nastaví `KALOKO_PREVIEW_URL`.
4. **Projděte, co se změnilo**: `kaloko affected --fail-if-none` přeskočí scénáře, kterých se změna netýká; `kaloko walk --affected` projde kroky, jejichž routy, importované komponenty nebo soubory z `affects:` se změnily, a kroky před nimi.
5. **Okomentujte**: `kaloko share --pr` nahraje běh (nezměněné obrazovky se znovu neposílají) a u pull requestu udržuje jeden aktuální komentář na scénář.
6. **Když chcete, zablokujte merge**: s GitHub App Kaloko (od plánu Team) dostane pull request i jednu kontrolu `Kaloko` na posledním commitu. Zezelená, když běhy sdílené pro ten commit projdou nebo když se změna žádného scénáře netýká, takže ji ochrana větve může vyžadovat. Workflow před procházením pošle `kaloko ci plan`, aby kontrola věděla, na které scénáře čekat.

## Skilly a prompty

Spusťte příkaz v repozitáři, projděte soubor, přidejte secret a commitněte:

```
npx kaloko ci github --scenario qa/flows/checkout.yml
```

Takové workflow zapíše:

```yaml
# .github/workflows/kaloko.yml
name: Kaloko
on:
  # Vercel, Netlify and Cloudflare Pages report each preview as a GitHub deployment
  deployment_status:
  workflow_dispatch:
concurrency:
  group: kaloko-${{ github.event.deployment.sha || github.event.pull_request.head.sha || github.sha }}
  cancel-in-progress: true
permissions:
  contents: read
  deployments: read
  pull-requests: write
jobs:
  walk:
    if: github.event_name != 'deployment_status' || (github.event.deployment_status.state == 'success' && !startsWith(github.event.deployment_status.environment, 'Production') && !startsWith(github.event.deployment_status.environment, 'production'))
    runs-on: ubuntu-latest
    timeout-minutes: 30
    env:
      KALOKO_TOKEN: ${{ secrets.KALOKO_TOKEN }}
      TYPESAFE_API_KEY: ${{ secrets.TYPESAFE_API_KEY }}
      GH_TOKEN: ${{ github.token }}
      KALOKO_AGENT: github-actions
      KALOKO_BROWSER_CHANNEL: chromium
    steps:
      - uses: actions/checkout@v4
        with:
          ref: ${{ github.event.deployment.sha || github.event.pull_request.head.sha || github.sha }}
          fetch-depth: 0   # walk --affected compares with the pull request's base
      - uses: actions/setup-node@v4
        with:
          node-version: 22
      - run: npm ci
      - run: npx kaloko browser install --with-deps   # the Chromium of kaloko's own Playwright
      - name: Preview deployment
        # the deployment's URL, the pull request and its base; waits for the preview when it is still building
        run: npx kaloko ci preview-url --wait 600 --github-env
      - name: Walk, share, comment
        run: |
          status=0
          npx kaloko ci plan --scenario qa/flows/checkout.yml || echo "kaloko ci plan did not reach Kaloko; the GitHub check guesses from the changed files."
          for s in qa/flows/checkout.yml; do
            if ! npx kaloko affected --scenario "$s" --check; then echo "Nothing in $s is affected; skipped."; continue; fi
            npx kaloko start --scenario "$s" --env preview
            npx kaloko walk --ephemeral --affected || status=1
            npx kaloko share --pr || status=1
          done
          exit $status
```

Na GitLabu zapíše `npx kaloko ci gitlab` soubor `kaloko.gitlab-ci.yml` pro pipeline merge requestů; vložte ho do `.gitlab-ci.yml` přes `include` a přidejte `KALOKO_TOKEN` a `KALOKO_GITLAB_TOKEN` (project access token s rozsahem api, kvůli poznámce v merge requestu).

Nebo požádejte agenta:

```
Nastav Kaloko v CI pro tenhle repozitář: na každém náhledu pull requestu projdi checkout a registraci a okomentuj PR. Než workflow commitneš, ukaž mi ho.
```

Očekávaný výsledek: u dalšího pull requestu komentář ke každému scénáři se souhrnným řádkem a odkazem na plachtu, aktualizovaný při každém pushi.

## Co dostanete

- Každý náhled prověřený ve všech jazycích a viewportech scénáře, ne jen jednou proklikaný.
- Jen kroky, kterých se pull request týká, a u každého v logu úlohy důvod.
- Jeden komentář na scénář, aktualizovaný na místě; rozhoduje se na plachtě.
- Kontrolu `Kaloko` se stálým jménem, kterou může ochrana větve vyžadovat.

## Otázky

### Co když náhledy neběží na Vercelu, Netlify ani Cloudflare?

Nastavte v úloze `KALOKO_PREVIEW_URL` (třeba `https://pr-${{ github.event.number }}.review.example.com`) a workflow vygenerujte s `--trigger pull_request`. Funguje každá adresa, na kterou CI dosáhne.

### Jak dlouho běh v CI trvá?

Zhruba minutu na deset kroků ve dvou jazycích a dvou viewportech, plus vyhodnocení. S `--affected` projde běžný pull request jen pár kroků. Jazyky běží v CI vedle sebe.

### Naši kódovací agenti běží v cloudu. Potřebujeme tohle workflow?

Pro kontrolu ne. Agent v Claude Code na webu, v Codexu nebo v Cursoru spustí ve svém sandboxu stejné `kaloko walk --affected` a `kaloko share` a kontrola `Kaloko` v pull requestu si běh najde podle commitu. Před procházením commitněte: běh s necommitnutými změnami se nepočítá. Workflow se hodí, když sandbox neumí spustit prohlížeč nebo se nedostane na náhled.

### Jde kontrolu u jednoho pull requestu přeskočit?

Ano, pokud máte právo, které zvolil správce (výchozí je zápis): štítek `kaloko:skip`, nebo komentář `/kaloko skip <důvod>` pro aktuální commit. Aplikace a boti přeskakovat nemůžou a kontrola ukáže, kdo ji přeskočil a proč.

### Může CI běh přijmout automaticky?

Ne. Běh přijímá člověk; CI může jen ověřit, že to někdo udělal (`kaloko feedback --json`).
