The best way to control Claude Code, Codex and more from any computer or phone
Mirrored from https://github.com/Camo67/t3code.git
Synced Nov 21, 03:37 UTC
name: launch-video
description: Make a short launch video (1920x1080 MP4 plus an outro PNG) that demos a T3 Code feature, built from the real app with added motion, for an X/Twitter announcement or release thread. Use when asked for a launch video, demo video, feature teaser or announcement clip, or to add a video to a release tweet.
Launch videos
A launch video is 20–30 seconds: the app goes through one story in two or three beats, the camera punches in on each, a caption names it, and an outro card closes. Frames are rendered one by one in headless Chromium, so the result is deterministic.
There are two ways to build one:
- Real app (default). A staging script runs the real server and web client with fictional
data and the free replay agent, drives the flow in a browser, and freezes the page at each
beat into
beats/<name>.html. The story stacks those frozen pages and adds the motion: the camera, cursor, pops, glows, typing and captions. The UI is whatever the app draws today, so re-staging on main updates the video.stagings/linked-environments/is a finished example. - Mock.
template/story.htmlis a hand-built HTML copy of the app (the 0.1.11 tunnels video). Use it only for what a staging can't produce, such as another app on the desktop or a desktop-only screen. It drifts as the app changes.
Workflow (real app)
- Learn the feature. Read the PRs and the components it touches. Write down the one thing a user can now do that they couldn't before, in the user's words.
- Write the story before any code: who the user is, what they want, and two or three beats that get them there. Show it to the maintainer if the angle is a guess.
- Stage it. Copy
stagings/linked-environments/tostagings/<slug>/.serve.mjsbuilds fresh homes under.t3/launch/<slug>/withscripts/stage-env.mjs. Each home gets a fictional machine label, the replay agent, and no paid provider. It starts the servers, creates projects, writes<out>/stage.jsonand keeps running. Run it in the background.drive.mjsopens the web client withopenBrowser()(1440×720, dark, release branding) and walks the flow. It callsbeat(name)at each moment the video needs. Re-run it as often as you like against the same servers.- Agent turns: pass
claude: [turns]toprepareHomeand the real Claude provider runsscripts/fake-claude.mjsas its CLI, so the video shows Claude's logo, models, thinking and tool rows. Each turn is{ match, steps }:think,text,bash(+output,ms),wait, andtool(+input), which calls that T3 MCP tool for real, e.g.delegate_task. Match generated titles with a{ match: "title", repeat: true }turn.<var:name>is filled from the JSON file atFAKE_CLAUDE_VARS, for ids that change every run.fake-claude.login the home records the protocol, for debugging. - Data a real flow can't produce cheaply goes into the app's own stores, never into pixels.
insertPeerLinkswrites link rows into a stopped server;serveDescriptorsmakes fake machines answer the reachability probe. The client's saved environments and routes live in IndexedDB (t3code:connection-runtime/catalog/document): write the document from the page after its first load, then reload. Route kinds come from hostnames (*.localhostis LAN,*.ts.netTailscale); Chrome's--host-resolver-rules=MAP *.tail-demo.ts.net 127.0.0.1makes fake tailnet names work. - Gestures: hold the mouse down, move in steps, and
saveBeatmid-drag to freeze the app's own drag line and highlight; animate between those beats withKit.reveal. - A capped, scrolling modal freezes at different scroll offsets per beat. Freeze at a
viewport tall enough that nothing scrolls, and size
.appto match. - Without
claude, turns go to the dev replay agent (apps/server/scripts/dev-replay-agent.ts), which shows as an ACP provider.
- Create the story:
scripts/new.sh ~/launch-videos/<slug>, then copy the beats in, or pass that directory as the staging's<out>. Add one<iframe data-beat>per beat and writesetup()andplaceCursor()(see Anatomy). - Find targets in a beat:
scripts/find.mjs <dir>/beats/<name>.html "<text>"prints selectors and boxes for the elements containing that text and their ancestors. - Probe with contact sheets at every beat, fix, repeat:
scripts/sheet.sh ~/launch-videos/<slug> 1,4.5,8,12,16,21,26then Readsheet.png. The times are video seconds (afterKit.timeline), not animation seconds. Read the full-size frames inprobe/to check small text. A probe takes about 2 s a frame. - Render:
scripts/render.sh ~/launch-videos/<slug> t3code-<slug>givest3code-<slug>.mp4andoutro.png. A 30 s video takes 3–6 minutes. - Hand back with the video and outro embedded (
), the caption copy, anyKit.textedits, and anything you assumed rather than verified.
The scripts need this repo's node_modules (vp i) for playwright-core, any Chromium in
the Playwright cache (or CHROME=/path), and ffmpeg on PATH. Stop serve.mjs with your
harness's task stop; it ends its servers' process groups.
Staging traps
- Machine names and icons.
T3CODE_ENVIRONMENT_LABELandT3CODE_ENVIRONMENT_MACHINE_KIND(laptop, desktop, cloud, linux, mac-mini, mac-studio) override what the server detects.prepareHome({ label, machine })records them andstartEnvironmentandcli()pass them on; the CLI needs them too, because a link introduces the machine by its label. - Linked environments refuse loopback addresses ("this machine"), and plain http works
only on tailnet names.
serve.mjslinks to this machine's tailnet DNS name. - Leaks. Grep the beats for the real hostname, username and tailnet name before
rendering.
snapshot.mjsdrops hidden inputs' values (they hold local paths). - Timing. A replayed turn streams in real time (each frame delay caps at 2 s). Make a recording long enough for the drive to catch the state you need, and freeze beats on a timer when the UI summarises (a running command shows only "Running pnpm").
- Agent wake-ups. When a delegated child finishes, the parent agent gets a new turn. Give its recording a second turn, or the first replays and delegates again.
What the maintainers asked for
These came from review of the 0.1.11 videos. Each one was a real correction.
- It must look like the real app. "Quite far off how it actually looks" was the first
round's verdict on a mock. Stage the real app; mock only what can't be staged, rebuilt from
the real component (strings live in
apps/web/src/i18n/translations/en.jsonunder hashed keys, so grep by the text). - Punchier than the app. Extra motion is welcome (pops, glows, punch-ins, typing), as long as every pixel it moves is the real UI.
- Readable on a phone. Captions are 40px; zoom the camera 1.5–1.9× onto whatever the beat is about. If text is under ~14px after zoom, zoom further or cut it.
- Slow enough to follow. Slow the key interactions to 0.6–0.8× and hold 0.8–1.5 s after each payoff. A viewer must see the result before the next beat starts.
- A realistic example. The demo has to be something a user would really do. A local terminal querying a forwarded port was rejected ("why not use the in-app terminal?"); a desktop database client was the right example.
- Distinct features read as distinct. Two features get two numbered captions and two clearly separate payoffs, never one blended beat.
- Brand. Production logo only (
logo-prod.png, fromassets/prod/), never the blue dev icon. The app's dark palette (below); orange only where the app uses it. - Only announced things. Before showing a screen, check it ships enabled. Feature-flagged or separately announced work (for 0.1.11: GitHub sign-in and PR tooling, the mobile app) stays out, even as background UI. A video whose subject is an opt-in Labs feature is fine when the maintainer asked for it; say where to turn it on in the caption or tweet, and ask whether the outro should call it a beta. Ask when unsure.
- Fictional demo data. Project
acme/mugshot, machinedevbox, made-up people with@example.com. No real people, teams, emails, repos or the user's own threads. - Timing is checked, not assumed. Typing must finish before the cursor clicks, a tooltip must appear before it is read, and card text must not overflow. The contact sheet catches these; full-size probe frames catch the rest.
Look
From apps/web/src/index.css, dark theme:
- Background
#000with a faint primary glow at the top (rgba(52,107,241,.13)). - Text
#f1f3f7, secondary#a3a3a3, UI muted#8e8e93, dim#636368. - Borders
#1d1d20or white at 8%; surfaces#0e0e0fto#191a1d; chips#191a1d. - Primary
#346bf1, light primary#6e9bfb, success#4ade80, destructive#e5484d. - Orange
#f07a4aonly for the agent ✳ next to a Claude model and provider marks. - Fonts: Inter (UI) and JetBrains Mono as
JB(code, ports, versions, URLs).
Anatomy of a real-app story
Everything runs on one clock in animation seconds. capture.mjs serves the directory over
HTTP, loads the beats, calls setup(), seeks to layoutTime, calls placeCursor(), then
seeks every animation (in the story and inside each beat) to each frame's time.
- Canvas 1600×900 CSS px, rendered at device scale 1.2 to 1920×1080. Beats were frozen at
1440×720 and
.appscales them 1.0556× into the 1520×760 window, so beat point (x, y) is canvas (40 + 1.0556·x, 26 + 1.0556·y). - Targets are
"<beat> >> <css>"(or"* >> <css>"for every beat). Prefer the app'sdata-*andaria-labelattributes;find.mjsprints them. A trailing:text(words)keeps the matches containing those words, e.g.[role=menuitem]:text(From MacBook). - Beat size. Each beat records the viewport it was frozen at (
kit-viewportmeta). Size.appand its iframes to match and scale them to the 1520×760 window (1440×720 → 1.0556, 1600×800 → .95). setup():Kit.beats([[name, at, fade?], ...])gives each beat one visibility window. Then the motion, all at absolute times:Kit.pop / rise / slide / stagger / type / press / punch / fadeIn / drawanimate elements inside a beat;Kit.glow(target, at)draws a ring on the story layer, so app overflow can't clip it;Kit.animtakes raw keyframes;Kit.textmakes a static edit (say so at handback).placeCursor(): wrap inKit.measureand callKit.camera(steps)andKit.cursor("#cur", steps)there. Both take{ t, on|at: target, ... }steps measured atlayoutTimewith the camera at rest. Pick alayoutTimeafter every entrance has finished. Camera steps centreonat screen heighty(default 420, clear of the captions) at scales; repeat a step to hold. Cursor clicks draw a ripple.- Captions
.cap: a numbered chip, a bold lead phrase and a muted rest. Short enough to read in two seconds. Play them withKit.captions([[selector, from, to], ...]), which throws if two overlap; two captions crossfading read as garbled text. - Pacing:
Kit.timeline([[realSeconds, animFrom, animTo], ...])maps video time to animation time;animFrom == animToholds a frame. It also sets the video length. - Outro
.outro: logo, a two-line headline, "Available now in T3 Code<version>",t3.codes. Change the headline and version, keep the rest. Hold it about 3 s.
Two animations on one property of one element fight (the later one wins for its whole
fill). Give an element one animation per property, as Kit.beats does for visibility.
Mock stories
template/story.html uses the same kit (cursor, timeline) but draws the app in HTML on a
2000×1000 .stage scaled .76 (stage point (x, y) is canvas (40 + .76·x, 26 + .76·y)), with CSS
@keyframes and delays for motion and one @keyframes camera for the camera. Rebuild any
screen it lacks from the real component's strings, layout and lucide icons.
Delivery checklist
- 1920×1080, 30 fps, 20–30 s (
render.shprints it). - Every beat checked in a contact sheet and at full size.
- No unannounced feature, real person, real machine name or real thread on screen.
-
outro.pngexported and embedded in the reply with the video.