nandi/frq · justfile

nandi/frqpublic⑂ Fork 0
⑂ ed528b295f8c0fe67f7cd5eadc7c8763309684a3
justfile · 410 lines · 18.1 KBMakefile    Blame HistoryRaw
Inline the babashka scripts into the justfile   1# The work is here now, in recipe bodies, where it used to be in scripts/ —
2# babashka scripts run through a scripts/bb that went looking for a babashka.
3# That indirection bought one thing worth having, a shared way to reach nix on
4# a host that keeps it in a container, and `nix` below is the whole of it.
6# Every recipe that runs frq has the same shape: outside the dev shell, re-enter
7# it and come back to this same recipe; inside, hand jolt the deps overrides and
8# the library path the shell exported. The re-entry test is JOLT_NATIVE_LIB,
9# which only the shell sets — no flag to forget, and no second code path for
10# someone who runs `nix develop --command just run` by hand.
Take glimmer-vidya from gitlab, so a stranger can build this   11
Write the build in babashka, and pin the babashka   12set shell := ["bash", "-euo", "pipefail", "-c"]
A freeq client in jolt, as glimmer components on Vidya   13
Give the terminal's classpath an nREPL, and hand recipes their arguments   14# Every recipe below is a `#!` script and passes its arguments on with "$@".
15# Without this that is empty in one — just interpolates into a shebang recipe
16# rather than handing it argv — and `just tui --headless` silently ran the
17# terminal instead.
18set positional-arguments
Inline the babashka scripts into the justfile   20# nix is not on every host this runs on: on the machine these recipes were
21# written for it lives in an Arch distrobox, at the same path — which is why
22# the container is entered rather than the tree copied into it. See CLAUDE.md.
23nix := `command -v nix >/dev/null 2>&1 && echo nix || echo "distrobox enter arch -- nix"`
25# --max-jobs 0 is what sends the work to the `builders` entry rather than
26# compiling it here. Left to the default, nix prefers the local machine, and a
27# cold jolt-native is egui, openh264 and quinn on a laptop — for a derivation a
28# remote builder has likely built already. FRQ_MAX_JOBS=auto is the way out on
29# a machine with no builder configured.
30jobs := env("FRQ_MAX_JOBS", "0")
A freeq client in jolt, as glimmer components on Vidya   32
33    @just --list
Paint the phone in COSMIC's own theme, read from cosmic-config   35# Re-read the COSMIC theme into the APK.
37# libcosmic asks cosmic-config for the accent and the surfaces at run time, so
38# `just run` already follows COSMIC Settings as it changes. A phone has no
39# cosmic-config, so the APK carries them instead — read here, on the machine
40# that has them, and compiled in. That is the one real difference between the
41# two, and it is why the generated file is in git rather than gitignored: a
42# checkout on a machine with no COSMIC still builds.
44# Run it after changing the theme in COSMIC Settings, then `just apk`.
46    #!/usr/bin/env bash
47    set -euo pipefail
48    cd "{{justfile_directory()}}"
49    python3 tools/cosmic2cljd.py flutter/src/frq/theme/cosmic.cljd
Build the APK, out of ClojureDart and Flutter   51# The APK: ClojureDart compiled to Dart, then Flutter's Gradle build.
53# Impure on purpose, and worth saying why rather than leaving it to be
54# discovered. Gradle resolves its own dependencies over the network and
55# installs build-tools and a platform into ANDROID_HOME as it goes, so it
56# cannot run in a sandbox and cannot write to the store. What nix gives here
57# is the toolchain — clojure, a JDK, Flutter, and an SDK composed by
58# androidenv — and the recipe copies that SDK somewhere writable
59# (flutter/.home) for Gradle to finish off. That copy and everything Gradle
60# leaves behind are gitignored.
62# No ndkVersion in android/app/build.gradle.kts, for the same reason: the
63# Flutter template sets it, setting it makes Gradle fetch that exact NDK, and
64# there is no native code here to need one.
66#   just apk                build the debug APK
67#   just apk install        build it and put it on a connected device
68#   just apk run            install and launch
69#   just apk log            logcat, filtered to this app
70apk action="build":
71    #!/usr/bin/env bash
72    set -euo pipefail
73    cd "{{justfile_directory()}}/flutter"
Build the APK from the flake, at the rev flake.lock pins   75    # The flake's, not an --impure --expr against whatever nixos-unstable is
76    # today: the licence config the SDK needs lives in `androidPkgsFor` now,
77    # so this is an ordinary output at the rev flake.lock pins.
78    sdk="$(nix build --no-link --print-out-paths \
79        "{{justfile_directory()}}#android-sdk")/libexec/android-sdk"
Build the APK, out of ClojureDart and Flutter   80
Let adb keep its identity when the APK recipe moves HOME   81    # adb keeps the key the phone has already trusted under the real HOME, and
82    # HOME moves below so Gradle can write into the SDK copy. Told where to
83    # look, adb keeps its identity; left to find $HOME/.android it generates a
84    # new one, the device stops recognising this machine, and the deploy ends
85    # in "no devices/emulators found" while `adb devices` in any other shell
86    # lists it perfectly well.
87    export ANDROID_USER_HOME="${ANDROID_USER_HOME:-$HOME/.android}"
Build the APK, out of ClojureDart and Flutter   89    export HOME="$PWD/.home"
90    export ANDROID_HOME="$HOME/android-sdk"
91    export ANDROID_SDK_ROOT="$ANDROID_HOME"
92    mkdir -p "$HOME"
94    # Gradle writes into ANDROID_HOME, so it is a copy rather than the store
95    # path. Made once and kept: re-copying would throw away the build-tools
96    # and platform Gradle installed into it on the last run.
97    if [ ! -d "$ANDROID_HOME" ]; then
98        cp -r "$sdk" "$ANDROID_HOME"
99        chmod -R u+w "$ANDROID_HOME"
Seed the ClojureDart caches out of the flake   102    # The compile's three caches, same flake-output-and-copy shape as the SDK
103    # and for the same reason: tools.deps and pub both write into theirs, and
104    # the store is read-only. What this buys is the "Resolving dependencies…
105    # Downloading packages…" that used to open every run.
106    deps="$(nix build --no-link --print-out-paths \
107        "{{justfile_directory()}}#cljd-deps")"
109    # Neither of these follows HOME. Both are read off the JVM's user.home,
110    # which comes from /etc/passwd rather than the environment — so moving
111    # HOME below is not enough to move them, and left alone they would be the
112    # real ~/.m2 and ~/.gitlibs, shared with every other project on the box.
113    export GITLIBS="$HOME/gitlibs"
114    m2="$HOME/m2"
115    export PUB_CACHE="$HOME/.pub-cache"
117    # Seeded once each and then left alone, exactly as ANDROID_HOME is: after
118    # the first compile these hold whatever the working tree has asked for
119    # since, and re-copying would throw that away.
120    seed() {
121        [ -e "$2" ] && return 0
122        mkdir -p "$(dirname "$2")"
123        cp -r "$deps/$1" "$2"
124        chmod -R u+w "$2"
126    seed m2 "$m2"
127    seed gitlibs "$GITLIBS"
128    seed pub-cache "$PUB_CACHE"
129    seed clojuredart/cache "$PWD/.clojuredart/cache"
Build the APK from the flake, at the rev flake.lock pins   131    # Also the flake's. `nix shell nixpkgs#...` read the registry, which is a
132    # different and unlocked nixpkgs — the Flutter that built the APK could
133    # move under it without flake.lock changing a line.
134    flutter="nix develop {{justfile_directory()}}#flutter --command"
Build the APK, out of ClojureDart and Flutter   135
Seed the ClojureDart caches out of the flake   136    # cljd-deps ships the analyzer project unresolved — a fixed-output
137    # derivation may not name the store, and a resolved pub project is
138    # nothing but store paths. So it is resolved here instead, offline,
139    # against the cache that derivation did fetch. ClojureDart reaches for the
140    # network only when bin/analyzer.dart is missing, and after this it is not.
141    for helper in .clojuredart/cache/*/cljd_helper; do
142        [ -d "$helper" ] || continue
143        [ -e "$helper/.dart_tool/package_config.json" ] && continue
144        ( cd "$helper" && $flutter flutter pub get --offline )
145
147    $flutter clojure -Sdeps "{:mvn/local-repo \"$m2\"}" -M:cljd compile
Build the APK, out of ClojureDart and Flutter   148
149    # Rewritten every run: it carries absolute store paths, and the flutter
150    # one moves whenever nixpkgs does.
151    $flutter flutter config --android-sdk "$ANDROID_HOME" >/dev/null
153    apk=build/app/outputs/flutter-apk/app-debug.apk
154    adb="${ADB:-$ANDROID_HOME/platform-tools/adb}"
156    case "{{action}}" in
157        build)   $flutter flutter build apk --debug ;;
158        install) $flutter flutter build apk --debug && "$adb" install -r "$apk" ;;
159        run)     $flutter flutter build apk --debug && "$adb" install -r "$apk" \
160                     && "$adb" shell monkey -p uk.nandi.frq -c android.intent.category.LAUNCHER 1 ;;
161        log)     "$adb" logcat -s flutter ;;
162        *)       echo "usage: just apk [build|install|run|log]" >&2; exit 1 ;;
163
Inline the babashka scripts into the justfile   165# Two halves, and the split is the point. The frq source is the files on disk,
Split the tree three ways, and let the phone be Flutter's   166# uncommitted edits and all. Everything under it — jolt, glimmer, glimmer-cosmic
167# and the native objects — is the flake's, built rather than fetched.
Inline the babashka scripts into the justfile   168
169# Deliberately not `nix run .#frq`. That builds the flake's own copy of the
170# source, which is the tree as git has it — so an edit that has not been
171# committed, or committed on a branch the command was not pointed at, runs as
172# whatever was there before, silently. A run meant to answer "does my change
173# work" has to be the files on disk.
Split the tree three ways, and let the phone be Flutter's   175# libcosmic paints through wgpu, so this needs nixGL off NixOS for the same
176# reason the window always did: the real driver is the host's.
178# There is no jvui and no vidya here any more — both were experiments. The
179# window is libcosmic and the terminal is libjolttui, and those are the two.
Run this tree on a native half the builders made   181# The app: this tree's source on the flake's everything-else, in the dev shell.
A freeq client in jolt, as glimmer components on Vidya   182
Inline the babashka scripts into the justfile   183    #!/usr/bin/env bash
184    set -euo pipefail
185    cd "{{justfile_directory()}}"
186    if [ -z "${JOLT_NATIVE_LIB:-}" ]; then
187        exec {{nix}} develop . --max-jobs {{jobs}} --command just run "$@"
190    deps="{:deps {jolt-lang/glimmer {:local/root \"$GLIMMER_SRC\"}"
Split the tree three ways, and let the phone be Flutter's   191    deps="$deps nandi/glimmer-cosmic {:local/root \"$GLIMMER_COSMIC_SRC\"}}}"
Inline the babashka scripts into the justfile   192
193    export LD_LIBRARY_PATH="$JOLT_NATIVE_LIB:$FRQ_LIB_PATH${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}"
Paint the same screens into a terminal   194
Inline the babashka scripts into the justfile   195    runner=()
196    [ -e /run/current-system ] || runner=("$NIXGL")
Split the tree three ways, and let the phone be Flutter's   198    exec "${runner[@]}" jolt -Sdeps "$deps" -m frq.cosmic "$@"
Inline the babashka scripts into the justfile   199
Split the tree three ways, and let the phone be Flutter's   200# `run` with the other backend under it. Only libjolttui: `frq.app` names no
201# backend at all any more, and `frq.tui` requires glimmer-tui so the one
202# installed is the terminal.
Inline the babashka scripts into the justfile   203
204# No nixGL here, unlike `run`: a terminal wants nothing from the host's GL
205# driver, which is the reason this output exists on machines that have none.
Check what common/ may contain, on every push   207# What may appear in common/, checked — the half of the tree both backends
208# compile. Needs nothing built: it reads the source, so it is the one check
209# that runs anywhere, and CI runs exactly this.
210check-common:
211    #!/usr/bin/env bash
212    python3 tools/check-common.py common
Paint the same screens into a terminal   214# The same screens in a terminal. `just tui --headless` prints one screenshot.
215
Inline the babashka scripts into the justfile   216    #!/usr/bin/env bash
217    set -euo pipefail
218    cd "{{justfile_directory()}}"
219    if [ -z "${JOLT_NATIVE_LIB:-}" ]; then
220        exec {{nix}} develop . --max-jobs {{jobs}} --command just tui "$@"
223    deps="{:deps {jolt-lang/glimmer {:local/root \"$GLIMMER_SRC\"}"
224    deps="$deps nandi/glimmer-tui {:local/root \"$GLIMMER_TUI_SRC\"}}}"
226    export LD_LIBRARY_PATH="$JOLT_NATIVE_LIB${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}"
Build the desktop libraries rather than fetching a release of them   227
Inline the babashka scripts into the justfile   228    exec jolt -Sdeps "$deps" -m frq.tui "$@"
Give the terminal's classpath an nREPL, and hand recipes their arguments   230# The same classpath as `tui`, with an nREPL on it instead of a `-main`: a
231# session that can require `frq.tui` and then redefine a component while it is
232# on screen, which is a second and not the minute a rebuild costs.
234#     just nrepl                      then, from an editor or a client on 7888:
235#     (require (quote frq.tui))       both backends, terminal installed last
236#     (frq.tui/-main "--headless" "--demo")
237#     (glimmer.core/reload!)          re-mount after redefining a component
239# `just repl nrepl-server` is the window's half of this — the same thing minus
240# glimmer-tui. Port is nrepl-server's own positional: `just nrepl 7889`.
241nrepl *args:
242    #!/usr/bin/env bash
243    set -euo pipefail
244    cd "{{justfile_directory()}}"
245    if [ -z "${JOLT_NATIVE_LIB:-}" ]; then
246        exec {{nix}} develop . --max-jobs {{jobs}} --command just nrepl "$@"
249    deps="{:deps {jolt-lang/glimmer {:local/root \"$GLIMMER_SRC\"}"
250    deps="$deps nandi/glimmer-tui {:local/root \"$GLIMMER_TUI_SRC\"}}}"
252    export LD_LIBRARY_PATH="$JOLT_NATIVE_LIB:$FRQ_LIB_PATH${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}"
254    exec jolt -Sdeps "$deps" nrepl-server "$@"
Inline the babashka scripts into the justfile   256# `jolt` in the repo root does not work on its own: deps.edn carries
257# :jolt/native, so every invocation here loads libvidya and libjoltmoq before it
258# reads a line, and dies naming the library if the loader cannot find them. So
259# this is `run` without the app — and `run` is this with a window's worth of
260# extra care about the GL driver.
Build the desktop libraries rather than fetching a release of them   262# A jolt with the native libraries under it: a REPL, or `just repl nrepl-server`.
263repl *args:
Inline the babashka scripts into the justfile   264    #!/usr/bin/env bash
265    set -euo pipefail
266    cd "{{justfile_directory()}}"
267    if [ -z "${JOLT_NATIVE_LIB:-}" ]; then
268        exec {{nix}} develop . --max-jobs {{jobs}} --command just repl "$@"
271    deps="{:deps {jolt-lang/glimmer {:local/root \"$GLIMMER_SRC\"}"
Split the tree three ways, and let the phone be Flutter's   272    deps="$deps nandi/glimmer-cosmic {:local/root \"$GLIMMER_COSMIC_SRC\"}}}"
Inline the babashka scripts into the justfile   273
274    export LD_LIBRARY_PATH="$JOLT_NATIVE_LIB:$FRQ_LIB_PATH${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}"
276    exec jolt -Sdeps "$deps" "$@"
Bind libmoq_ffi from the object's own metadata, not from its header   277
278# Regenerate src/frq/moq/raw.clj from the libmoq_ffi we actually load.
280# UniFFI embeds its interface metadata in the object, so `uniffi-bindgen
281# --library` reads the truth out of the .so rather than a header shipped
Fetch libmoq_ffi again, and keep the codecs out of Rust   282# beside it. Those differ at one version number: the published Linux and
283# Android objects are built without moq-ffi's `audio` and `video` features
284# (206 functions, no codecs), while the shipped C header describes the Apple
285# build (230). The object is the only source this recipe will accept.
Bind libmoq_ffi from the object's own metadata, not from its header   286
287# The bindgen must match the uniffi that built the object — 0.32 for moq-ffi
288# 0.3.17 — and it is built once into the scratch dir rather than pinned into
289# the flake: nothing in a normal build needs it, and a regeneration is a thing
290# done when the moq-ffi pin moves, by hand, on purpose.
292#   just gen-moq                     # the loaded library
293#   just gen-moq path/to/libmoq_ffi.so
295# Regenerate the libmoq_ffi bindings from the object's own embedded metadata.
296gen-moq lib="":
297    #!/usr/bin/env bash
298    set -euo pipefail
299    lib="${1:-${JOLT_NATIVE_LIB:-}/libmoq_ffi.so}"
300    [ -f "$lib" ] || { echo "no libmoq_ffi.so at $lib — pass one: just gen-moq <path>" >&2; exit 1; }
301    work="${TMPDIR:-/tmp}/frq-gen-moq"
302    mkdir -p "$work/ubg/src"
303    cat > "$work/ubg/Cargo.toml" <<'TOML'
304    [package]
305    name = "ubg"
306    version = "0.1.0"
307    edition = "2021"
308    [[bin]]
309    name = "uniffi-bindgen"
310    path = "src/main.rs"
311    [dependencies]
312    uniffi = { version = "0.32", features = ["cli"] }
313
314    echo 'fn main() { uniffi::uniffi_bindgen_main() }' > "$work/ubg/src/main.rs"
315    ( cd "$work/ubg" && cargo build --release -q )
316    ( cd "$work/ubg" && ./target/release/uniffi-bindgen generate \
317        --library "$lib" --language python --out-dir "$work/py" --no-format )
318    python3 tools/py2jolt.py "$work"/py/*.py > "$work/body.clj"
319    { sed -n '1,/^  (:require \[jolt.ffi :as ffi\]))$/p' src/frq/moq/raw.clj; echo; cat "$work/body.clj"; } > "$work/raw.clj"
320    mv "$work/raw.clj" src/frq/moq/raw.clj
321    echo "wrote src/frq/moq/raw.clj ($(grep -c '^(ffi/defcfn' src/frq/moq/raw.clj) entry points)"
Paint the desktop with Flutter too, beside libcosmic   322
323# The other desktop GUI: the same screens, painted by Flutter instead of
324# libcosmic.
326# `just run` and this one are two frontends over one tree, and the split is
327# the same one the APK already draws. Everything under `common/` — the
328# screens, the cells, `frq.io` — is shared; what differs is who paints it and
329# who answers the host. So this recipe is `just apk` with the Android half
330# taken out: the same `clojure -M:cljd compile` over the same flutter/src,
331# then Flutter's Linux target rather than its Android one. CMake and Ninja
332# instead of Gradle, `flutter/linux/` as the runner, no SDK and no JDK.
334# Still impure, for one of the two reasons `apk` is: pub.dev resolution and
335# Flutter's own engine artifacts are network. What it does NOT need is the
336# writable-ANDROID_HOME dance — nothing here writes into the store — so there
337# is no `flutter/.home` on this path.
339# nixGL for the reason `run` needs it and `tui` does not: Flutter paints
340# through GL, and off NixOS the driver is the host's.
342#   just flutter-desktop            build the debug bundle
343#   just flutter-desktop run        build it and open the window
344flutter-desktop action="build":
345    #!/usr/bin/env bash
346    set -euo pipefail
347    cd "{{justfile_directory()}}"
348    if [ -z "${FRQ_FLUTTER_DESKTOP:-}" ]; then
349        exec {{nix}} develop .#flutter-desktop --max-jobs {{jobs}} \
350            --command just flutter-desktop "$@"
352    cd flutter
Seed the ClojureDart caches out of the flake   354    # The same three caches `just apk` seeds, in the same place and out of the
355    # same flake output — one compiler, one set of dependencies, and no reason
356    # for the two frontends to keep a copy each. `.home/` is `apk`'s directory
357    # by name and this is the only thing put there from here, which is the
358    # point: whichever recipe runs first pays for the copy and the other finds
359    # it warm.
361    # No `nix build` here, unlike `apk`: this recipe is already inside the
362    # shell that names FRQ_CLJD_DEPS by the time it gets this far, and `apk`
363    # needs the path before it enters anything.
365    # m2 and gitlibs are set here for the reason they are set there — the JVM
366    # reads user.home out of /etc/passwd, so neither follows HOME and left
367    # alone they are the real ~/.m2 and ~/.gitlibs.
368    export PUB_CACHE="$PWD/.home/.pub-cache"
369    export GITLIBS="$PWD/.home/gitlibs"
370    m2="$PWD/.home/m2"
372    seed() {
373        [ -e "$2" ] && return 0
374        mkdir -p "$(dirname "$2")"
375        cp -r "$FRQ_CLJD_DEPS/$1" "$2"
376        chmod -R u+w "$2"
378    seed m2 "$m2"
379    seed gitlibs "$GITLIBS"
380    seed pub-cache "$PUB_CACHE"
381    seed clojuredart/cache "$PWD/.clojuredart/cache"
383    # Resolved here rather than in cljd-deps, which was not allowed to name
384    # the store — see the same loop in `apk`.
385    for helper in .clojuredart/cache/*/cljd_helper; do
386        [ -d "$helper" ] || continue
387        [ -e "$helper/.dart_tool/package_config.json" ] && continue
388        ( cd "$helper" && flutter pub get --offline )
389
391    clojure -Sdeps "{:mvn/local-repo \"$m2\"}" -M:cljd compile
Paint the desktop with Flutter too, beside libcosmic   392    flutter build linux --debug
394    # x64/arm64 is Flutter's own name for the host arch, not uname's.
395    case "$(uname -m)" in
396        x86_64)  arch=x64 ;;
397        aarch64) arch=arm64 ;;
398        *)       echo "unknown arch $(uname -m)" >&2; exit 1 ;;
399
400    bundle="build/linux/$arch/debug/bundle"
402    case "{{action}}" in
403        build) echo "built $PWD/$bundle/frq" ;;
404        run)
405            runner=()
406            [ -e /run/current-system ] || runner=("$NIXGL")
407            exec "${runner[@]}" "$bundle/frq"
409        *) echo "usage: just flutter-desktop [build|run]" >&2; exit 1 ;;
410