Frank
d9f3d1be1e
open-notebook has no user accounts upstream (PasswordAuthMiddleware = one shared password; SurrealDB has no user/account/owner table — verified in the running image). One shared password = one shared workspace; the guard chain gates access but cannot partition data, and Authentik identity is never consumed. Multi-user is approved-but-unbuilt upstream (#712, post-v2); OIDC declined (#607). So move the homepage card from the user grid to the admin tier and add the single-tenant boundary to the vault page. Fix the card's stale 'frank-zealot' -> frank-archon. Update the seam's incidental category pin to the new intentional value. Password rotated on the host (not repo).
317 lines
16 KiB
Bash
Executable File
317 lines
16 KiB
Bash
Executable File
#!/usr/bin/env bats
|
|
# Seam: open-notebook, the fleet's podcast generator on Dankclaw — the Quadlet
|
|
# pair (app + SurrealDB), the private network between them, the env file both
|
|
# units read, the deployer routing, and the homepage card. Runbook:
|
|
# serverAppConfigs-docs/Dankclaw/Open Notebook.md.
|
|
#
|
|
# Structure only: what the files declare and what the deployer can see. Nothing
|
|
# here starts a container, opens a socket, or touches the network — the app's
|
|
# behaviour inside the image is upstream's contract, cited in the docs page.
|
|
|
|
load helpers
|
|
|
|
UNIT_DIR="dankclaw/open-notebook/quadlet"
|
|
APP="$REPO_ROOT/$UNIT_DIR/open-notebook.container"
|
|
DB="$REPO_ROOT/$UNIT_DIR/open-notebook-surrealdb.container"
|
|
NET="$REPO_ROOT/$UNIT_DIR/open-notebook.network"
|
|
ENVF="$REPO_ROOT/scripts/open-notebook.env"
|
|
PLANNER="$REPO_ROOT/scripts/deploy-plan.py"
|
|
REMOTE="$REPO_ROOT/scripts/deploy-remote.sh"
|
|
CADDY="$REPO_ROOT/dankclaw/Caddyfile"
|
|
# The host-side path the units read (they run on Dankclaw, not here), spelled
|
|
# out once so the ordering test below compares against a real constant.
|
|
HOST_TUNABLES="EnvironmentFile=/home/dank/serverAppConfigs/scripts/open-notebook.env"
|
|
HOST_SECRETS="EnvironmentFile=/home/dank/Containers/open-notebook/env"
|
|
|
|
# The pins are part of the contract, so a silent re-resolution to a different
|
|
# build has to fail here rather than at the next deploy. Both digests were
|
|
# resolved from the registry on 2026-10-18; the SurrealDB one is 2.7.0.
|
|
APP_PIN="sha256:54b2025a4a4853c188f74b9b8246eca8c5480e5dd1babfa92db1038ff2f30212"
|
|
DB_PIN="sha256:e5d7387e3727bbe2f7cd6d869e48cd34777272258572ead37c9656b25f745723"
|
|
|
|
@test "open-notebook ships a network, a database unit and an app unit" {
|
|
[ -f "$NET" ]
|
|
[ -f "$DB" ]
|
|
[ -f "$APP" ]
|
|
}
|
|
|
|
@test "both units are boot-persistent and self-healing" {
|
|
for unit in "$APP" "$DB"; do
|
|
grep -qE '^Restart=(always|on-failure)$' "$unit" || {
|
|
echo "$(basename "$unit") has no Restart="; false; }
|
|
# "short RestartSec": a podcast service has no reason to wait minutes.
|
|
restart_sec="$(sed -n 's/^RestartSec=\([0-9]*\)s\?$/\1/p' "$unit")"
|
|
[ -n "$restart_sec" ] || {
|
|
echo "$(basename "$unit") has no RestartSec"; false; }
|
|
[ "$restart_sec" -le 30 ] || {
|
|
echo "$(basename "$unit") RestartSec=${restart_sec}s is not short"; false; }
|
|
grep -qE '^\[Install\]' "$unit"
|
|
grep -qE '^WantedBy=default\.target$' "$unit"
|
|
done
|
|
}
|
|
|
|
@test "both images are digest-pinned and never re-resolved at start" {
|
|
grep -qxF "Image=docker.io/lfnovo/open_notebook:v1-latest@$APP_PIN" "$APP"
|
|
grep -qxF "Image=docker.io/surrealdb/surrealdb:v2@$DB_PIN" "$DB"
|
|
grep -qxF 'Pull=never' "$APP"
|
|
grep -qxF 'Pull=never' "$DB"
|
|
# Pull=never is only honest if the fetch it depends on is written down where
|
|
# the operator reads the unit, and wired into the deployer's precondition.
|
|
grep -qF 'podman pull' "$APP"
|
|
grep -qF 'podman pull' "$DB"
|
|
grep -qF 'ensure_pinned_image' "$REMOTE"
|
|
}
|
|
|
|
@test "the database port is never published" {
|
|
# 8000 belongs to the private bridge. A published 8000 would put the RPC,
|
|
# root credentials included, on every interface of the host.
|
|
! grep -qE '^PublishPort=' "$DB"
|
|
! grep -qE '^PublishPort=.*:8000(:|$)' "$APP"
|
|
}
|
|
|
|
# onb_vhost — the host Caddy routes to the UI's 8502. Derived, never restated:
|
|
# the API origin and the homepage link have to agree with whatever the Caddyfile
|
|
# actually routes, so renaming the vhost there moves this seam instead of
|
|
# leaving it blessing a stale name.
|
|
onb_vhost() {
|
|
awk '
|
|
/^[[:space:]]*@[A-Za-z0-9_-]+[[:space:]]+host[[:space:]]/ { h = $3 }
|
|
/^[[:space:]]*reverse_proxy[[:space:]]+192\.168\.0\.143:8502$/ { if (h) { print h; exit } }
|
|
' "$CADDY"
|
|
}
|
|
|
|
@test "the app publishes the UI for the guard chain and keeps the API off the LAN" {
|
|
# 8502 is the single upstream the post-auth listener dials, so it is the
|
|
# only port that has to answer on a LAN interface.
|
|
grep -qxF 'PublishPort=0.0.0.0:8502:8502' "$APP"
|
|
[ "$(grep -cE '^PublishPort=0\.0\.0\.0:' "$APP")" = "1" ] || {
|
|
echo "the UI port is not the only wildcard publish: $(grep -E '^PublishPort=' "$APP")"; false; }
|
|
# seerr already binds 127.0.0.1:5055 on this host, so the API cannot leave
|
|
# the container on the port upstream uses; and it needs no outward face at
|
|
# all, because the image's Next.js layer rewrites /api/* to it. Loopback is
|
|
# where the deployer's health gate dials it.
|
|
grep -qxF 'PublishPort=127.0.0.1:5056:5055' "$APP"
|
|
# One origin serves UI and API, so API_URL names the guarded vhost rather
|
|
# than a host:port. Left to itself the frontend auto-detects `<host>:5055`;
|
|
# a LAN-origin API_URL takes the browser around the guard chain, where its
|
|
# authenticated session does not ride.
|
|
api_url="$(sed -n 's/^API_URL=//p' "$ENVF")"
|
|
vhost="$(onb_vhost)"
|
|
[ -n "$vhost" ] || { echo "no Caddy route to the UI port was found"; false; }
|
|
[ "$api_url" = "https://${vhost}" ] || {
|
|
echo "API_URL ($api_url) is not the guarded origin https://${vhost}"; false; }
|
|
# Same-origin traffic needs no CORS at all, but while CORS_ORIGINS is unset
|
|
# the app warns and defaults to `*` in front of every episode's audio.
|
|
cors="$(sed -n 's/^CORS_ORIGINS=//p' "$ENVF")"
|
|
[ "$cors" = "https://${vhost}" ] || {
|
|
echo "CORS_ORIGINS ($cors) is not the single guarded origin https://${vhost}"; false; }
|
|
}
|
|
|
|
@test "the vhost is guarded and the app login stays behind it" {
|
|
vhost="$(onb_vhost)"
|
|
# The vhost itself proxies the WHOLE request to Anubis — an unmatched path
|
|
# must never reach the app unchallenged.
|
|
awk -v v="$vhost" '
|
|
$0 == v " {" { inblock = 1; seen = 0 }
|
|
inblock && /reverse_proxy anubis:8923/ { seen = 1 }
|
|
inblock && /^}/ { exit }
|
|
END { exit !seen }
|
|
' "$CADDY" || { echo "$vhost does not proxy everything through Anubis"; false; }
|
|
# And the app's own password is still required, so a route that ever bypasses
|
|
# the chain does not hand out the episode library: the deployer refuses to
|
|
# start the units while the secret file leaves it blank.
|
|
grep -qF 'OPEN_NOTEBOOK_PASSWORD' "$ENVF"
|
|
}
|
|
|
|
@test "the pair shares one network and the app finds the database by container name" {
|
|
grep -qxF 'Network=open-notebook.network' "$DB"
|
|
grep -qxF 'Network=open-notebook.network' "$APP"
|
|
[ "$(grep -cE '^Network=' "$DB")" = "1" ]
|
|
# dankclaw_default is the app's second network and must come FIRST: the
|
|
# generated --network flags keep file order, so the default route (and the
|
|
# gateway name proven on that network) rides it.
|
|
[ "$(grep -cE '^Network=' "$APP")" = "2" ]
|
|
[ "$(grep -E '^Network=' "$APP" | head -1)" = "Network=dankclaw_default" ]
|
|
db_name="$(sed -n 's/^ContainerName=//p' "$DB")"
|
|
[ "$db_name" = "open-notebook-surrealdb" ]
|
|
grep -qxF "SURREAL_URL=ws://${db_name}:8000/rpc" "$ENVF"
|
|
}
|
|
|
|
@test "each unit reads the repo tunables first and the host secrets second" {
|
|
# podman applies --env-file in argument order and the LAST file wins, so
|
|
# swapping these two lines would blank every credential the app needs.
|
|
for unit in "$APP" "$DB"; do
|
|
files="$(grep -E '^EnvironmentFile=' "$unit")"
|
|
[ "$(echo "$files" | wc -l)" = "2" ] || {
|
|
echo "$(basename "$unit") must read exactly two env files"; false; }
|
|
[ "$(echo "$files" | head -1)" = "$HOST_TUNABLES" ] || {
|
|
echo "$(basename "$unit") must read the tracked env file first"; false; }
|
|
[ "$(echo "$files" | tail -1)" = "$HOST_SECRETS" ] || {
|
|
echo "$(basename "$unit") must read the host secret file last"; false; }
|
|
done
|
|
}
|
|
|
|
@test "the interim episode destination is mounted exactly once" {
|
|
# The bind that answers Gitea issue #7 provisionally: two of them is a
|
|
# shadowing bug, none is episode audio locked inside a named volume.
|
|
[ "$(grep -cE '^Volume=/home/dank/media/podcasts:/app/data/podcasts$' "$APP")" = "1" ]
|
|
# The app's own state stays in a named volume; the database gets its own.
|
|
grep -qE '^Volume=open-notebook-data:/app/data$' "$APP"
|
|
grep -qE '^Volume=open-notebook-db:/mydata$' "$DB"
|
|
# The deployer creates the host directory as the deploy user.
|
|
grep -qF 'mkdir -p /home/dank/media/podcasts' "$REMOTE"
|
|
}
|
|
|
|
@test "the env file declares the CPU-shutdown guard and both timeouts" {
|
|
# Upstream defaults are 5 and 5; frank-tts spawns ~8 GiB / 8 threads per
|
|
# request on a box that also serves two LLM endpoints.
|
|
grep -qxF 'TTS_BATCH_SIZE=1' "$ENVF"
|
|
grep -qxF 'OPEN_NOTEBOOK_WORKER_MAX_TASKS=1' "$ENVF"
|
|
# Per dialogue line, and strictly beyond frank-tts's own per-request
|
|
# ceiling: nested budgets go inside-out (the rule scripts/frank-tts.env
|
|
# states for LLAMA_TIMEOUT), so a shim give-up surfaces as frank-tts's
|
|
# error instead of the worker's own timeout. The seam reads the ceiling
|
|
# rather than restating it, so re-measuring frank-tts cannot leave this
|
|
# file silently behind.
|
|
tts="$(sed -n 's/^ESPERANTO_TTS_TIMEOUT=//p' "$ENVF")"
|
|
shim="$(sed -n 's/^SHIM_TIMEOUT=//p' "$REPO_ROOT/scripts/frank-tts.env")"
|
|
[ -n "$tts" ] || { echo "no ESPERANTO_TTS_TIMEOUT in the env file"; false; }
|
|
[ -n "$shim" ] || { echo "no SHIM_TIMEOUT in scripts/frank-tts.env"; false; }
|
|
[ "$tts" -gt "$shim" ] || {
|
|
echo "ESPERANTO_TTS_TIMEOUT=$tts is not beyond frank-tts SHIM_TIMEOUT=$shim"; false; }
|
|
# Upstream: keep the scriptwriting call under the web UI's ~600 s patience,
|
|
# or the failure arrives as a UI timeout with no name on it.
|
|
llm="$(sed -n 's/^ESPERANTO_LLM_TIMEOUT=//p' "$ENVF")"
|
|
[[ "$llm" =~ ^[0-9]+$ ]] && [ "$llm" -lt 600 ] || {
|
|
echo "ESPERANTO_LLM_TIMEOUT=$llm is not a number under 600"; false; }
|
|
}
|
|
|
|
@test "secrets stay declared-but-empty in the tracked env file" {
|
|
# scripts/*.env is un-ignored for "paths and numbers, never credentials":
|
|
# the values belong to the host file the deployer seeds.
|
|
for key in OPEN_NOTEBOOK_ENCRYPTION_KEY OPEN_NOTEBOOK_PASSWORD SURREAL_PASSWORD SURREAL_PASS; do
|
|
grep -qxF "${key}=" "$ENVF" || {
|
|
echo "$key is not declared, empty, in $ENVF"; false; }
|
|
done
|
|
has_no_leaked_secret "$ENVF"
|
|
has_no_leaked_sudo_pw "$ENVF"
|
|
# And the deployer treats blank as fatal, because blank means "auth off",
|
|
# not "unconfigured".
|
|
grep -qF 'seed_open_notebook_env' "$REMOTE"
|
|
}
|
|
|
|
@test "the database password never rides in a command line" {
|
|
# `surreal start` reads SURREAL_USER / SURREAL_PASS from the environment;
|
|
# --pass would put it in /proc/<pid>/cmdline for any ps on the host.
|
|
grep -qE '^Exec=start' "$DB"
|
|
! grep -qE '^Exec=.*--(pass|user)' "$DB"
|
|
}
|
|
|
|
@test "the database probe can run in a shell-less image and the API probe names the health route" {
|
|
# podman wraps a BARE HealthCmd as CMD-SHELL (measured on this host's podman
|
|
# 5.7), and the SurrealDB image is distroless — no /bin/sh — so a bare
|
|
# command there is a probe that can only ever fail: the database answers
|
|
# perfectly while the health status stays `unhealthy` and the deploy gate
|
|
# times out. Only the exec-form JSON array runs in that image.
|
|
db_cmd="$(sed -n 's/^HealthCmd=//p' "$DB")"
|
|
[ "$db_cmd" = '["/surreal","is-ready"]' ] || {
|
|
echo "database probe is not exec-form JSON: $db_cmd"; false; }
|
|
# The API image ships curl and a shell, so a bare command is fine there; it
|
|
# must name the route that is exempt from the password middleware, on the
|
|
# CONTAINER port (the probe runs inside the netns).
|
|
grep -qxF 'HealthCmd=curl -fsS http://127.0.0.1:5055/health' "$APP"
|
|
}
|
|
|
|
@test "the deployer gates open-notebook on the health path that actually answers" {
|
|
grep -qF 'open-notebook) deploy_open_notebook ;;' "$REMOTE"
|
|
gate="$(grep -E '^[[:space:]]*wait_for_health open-notebook ' "$REMOTE" | head -1)"
|
|
[ -n "$gate" ] || { echo "deploy_open_notebook has no wait_for_health gate"; false; }
|
|
# /health is the route upstream serves; the suite must not bless a guess.
|
|
printf '%s' "$gate" | grep -qE '/health( |$)'
|
|
# The gate is a host-loopback URL (the publish is wildcard, so 127.0.0.1
|
|
# answers) on the PUBLISHED port, never the container's 5055.
|
|
printf '%s' "$gate" | grep -qE 'http://127\.0\.0\.1:[0-9]+/health'
|
|
! printf '%s' "$gate" | grep -qE ':5055/'
|
|
# The database is gated by its container health before the app is started.
|
|
grep -qE 'wait_container_healthy open-notebook-surrealdb' "$REMOTE"
|
|
}
|
|
|
|
@test "the deployer refuses to start the pair on blank secrets and never rewrites a seeded file" {
|
|
# Read the seed function itself: the refusal, and the no-clobber rule that
|
|
# protects a password an operator set by hand.
|
|
seed="$(sed -n '/^seed_open_notebook_env()/,/^}/p' "$REMOTE")"
|
|
[ -n "$seed" ]
|
|
printf '%s' "$seed" | grep -qF 'return 1'
|
|
printf '%s' "$seed" | grep -qF 'if [[ ! -e "$dest" ]]'
|
|
printf '%s' "$seed" | grep -qF 'chmod 600'
|
|
# One value, two spellings: the app reads SURREAL_PASSWORD, the CLI SURREAL_PASS.
|
|
printf '%s' "$seed" | grep -qF 'SURREAL_PASS='
|
|
}
|
|
|
|
@test "the planner maps every open-notebook path to the open-notebook service" {
|
|
run python3 "$PLANNER" --target dankclaw --paths \
|
|
dankclaw/open-notebook/quadlet/open-notebook.container \
|
|
dankclaw/open-notebook/quadlet/open-notebook-surrealdb.container \
|
|
dankclaw/open-notebook/quadlet/open-notebook.network \
|
|
scripts/open-notebook.env
|
|
[ "$status" -eq 0 ]
|
|
[ "$output" = "open-notebook" ]
|
|
# One deployable owns the pair: the unit files never plan separately.
|
|
run python3 "$PLANNER" --target dankclaw --paths \
|
|
dankclaw/open-notebook/quadlet/open-notebook-surrealdb.container
|
|
[ "$output" = "open-notebook" ]
|
|
# And the service belongs to dankclaw only.
|
|
run python3 "$PLANNER" --target dankserver --paths scripts/open-notebook.env
|
|
[ "$status" -eq 0 ]
|
|
[ -z "$output" ]
|
|
}
|
|
|
|
@test "changed-path routing selects this seam" {
|
|
run "$REPO_ROOT/scripts/test-changed.sh" --list --paths \
|
|
dankclaw/open-notebook/quadlet/open-notebook.container
|
|
[ "$status" -eq 0 ]
|
|
printf '%s\n' "$output" | grep -qx "tests/open_notebook.bats"
|
|
|
|
run "$REPO_ROOT/scripts/test-changed.sh" --list --paths scripts/open-notebook.env
|
|
[ "$status" -eq 0 ]
|
|
printf '%s\n' "$output" | grep -qx "tests/open_notebook.bats"
|
|
}
|
|
|
|
@test "both deployer entry points know the service" {
|
|
grep -qF 'dankclaw:open-notebook|' "$REMOTE"
|
|
grep -qF 'dankclaw:open-notebook|' "$REPO_ROOT/scripts/deploy.sh"
|
|
}
|
|
|
|
@test "the homepage card links the guarded vhost now that the service is live" {
|
|
python3 - "$REPO_ROOT/shared/homepage/services.json" "$(onb_vhost)" <<'PY'
|
|
import json, os, sys
|
|
data = json.load(open(sys.argv[1]))
|
|
vhost = sys.argv[2]
|
|
cards = [s for s in data if s["name"] == "open-notebook"]
|
|
assert len(cards) == 1, f"expected exactly one open-notebook card, got {len(cards)}"
|
|
card = cards[0]
|
|
# category moved to "admin": single shared password, no per-user accounts, so it
|
|
# is positioned as an admin-side tool, not a user-facing app (see the vault page).
|
|
assert card["category"] == "admin" and card["section"] == "AI", card
|
|
assert card["probe"] == "127.0.0.1:8502", card["probe"]
|
|
assert card["method"] == "http"
|
|
# Deployed and guarded: the card is live and its link is the vhost, so the
|
|
# button on the page reaches the app through the guard chain. Card links carry
|
|
# the fleet's http:// form everywhere; Caddy answers the redirect to HTTPS.
|
|
assert not card.get("wip"), f"card should be live, got wip={card.get('wip')!r}"
|
|
assert card.get("showLink") is True, card.get("showLink")
|
|
assert card.get("url") == f"http://{vhost}", card.get("url")
|
|
art = card["art"].lstrip("/")
|
|
assert os.path.exists(os.path.join(os.path.dirname(sys.argv[1]), art)), art
|
|
PY
|
|
}
|
|
|
|
@test "the runbook page exists and names the interim mount's owning issue" {
|
|
page="$REPO_ROOT/serverAppConfigs-docs/Dankclaw/Open Notebook.md"
|
|
[ -f "$page" ]
|
|
grep -qF 'issue #7' "$page"
|
|
grep -qF 'human-only' "$page"
|
|
# The interim decision is one mount line; the page has to say how to undo it.
|
|
grep -qF '## Rollback' "$page"
|
|
}
|