Files
luxe/scripts/site-record.sh
Evan Whittaker a0666d6c81 luxe 0.1.4: remembered models, wheel-driven lists, and a steadier phone app
- luxe starts on the model you last chose in this project, then the last one anywhere. Signing in
  opens the model picker instead of choosing for you.
- Every list in a modal takes the mouse wheel and a draggable scrollbar.
- The phone app shows reasoning in full, stays put while you read back through a long session, and
  shows a question's answer on its card.
- On Windows, luxe update replaces the running luxe, and a signed-in install no longer sees setup
  again.
- The file tree no longer shows "engine busy" in a large project, loop output is easier to follow,
  and the name is written lowercase.

The CHANGELOG has the full list.
2026-10-20 13:51:34 -05:00

506 lines
20 KiB
Bash
Executable File

#!/usr/bin/env bash
# Record a demo for the website by driving the real luxe in a real terminal.
#
# These used to be scripted through the reducer with no terminal involved, which made them exactly
# reproducible and exactly as much work as writing the app twice. This runs the shipped binary
# against a real provider in Ghostty and records what a person would have seen — so a demo is a
# take, and re-shooting it after a visual change is re-running one command rather than editing a
# thousand lines of Rust.
#
# What that costs, stated plainly: a recording is no longer verifiable by CI, so nothing checks
# that it still matches the build. `web/src/assets/captures/manifest.json` records what each take
# was shot against, and re-recording is the only way to refresh one.
#
# Usage:
# scripts/site-record.sh [options] <script-file>
#
# Options:
# --name NAME output basename (default: the script's own)
# --cols N terminal columns (default 92 — see below)
# --rows N terminal rows (default 28)
# --font-size N Ghostty font size (default 13)
# --theme NAME luxe theme (default luxe)
# --project DIR where to run luxe (default: a scratch copy of web/demo)
# --project-src DIR the project template to copy
# --project-name N what the scratch copy is called, which is the name every surface shows
# --max-idle SECS cap on a gap between frames after editing (default 1.2)
# --speed N play the finished take N times faster (default 1.0)
# --timeout SECS abandon a take that has not finished (default 900)
# --out DIR where the finished cast lands (default web/src/assets/captures)
# --raw keep the unedited recording beside the finished one
# --keep-project leave the scratch project behind for inspection
# --monitor NAME which output the recording window opens on, when --watch is set
# --watch put the recording window on screen instead of hiding it
# --seed 'CMD' shell run before the first commit, so its result is the project's history
# --setup 'CMD' shell run after it, so its result is an uncommitted change
# --model P/ID which model answers (default: LUXE_RECORD_MODEL, else whatever is remembered)
# --thinking LEVEL reasoning level for the take
# --glyphs STYLE glyph fidelity: auto, nerd, nerd_wide, unicode, ascii
# --bin DIR put DIR first on luxe's PATH (relative to web/demo-scripts), for stand-ins
#
# Both are how a demo gets a starting state without spending a turn on it: a changes-and-commit
# demo needs a dirty tree, and paying a provider to manufacture one so the demo can then talk about
# it is a minute of recording nobody watches.
#
# Which side of the commit matters. A defect introduced *after* it is a defect `git checkout` can
# undo, and a model asked to fix one will notice — one take ended with "restoring working tree to
# HEAD", which is a correct answer to a question the demo did not mean to ask. `--seed` puts it in
# history instead, where fixing it means editing the code.
#
# 92 columns is the whole mobile strategy. A demo is drawn at a fixed size per character, so the
# column count *is* the type size — and the review surface at 180 columns is three pixels a
# character on a phone, which is the same as not being there. 92 carries a two-pane review and
# still reads at 390px wide.
#
# The keystrokes go into luxe's pty, never to the compositor. `wtype` was the obvious way to drive
# a TUI and it works right up until focus moves, after which every remaining key — `Ctrl+C`
# included — is typed into whatever window took it. `scripts/site-drive.py` writes to the pty
# instead, which cannot reach another window and does not need the recording to hold focus.
#
# The step language is documented in that script.
#
# A demo declares its own options in `#:` directives at the top of its script, so re-shooting the
# set is one command and the size a demo needs lives with the demo rather than in somebody's shell
# history. A flag on the command line overrides its directive.
#
# #: cols 150
# #: speed 1.6
# #: setup sed -i 's/x/y/' src/filter.js
set -euo pipefail
repo_root="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
name=""
cols=92
rows=28
font_size=13
theme="luxe"
project=""
project_src="${repo_root}/web/demo"
# The directory name is the project name in the statusline, the dock and the dashboard, so it is
# part of the shot rather than an implementation detail of the scratch copy.
project_name="todo"
max_idle=1.2
speed=1.0
take_timeout=900
out_dir="${repo_root}/web/src/assets/captures"
keep_raw=false
keep_project=false
script_file=""
monitor="${LUXE_RECORD_MONITOR:-}"
watch=false
setup_cmd=""
seed_cmd=""
model="${LUXE_RECORD_MODEL:-}"
thinking="${LUXE_RECORD_THINKING:-}"
glyphs=""
bin_dir=""
usage() { sed -n '2,40p' "${BASH_SOURCE[0]}" | sed 's/^# \{0,1\}//'; }
while [[ $# -gt 0 ]]; do
case "$1" in
--name) name="$2" && shift 2 ;;
--cols) cols="$2" && shift 2 ;;
--rows) rows="$2" && shift 2 ;;
--font-size) font_size="$2" && shift 2 ;;
--theme) theme="$2" && shift 2 ;;
--project) project="$2" && shift 2 ;;
--project-src) project_src="$2" && shift 2 ;;
--project-name) project_name="$2" && shift 2 ;;
--max-idle) max_idle="$2" && shift 2 ;;
--speed) speed="$2" && shift 2 ;;
--timeout) take_timeout="$2" && shift 2 ;;
--out) out_dir="$2" && shift 2 ;;
--raw) keep_raw=true && shift ;;
--keep-project) keep_project=true && shift ;;
--monitor) monitor="$2" && shift 2 ;;
--watch) watch=true && shift ;;
--setup) setup_cmd="$2" && shift 2 ;;
--seed) seed_cmd="$2" && shift 2 ;;
--model) model="$2" && shift 2 ;;
--thinking) thinking="$2" && shift 2 ;;
--glyphs) glyphs="$2" && shift 2 ;;
--bin) bin_dir="$2" && shift 2 ;;
-h | --help)
usage
exit 0
;;
-*)
echo "unknown flag: $1" >&2
exit 2
;;
*) script_file="$1" && shift ;;
esac
done
[[ -n "$script_file" ]] || {
usage
exit 2
}
[[ -f "$script_file" ]] || {
echo "no such script: $script_file" >&2
exit 2
}
[[ -n "$name" ]] || name="$(basename "${script_file%.*}")"
# Directives first, so an explicit flag still wins: everything above has already been parsed, so
# only a setting still at its default is taken from the file.
while IFS= read -r directive; do
key="${directive%% *}"
value="${directive#"$key"}"
value="${value# }"
case "$key" in
cols) [[ "$cols" == 92 ]] && cols="$value" ;;
rows) [[ "$rows" == 28 ]] && rows="$value" ;;
speed) [[ "$speed" == 1.0 ]] && speed="$value" ;;
max-idle) [[ "$max_idle" == 1.2 ]] && max_idle="$value" ;;
setup) [[ -z "$setup_cmd" ]] && setup_cmd="$value" ;;
seed) [[ -z "$seed_cmd" ]] && seed_cmd="$value" ;;
model) [[ -z "$model" ]] && model="$value" ;;
thinking) [[ -z "$thinking" ]] && thinking="$value" ;;
glyphs) [[ -z "$glyphs" ]] && glyphs="$value" ;;
bin) [[ -z "$bin_dir" ]] && bin_dir="$value" ;;
project-name) [[ "$project_name" == todo ]] && project_name="$value" ;;
*)
echo "unknown directive in ${script_file}: ${key}" >&2
exit 2
;;
esac
done < <(sed -n 's/^#: *//p' "$script_file")
for tool in ghostty python3 git; do
command -v "$tool" >/dev/null || {
echo "missing required tool: $tool" >&2
exit 2
}
done
luxe_bin="${repo_root}/target/release/luxe"
[[ -x "$luxe_bin" ]] || {
echo "no release binary at ${luxe_bin} — run scripts/install-dev.sh first" >&2
exit 2
}
mkdir -p "$out_dir"
work="$(mktemp -d /tmp/luxe-record-XXXXXX)"
raw_cast="${work}/raw.cast"
marks_file="${work}/marks"
drive_log="${work}/drive.log"
# === The terminal ===
# Ghostty wears the luxe palette. The app paints nearly every cell itself, but not the ones it has
# not reached yet — and a demo whose first frame is somebody else's background color announces that
# it was staged.
theme_json="${repo_root}/crates/luxe-core/src/themes/${theme}.json"
[[ -f "$theme_json" ]] || {
echo "no such theme: ${theme_json}" >&2
exit 2
}
read -r term_bg term_fg < <(python3 -c "
import json, sys
palette = json.load(open(sys.argv[1]))['vars']
print(palette['bg'], palette['fg'])
" "$theme_json")
ghostty_config="${work}/ghostty.conf"
cat >"$ghostty_config" <<CONF
font-family = JetBrainsMono Nerd Font Mono
font-size = ${font_size}
window-width = ${cols}
window-height = ${rows}
window-padding-x = 0
window-padding-y = 0
window-decoration = none
window-inherit-font-size = false
background = ${term_bg}
foreground = ${term_fg}
confirm-close-surface = false
resize-overlay = never
mouse-hide-while-typing = true
cursor-style-blink = false
shell-integration = none
CONF
# === The project under the demo ===
# A scratch copy, every time. A demo that edits a file has to start from the same file next time,
# and a template that accumulates the last five takes is a template that eventually shows them.
if [[ -z "$project" ]]; then
[[ -d "$project_src" ]] || {
echo "no demo project at ${project_src} — pass --project" >&2
exit 2
}
project="${work}/${project_name}"
cp -r "$project_src" "$project"
if [[ -n "$seed_cmd" ]]; then
(cd "$project" && DEMO_SCRIPTS="${repo_root}/web/demo-scripts" eval "$seed_cmd")
fi
git -C "$project" init --quiet --initial-branch=main
# Configured on the repository, not passed per command. A `git commit` with no identity anywhere
# cannot proceed, so an agent asked to commit correctly stops and asks who it is — which is good
# behavior and a poor demo, and it is the recorder's doing rather than something to talk the
# model out of in the prompt.
git -C "$project" config user.name "luxe"
git -C "$project" config user.email "demo@luxe.dev"
git -C "$project" add -A
git -C "$project" commit --quiet -m "Initial commit"
fi
# After the commit, so whatever it does shows up as a change rather than as the baseline.
#
# `DEMO_SCRIPTS` because the command runs in the scratch project, which is somewhere under /tmp —
# so a change big enough to live in its own file has no relative path to reach itself by.
if [[ -n "$setup_cmd" ]]; then
(cd "$project" && DEMO_SCRIPTS="${repo_root}/web/demo-scripts" eval "$setup_cmd")
fi
# === luxe's own config ===
# Copied from the real one so the credentials and the model are the ones being demonstrated, then
# overridden where a demo needs a fixed answer. Never the real directory: a take must not be able
# to write to it, and a theme set for a recording must not outlive it.
config_home="${work}/config"
mkdir -p "${config_home}/luxe"
real_config="${XDG_CONFIG_HOME:-$HOME/.config}/luxe"
if [[ -d "$real_config" ]]; then
# Not `mcp.json`: the operator's servers would sit in the picker's MCP tab of every take, and
# connect to real services on the way.
find "$real_config" -maxdepth 1 -name '*.json' ! -name 'auth.json' ! -name 'mcp.json' \
-exec cp {} "${config_home}/luxe/" \;
# Linked, not copied. An OAuth credential rotates: the provider hands back a new refresh token
# and invalidates the one just used, and luxe writes it to whichever auth file it was given. A
# copy in a scratch directory therefore takes the rotation with it when the directory is
# deleted, and every later take authenticates with a token the provider has already retired —
# which is a signed-out account after one recording, not a recording problem you notice at the
# time. The real file is the credential store; a take uses it exactly as a normal run would.
[[ -e "${real_config}/auth.json" ]] &&
ln -s "${real_config}/auth.json" "${config_home}/luxe/auth.json"
fi
python3 - "$config_home" "$theme" "$glyphs" <<'PY'
import json, pathlib, sys
home, theme, glyphs = sys.argv[1], sys.argv[2], sys.argv[3]
path = pathlib.Path(home) / "luxe" / "config.json"
config = json.loads(path.read_text()) if path.exists() else {}
config["theme"] = theme
if glyphs:
config["glyphs"] = glyphs
# Straight into a session. The dashboard is a real surface and it has its own demo if it ever wants
# one, but as a preamble it costs every take three seconds of a screen the demo is not about.
config["dashboard"] = False
# A desktop notification landing mid-take is somebody else's window in the shot.
config["notifications"] = False
# The update check is one request that can only make a recording slower or wrong.
config.setdefault("update", {})["check"] = False
path.write_text(json.dumps(config, indent=2))
PY
# A scratch state directory, always. The remembered model outranks `default_model`, and it lives
# outside the config directory — so without this a take silently inherits whichever model the
# operator last picked, which is how a demo meant for a local model got recorded against a frontier
# one. Isolating it also stops a recording from writing back to real state.
state_home="${work}/state"
mkdir -p "${state_home}/luxe"
python3 - "$state_home" "$model" <<'PY'
import json, pathlib, sys
home, model = sys.argv[1], sys.argv[2]
state = {"schema_version": 1}
if model:
provider, _, identifier = model.partition("/")
if not identifier:
sys.exit(f"--model wants provider/id, got {model!r}")
state["model"] = {"provider": provider, "id": identifier}
path = pathlib.Path(home) / "luxe" / "state.json"
path.write_text(json.dumps(state, indent=2))
path.chmod(0o600)
PY
# `--thinking` on the command line, not in the state file. A model's own configured level in
# `models.json` outranks the remembered one, so a level written to state is silently ignored for
# exactly the models that declare a default — which is the set worth overriding.
luxe_args=()
[[ -n "$thinking" ]] && luxe_args+=(--thinking "$thinking")
# A stand-in for a program the demo project has no real counterpart for, like `gh` for a repository
# that doesn't exist. First on PATH, so luxe and every command the model runs find it.
record_path="$PATH"
if [[ -n "$bin_dir" ]]; then
[[ "$bin_dir" == /* ]] || bin_dir="${repo_root}/web/demo-scripts/${bin_dir}"
[[ -d "$bin_dir" ]] || {
echo "no such bin directory: ${bin_dir}" >&2
exit 2
}
record_path="${bin_dir}:${PATH}"
fi
# === Launch ===
cleanup() {
# `|| true`: by the time this runs the terminal has usually already gone, and under `set -e` a
# failed kill in the exit trap turns a finished recording into a non-zero exit.
if [[ -n "${term_pid:-}" ]]; then
kill "$term_pid" 2>/dev/null || true
fi
if [[ "$keep_project" == true ]]; then
echo "project left at ${project}"
else
rm -rf "$work"
fi
return 0
}
trap cleanup EXIT
# By default the window is hidden on a silent special workspace, and that is the important setting
# rather than a convenience.
#
# A take does not need to be seen: the recording comes from the pty the driver owns, and a hidden
# GTK window still answers the device queries luxe asks. What an on-screen window *does* do is sit
# in the way — it takes focus, it lands on whichever monitor the pointer last touched, and the
# operator cannot use their machine without wondering whether they just spoiled a minute of
# recording. `silent` keeps the workspace from being switched to.
#
# `--watch` puts it back on screen for the times you need to see what a script is actually doing.
# A class of its own, per run.
#
# `hyprctl keyword windowrulev2` *adds* a rule for the rest of the compositor's session; there is no
# unset. So a run that once asked for `float, size, center, monitor DP-2` leaves those rules behind,
# and every later run of the hidden variant matches them too — the window floats onto whichever
# monitor last had the pointer instead of going quietly to its workspace. A unique class means only
# this run's rules can ever match this run's window.
#
# The segment cannot start with a digit: Ghostty validates the class as a GTK application id and
# silently ignores an invalid one, which puts the window back under the desktop's own class where
# no rule reaches it.
window_class="dev.luxe.record.r$$"
rule() { hyprctl keyword windowrulev2 "$1, class:^(${window_class})\$" >/dev/null 2>&1 || true; }
if [[ "$watch" == true ]]; then
# Ghostty's own `window-width`/`window-height` are in cells and Hyprland overrides them for a
# new float, so the size is asked for again in pixels. The cell is JetBrains Mono's own box, a
# 0.6em advance by a 1.32em line, at the 20px a 13pt face measures on this display.
read -r window_px_w window_px_h < <(python3 -c "
import sys
cols, rows, size = (int(a) for a in sys.argv[1:4])
print(round(cols * 12.02 * size / 13), round(rows * 26.45 * size / 13))
" "$cols" "$rows" "$font_size")
rule "float"
rule "size ${window_px_w} ${window_px_h}"
rule "center"
[[ -n "$monitor" ]] && rule "monitor ${monitor}"
else
rule "workspace special:luxe-record silent"
rule "noanim"
fi
echo "==> recording ${name} (${cols}x${rows}, ${theme})"
XDG_CONFIG_HOME="$config_home" \
XDG_STATE_HOME="$state_home" \
TERM=xterm-256color \
LUXE_UPDATE_CHECK=0 \
LUXE_WIRE_LOG="${work}/wire.jsonl" \
PATH="$record_path" \
ghostty \
--config-default-files=false \
--config-file="$ghostty_config" \
--gtk-single-instance=false \
--class="${window_class}" \
--title="luxe-record-$$" \
-e python3 "${repo_root}/scripts/site-drive.py" \
--script "$script_file" \
--out "$raw_cast" \
--marks "$marks_file" \
--log "$drive_log" \
--cols "$cols" --rows "$rows" \
--cwd "$project" \
--title "luxe — ${name}" \
-- "$luxe_bin" "${luxe_args[@]}" &
term_pid=$!
# A take that never finishes is a script with a step that never lands. Bounded, so a bad script
# costs a wait rather than a window nobody notices is still open.
waited=0
while kill -0 "$term_pid" 2>/dev/null; do
sleep 1
waited=$((waited + 1))
if ((waited > take_timeout)); then
echo "take exceeded ${take_timeout}s — abandoning" >&2
kill "$term_pid" 2>/dev/null || true
break
fi
done
wait "$term_pid" 2>/dev/null || true
# The driver's notes, always — a take that went wrong is exactly the one whose window is gone.
if [[ -f "$drive_log" ]]; then
cp "$drive_log" "${out_dir}/${name}.log"
fi
# And what the take actually said and sent: the session it wrote and every request and reply on
# the wire. A card that went red for no reason the cast can show is answered by these, and the
# scratch project they lived in is about to be deleted. Kept beside the driver's notes, and like
# them never committed (`luxe wire` reads the second).
if [[ -f "${work}/wire.jsonl" ]]; then
cp "${work}/wire.jsonl" "${out_dir}/${name}.wire.jsonl"
fi
session_file="$(ls -t "${project}"/.luxe/sessions/*/*.jsonl 2>/dev/null | head -1 || true)"
if [[ -n "$session_file" ]]; then
cp "$session_file" "${out_dir}/${name}.session.jsonl"
fi
[[ -s "$raw_cast" ]] || {
echo "nothing was recorded — see ${out_dir}/${name}.log" >&2
exit 1
}
# === Cut ===
python3 "${repo_root}/scripts/cast-edit.py" "$raw_cast" \
--out "${out_dir}/${name}.cast" \
--marks "$marks_file" \
--max-idle "$max_idle" \
--speed "$speed" \
--title "luxe — ${name}"
[[ "$keep_raw" == true ]] && cp "$raw_cast" "${out_dir}/${name}.raw.cast"
python3 - "$out_dir" "$name" "$cols" "$rows" "$theme" "$script_file" "$repo_root" <<'PY'
import datetime, json, pathlib, subprocess, sys
out_dir, name, cols, rows, theme, script, root = sys.argv[1:8]
path = pathlib.Path(out_dir) / "manifest.json"
manifest = json.loads(path.read_text()) if path.exists() else {}
def relative(target: str) -> str:
"""Names the script inside the repository, or absolutely for a one-off from elsewhere."""
try:
return str(pathlib.Path(target).resolve().relative_to(pathlib.Path(root).resolve()))
except ValueError:
return str(pathlib.Path(target).resolve())
def git(*args: str) -> str:
try:
done = subprocess.run(["git", "-C", root, *args], capture_output=True, text=True, check=True)
return done.stdout.strip()
except (subprocess.CalledProcessError, OSError):
return "unknown"
manifest[name] = {
"recorded": datetime.datetime.now().astimezone().strftime("%Y-%m-%d"),
"commit": git("rev-parse", "--short", "HEAD"),
"dirty": bool(git("status", "--porcelain")),
"cols": int(cols),
"rows": int(rows),
"theme": theme,
"script": relative(script),
}
path.write_text(json.dumps(dict(sorted(manifest.items())), indent=2) + "\n")
PY
echo "==> ${out_dir}/${name}.cast"