From 8c54977177ad99003c75fa6dbcca13f1cbd1074b Mon Sep 17 00:00:00 2001 From: John Coffey Date: Wed, 14 Oct 2026 13:00:01 -0700 Subject: [PATCH] interface: join a server from the screens, as inbuxa join does Skipping the mail server on the components screen used to be refused with a pointer to inbuxa join. It now is a join: a Server screen asks for the server's address (the mail server's name from Names, over HTTPS, unless another is typed) and an API key made in its console, typed but never shown, and whether to replace front ends it already lists. Leaving it asks the server what join asks before anything else, in the background, with Esc to stop waiting; a refusal stays on the screen with the server's reason. The plan shows inbuxa join with --key -, the install is apply.Join and apply.JoinVerify, and the summary says where it joined and that the key wasn't kept. The key is dropped once the join has it. A machine that runs the server itself is told on the components screen, as apply.Join would refuse it later, and a plan the server wasn't asked about can't start. Tests: the flow, a refused key, stopping a slow check, the re-check, the command, the server's own machine. e2e interface-join.sh 36/36 against a real server on a Debian 13 lab VM; interface.sh still 22/22. --- cmd/inbuxa/main.go | 12 ++ e2e/cases/interface-join.sh | 225 ++++++++++++++++++++ internal/tui/install.go | 96 +++++++-- internal/tui/install_test.go | 25 ++- internal/tui/join.go | 394 +++++++++++++++++++++++++++++++++++ internal/tui/join_test.go | 236 +++++++++++++++++++++ 6 files changed, 971 insertions(+), 17 deletions(-) create mode 100755 e2e/cases/interface-join.sh create mode 100644 internal/tui/join.go create mode 100644 internal/tui/join_test.go diff --git a/cmd/inbuxa/main.go b/cmd/inbuxa/main.go index 1389913..3e0d7ec 100644 --- a/cmd/inbuxa/main.go +++ b/cmd/inbuxa/main.go @@ -418,6 +418,18 @@ func (installer) Run(ctx context.Context, p plan.Plan, f host.Facts, log apply.L return apply.Run(ctx, p, f, log) } +func (installer) JoinCheck(ctx context.Context, o plan.Options, key string) error { + return apply.JoinCheck(ctx, o, key) +} + +func (installer) Join(ctx context.Context, p plan.Plan, f host.Facts, key string, log apply.Log) (*apply.Result, error) { + return apply.Join(ctx, p, f, key, log) +} + +func (installer) JoinVerify(ctx context.Context, res *apply.Result, console, webmail plan.Shape, log apply.Log) []string { + return apply.JoinVerify(ctx, res, console, webmail, log) +} + func (installer) Verify(ctx context.Context, res *apply.Result, o plan.Options, log apply.Log) []string { return apply.Verify(ctx, res, o, true, log) } diff --git a/e2e/cases/interface-join.sh b/e2e/cases/interface-join.sh new file mode 100755 index 0000000..f7bd0e4 --- /dev/null +++ b/e2e/cases/interface-join.sh @@ -0,0 +1,225 @@ +#!/bin/bash +# SPDX-FileCopyrightText: 2026 Coffey Labs LLC +# SPDX-License-Identifier: AGPL-3.0-or-later +# +# Joining from the interface: `inbuxa` with no arguments in a terminal (a +# pseudo-terminal here), the mail server skipped, and the Server screen +# filled in with a server and an API key, as a person would. Two machines are +# played by one, as in join.sh, and the result is held to what join.sh checks +# of the command: the server lists the front ends, the console may call it, +# and a person signs in to the joined webmail. +# +# What only the interface can get wrong is checked too: skipping the server +# leads to the Server screen rather than a refusal, the key is never on +# screen, the server is asked before the plan, the plan shows `inbuxa join` +# with `--key -`, nothing happens before the "y", and the summary says where +# it joined and that the key wasn't kept. +# +# Run from the host with: e2e/vm/run.sh e2e/cases/interface-join.sh +set -uo pipefail +pass=0; fail=0 +ok() { echo " ok $*"; pass=$((pass+1)); } +bad() { echo " FAIL $*"; fail=$((fail+1)); } + +SERVER_DIR=/var/lib/inbuxa +DIR=/var/lib/inbuxa-joined +SERVER=http://127.0.0.1:8081 +if [ -x /tmp/inbuxa-server-test ]; then + export INBUXA_SERVER_BINARY=/tmp/inbuxa-server-test + # A debug build needs a deeper stack than a release one, as the server's + # own test suites do (RUST_MIN_STACK in its CI). A drop-in made before the + # unit exists applies when it does. + mkdir -p /etc/systemd/system/inbuxa-server.service.d + printf '[Service]\nEnvironment=RUST_MIN_STACK=16777216\n' > /etc/systemd/system/inbuxa-server.service.d/test-build.conf +fi + +rt() { command -v docker >/dev/null 2>&1 && echo docker || echo podman; } +compose() { + if [ "$(rt)" = docker ]; then + docker compose -f "$DIR/compose.yaml" "$@" + else + DOCKER_HOST=unix:///run/podman/podman.sock \ + /usr/local/lib/docker/cli-plugins/docker-compose -f "$DIR/compose.yaml" "$@" + fi +} +jmap() { # jmap TOKEN-or-user:pass CAPABILITY JSON-CALLS + local auth + case "$1" in *:*) auth=(-u "$1") ;; *) auth=(-H "Authorization: Bearer $1") ;; esac + curl -s "${auth[@]}" -H 'Content-Type: application/json' \ + -d "{\"using\":[\"urn:ietf:params:jmap:core\",\"$2\"],\"methodCalls\":$3}" "$SERVER/jmap/" +} +wait_server() { for _ in $(seq 1 60); do [ "$(curl -s -o /dev/null -w '%{http_code}' $SERVER/.well-known/jmap)" != 000 ] && return 0; sleep 2; done; return 1; } + +echo "==> the server, on its own" +OUT="$(/tmp/inbuxa install --local --domain example.test --server host --console skip --webmail skip --yes 2>&1)"; rc=$? +if [ $rc -eq 0 ]; then ok "installed the server alone"; else + bad "server install exit $rc"; echo "$OUT" | tail -15 | sed 's/^/ /' + journalctl -u inbuxa-server -n 30 --no-pager -o cat | sed 's/^/ | /' + echo; echo "==> $pass passed, $fail failed (stopped: no server to join)"; exit 1 +fi +[ -n "${INBUXA_SERVER_BINARY:-}" ] && echo " (server: $(/usr/local/bin/inbuxa-server --version 2>&1 | head -1), from the build given)" + +echo +echo "==> an API key, as an administrator makes one in the console" +# The console is a browser; here the server takes the administrator's +# password for one restart, the way the installer's own setup does. +AUSER=$(awk '/^administrator/ {print $2}' "$SERVER_DIR/credentials.txt") +APASS=$(awk '/^administrator/{getline; print $2}' "$SERVER_DIR/credentials.txt") +echo "INBUXA_HTTP_BASIC_AUTH=all" >> "$SERVER_DIR/server.env" +systemctl restart inbuxa-server; wait_server +EXPIRES=$(date -u -d '+1 hour' +%Y-%m-%dT%H:%M:%SZ) +ANSWER=$(jmap "$AUSER:$APASS" urn:inbuxa:jmap:registry "[[\"x:ApiKey/set\",{\"create\":{\"k\":{\"description\":\"join test\",\"expiresAt\":\"$EXPIRES\",\"permissions\":{\"@type\":\"Inherit\"}}}},\"0\"]]") +KEY=$(sed -n 's/.*"secret":"\([^"]*\)".*/\1/p' <<<"$ANSWER") +sed -i '/^INBUXA_HTTP_BASIC_AUTH=/d' "$SERVER_DIR/server.env" +systemctl restart inbuxa-server; wait_server +[ -n "$KEY" ] && ok "an API key for the administrator" || { bad "no API key"; head -c 300 <<<"$ANSWER" | sed 's/^/ /'; } + +ACCOUNT=$(curl -s -H "Authorization: Bearer $KEY" $SERVER/jmap/session | grep -o '"primaryAccounts":{[^}]*}' | sed -n 's/^"primaryAccounts":{"[^"]*":"\([^"]*\)".*/\1/p') +[ -n "$ACCOUNT" ] || bad "no account id in the key's session" + +# From here this is "another machine": no install recorded on it. +mv /etc/inbuxa/install.json /etc/inbuxa/install.server.json + +# From here this is "another machine": no install recorded on it. + +command -v python3 >/dev/null || { bad "no python3 on this machine to drive a terminal with"; echo "==> $pass passed, $fail failed"; exit 1; } +cat > /tmp/drive-join.py <<'PY' +import os, pty, re, select, struct, sys, time, fcntl, termios +KEY = os.environ.pop("KEY") +pid, fd = pty.fork() +if pid == 0: + os.environ["TERM"] = "xterm-256color" + os.execv("/tmp/inbuxa", ["/tmp/inbuxa"]) +fcntl.ioctl(fd, termios.TIOCSWINSZ, struct.pack("HHHH", 32, 110, 0, 0)) +seen = "" +def plain(s): + return re.sub(r"\x1b\[[0-9;?]*[A-Za-z]", "", s) +def pump(t): + global seen + end = time.time() + t + while time.time() < end: + r, _, _ = select.select([fd], [], [], 0.1) + if r: + try: + seen += os.read(fd, 65536).decode("utf-8", "replace") + except OSError: + return False + return True +def frame(): + return plain(seen.split("\x1b[H")[-1]) +def wait_for(text, timeout, label): + end = time.time() + timeout + while time.time() < end: + if text in " ".join(frame().replace("|", " ").split()): + print("OK", label); return True + if not pump(0.5): + break + print("FAIL", label, "-- never saw:", text) + print("\n".join(" | " + l for l in frame().split("\r\n")[:30])) + return False +def wait_done(timeout, label): + # Done, or Stopped with the reason: either way the screen has its answer. + end = time.time() + timeout + while time.time() < end: + words = " ".join(frame().replace("|", " ").split()) + if "Done." in words: + print("OK", label); return True + if "Stopped:" in words: + break + if not pump(0.5): + break + print("FAIL", label, "-- the screen says:") + print("\n".join(" | " + l for l in frame().split("\r\n")[:30])) + return False +def keys(s): + os.write(fd, s.encode()); pump(0.4) +ENTER, DOWN, CTRL_U = "\r", "\x1b[B", "\x15" +wait_for("What this machine allows", 30, "screen 1: what it found") +keys(ENTER) +wait_for("Where it will be reached", 10, "screen 2: names") +keys(DOWN * 5 + CTRL_U + "/var/lib/inbuxa-joined" + DOWN + " ") +wait_for("example.test", 5, "loopback, in a directory of its own") +keys(ENTER) +wait_for("What goes on this machine", 10, "screen 3: components") +keys("s") +keys(ENTER) +wait_for("The server these front ends are for", 10, "skipping the server leads to the Server screen") +wait_for("Server › Reach", 5, "and the steps say so") +keys("http://127.0.0.1:8081" + DOWN + KEY) +print("FAIL the key is on screen" if KEY in plain(seen) else "OK the key is typed, not shown") +keys(DOWN + ENTER) +wait_for("The key works, and the server can take these front ends", 30, "the server is asked before the plan") +wait_for("publishes nothing", 10, "then reach, on loopback") +keys(ENTER) +wait_for("Nothing has happened yet", 10, "the plan") +wait_for("Register these front ends with the server", 5, "the plan registers them with the server") +keys("\x1b[6~" * 4) +wait_for("inbuxa join http://127.0.0.1:8081 --key - --local --domain example.test --dir /var/lib/inbuxa-joined --install-deps --yes", 5, "the plan shows the join command, with --key -") +keys(ENTER) +wait_for("Join now?", 5, "a confirmation before anything happens") +print("OK nothing joined before the y" if not os.path.exists("/var/lib/inbuxa-joined/compose.yaml") else "FAIL something was written before the y") +keys("y") +wait_done(1500, "the join finishes on screen") +keys("q") +pump(2) +after = plain(seen.split("\x1b[?1049l")[-1]) if "\x1b[?1049l" in seen else "" +print("OK the terminal is given back" if "\x1b[?1049l" in seen and "\x1b[?25h" in seen else "FAIL the terminal was not restored") +print("OK the summary says where it joined" if "joined to" in after and "127.0.0.1:8081" in after else "FAIL no join in the summary: " + repr(after[-300:])) +print("OK and that the key wasn't kept" if "not kept here" in after else "FAIL the summary doesn't say the key wasn't kept") +print("FAIL the key appeared on screen at some point" if KEY in plain(seen) else "OK the key never appeared on screen") +_, status = os.waitpid(pid, 0) +code = os.waitstatus_to_exitcode(status) +print(("OK" if code == 0 else "FAIL") + f" exit status {code}") +PY +echo +echo "==> joining from the interface" +OUT="$(KEY="$KEY" python3 /tmp/drive-join.py 2>&1)" +while IFS= read -r line; do + case "$line" in + OK\ *) ok "${line#OK }" ;; + FAIL\ *) bad "${line#FAIL }" ;; + *) echo "$line" ;; + esac +done <<<"$OUT" + +echo +echo "==> what it joined" +grep -q "$KEY" <<<"$(cat $DIR/* 2>/dev/null)" && bad "the API key was written down here" || ok "the API key was not kept" +STATE="$(compose ps --format '{{.Service}} {{.State}}')" +for s in console webmail; do + grep -q "^$s running" <<<"$STATE" && ok "$s is running" || { bad "$s is not running"; echo "$STATE" | sed 's/^/ /'; } +done +grep -q "^ server:" "$DIR/compose.yaml" && bad "a server was put here too" || ok "no server here" +grep -q '"serverUrl": "http://127.0.0.1:8081"' /etc/inbuxa/install.json && ok "the install record names the server it joined" || bad "no serverUrl in the install record" +echo "==> the server knows the front ends" +FE=$(jmap "$KEY" urn:inbuxa:jmap '[["inbuxa:FrontEnds/get",{"accountId":"'"$ACCOUNT"'"},"0"]]') +grep -q '"adminUrl":"http://127.0.0.1:8082"' <<<"$FE" && ok "the console's address" || bad "adminUrl: $FE" +grep -q '"webmailUrl":"http://127.0.0.1:8080"' <<<"$FE" && ok "the webmail's address" || bad "webmailUrl: $FE" +grep -q '"webmailClientSecretSet":true' <<<"$FE" && ok "and a webmail secret, which it does not show" || bad "no webmail secret: $FE" +ALLOW=$(curl -s -o /dev/null -D - -X OPTIONS $SERVER/jmap/session -H 'Origin: http://127.0.0.1:8082' \ + -H 'Access-Control-Request-Method: GET' -H 'Access-Control-Request-Headers: authorization' | tr -d '\r' | awk -F': ' 'tolower($1)=="access-control-allow-origin"{print $2}') +[ "$ALLOW" = "http://127.0.0.1:8082" ] && ok "the console's origin may call the server" || bad "access-control-allow-origin: '$ALLOW'" +curl -fsS http://127.0.0.1:8082/ 2>/dev/null | grep -q "content=\"$SERVER\"" && ok "the console points at the server" || bad "the console's api-base-url is not $SERVER" + +echo +echo "==> a person signs in to the joined webmail" +USER=$(awk '/^first mailbox/ {print $3}' "$SERVER_DIR/credentials.txt") +PASS=$(awk '/^first mailbox/{getline; print $2}' "$SERVER_DIR/credentials.txt") +rm -f /tmp/jar +LOC=$(curl -s -o /dev/null -c /tmp/jar -w '%{redirect_url}' "http://127.0.0.1:8080/api/auth/oauth/start?username=$USER&remember=1") +grep -q "^$SERVER/" <<<"$LOC" && ok "the webmail sends sign-in to the server" || bad "sign-in went to '${LOC:-nowhere}'" +q() { sed -n "s/.*[?&]$1=\([^&]*\).*/\1/p" <<<"$LOC"; } +urldecode() { printf '%b' "${1//%/\\x}"; } +STATE=$(q state); CHALLENGE=$(q code_challenge); REDIRECT=$(urldecode "$(q redirect_uri)") +ANSWER=$(curl -s -X POST $SERVER/api/auth -H 'Content-Type: application/json' -H 'Accept: application/json' \ + -d "{\"type\":\"authCode\",\"accountName\":\"$USER\",\"accountSecret\":\"$PASS\",\"clientId\":\"ihasmail-inbuxa\",\"redirectUri\":\"$REDIRECT\",\"codeChallenge\":\"$CHALLENGE\",\"codeChallengeMethod\":\"S256\"}") +AUTHCODE=$(sed -n 's/.*"client_\{0,1\}[cC]ode":"\([^"]*\)".*/\1/p' <<<"$ANSWER") +[ -n "$AUTHCODE" ] && ok "the server takes the joined webmail's redirect" || { bad "the server's sign-in answered"; head -c 200 <<<"$ANSWER" | sed 's/^/ /'; } +BACK=$(curl -s -o /dev/null -b /tmp/jar -c /tmp/jar -w '%{redirect_url}' "$REDIRECT?code=$AUTHCODE&state=$STATE") +grep -q "signin_error" <<<"$BACK" && bad "the webmail's code exchange failed (its secret?): $BACK" || ok "the webmail exchanges the code with the secret made here" +CODE=$(curl -s -o /tmp/login.json -b /tmp/jar -w '%{http_code}' -H 'X-Requested-With: ihasmail' http://127.0.0.1:8080/api/auth/session) +[ "$CODE" = 200 ] && grep -q "urn:ietf:params:jmap:mail" /tmp/login.json && ok "signed in, with mail" || { bad "the session answered $CODE"; head -c 200 /tmp/login.json | sed 's/^/ /'; } + +echo +echo "==> $pass passed, $fail failed" +[ "$fail" -eq 0 ] diff --git a/internal/tui/install.go b/internal/tui/install.go index beccc65..a2f7df1 100644 --- a/internal/tui/install.go +++ b/internal/tui/install.go @@ -5,6 +5,8 @@ package tui // The installer's interface: six screens, always in this order, with the // plan in front of the operator before anything happens (installer spec §4). +// With the mail server skipped, it joins a server on another machine instead, +// and a seventh screen, Join, asks for that server and an API key (join.go). // // It is a way of filling in the flags with the machine's own facts on // screen, not a second implementation. Every screen writes into the same @@ -29,18 +31,23 @@ const ( screenFound = iota screenNames screenComponents + screenJoin screenReach screenPlan screenApply ) -var screenTitles = []string{"What it found", "Names", "Components", "Reach", "The plan", "Install"} +var screenTitles = []string{"What it found", "Names", "Components", "Server", "Reach", "The plan", "Install"} // Installer carries out an install. In the program it is apply.Run and // apply.Verify; tests give it something that changes nothing. type Installer interface { Run(ctx context.Context, p plan.Plan, f host.Facts, log apply.Log) (*apply.Result, error) Verify(ctx context.Context, res *apply.Result, o plan.Options, log apply.Log) []string + // The same for a join: apply.JoinCheck, apply.Join and apply.JoinVerify. + JoinCheck(ctx context.Context, o plan.Options, key string) error + Join(ctx context.Context, p plan.Plan, f host.Facts, key string, log apply.Log) (*apply.Result, error) + JoinVerify(ctx context.Context, res *apply.Result, console, webmail plan.Shape, log apply.Log) []string } // Wizard is the interface's state. @@ -61,6 +68,8 @@ type Wizard struct { proxy int // 0 caddy, 1 snippets for your own, 2 none + join joinState // the Join screen, when the server is skipped (join.go) + built plan.Plan buildErr error confirming bool @@ -76,6 +85,7 @@ type field struct { value []rune cursor int toggle bool // a yes/no field, in value "yes" or "" + secret bool // typed but never shown: the API key placeholder func(o plan.Options) string } @@ -105,6 +115,7 @@ func NewWizard(f host.Facts, inst Installer) *Wizard { for _, f := range w.fields { f.cursor = len(f.value) } + w.join.fields = joinFields() w.shapes = map[plan.Component]plan.Shape{plan.Server: plan.Container, plan.Console: plan.Container, plan.Webmail: plan.Container} for _, c := range []plan.Component{plan.Server, plan.Console, plan.Webmail} { w.shapes[c] = w.defaultShape(c) @@ -150,6 +161,9 @@ func (w *Wizard) Options() plan.Options { for _, c := range []plan.Component{plan.Server, plan.Console, plan.Webmail} { o.Choices = append(o.Choices, plan.Choice{Component: c, Shape: w.shapes[c]}) } + if w.joining() { + w.joinOptions(&o) + } // What the machine lacks for the shapes chosen is installed rather // than refused: the components screen says what that will be. o.InstallDeps = len(w.needs(o)) > 0 @@ -175,9 +189,13 @@ func withDeps(o plan.Options) plan.Options { // Update handles one key. func (w *Wizard) Update(k Key) bool { + w.settle() if w.screen == screenApply { return w.updateApply(k) } + if w.join.checking() { + return w.updateChecking(k) + } if k.Kind == KeyCtrlC { return true } @@ -194,11 +212,14 @@ func (w *Wizard) Update(k Key) bool { } w.message = "" // q quits everywhere but in a text field, where it is a letter - if k.Kind == KeyRune && k.Rune == 'q' && !(w.screen == screenNames && !w.fields[w.focus].toggle) { + if k.Kind == KeyRune && k.Rune == 'q' && !w.typing() { return true } if k.Kind == KeyEsc && w.screen > screenFound { w.screen-- + if w.screen == screenJoin && !w.joining() { + w.screen-- + } w.scroll = 0 return false } @@ -212,6 +233,8 @@ func (w *Wizard) Update(k Key) bool { w.updateNames(k) case screenComponents: w.updateComponents(k) + case screenJoin: + w.updateJoin(k) case screenReach: w.updateReach(k) case screenPlan: @@ -222,6 +245,8 @@ func (w *Wizard) Update(k Key) bool { w.message = "The plan can't be carried out as it stands: Esc to go back and change it." case !w.Facts.Root: w.message = "Installing needs root: run it again as root (sudo inbuxa). Nothing has happened." + case w.joining() && !w.joinChecked(): + w.message = "The server hasn't been asked about this exact join: Esc back to the Server screen and ask it again." default: w.confirming = true } @@ -232,6 +257,9 @@ func (w *Wizard) Update(k Key) bool { func (w *Wizard) next() { w.screen++ + if w.screen == screenJoin && !w.joining() { + w.screen++ + } w.scroll = 0 if w.screen == screenPlan { w.built, w.buildErr = plan.Build(w.Facts, w.Options()) @@ -284,6 +312,19 @@ func (w *Wizard) updateNames(k Key) { } return } + f.edit(k) + default: + f.edit(k) + } +} + +// edit is a key in a text field: typing, deleting and moving the cursor. +func (f *field) edit(k Key) { + switch k.Kind { + case KeyRune: + if f.toggle { + return + } f.value = append(f.value[:f.cursor], append([]rune{k.Rune}, f.value[f.cursor:]...)...) f.cursor++ case KeyBackspace: @@ -434,8 +475,10 @@ func (w *Wizard) componentsProblem() string { if !any { return "Choose at least one component." } - if w.shapes[plan.Server] == plan.Skip { - return "Front ends for a server on another machine are installed with inbuxa join, not here: keep the server, or quit and use join." + if w.joining() { + if s := recordedServer(); s != "" { + return fmt.Sprintf("This machine runs the mail server itself (a %s install), so its console and webmail are added with it, not joined to it: keep the mail server here.", s) + } } // What each choice can do on its own is above; what the choices can't // do together -- a console of files on loopback, with no web server to @@ -472,16 +515,23 @@ func (w *Wizard) View(width, height int) []string { if width < 60 || height < 16 { return []string{"", " The window is too small for the installer.", " Make it at least 60 by 16, or press q to quit."} } + w.settle() var out []string - steps := make([]string, len(screenTitles)) + var steps []string for i, t := range screenTitles { + if i == screenJoin && !w.joining() { + continue + } + if i == screenApply && w.joining() { + t = "Join" + } switch { case i == w.screen: - steps[i] = Bold(Accent(t)) + steps = append(steps, Bold(Accent(t))) case i < w.screen: - steps[i] = t + steps = append(steps, t) default: - steps[i] = Dim(t) + steps = append(steps, Dim(t)) } } out = append(out, " "+Bold("inbuxa installer")+Dim(" · ")+strings.Join(steps, Dim(" › ")), "") @@ -496,6 +546,8 @@ func (w *Wizard) View(width, height int) []string { body, help = w.viewNames(width) case screenComponents: body, help = w.viewComponents(width) + case screenJoin: + body, help = w.viewJoin(width) case screenReach: body, help = w.viewReach(width) case screenPlan: @@ -522,6 +574,8 @@ func (w *Wizard) View(width, height int) []string { out = append(out, "") } switch { + case w.confirming && w.joining(): + out = append(out, " "+Bold(Warn("Join now? This changes this machine and the server's front ends. y to go ahead, any other key not to."))) case w.confirming: out = append(out, " "+Bold(Warn("Install now? This changes this machine. y to go ahead, any other key not to."))) case w.message != "": @@ -630,7 +684,7 @@ func (w *Wizard) viewComponents(width int) ([]string, string) { body = append(body, "", " "+Dim("container: an image, run with this machine's docker or podman"), " "+Dim("host: from its release, under systemd or as files a web server serves"), - " "+Dim("skip: not on this machine")) + " "+Dim("skip: not on this machine; skip the mail server to join one that runs elsewhere")) return body, "↑↓: component ←→ or s/c/h: choose Enter: next Esc: back q: quit" } @@ -682,12 +736,19 @@ func (w *Wizard) viewPlan(width int) ([]string, string) { for _, l := range Wrap(Command(w.built.Options), width-6) { body = append(body, " "+Accent(l)) } - return body, "Enter: install ↑↓ PgUp PgDn: scroll Esc: back q: quit" + verb := "install" + if w.joining() { + verb = "join" + } + return body, "Enter: " + verb + " ↑↓ PgUp PgDn: scroll Esc: back q: quit" } // Command is the flags that do what the screens chose, leaving out what // would be the default anyway. func Command(o plan.Options) string { + if o.ServerURL != "" { + return joinCommand(o) + } args := []string{"inbuxa", "install"} add := func(flag, v, def string) { if v != "" && v != def { @@ -727,6 +788,7 @@ type progress struct { err error result *apply.Result problems []string + extra []string // after the summary: what a join leaves to say poke func() } @@ -763,6 +825,10 @@ func (l lineWriter) Write(b []byte) (int, error) { } func (w *Wizard) startInstall() { + if w.joining() { + w.startJoin() + return + } w.screen = screenApply w.message = "" ctx, cancel := context.WithCancel(context.Background()) @@ -827,6 +893,7 @@ func (w *Wizard) viewApply(width, room int) ([]string, string) { if pr.done { body = append(body, "") body = append(body, Summary(pr.result, pr.err, pr.problems)...) + body = append(body, pr.extra...) return body, "Enter or q: leave (the summary stays in your terminal)" } // Under the steps, the last of what is being said @@ -871,7 +938,9 @@ func Summary(res *apply.Result, err error, problems []string) []string { } row("administrator", res.AdminUser) row("first mailbox", res.FirstUser) - row("passwords", filepath.Join(res.Dir, "credentials.txt")) + if res.AdminUser != "" { // a join makes no accounts, so writes no passwords + row("passwords", filepath.Join(res.Dir, "credentials.txt")) + } row("console", res.ConsoleURL) row("webmail", res.WebmailURL) if res.Certificate != "" { @@ -894,7 +963,10 @@ func (w *Wizard) Outcome() (summary []string, ran, ok bool) { pr.mu.Lock() defer pr.mu.Unlock() if !pr.done { + if w.joining() { + return []string{" The join was left before it finished; run inbuxa again to pick it up."}, true, false + } return []string{" The install was left before it finished; run inbuxa again to pick it up."}, true, false } - return Summary(pr.result, pr.err, pr.problems), true, pr.err == nil && len(pr.problems) == 0 + return append(Summary(pr.result, pr.err, pr.problems), pr.extra...), true, pr.err == nil && len(pr.problems) == 0 } diff --git a/internal/tui/install_test.go b/internal/tui/install_test.go index 02b0b80..bc96886 100644 --- a/internal/tui/install_test.go +++ b/internal/tui/install_test.go @@ -33,6 +33,13 @@ type fakeInstaller struct { got *plan.Plan fail error hold chan struct{} // when set, Run waits on it + + // joins (join_test.go) + checkErr error + checkHold chan struct{} // when set, JoinCheck waits on it + checkedOn []string // the keys JoinCheck was given + joined *plan.Plan + joinKey string } func (f *fakeInstaller) Run(ctx context.Context, p plan.Plan, _ host.Facts, log apply.Log) (*apply.Result, error) { @@ -154,12 +161,20 @@ func TestWhatCannotBeBuiltIsRefusedOnItsScreen(t *testing.T) { if w.screen != screenComponents || !strings.Contains(w.message, "web server") { t.Errorf("a console host install on loopback got through: screen %d, %q", w.screen, w.message) } - w.Update(Key{Kind: KeyRune, Rune: 'c'}) - press(w, KeyUp) - w.Update(Key{Kind: KeyRune, Rune: 's'}) // no server + w.Update(Key{Kind: KeyRune, Rune: 's'}) // no console + press(w, KeyDown) + w.Update(Key{Kind: KeyRune, Rune: 's'}) // no webmail + press(w, KeyUp, KeyUp) + w.Update(Key{Kind: KeyRune, Rune: 's'}) // and no server: nothing at all press(w, KeyEnter) - if w.screen != screenComponents || !strings.Contains(w.message, "join") { - t.Errorf("front ends without a server got through: %q", w.message) + if w.screen != screenComponents || !strings.Contains(w.message, "at least one") { + t.Errorf("nothing at all got through: %q", w.message) + } + press(w, KeyDown) + w.Update(Key{Kind: KeyRune, Rune: 'c'}) // a console, for a server elsewhere: a join + press(w, KeyEnter) + if w.screen != screenJoin { + t.Errorf("front ends without a server did not lead to the Server screen: %d, %q", w.screen, w.message) } } diff --git a/internal/tui/join.go b/internal/tui/join.go new file mode 100644 index 0000000..3e4fd70 --- /dev/null +++ b/internal/tui/join.go @@ -0,0 +1,394 @@ +// SPDX-FileCopyrightText: 2026 Coffey Labs LLC +// SPDX-License-Identifier: AGPL-3.0-or-later + +package tui + +// Joining from the interface: the mail server skipped on the components +// screen means the console and the webmail are for a server that already +// runs on another machine, as `inbuxa join` installs them. One more screen +// asks which server and for an API key made in its console; leaving it asks +// the server, as join does before anything else, whether the key works and +// whether it can take these front ends. The rest is the same screens, the +// same plan.Options, and apply.Join instead of apply.Run. +// +// The key is typed, never shown, never written down and never put in the +// command the plan screen shows (that says --key -). It is dropped once the +// join has used it. + +import ( + "context" + "fmt" + "net" + "strings" + "sync" + "time" + + "git.coffeylabs.org/inbuxa/inbuxa-installer/internal/plan" + "git.coffeylabs.org/inbuxa/inbuxa-installer/internal/state" +) + +// recordedServer is how the mail server is installed on this machine, from +// its install record, or "". A machine that runs the server adds front ends +// with install, so the interface says so before a join gets anywhere, as +// apply.Join would refuse it after. Tests replace it. +var recordedServer = func() string { + if st, err := state.Load(); err == nil { + return st.Shapes["server"] + } + return "" +} + +// joinState is the Join screen and the check it makes. +type joinState struct { + fields []*field + focus int + + mu sync.Mutex + running bool + done bool + err error + cancel context.CancelFunc + checked string // the address and choices the key was last checked against +} + +const ( + joinAddress = iota + joinKey + joinReplace +) + +func joinFields() []*field { + return []*field{ + {label: "Server", hint: "the mail server's address, as a browser reaches it", placeholder: func(o plan.Options) string { return defaultServerURL(o) }}, + {label: "API key", hint: "made in that server's console: your account, API keys; used once, never kept", secret: true}, + {label: "Replace", hint: "put these in place of a console or webmail the server already lists", toggle: true}, + } +} + +// joining is whether the screens describe a join: the server is elsewhere. +func (w *Wizard) joining() bool { return w.shapes[plan.Server] == plan.Skip } + +// typing is whether a key is a letter for a text field rather than a command. +func (w *Wizard) typing() bool { + switch w.screen { + case screenNames: + return !w.fields[w.focus].toggle + case screenJoin: + return !w.join.fields[w.join.focus].toggle + } + return false +} + +// defaultServerURL is the server a join would reach if nothing else is +// typed: the mail server's name from the Names screen, over HTTPS. +func defaultServerURL(o plan.Options) string { + switch { + case o.MailHost != "": + return "https://" + o.MailHost + case o.Domain != "": + return "https://mail." + o.Domain + } + return "https://mail.example.com" +} + +// serverURL is the address typed, the way `inbuxa join` reads its argument. +func serverURL(typed string, o plan.Options) string { + u := strings.TrimRight(strings.TrimSpace(typed), "/") + if u == "" { + u = defaultServerURL(o) + } + if !strings.HasPrefix(u, "https://") && !strings.HasPrefix(u, "http://") { + u = "https://" + u + } + return u +} + +// joinOptions turns Options into a join's: the server's address and +// --replace, and no mail host of its own, as the join command builds them. +func (w *Wizard) joinOptions(o *plan.Options) { + o.ServerURL = serverURL(w.join.fields[joinAddress].text(), *o) + o.Replace = w.join.fields[joinReplace].text() == "yes" + o.MailHost = "" +} + +func (w *Wizard) joinKeyText() string { return strings.TrimSpace(w.join.fields[joinKey].text()) } + +func (w *Wizard) updateJoin(k Key) { + j := &w.join + f := j.fields[j.focus] + switch k.Kind { + case KeyUp, KeyBackTab: + if j.focus > 0 { + j.focus-- + } + case KeyDown, KeyTab: + if j.focus < len(j.fields)-1 { + j.focus++ + } + case KeyEnter: + if j.focus < len(j.fields)-1 { + j.focus++ + return + } + if why := w.joinProblem(); why != "" { + w.message = why + return + } + w.startCheck() + case KeyRune: + if f.toggle { + if k.Rune == ' ' || k.Rune == 'y' || k.Rune == 'n' { + if (k.Rune == ' ' && f.text() != "yes") || k.Rune == 'y' { + f.value = []rune("yes") + } else { + f.value = nil + } + } + return + } + f.edit(k) + default: + f.edit(k) + } +} + +// joinProblem is why the Join screen can't be left yet, or "". +func (w *Wizard) joinProblem() string { + o := w.Options() + host := strings.TrimPrefix(strings.TrimPrefix(o.ServerURL, "https://"), "http://") + host = strings.SplitN(host, "/", 2)[0] + if host == "" || strings.ContainsAny(host, " @") { + return fmt.Sprintf("%q is not a server address like https://mail.example.com.", o.ServerURL) + } + if h, _, err := net.SplitHostPort(host); err == nil { + host = h + } + if net.ParseIP(host) == nil && !strings.Contains(host, ".") { + return fmt.Sprintf("%q is not a server address like https://mail.example.com.", o.ServerURL) + } + if w.joinKeyText() == "" { + return "An API key is needed: make one in the server's console (your account, API keys) and type it here." + } + return "" +} + +// startCheck asks the server, in the background, what `inbuxa join` asks +// before anything else. The screen says it is asking; Esc stops waiting. +func (w *Wizard) startCheck() { + o := w.Options() + key := w.joinKeyText() + ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second) + j := &w.join + j.mu.Lock() + j.running, j.done, j.err, j.cancel = true, false, nil, cancel + j.mu.Unlock() + w.message = "Asking " + o.ServerURL + " whether the key works…" + go func() { + err := w.Installer.JoinCheck(ctx, o, key) + cancel() + j.mu.Lock() + if j.running { // not abandoned meanwhile + j.running, j.done, j.err = false, true, err + if err == nil { + j.checked = checkedAs(o) + } + } + j.mu.Unlock() + w.poke() + }() +} + +// checkedAs is what a check vouched for: the server, and which front ends +// it was asked about. Changing any of it sends the operator back through +// the check before the plan. +func checkedAs(o plan.Options) string { + return fmt.Sprintf("%s|%s|%s|%s|%s|%t|%t", o.ServerURL, o.Shape(plan.Console), o.Shape(plan.Webmail), o.ConsoleHost, o.WebmailHost, o.Local, o.Replace) +} + +func (j *joinState) checking() bool { + j.mu.Lock() + defer j.mu.Unlock() + return j.running +} + +// updateChecking is the keys while the server is being asked: Esc or Ctrl-C +// stops waiting, everything else waits. +func (w *Wizard) updateChecking(k Key) bool { + if k.Kind == KeyEsc || k.Kind == KeyCtrlC { + j := &w.join + j.mu.Lock() + if j.cancel != nil { + j.cancel() + } + j.running = false + j.mu.Unlock() + w.message = "Stopped asking. Nothing has happened." + } + return false +} + +// settle takes in a finished check: on to the next screen if the server +// agreed, the server's answer on screen if it didn't. +func (w *Wizard) settle() { + j := &w.join + j.mu.Lock() + done, err := j.done, j.err + j.done = false + j.mu.Unlock() + if !done { + return + } + if err != nil { + w.message = err.Error() + return + } + if w.screen == screenJoin { + w.message = "The key works, and the server can take these front ends." + w.next() + } +} + +// joinChecked is whether the server agreed to exactly what the plan would do. +func (w *Wizard) joinChecked() bool { + j := &w.join + j.mu.Lock() + defer j.mu.Unlock() + return j.checked != "" && j.checked == checkedAs(w.Options()) +} + +func (w *Wizard) viewJoin(width int) ([]string, string) { + o := w.Options() + body := []string{" " + Bold("The server these front ends are for"), ""} + for i, f := range w.join.fields { + label := Pad(f.label, 20) + var val string + switch { + case f.toggle: + val = "[ ]" + if f.text() == "yes" { + val = "[x]" + } + if i == w.join.focus { + val = Reverse(val) + } + case f.secret: + // Never the key itself, only that something was typed. + val = strings.Repeat("•", len(f.value)) + if len(f.value) == 0 && i != w.join.focus { + val = Dim("none yet") + } + if i == w.join.focus { + val += Reverse(" ") + } + case len(f.value) == 0 && i != w.join.focus: + val = Dim(f.placeholder(o)) + case i == w.join.focus: + s := f.value + before, at, after := string(s[:f.cursor]), " ", "" + if f.cursor < len(s) { + at, after = string(s[f.cursor]), string(s[f.cursor+1:]) + } + val = before + Reverse(at) + after + if len(f.value) == 0 { + val = Reverse(" ") + Dim(f.placeholder(o)) + } + default: + val = f.text() + } + line := " " + if i == w.join.focus { + line = Accent("› ") + } + body = append(body, line+label+val) + if i == w.join.focus { + body = append(body, " "+Dim(Pad("", 18)+f.hint)) + } + } + body = append(body, "") + for _, l := range WrapProse("The server is reached only as a browser reaches it, over its own address. "+ + "The key goes to it once, to register these front ends; it isn't kept on this machine, "+ + "and you can remove it in the console when the join is done.", width-6) { + body = append(body, " "+Dim(l)) + } + if w.join.checking() { + return body, "Asking the server… Esc: stop waiting" + } + return body, "↑↓ Tab: move type to edit Space: toggle Enter: ask the server Esc: back Ctrl-C: quit" +} + +// joinCommand is `inbuxa join` with the flags the screens chose. The key +// is read from standard input there, never written on a command line. +func joinCommand(o plan.Options) string { + args := []string{"inbuxa", "join", o.ServerURL, "--key", "-"} + add := func(flag, v, def string) { + if v != "" && v != def { + args = append(args, flag, v) + } + } + if o.Local { + args = append(args, "--local") + } + add("--domain", o.Domain, joinDomain(o.ServerURL)) + add("--console-host", o.ConsoleHost, "admin."+o.Domain) + add("--webmail-host", o.WebmailHost, "webmail."+o.Domain) + add("--email", o.ACMEEmail, "postmaster@"+o.Domain) + add("--console", string(o.Shape(plan.Console)), "container") + add("--webmail", string(o.Shape(plan.Webmail)), "container") + if !o.Local { + add("--proxy", o.Proxy, "caddy") + } + add("--dir", o.Dir, "/var/lib/inbuxa") + if o.InstallDeps { + args = append(args, "--install-deps") + } + if o.Replace { + args = append(args, "--replace") + } + return strings.Join(append(args, "--yes"), " ") +} + +// joinDomain is the domain `inbuxa join` takes from the server's address +// when --domain isn't given, so the command leaves it out when they agree. +func joinDomain(serverURL string) string { + host := strings.TrimPrefix(strings.TrimPrefix(serverURL, "https://"), "http://") + host = strings.SplitN(strings.SplitN(host, "/", 2)[0], ":", 2)[0] + if net.ParseIP(host) != nil { + return "" + } + if _, rest, ok := strings.Cut(host, "."); ok && strings.Contains(rest, ".") { + return rest + } + return host +} + +// startJoin carries out the join, as `inbuxa join` does after its check. +func (w *Wizard) startJoin() { + w.screen = screenApply + w.message = "" + ctx, cancel := context.WithCancel(context.Background()) + w.cancel = cancel + pr := &progress{poke: w.poke} + w.progress = pr + p := w.built + key := w.joinKeyText() + // The key leaves the screen's memory now; the join below has its copy. + w.join.fields[joinKey].value, w.join.fields[joinKey].cursor = nil, 0 + go func() { + res, err := w.Installer.Join(ctx, p, w.Facts, key, pr) + var problems []string + var extra []string + if err == nil { + pr.Step("checking it works") + problems = w.Installer.JoinVerify(ctx, res, p.Options.Shape(plan.Console), p.Options.Shape(plan.Webmail), pr) + extra = []string{ + " joined to " + p.Options.ServerURL, + "", + " The API key is not kept here; you can remove it in the console now.", + } + } + pr.mu.Lock() + pr.done, pr.err, pr.result, pr.problems, pr.extra = true, err, res, problems, extra + pr.mu.Unlock() + pr.poke() + }() +} diff --git a/internal/tui/join_test.go b/internal/tui/join_test.go new file mode 100644 index 0000000..eb70091 --- /dev/null +++ b/internal/tui/join_test.go @@ -0,0 +1,236 @@ +// SPDX-FileCopyrightText: 2026 Coffey Labs LLC +// SPDX-License-Identifier: AGPL-3.0-or-later + +package tui + +import ( + "context" + "errors" + "strings" + "testing" + "time" + + "git.coffeylabs.org/inbuxa/inbuxa-installer/internal/apply" + "git.coffeylabs.org/inbuxa/inbuxa-installer/internal/host" + "git.coffeylabs.org/inbuxa/inbuxa-installer/internal/plan" +) + +func (f *fakeInstaller) JoinCheck(ctx context.Context, o plan.Options, key string) error { + f.mu.Lock() + f.checkedOn = append(f.checkedOn, key) + hold := f.checkHold + f.mu.Unlock() + if hold != nil { + select { + case <-hold: + case <-ctx.Done(): + return ctx.Err() + } + } + return f.checkErr +} + +func (f *fakeInstaller) Join(ctx context.Context, p plan.Plan, _ host.Facts, key string, log apply.Log) (*apply.Result, error) { + f.mu.Lock() + f.joined, f.joinKey = &p, key + f.mu.Unlock() + log.Step("registering these front ends with %s", p.Options.ServerURL) + return &apply.Result{Dir: p.Options.Dir, ConsoleURL: "https://admin." + p.Options.Domain, WebmailURL: "https://webmail." + p.Options.Domain, ServerURL: p.Options.ServerURL}, nil +} + +func (f *fakeInstaller) JoinVerify(context.Context, *apply.Result, plan.Shape, plan.Shape, apply.Log) []string { + return nil +} + +const testKey = "k3y-that-must-never-show" + +// The tests never read this machine's own install record. +func init() { recordedServer = func() string { return "" } } + +// toJoin goes from the first screen to the Server screen: a domain, the +// defaults for the names, and the mail server skipped. +func toJoin(t *testing.T, w *Wizard, domain string) { + t.Helper() + press(w, KeyEnter) + typeText(w, domain) + for i := 0; i < len(w.fields); i++ { + press(w, KeyEnter) + } + w.Update(Key{Kind: KeyRune, Rune: 's'}) // the mail server: skip + press(w, KeyEnter) + if w.screen != screenJoin { + t.Fatalf("skipping the server did not lead to the Server screen, at %d: %q", w.screen, w.message) + } +} + +// waitCheck waits for the question to the server to be answered, then lets +// the wizard take the answer in, as the next redraw would. +func waitCheck(t *testing.T, w *Wizard) { + t.Helper() + deadline := time.Now().Add(5 * time.Second) + for w.join.checking() { + if time.Now().After(deadline) { + t.Fatal("the check never finished") + } + time.Sleep(5 * time.Millisecond) + } + w.View(100, 30) +} + +func TestSkippingTheServerJoinsOne(t *testing.T) { + inst := &fakeInstaller{} + w := NewWizard(debian13(true), inst) + toJoin(t, w, "example.org") + + head := w.View(100, 30)[0] + if !strings.Contains(head, "Server") || !strings.Contains(head, "Join") || strings.Contains(head, "Install") { + t.Errorf("the steps don't say this is a join: %q", head) + } + if got := w.Options().ServerURL; got != "https://mail.example.org" { + t.Errorf("the server defaults to %q", got) + } + + press(w, KeyDown, KeyDown) // to Replace, past an empty key + press(w, KeyEnter) + if !strings.Contains(w.message, "API key") || w.join.checking() { + t.Fatalf("no key, and it asked the server anyway: %q", w.message) + } + + press(w, KeyUp) // the key + typeText(w, testKey) + view := strings.Join(w.View(100, 30), "\n") + if strings.Contains(view, testKey) || !strings.Contains(view, "••••") { + t.Fatalf("the key is on screen:\n%s", view) + } + press(w, KeyDown, KeyEnter) + waitCheck(t, w) + if w.screen != screenReach || len(inst.checkedOn) != 1 || inst.checkedOn[0] != testKey { + t.Fatalf("after the check: screen %d, %q, asked with %q", w.screen, w.message, inst.checkedOn) + } + + press(w, KeyEnter) // reach + if w.screen != screenPlan { + t.Fatalf("not at the plan: %q", w.message) + } + view = strings.Join(w.View(140, 60), "\n") + if !strings.Contains(view, "inbuxa join https://mail.example.org --key - ") || strings.Contains(view, testKey) { + t.Errorf("the plan's command:\n%s", view) + } + + press(w, KeyEnter) + if !w.confirming || !strings.Contains(strings.Join(w.View(140, 30), "\n"), "Join now?") { + t.Fatal("no confirmation before joining") + } + w.Update(Key{Kind: KeyRune, Rune: 'y'}) + waitDone(t, w) + if inst.got != nil { + t.Error("a join ran an install") + } + if inst.joined == nil || inst.joinKey != testKey || inst.joined.Options.ServerURL != "https://mail.example.org" || inst.joined.Options.Shape(plan.Server) != plan.Skip { + t.Fatalf("joined %+v with %q", inst.joined, inst.joinKey) + } + if len(w.join.fields[joinKey].value) != 0 { + t.Error("the key is still held after the join used it") + } + summary, ran, ok := w.Outcome() + text := strings.Join(summary, "\n") + if !ran || !ok || !strings.Contains(text, "joined to https://mail.example.org") || !strings.Contains(text, "not kept here") || strings.Contains(text, "credentials.txt") { + t.Errorf("outcome %v %v:\n%s", ran, ok, text) + } +} + +func TestAKeyTheServerRefusesStaysOnItsScreen(t *testing.T) { + inst := &fakeInstaller{checkErr: errors.New("the server refused the API key; make one in the console under your account's API keys, then pass it with --key")} + w := NewWizard(debian13(true), inst) + toJoin(t, w, "example.org") + press(w, KeyDown) + typeText(w, testKey) + press(w, KeyDown, KeyEnter) + waitCheck(t, w) + if w.screen != screenJoin || !strings.Contains(w.message, "refused the API key") { + t.Fatalf("a refused key: screen %d, %q", w.screen, w.message) + } +} + +func TestWaitingOnTheServerCanBeStopped(t *testing.T) { + inst := &fakeInstaller{checkHold: make(chan struct{})} + w := NewWizard(debian13(true), inst) + toJoin(t, w, "example.org") + press(w, KeyDown) + typeText(w, testKey) + press(w, KeyDown, KeyEnter) + if !w.join.checking() { + t.Fatal("not asking the server") + } + if quit := w.Update(Key{Kind: KeyRune, Rune: 'q'}); quit || w.screen != screenJoin { + t.Fatal("a key other than Esc did something while asking") + } + press(w, KeyEsc) + if w.join.checking() || w.screen != screenJoin || !strings.Contains(w.message, "Stopped asking") { + t.Fatalf("Esc did not stop waiting: %q", w.message) + } + close(inst.checkHold) + time.Sleep(20 * time.Millisecond) + w.View(100, 30) + if w.screen != screenJoin { + t.Error("an abandoned check moved the screens on when it finished") + } +} + +func TestAJoinChangedAfterItsCheckIsAskedAgain(t *testing.T) { + inst := &fakeInstaller{} + w := NewWizard(debian13(true), inst) + toJoin(t, w, "example.org") + press(w, KeyDown) + typeText(w, testKey) + press(w, KeyDown, KeyEnter) + waitCheck(t, w) + press(w, KeyEnter) // reach + w.join.fields[joinReplace].value = []rune("yes") // what the server was not asked about + press(w, KeyEnter) + if w.confirming || !strings.Contains(w.message, "asked about this exact join") { + t.Fatalf("a join the server didn't see was offered: %q", w.message) + } +} + +func TestAnInstallNeverShowsTheServerStep(t *testing.T) { + w := NewWizard(debian13(true), &fakeInstaller{}) + if head := w.View(120, 30)[0]; strings.Contains(head, "Server") { + t.Errorf("an install shows the join's step: %q", head) + } + toPlan(t, w, "example.org") // components → reach, never the Server screen + press(w, KeyEsc, KeyEsc) + if w.screen != screenComponents { + t.Errorf("Esc from reach went to %d, not components", w.screen) + } +} + +func TestTheJoinCommandLeavesOutWhatJoinWouldWorkOut(t *testing.T) { + o := plan.Options{ServerURL: "https://mail.example.org", Domain: "example.org", Dir: "/var/lib/inbuxa", Proxy: "caddy", + Choices: []plan.Choice{{Component: plan.Server, Shape: plan.Skip}, {Component: plan.Console, Shape: plan.Container}, {Component: plan.Webmail, Shape: plan.Host}}} + if got, want := Command(o), "inbuxa join https://mail.example.org --key - --webmail host --yes"; got != want { + t.Errorf("Command = %q, want %q", got, want) + } + // The names the plan fills in are the defaults, and left out too. + o.ConsoleHost, o.WebmailHost, o.ACMEEmail = "admin.example.org", "webmail.example.org", "postmaster@example.org" + if got, want := Command(o), "inbuxa join https://mail.example.org --key - --webmail host --yes"; got != want { + t.Errorf("Command = %q, want %q", got, want) + } +} + +func TestAMachineThatRunsTheServerIsNotJoinedToIt(t *testing.T) { + was := recordedServer + recordedServer = func() string { return "host" } + defer func() { recordedServer = was }() + w := NewWizard(debian13(true), &fakeInstaller{}) + press(w, KeyEnter) + typeText(w, "example.org") + for i := 0; i < len(w.fields); i++ { + press(w, KeyEnter) + } + w.Update(Key{Kind: KeyRune, Rune: 's'}) + press(w, KeyEnter) + if w.screen != screenComponents || !strings.Contains(w.message, "runs the mail server itself") { + t.Fatalf("a join on the server's own machine got through: screen %d, %q", w.screen, w.message) + } +} -- 2.54.0