kaloko 0.4.9 → 0.4.11

package/src/lib/upload.mjs

@@ -0,0 +1,114 @@
+// Uploads of a run's files (#28): by content hash, so captures that did not change since an earlier run (or an
+// interrupted share) are not sent again, with progress on the terminal. The service stores each file once as an
+// organization blob and the run's file list points at it. An older service without blob references gets the files
+// by path as before; the paths it already took are remembered in the run folder, so a share that broke off resumes.
+import { readFile, writeFile } from 'node:fs/promises'
+import { gzipSync } from 'node:zlib'
+import { createHash } from 'node:crypto'
+import { join } from 'node:path'
+import { readJson } from './util.mjs'
+
+const TEXT = new Set(['html', 'json'])
+const IMAGE = /\.(png|webp|jpe?g)$/i
+export const PROGRESS_FILE = 'share.progress.json'
+
+export const fmtBytes = (n) => { n = Number(n) || 0; const u = ['B', 'kB', 'MB', 'GB']; let i = 0; while (n >= 1024 && i < u.length - 1) { n /= 1024; i++ } return `${n.toFixed(i ? 1 : 0)} ${u[i]}` }
+const extOf = (p) => { const e = p.split('.').pop().toLowerCase(); return e === 'jpeg' ? 'jpg' : e }
+/** Text files travel and rest gzip-compressed above 512 bytes; the hash is always of the raw content. */
+const encode = (p, raw) => { const gz = TEXT.has(extOf(p)) && raw.length > 512; return { data: gz ? gzipSync(raw, { level: 6 }) : raw, gz } }
+
+/** Content hash, size and type of every file to share (paths relative to the run folder). */
+export async function hashFiles (dir, paths) {
+  const out = []
+  for (const path of paths) {
+    const raw = await readFile(join(dir, path))
+    out.push({ path, hash: createHash('sha256').update(raw).digest('hex'), bytes: raw.length, ext: extOf(path) })
+  }
+  return out
+}
+
+/** Hashes the service does not store yet; null when it has no blob endpoint (an older service, or a token without it). */
+export async function missingHashes (client, org, hashes) {
+  const missing = new Set()
+  const list = [...new Set(hashes)]
+  try {
+    for (let i = 0; i < list.length; i += 1000) for (const h of (await client.request('POST', `/orgs/${org}/blobs/missing`, { hashes: list.slice(i, i + 1000) })).missing) missing.add(h)
+  } catch (e) {
+    if (/HTTP (403|404|405)\b/.test(e.message)) return null
+    throw e
+  }
+  return missing
+}
+
+/** Runs `job` over `items` with `n` workers; `tick` after each item. */
+async function pool (items, n, job, tick) {
+  const queue = [...items]
+  const worker = async () => { for (let it = queue.shift(); it; it = queue.shift()) { await job(it); tick?.(it) } }
+  await Promise.all(Array.from({ length: Math.max(1, Math.min(n, queue.length)) }, worker))
+}
+
+function progressLine (write, label) {
+  let last = 0
+  return (done, total, bytes) => {
+    const now = Date.now()
+    if (done !== total && now - last < 250) return
+    last = now
+    write(`\r  ${label} ${done}/${total}${bytes != null ? ` · ${fmtBytes(bytes)}` : ''}${done === total ? '\n' : ''}`)
+  }
+}
+
+/**
+ * Uploads the files of a created run. `entries` from hashFiles; `missing` from missingHashes (null: by path).
+ * Returns { mode: 'blobs'|'paths', uploaded, reused, bytes }.
+ */
+export async function uploadRunFiles ({ client, org, runId, dir, entries, missing, say = console.log, write = (s) => process.stdout.write(s), concurrency }) {
+  const workers = concurrency || (entries.length > 200 ? 12 : 6)
+  if (missing) {
+    // 1. the blobs the service lacks, each once (identical files in a run share one blob)
+    const byHash = new Map()
+    for (const e of entries) if (missing.has(e.hash) && !byHash.has(e.hash)) byHash.set(e.hash, e)
+    let sent = 0; let done = 0
+    const tick = progressLine(write, 'uploaded')
+    await pool([...byHash.values()], workers, async (e) => {
+      const { data, gz } = encode(e.path, await readFile(join(dir, e.path)))
+      await client.upload(`/orgs/${org}/blobs/${e.hash}`, data, e.path, { 'X-QAwalk-Type': e.ext, ...(gz ? { 'Content-Encoding': 'gzip' } : {}) })
+      sent += data.length
+    }, () => tick(++done, byHash.size, sent))
+    // 2. the run's file list points at the blobs; a service that does not know references says so by leaving out `blobs`
+    const plan = await client.request('POST', `/orgs/${org}/runs/${runId}/files`, { files: entries.map((e) => ({ path: e.path, bytes: e.bytes, blob: e.hash, ...(IMAGE.test(e.path) ? { sha256: e.hash } : {}) })) })
+    if (plan && typeof plan.blobs === 'number') {
+      return { mode: 'blobs', uploaded: byHash.size, reused: new Set(entries.map((e) => e.hash)).size - byHash.size, bytes: sent }
+    }
+    say('  The service does not take blob references yet; uploading the files by path.')
+  }
+  return uploadByPath({ client, org, runId, dir, entries, say, write, workers })
+}
+
+/** Per-path uploads (older services): a plan first, then each file; finished paths are remembered for a resume. */
+async function uploadByPath ({ client, org, runId, dir, entries, say, write, workers }) {
+  const progressFile = join(dir, PROGRESS_FILE)
+  const saved = await readJson(progressFile, null).catch(() => null)
+  const done = new Set(saved?.run === runId ? saved.done : [])
+  const todo = entries.filter((e) => !done.has(`${e.path}|${e.hash}`))
+  if (done.size && todo.length < entries.length) say(`  Resuming: ${entries.length - todo.length} of ${entries.length} file(s) were uploaded before the interruption.`)
+  // screenshots name their SHA-256 (sent uncompressed, so the hash of the raw file): the service checks it on
+  // arrival and compares unchanged steps with it (review mode)
+  if (todo.length) {
+    const plan = []
+    for (const e of todo) plan.push({ path: e.path, bytes: encode(e.path, await readFile(join(dir, e.path))).data.length, ...(IMAGE.test(e.path) ? { sha256: e.hash } : {}) })
+    await client.request('POST', `/orgs/${org}/runs/${runId}/files`, { files: plan }).catch((err) => { if (!/HTTP (404|405)/.test(err.message)) throw err })
+  }
+  let sent = 0; let n = 0; let since = 0
+  const remember = () => writeFile(progressFile, JSON.stringify({ run: runId, done: [...done] }) + '\n').catch(() => {})
+  const tick = progressLine(write, 'uploaded')
+  try {
+    await pool(todo, workers, async (e) => {
+      const { data, gz } = encode(e.path, await readFile(join(dir, e.path)))
+      await client.upload(`/orgs/${org}/runs/${runId}/files/${e.path.split('/').map(encodeURIComponent).join('/')}`, data, e.path, gz ? { 'Content-Encoding': 'gzip' } : {})
+      sent += data.length
+      done.add(`${e.path}|${e.hash}`)
+      if (++since >= 25) { since = 0; await remember() }
+    }, () => tick(++n, todo.length, sent))
+  } finally { await remember() }
+  return { mode: 'paths', uploaded: todo.length, reused: entries.length - todo.length, bytes: sent }
+}

package/src/lib/video-cli.mjs

@@ -0,0 +1,209 @@
+/* global MediaRecorder, createImageBitmap, requestAnimationFrame */
+// `kaloko video …` (batch D, #23): the walkthrough video of a run (step recordings stitched with a title card per
+// step: its title and verdict), recordings and traces of a run, and what this machine can record with.
+import { mkdtemp, rm, writeFile, stat, mkdir } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join, resolve, relative, dirname } from 'node:path'
+import { resolveRun, addCapture } from './run.mjs'
+import { loadScenario } from './scenario.mjs'
+import { buildManifest } from './build.mjs'
+import { launchEphemeral } from './browser.mjs'
+import { readJson, localized, UserError } from './util.mjs'
+import { videoTools, encoderCaps, ffmpeg, preset, installHint, outputSize } from './video.mjs'
+import { formatTrace } from './trace.mjs'
+
+const FORMATS = ['mp4', 'webm', 'gif']
+const VERDICT = {
+  en: { pass: 'Passed', fail: 'Failed', partial: 'Partly passed', skip: 'Not walked', step: (i, n) => `Step ${i} of ${n}` },
+  cs: { pass: 'Splněno', fail: 'Nesplněno', partial: 'Splněno zčásti', skip: 'Nekontrolováno', step: (i, n) => `Krok ${i} z ${n}` }
+}
+const fmtSize = (n) => n >= 1048576 ? `${(n / 1048576).toFixed(1)} MB` : `${Math.round(n / 1024)} kB`
+const flowOrder = (nodes) => nodes.filter((n) => n.kind !== 'decision' && n.kind !== 'stack').sort((a, b) => a.col - b.col || a.lane - b.lane)
+
+/**
+ * The segments of a walkthrough in flow order for one locale and viewport: a step's own recording, or its chapter of
+ * the flow recording. [{ node, title, status, file, from, to }] (from/to in seconds, null for the whole file).
+ */
+export function walkthroughPlan (manifest, { locale, viewport = null, steps = null } = {}) {
+  const loc = locale || manifest.scope?.locales?.[0]
+  const flow = manifest.recordings?.flow?.[loc]
+  const out = []
+  for (const n of flowOrder(manifest.nodes || [])) {
+    if (steps && !steps.includes(n.id)) continue
+    const vps = n.captures?.[loc] || {}
+    const vp = viewport && vps[viewport]?.rec ? viewport : Object.keys(vps).find((v) => vps[v]?.rec && (!viewport || v === viewport))
+    const rec = vp ? vps[vp].rec : (n.recordings || []).find((r) => r.locale === loc && (!viewport || r.viewport === viewport))
+    const status = n.by_locale?.[loc] || n.status || 'skip'
+    const title = localized(n.title, loc) || n.id
+    if (rec) { out.push({ node: n.id, title, status, file: rec.mp4 || rec.webm, from: null, to: null }); continue }
+    const ch = flow?.chapters?.find((c) => c.node === n.id)
+    if (ch) out.push({ node: n.id, title, status, file: flow.mp4 || flow.webm, from: ch.start / 1000, to: ch.capture / 1000 })
+  }
+  return out
+}
+
+/** ffmpeg arguments that stitch title cards and clips into one file. */
+export function stitchArgs ({ parts, out, format, width, height, fps, card = 1.6, encoders = {} }) {
+  const inputs = []; const filters = []; let k = 0
+  for (const p of parts) {
+    if (p.card) inputs.push('-loop', '1', '-t', String(card), '-framerate', String(fps), '-i', p.card)
+    else inputs.push(...(p.from != null ? ['-ss', p.from.toFixed(3)] : []), ...(p.to != null ? ['-to', p.to.toFixed(3)] : []), '-i', p.file)
+    filters.push(`[${k}:v]scale=${width}:${height}:force_original_aspect_ratio=decrease,pad=${width}:${height}:(ow-iw)/2:(oh-ih)/2:color=0x151514,fps=${fps},format=yuv420p,setsar=1[v${k}]`)
+    k++
+  }
+  const joined = `${parts.map((_, i) => `[v${i}]`).join('')}concat=n=${parts.length}:v=1:a=0[out]`
+  if (format === 'gif') return [...inputs, '-filter_complex', `${filters.join(';')};${joined};[out]split[a][b];[a]palettegen=max_colors=128[p];[b][p]paletteuse=dither=bayer[g]`, '-map', '[g]', '-loop', '0', out]
+  const codec = format === 'webm'
+    ? ['-c:v', encoders.vp9 || 'libvpx-vp9', '-deadline', 'good', '-cpu-used', '5', '-row-mt', '1', '-b:v', '0', '-crf', '36']
+    : encoders.h264 === 'libx264' || !encoders.h264 ? ['-c:v', 'libx264', '-preset', 'medium', '-crf', '26', '-movflags', '+faststart'] : ['-c:v', encoders.h264, '-b:v', '2M', '-movflags', '+faststart']
+  return [...inputs, '-filter_complex', `${filters.join(';')};${joined}`, '-map', '[out]', '-an', ...codec, '-g', String(fps * 2), out]
+}
+
+/** Without ffmpeg: the browser plays the clips and title cards onto a canvas and MediaRecorder keeps it (real time). */
+async function stitchInBrowser (page, { parts, width, height, fps, card }) {
+  const clips = []
+  for (const p of parts) {
+    if (p.card) clips.push({ card: p.cardData, ms: card * 1000 })
+    else clips.push({ video: (await import('node:fs/promises').then((fs) => fs.readFile(p.file))).toString('base64'), type: p.file.endsWith('.mp4') ? 'video/mp4' : 'video/webm', from: p.from, to: p.to })
+  }
+  return page.evaluate(async ({ clips, width, height, fps }) => {
+    const canvas = document.createElement('canvas'); canvas.width = width; canvas.height = height; document.body.append(canvas)
+    const g = canvas.getContext('2d')
+    const fromB64 = (s) => Uint8Array.from(atob(s), (c) => c.charCodeAt(0))
+    const stream = canvas.captureStream(fps)
+    const type = ['video/webm;codecs=vp9', 'video/webm;codecs=vp8', 'video/webm'].find((t) => MediaRecorder.isTypeSupported(t))
+    const rec = new MediaRecorder(stream, { mimeType: type, videoBitsPerSecond: 1_500_000 })
+    const chunks = []; rec.ondataavailable = (e) => { if (e.data.size) chunks.push(e.data) }
+    const fit = (w, h) => { const k = Math.min(width / w, height / h); return [(width - w * k) / 2, (height - h * k) / 2, w * k, h * k] }
+    rec.start(500)
+    for (const c of clips) {
+      g.fillStyle = '#151514'; g.fillRect(0, 0, width, height)
+      if (c.card) {
+        const bm = await createImageBitmap(new Blob([fromB64(c.card)], { type: 'image/png' }))
+        const end = performance.now() + c.ms
+        while (performance.now() < end) { g.drawImage(bm, 0, 0, width, height); await new Promise((resolve) => requestAnimationFrame(resolve)) }
+        continue
+      }
+      const v = document.createElement('video'); v.muted = true; v.playsInline = true
+      v.src = URL.createObjectURL(new Blob([fromB64(c.video)], { type: c.type }))
+      await new Promise((resolve, reject) => { v.onloadeddata = resolve; v.onerror = reject })
+      if (c.from != null) { v.currentTime = c.from; await new Promise((resolve) => { v.onseeked = resolve }) }
+      await v.play()
+      while (!v.ended && (c.to == null || v.currentTime < c.to)) { const [x, y, w, h] = fit(v.videoWidth, v.videoHeight); g.fillStyle = '#151514'; g.fillRect(0, 0, width, height); g.drawImage(v, x, y, w, h); await new Promise((resolve) => requestAnimationFrame(resolve)) }
+      v.pause(); URL.revokeObjectURL(v.src)
+    }
+    await new Promise((resolve) => { rec.onstop = resolve; rec.stop() })
+    const buf = new Uint8Array(await new Blob(chunks).arrayBuffer())
+    let s = ''; for (let i = 0; i < buf.length; i += 0x8000) s += String.fromCharCode.apply(null, buf.subarray(i, i + 0x8000))
+    return btoa(s)
+  }, { clips, width, height, fps })
+}
+
+/** `kaloko video export`: the walkthrough of the current run (or --run) as MP4, WebM or GIF. */
+export async function exportWalkthrough ({ config, root, args, say }) {
+  const run = await resolveRun({ root, output: config.output, run: args.run })
+  const scenario = await loadScenario(resolve(root, run.meta.scenario_file))
+  const manifest = await buildManifest({ run, scenario, config, root, catalog: [] })
+  const format = FORMATS.includes(args.format) ? args.format : 'mp4'
+  const lang = args.lang === 'cs' ? 'cs' : 'en'
+  const locale = typeof args.locale === 'string' ? args.locale : manifest.scope.locales[0]
+  const steps = typeof args.steps === 'string' ? args.steps.split(',').map((s) => s.trim()).filter(Boolean) : null
+  const plan = walkthroughPlan(manifest, { locale, viewport: typeof args.viewport === 'string' ? args.viewport : null, steps })
+  if (!plan.length) throw new UserError(`No recordings in run ${run.meta.id} for ${locale}. Walk with recordings first: kaloko walk --record (or --record flow), then export.`)
+  const tools = await videoTools()
+  if (!tools.ffmpeg && format !== 'webm') throw new UserError(`A walkthrough as ${format.toUpperCase()} needs ffmpeg (${installHint('ffmpeg')}). Without it, export WebM: kaloko video export --format webm (it plays the clips once in real time).`)
+  const P = preset(args.quality || 'medium')
+  const fps = format === 'gif' ? 10 : P.fps
+  const [width, height] = format === 'gif' ? outputSize(1280, 800, 800) : outputSize(1280, 800, Math.min(P.width, 1280))
+  const card = Math.max(0.5, Math.min(6, Number(args['card-seconds']) || 1.6))
+  const browser = await launchEphemeral(config)
+  const tmp = await mkdtemp(join(tmpdir(), 'kaloko-walkthrough-'))
+  const defaultOut = join(run.dir, 'attachments', `walkthrough.rec.${format}`)
+  const out = typeof args.out === 'string' ? resolve(args.out) : defaultOut
+  try {
+    const page = await browser.newPage()
+    await encoderCaps(page)
+    const V = VERDICT[lang]
+    const parts = []
+    const cardPng = async (lines, verdict) => {
+      const r = await page.evaluate((a) => window.__kenc.card(a), { width, height, lines, verdict })
+      const f = join(tmp, `card${parts.length}.png`)
+      await writeFile(f, Buffer.from(r.data, 'base64'))
+      return { card: f, cardData: r.data }
+    }
+    const s = manifest.summary || {}
+    parts.push(await cardPng([`${manifest.environment?.name || ''} · ${locale} · ${new Date(manifest.started_at).toISOString().slice(0, 10)}`, localized(manifest.scenario.title, locale) || manifest.scenario.id, `${plan.length} ${lang === 'cs' ? 'kroků se záznamem' : 'recorded steps'}${s.pass != null ? ` · ${s.pass} ${V.pass.toLowerCase()} · ${s.fail || 0} ${V.fail.toLowerCase()}` : ''}`], null))
+    plan.forEach((p, i) => { p.index = i + 1 })
+    for (const p of plan) {
+      parts.push(await cardPng([V.step(p.index, plan.length), p.title, p.node], { status: p.status, text: V[p.status] || p.status }))
+      parts.push({ file: join(run.dir, p.file), from: p.from, to: p.to })
+    }
+    await mkdir(dirname(out), { recursive: true })
+    if (tools.ffmpeg) {
+      say(`Stitching ${plan.length} recording(s) with title cards (${format.toUpperCase()}, ${width}×${height})…`)
+      await ffmpeg(tools, stitchArgs({ parts, out, format, width, height, fps, card, encoders: tools.ffmpeg.encoders }))
+    } else {
+      say(`No ffmpeg: playing ${plan.length} recording(s) through the browser in real time to record a WebM…`)
+      await writeFile(out, Buffer.from(await stitchInBrowser(page, { parts, width, height, fps, card }), 'base64'))
+    }
+    const bytes = (await stat(out)).size
+    const duration = Math.round((plan.reduce((n, p) => n + ((p.to ?? 0) - (p.from ?? 0)), 0) + card * (plan.length + 1)) * 1000)
+    const inside = !relative(run.dir, out).startsWith('..')
+    if (inside) await addCapture(run.dir, { type: 'walkthrough', file: relative(run.dir, out), format, bytes, locale, viewport: args.viewport || null, steps: plan.length, ...(plan.every((p) => p.to != null) ? { duration_ms: duration } : {}), at: new Date().toISOString() })
+    say(`Walkthrough: ${relative(process.cwd(), out)} (${fmtSize(bytes)}, ${plan.length} steps)`)
+    if (inside) say('kaloko share uploads it with the run (Business plan and up); people with the link play or download it on the canvas.')
+    return { file: out, bytes, steps: plan.length }
+  } finally { await browser.close().catch(() => {}); await rm(tmp, { recursive: true, force: true }) }
+}
+
+export async function videoCmd ({ config, root, args, say }) {
+  const sub = args._[0] || 'help'
+  if (sub === 'export') return exportWalkthrough({ config, root, args, say })
+  if (sub === 'tools') {
+    const t = await videoTools({ refresh: true })
+    const ff = t.ffmpeg
+    say([
+      `ffmpeg      ${ff ? `${ff.version} · H.264 ${ff.encoders.h264 || '—'} · VP9 ${ff.encoders.vp9 ? 'yes' : '—'} · AV1 ${ff.encoders.av1 || '—'}` : `not found (${installHint('ffmpeg', t.platform)}); WebM still works, MP4 and the walkthrough export need it`}`,
+      `adb         ${t.adb ? 'found (Android screenrecord)' : `not found (${installHint('adb', t.platform)})`}`,
+      ...(t.platform === 'darwin' ? [`simctl      ${t.simctl ? 'found (iOS Simulator recordVideo)' : `not found (${installHint('simctl', 'darwin')})`}`, 'screencapture  macOS desktop recordings (needs Screen Recording permission: kaloko doctor checks it)'] : [])
+    ].join('\n'))
+    return t
+  }
+  const run = await resolveRun({ root, output: config.output, run: args.run })
+  const scenario = await loadScenario(resolve(root, run.meta.scenario_file))
+  const manifest = await buildManifest({ run, scenario, config, root, catalog: [] })
+  if (sub === 'list') {
+    const rows = []
+    for (const n of manifest.nodes) {
+      for (const [l, vps] of Object.entries(n.captures || {})) for (const [vp, c] of Object.entries(vps || {})) if (c?.rec || c?.trace_summary) rows.push({ step: n.id, locale: l, viewport: vp, recording: c.rec || null, trace: c.trace_summary || null })
+      for (const r of n.recordings || []) rows.push({ step: n.id, locale: r.locale, viewport: r.viewport, recording: r, trace: null })
+    }
+    const flows = manifest.recordings?.flow || {}
+    if (args.json) { say(JSON.stringify({ run: run.meta.id, steps: rows, flow: flows, walkthrough: manifest.walkthrough || null }, null, 2)); return }
+    for (const r of rows) say(`${r.step.padEnd(24)} ${r.locale}/${r.viewport}  ${r.recording ? `${Math.round(r.recording.duration_ms / 100) / 10} s ${[r.recording.webm && 'WebM', r.recording.mp4 && 'MP4'].filter(Boolean).join('+')} ${fmtSize(r.recording.bytes || 0)}${r.recording.failed ? ' (failed attempt)' : ''}` : 'no recording'}${r.trace ? ` · trace ${r.trace.actions} actions, ${r.trace.requests} requests${r.trace.failed_requests ? ` (${r.trace.failed_requests} failed)` : ''}, ${r.trace.console_errors} console errors` : ''}`)
+    for (const [l, f] of Object.entries(flows)) say(`flow ${l}: ${Math.round(f.duration_ms / 1000)} s, ${f.chapters?.length || 0} chapters, ${fmtSize(f.bytes || 0)}`)
+    if (manifest.walkthrough) say(`walkthrough: ${manifest.walkthrough.file} (${fmtSize(manifest.walkthrough.bytes || 0)})`)
+    if (!rows.length && !Object.keys(flows).length) say('Nothing recorded in this run. kaloko walk --record records each step; traces are on unless capture.trace is false.')
+    return
+  }
+  if (sub === 'trace') {
+    const step = typeof args.step === 'string' ? args.step : null
+    const n = manifest.nodes.find((x) => x.id === step)
+    if (!n) throw new UserError(`Usage: kaloko video trace --step <id> [--locale l] [--viewport v] [--json]. Steps: ${manifest.nodes.map((x) => x.id).join(', ')}`)
+    const loc = typeof args.locale === 'string' ? args.locale : Object.keys(n.captures || {})[0]
+    const vps = n.captures?.[loc] || {}
+    const vp = typeof args.viewport === 'string' ? args.viewport : Object.keys(vps).find((v) => vps[v]?.trace)
+    const file = vps[vp]?.trace
+    if (!file) throw new UserError(`No trace for ${step} ${loc}${vp ? `/${vp}` : ''}. Walk the step again (traces are on unless capture.trace is false).`)
+    const trace = await readJson(join(run.dir, file), null)
+    say(args.json ? JSON.stringify(trace, null, 2) : `${step} ${loc}/${vp}: ${trace.duration_ms} ms, ${trace.summary?.requests ?? 0} requests, ${trace.summary?.console_errors ?? 0} console errors\n${formatTrace(trace)}`)
+    return
+  }
+  say(`Usage:
+  kaloko video export [--format mp4|webm|gif] [--locale l] [--viewport v] [--steps a,b] [--lang en|cs] [--out file]
+                      The run's recordings stitched in flow order with a title card per step (title, verdict)
+  kaloko video list [--json]               Recordings and traces of the run, with sizes
+  kaloko video trace --step <id> [--locale l] [--viewport v] [--json]
+                                           Actions, requests and console messages of the step, in time order
+  kaloko video tools                       ffmpeg, adb, simctl: what this machine can record and encode with`)
+}