rickub
nandi/frqpublic⑂ Fork 0
⑂ 3ee0b5b70ed2e58332972e6dcb111aeb87dd036d
Branches
claude/add-remote-repository-47d12e main View all branches → View all tags →
Commits
⬇ Clone ▾
git clone https://git.rickub.com/nandi/frq.git
git clone ssh://git@rickub.com/nandi/frq.git

Host key fingerprint (ed25519): SHA256:iycHnxEyq0Q7uyVpB7JlznP0G7JrTPXLYRcAU5CSLhc — verify it before your first connect.

justfile · 333 lines · 14.7 KBMakefile Blame HistoryRaw
Inline the babashka scripts into the justfile 76dcc6c nandi 11d ago1# 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.
5#
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 5c40e75 nandi 19d ago11
Write the build in babashka, and pin the babashka 34832a8 nandi 18d ago12set shell := ["bash", "-euo", "pipefail", "-c"]
A freeq client in jolt, as glimmer components on Vidya 4719d6f nandi 20d ago13
Give the terminal's classpath an nREPL, and hand recipes their arguments 664397d nandi 10d ago14# 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
19
Inline the babashka scripts into the justfile 76dcc6c nandi 11d ago20# 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"`
24
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")
31
A freeq client in jolt, as glimmer components on Vidya 4719d6f nandi 20d ago32default:
33 @just --list
34
Paint the phone in COSMIC's own theme, read from cosmic-config ba4e71b nandi 7d ago35# Re-read the COSMIC theme into the APK.
36#
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.
43#
44# Run it after changing the theme in COSMIC Settings, then `just apk`.
45theme:
46 #!/usr/bin/env bash
47 set -euo pipefail
48 cd "{{justfile_directory()}}"
49 python3 tools/cosmic2cljd.py flutter/src/frq/theme/cosmic.cljd
50
Build the APK, out of ClojureDart and Flutter e2b0e6b nandi 7d ago51# The APK: ClojureDart compiled to Dart, then Flutter's Gradle build.
52#
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.
61#
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.
65#
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"
74
Build the APK from the flake, at the rev flake.lock pins 77d4bec nandi 7d ago75 # 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 e2b0e6b nandi 7d ago80
Let adb keep its identity when the APK recipe moves HOME bc0e14f nandi 7d ago81 # 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}"
88
Build the APK, out of ClojureDart and Flutter e2b0e6b nandi 7d ago89 export HOME="$PWD/.home"
90 export ANDROID_HOME="$HOME/android-sdk"
91 export ANDROID_SDK_ROOT="$ANDROID_HOME"
92 mkdir -p "$HOME"
93
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"
100 fi
101
Build the APK from the flake, at the rev flake.lock pins 77d4bec nandi 7d ago102 # Also the flake's. `nix shell nixpkgs#...` read the registry, which is a
103 # different and unlocked nixpkgs — the Flutter that built the APK could
104 # move under it without flake.lock changing a line.
105 flutter="nix develop {{justfile_directory()}}#flutter --command"
Build the APK, out of ClojureDart and Flutter e2b0e6b nandi 7d ago106
107 $flutter clojure -M:cljd compile
108
109 # Rewritten every run: it carries absolute store paths, and the flutter
110 # one moves whenever nixpkgs does.
111 $flutter flutter config --android-sdk "$ANDROID_HOME" >/dev/null
112
113 apk=build/app/outputs/flutter-apk/app-debug.apk
114 adb="${ADB:-$ANDROID_HOME/platform-tools/adb}"
115
116 case "{{action}}" in
117 build) $flutter flutter build apk --debug ;;
118 install) $flutter flutter build apk --debug && "$adb" install -r "$apk" ;;
119 run) $flutter flutter build apk --debug && "$adb" install -r "$apk" \
120 && "$adb" shell monkey -p uk.nandi.frq -c android.intent.category.LAUNCHER 1 ;;
121 log) "$adb" logcat -s flutter ;;
122 *) echo "usage: just apk [build|install|run|log]" >&2; exit 1 ;;
123 esac
124
Inline the babashka scripts into the justfile 76dcc6c nandi 11d ago125# 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 7070931 nandi 7d ago126# uncommitted edits and all. Everything under it — jolt, glimmer, glimmer-cosmic
127# and the native objects — is the flake's, built rather than fetched.
Inline the babashka scripts into the justfile 76dcc6c nandi 11d ago128#
129# Deliberately not `nix run .#frq`. That builds the flake's own copy of the
130# source, which is the tree as git has it — so an edit that has not been
131# committed, or committed on a branch the command was not pointed at, runs as
132# whatever was there before, silently. A run meant to answer "does my change
133# work" has to be the files on disk.
134#
Split the tree three ways, and let the phone be Flutter's 7070931 nandi 7d ago135# libcosmic paints through wgpu, so this needs nixGL off NixOS for the same
136# reason the window always did: the real driver is the host's.
137#
138# There is no jvui and no vidya here any more — both were experiments. The
139# window is libcosmic and the terminal is libjolttui, and those are the two.
140#
Run this tree on a native half the builders made a32699e nandi 17d ago141# 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 4719d6f nandi 20d ago142run *args:
Inline the babashka scripts into the justfile 76dcc6c nandi 11d ago143 #!/usr/bin/env bash
144 set -euo pipefail
145 cd "{{justfile_directory()}}"
146 if [ -z "${JOLT_NATIVE_LIB:-}" ]; then
147 exec {{nix}} develop . --max-jobs {{jobs}} --command just run "$@"
148 fi
149
150 deps="{:deps {jolt-lang/glimmer {:local/root \"$GLIMMER_SRC\"}"
Split the tree three ways, and let the phone be Flutter's 7070931 nandi 7d ago151 deps="$deps nandi/glimmer-cosmic {:local/root \"$GLIMMER_COSMIC_SRC\"}}}"
Inline the babashka scripts into the justfile 76dcc6c nandi 11d ago152
153 export LD_LIBRARY_PATH="$JOLT_NATIVE_LIB:$FRQ_LIB_PATH${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}"
Paint the same screens into a terminal ab83b42 nandi 17d ago154
Inline the babashka scripts into the justfile 76dcc6c nandi 11d ago155 runner=()
156 [ -e /run/current-system ] || runner=("$NIXGL")
157
Split the tree three ways, and let the phone be Flutter's 7070931 nandi 7d ago158 exec "${runner[@]}" jolt -Sdeps "$deps" -m frq.cosmic "$@"
Inline the babashka scripts into the justfile 76dcc6c nandi 11d ago159
Split the tree three ways, and let the phone be Flutter's 7070931 nandi 7d ago160# `run` with the other backend under it. Only libjolttui: `frq.app` names no
161# backend at all any more, and `frq.tui` requires glimmer-tui so the one
162# installed is the terminal.
Inline the babashka scripts into the justfile 76dcc6c nandi 11d ago163#
164# No nixGL here, unlike `run`: a terminal wants nothing from the host's GL
165# driver, which is the reason this output exists on machines that have none.
166#
Check what common/ may contain, on every push 86c2e1b nandi 7d ago167# What may appear in common/, checked — the half of the tree both backends
168# compile. Needs nothing built: it reads the source, so it is the one check
169# that runs anywhere, and CI runs exactly this.
170check-common:
171 #!/usr/bin/env bash
172 python3 tools/check-common.py common
173
Paint the same screens into a terminal ab83b42 nandi 17d ago174# The same screens in a terminal. `just tui --headless` prints one screenshot.
175tui *args:
Inline the babashka scripts into the justfile 76dcc6c nandi 11d ago176 #!/usr/bin/env bash
177 set -euo pipefail
178 cd "{{justfile_directory()}}"
179 if [ -z "${JOLT_NATIVE_LIB:-}" ]; then
180 exec {{nix}} develop . --max-jobs {{jobs}} --command just tui "$@"
181 fi
182
183 deps="{:deps {jolt-lang/glimmer {:local/root \"$GLIMMER_SRC\"}"
184 deps="$deps nandi/glimmer-tui {:local/root \"$GLIMMER_TUI_SRC\"}}}"
185
186 export LD_LIBRARY_PATH="$JOLT_NATIVE_LIB${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}"
Build the desktop libraries rather than fetching a release of them 0b81161 nandi 15d ago187
Inline the babashka scripts into the justfile 76dcc6c nandi 11d ago188 exec jolt -Sdeps "$deps" -m frq.tui "$@"
189
Give the terminal's classpath an nREPL, and hand recipes their arguments 664397d nandi 10d ago190# The same classpath as `tui`, with an nREPL on it instead of a `-main`: a
191# session that can require `frq.tui` and then redefine a component while it is
192# on screen, which is a second and not the minute a rebuild costs.
193#
194# just nrepl then, from an editor or a client on 7888:
195# (require (quote frq.tui)) both backends, terminal installed last
196# (frq.tui/-main "--headless" "--demo")
197# (glimmer.core/reload!) re-mount after redefining a component
198#
199# `just repl nrepl-server` is the window's half of this — the same thing minus
200# glimmer-tui. Port is nrepl-server's own positional: `just nrepl 7889`.
201nrepl *args:
202 #!/usr/bin/env bash
203 set -euo pipefail
204 cd "{{justfile_directory()}}"
205 if [ -z "${JOLT_NATIVE_LIB:-}" ]; then
206 exec {{nix}} develop . --max-jobs {{jobs}} --command just nrepl "$@"
207 fi
208
209 deps="{:deps {jolt-lang/glimmer {:local/root \"$GLIMMER_SRC\"}"
210 deps="$deps nandi/glimmer-tui {:local/root \"$GLIMMER_TUI_SRC\"}}}"
211
212 export LD_LIBRARY_PATH="$JOLT_NATIVE_LIB:$FRQ_LIB_PATH${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}"
213
214 exec jolt -Sdeps "$deps" nrepl-server "$@"
215
Inline the babashka scripts into the justfile 76dcc6c nandi 11d ago216# `jolt` in the repo root does not work on its own: deps.edn carries
217# :jolt/native, so every invocation here loads libvidya and libjoltmoq before it
218# reads a line, and dies naming the library if the loader cannot find them. So
219# this is `run` without the app — and `run` is this with a window's worth of
220# extra care about the GL driver.
221#
Build the desktop libraries rather than fetching a release of them 0b81161 nandi 15d ago222# A jolt with the native libraries under it: a REPL, or `just repl nrepl-server`.
223repl *args:
Inline the babashka scripts into the justfile 76dcc6c nandi 11d ago224 #!/usr/bin/env bash
225 set -euo pipefail
226 cd "{{justfile_directory()}}"
227 if [ -z "${JOLT_NATIVE_LIB:-}" ]; then
228 exec {{nix}} develop . --max-jobs {{jobs}} --command just repl "$@"
229 fi
230
231 deps="{:deps {jolt-lang/glimmer {:local/root \"$GLIMMER_SRC\"}"
Split the tree three ways, and let the phone be Flutter's 7070931 nandi 7d ago232 deps="$deps nandi/glimmer-cosmic {:local/root \"$GLIMMER_COSMIC_SRC\"}}}"
Inline the babashka scripts into the justfile 76dcc6c nandi 11d ago233
234 export LD_LIBRARY_PATH="$JOLT_NATIVE_LIB:$FRQ_LIB_PATH${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}"
235
236 exec jolt -Sdeps "$deps" "$@"
Bind libmoq_ffi from the object's own metadata, not from its header 9f081a1 nandi 9d ago237
238# Regenerate src/frq/moq/raw.clj from the libmoq_ffi we actually load.
239#
240# UniFFI embeds its interface metadata in the object, so `uniffi-bindgen
241# --library` reads the truth out of the .so rather than a header shipped
Fetch libmoq_ffi again, and keep the codecs out of Rust f518938 nandi 9d ago242# beside it. Those differ at one version number: the published Linux and
243# Android objects are built without moq-ffi's `audio` and `video` features
244# (206 functions, no codecs), while the shipped C header describes the Apple
245# 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 9f081a1 nandi 9d ago246#
247# The bindgen must match the uniffi that built the object — 0.32 for moq-ffi
248# 0.3.17 — and it is built once into the scratch dir rather than pinned into
249# the flake: nothing in a normal build needs it, and a regeneration is a thing
250# done when the moq-ffi pin moves, by hand, on purpose.
251#
252# just gen-moq # the loaded library
253# just gen-moq path/to/libmoq_ffi.so
254#
255# Regenerate the libmoq_ffi bindings from the object's own embedded metadata.
256gen-moq lib="":
257 #!/usr/bin/env bash
258 set -euo pipefail
259 lib="${1:-${JOLT_NATIVE_LIB:-}/libmoq_ffi.so}"
260 [ -f "$lib" ] || { echo "no libmoq_ffi.so at $lib — pass one: just gen-moq <path>" >&2; exit 1; }
261 work="${TMPDIR:-/tmp}/frq-gen-moq"
262 mkdir -p "$work/ubg/src"
263 cat > "$work/ubg/Cargo.toml" <<'TOML'
264 [package]
265 name = "ubg"
266 version = "0.1.0"
267 edition = "2021"
268 [[bin]]
269 name = "uniffi-bindgen"
270 path = "src/main.rs"
271 [dependencies]
272 uniffi = { version = "0.32", features = ["cli"] }
273 TOML
274 echo 'fn main() { uniffi::uniffi_bindgen_main() }' > "$work/ubg/src/main.rs"
275 ( cd "$work/ubg" && cargo build --release -q )
276 ( cd "$work/ubg" && ./target/release/uniffi-bindgen generate \
277 --library "$lib" --language python --out-dir "$work/py" --no-format )
278 python3 tools/py2jolt.py "$work"/py/*.py > "$work/body.clj"
279 { sed -n '1,/^ (:require \[jolt.ffi :as ffi\]))$/p' src/frq/moq/raw.clj; echo; cat "$work/body.clj"; } > "$work/raw.clj"
280 mv "$work/raw.clj" src/frq/moq/raw.clj
281 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 fc5f63c nandi 7d ago282
283# The other desktop GUI: the same screens, painted by Flutter instead of
284# libcosmic.
285#
286# `just run` and this one are two frontends over one tree, and the split is
287# the same one the APK already draws. Everything under `common/` — the
288# screens, the cells, `frq.io` — is shared; what differs is who paints it and
289# who answers the host. So this recipe is `just apk` with the Android half
290# taken out: the same `clojure -M:cljd compile` over the same flutter/src,
291# then Flutter's Linux target rather than its Android one. CMake and Ninja
292# instead of Gradle, `flutter/linux/` as the runner, no SDK and no JDK.
293#
294# Still impure, for one of the two reasons `apk` is: pub.dev resolution and
295# Flutter's own engine artifacts are network. What it does NOT need is the
296# writable-ANDROID_HOME dance — nothing here writes into the store — so there
297# is no `flutter/.home` on this path.
298#
299# nixGL for the reason `run` needs it and `tui` does not: Flutter paints
300# through GL, and off NixOS the driver is the host's.
301#
302# just flutter-desktop build the debug bundle
303# just flutter-desktop run build it and open the window
304flutter-desktop action="build":
305 #!/usr/bin/env bash
306 set -euo pipefail
307 cd "{{justfile_directory()}}"
308 if [ -z "${FRQ_FLUTTER_DESKTOP:-}" ]; then
309 exec {{nix}} develop .#flutter-desktop --max-jobs {{jobs}} \
310 --command just flutter-desktop "$@"
311 fi
312 cd flutter
313
314 clojure -M:cljd compile
315 flutter build linux --debug
316
317 # x64/arm64 is Flutter's own name for the host arch, not uname's.
318 case "$(uname -m)" in
319 x86_64) arch=x64 ;;
320 aarch64) arch=arm64 ;;
321 *) echo "unknown arch $(uname -m)" >&2; exit 1 ;;
322 esac
323 bundle="build/linux/$arch/debug/bundle"
324
325 case "{{action}}" in
326 build) echo "built $PWD/$bundle/frq" ;;
327 run)
328 runner=()
329 [ -e /run/current-system ] || runner=("$NIXGL")
330 exec "${runner[@]}" "$bundle/frq"
331 ;;
332 *) echo "usage: just flutter-desktop [build|run]" >&2; exit 1 ;;
333 esac