herdr-remote 0.2.18 → 0.2.20

package/dist/terminal-palette.js

@@ -0,0 +1,339 @@
+/**
+ * Reads the colors of the terminal the workstation is actually looking at.
+ *
+ * A browser cannot know what a Herdr session looks like on the host: the PTY
+ * only carries color *indices*, and whoever renders them decides what "red"
+ * or "the default background" means. So the host asks its own terminal, once,
+ * with the standard OSC color queries every mainstream emulator answers:
+ *
+ *   OSC 10 ; ? — default foreground
+ *   OSC 11 ; ? — default background
+ *   OSC 12 ; ? — cursor
+ *   OSC 4 ; n ; ? — ANSI slot n (0-15)
+ *
+ * The answers travel to the browser through `host_hello`, and xterm renders
+ * with them. Nothing here guesses: without a terminal to ask, the result is
+ * `null` and the browser keeps xterm's own defaults.
+ */
+import fs from 'node:fs';
+import { spawnSync } from 'node:child_process';
+// One definition of what a palette may contain, shared with the relay so the
+// host cannot report a shape the wire rejects.
+import { ANSI_PALETTE_KEYS, sanitizeTerminalPalette, } from 'herdr-remote-relay/protocol';
+import { readRuntime, updateRuntime } from './runtime.js';
+const ANSI_SLOTS = ANSI_PALETTE_KEYS.length;
+/**
+ * VTIME in tenths of a second: the terminal driver returns from a read after
+ * this long even with nothing to read, which is what bounds a silent terminal
+ * without burning CPU in a poll loop.
+ */
+const READ_TIMEOUT_TENTHS = '3';
+/**
+ * Two empty reads in a row mean this query will not be answered.
+ *
+ * The resulting ~600ms per query is not padding: with a multiplexer between
+ * this process and the emulator, the emulator's answer measurably arrives
+ * later than 400ms, and giving up sooner makes the multiplexer answer from its
+ * own configuration instead — a palette that is not the one on screen.
+ */
+const MAX_IDLE_READS = 2;
+/**
+ * The whole probe is bounded: a start must never wait on a terminal that
+ * answers slowly, or not at all. Sized for the nineteen queries a fully
+ * answering terminal replies to in milliseconds, with room for the mixed case
+ * where the ANSI ramp is reported but the default colors are not.
+ */
+const TOTAL_TIMEOUT_MS = 3000;
+const ANSI_KEYS = ANSI_PALETTE_KEYS;
+/**
+ * `rgb:RRRR/GGGG/BBBB` (and the 1/2/3-digit variants) to `#rrggbb`.
+ * Terminals answer in 16-bit-per-channel notation; the top byte is the color.
+ */
+function parseXColor(value) {
+    if (typeof value !== 'string')
+        return null;
+    const match = /^rgba?:([0-9a-f]+)\/([0-9a-f]+)\/([0-9a-f]+)/i.exec(value.trim());
+    if (!match)
+        return null;
+    const channels = match.slice(1, 4).map((raw) => {
+        const width = raw.length;
+        if (width === 0 || width > 4)
+            return null;
+        const scaled = Math.round((parseInt(raw, 16) / (16 ** width - 1)) * 255);
+        return Math.max(0, Math.min(255, scaled));
+    });
+    if (channels.some((channel) => channel === null))
+        return null;
+    return `#${channels.map((channel) => channel.toString(16).padStart(2, '0')).join('')}`;
+}
+/**
+ * Locates one complete OSC reply, e.g. `ESC ] 11 ; rgb:2222/2222/2626 ESC \`.
+ *
+ * A reply is only complete once its terminator arrives, so a half-read answer
+ * waits for the rest of the bytes instead of being parsed out of a fragment.
+ */
+function findOscColorReply(text, expectedPrefix) {
+    if (typeof text !== 'string')
+        return null;
+    const start = text.indexOf(`${expectedPrefix};`);
+    if (start === -1)
+        return null;
+    const stringTerminator = text.indexOf('\x1b\\', start);
+    const bell = text.indexOf('\x07', start);
+    let bodyEnd = -1;
+    let end = -1;
+    if (stringTerminator !== -1 && (bell === -1 || stringTerminator < bell)) {
+        bodyEnd = stringTerminator;
+        end = stringTerminator + 2;
+    }
+    else if (bell !== -1) {
+        bodyEnd = bell;
+        end = bell + 1;
+    }
+    else {
+        return null;
+    }
+    const color = parseXColor(text.slice(start + expectedPrefix.length + 1, bodyEnd).trim());
+    return color ? { color, start, end } : null;
+}
+/** Pulls the color out of one OSC reply. */
+function parseOscColorReply(reply, expectedPrefix) {
+    return findOscColorReply(reply, expectedPrefix)?.color ?? null;
+}
+/** A palette is only usable if every field it claims to have is a real color. */
+const sanitizePalette = sanitizeTerminalPalette;
+/** Reads a palette a parent process already captured, so children never re-probe. */
+function paletteFromEnvironment(env = process.env) {
+    const raw = env.HERDR_TERM_PALETTE_JSON;
+    if (!raw)
+        return null;
+    try {
+        return sanitizePalette(JSON.parse(raw));
+    }
+    catch {
+        return null;
+    }
+}
+function runStty(args, ttyPath) {
+    return spawnSync('stty', [...args, '-F', ttyPath], { encoding: 'utf8', timeout: 1000 });
+}
+/**
+ * Takes one reply out of the buffered bytes, leaving the rest.
+ *
+ * One read can carry several answers, and a terminal is free to volunteer
+ * bytes of its own; dropping everything on a match would throw away replies
+ * the next query is still waiting for.
+ */
+function takeOscColorReply(state, expectedPrefix) {
+    const found = findOscColorReply(state.pending, expectedPrefix);
+    if (!found)
+        return null;
+    state.pending = state.pending.slice(0, found.start) + state.pending.slice(found.end);
+    return found.color;
+}
+/**
+ * Runs the color conversation over an injected `ask(query, prefix)`.
+ *
+ * Order is not cosmetic here, and it was settled by measurement rather than by
+ * reasoning. Asking the default colors (OSC 10/11/12) first and the ANSI ramp
+ * afterwards makes a multiplexer between this process and the emulator pass
+ * the whole conversation through, and all nineteen answers then come from the
+ * emulator that is actually painting the screen — one coherent palette, in a
+ * few milliseconds. Asking the ramp first instead had the multiplexer answer
+ * OSC 4 from its own configuration while the default colors went unanswered:
+ * sixteen colors from one source, no background from the other.
+ *
+ * The ramp is asked for unconditionally, so a terminal that reports its colors
+ * but not its defaults (or the reverse) still contributes what it knows. A
+ * terminal that answers none of the first four questions is left alone rather
+ * than asked fifteen more times.
+ */
+function collectPalette(ask) {
+    const palette = {};
+    const foreground = ask('\x1b]10;?\x1b\\', '\x1b]10');
+    if (foreground)
+        palette.foreground = foreground;
+    const background = ask('\x1b]11;?\x1b\\', '\x1b]11');
+    if (background)
+        palette.background = background;
+    const cursor = ask('\x1b]12;?\x1b\\', '\x1b]12');
+    if (cursor)
+        palette.cursor = cursor;
+    const ansi = {};
+    for (let slot = 0; slot < ANSI_SLOTS; slot += 1) {
+        const color = ask(`\x1b]4;${slot};?\x1b\\`, `\x1b]4;${slot}`);
+        if (!color)
+            break;
+        ansi[ANSI_KEYS[slot]] = color;
+    }
+    if (Object.keys(ansi).length === ANSI_SLOTS)
+        palette.ansi = ansi;
+    return sanitizePalette(palette);
+}
+/**
+ * Asks one question and waits for that answer, on an already-raw terminal.
+ * Anything the terminal volunteers in the meantime is kept in `pending` so a
+ * late reply is still matched to the query it belongs to.
+ */
+function askTerminal(fd, query, expectedPrefix, state) {
+    fs.writeSync(fd, query);
+    const buffer = Buffer.alloc(256);
+    let idleReads = 0;
+    while (idleReads < MAX_IDLE_READS && Date.now() < state.overallDeadline) {
+        const matched = takeOscColorReply(state, expectedPrefix);
+        if (matched)
+            return matched;
+        let bytesRead = 0;
+        try {
+            // Blocking, but bounded by VTIME: it returns 0 when the terminal is quiet.
+            bytesRead = fs.readSync(fd, buffer, 0, buffer.length, null);
+        }
+        catch (error) {
+            if (error.code === 'EAGAIN') {
+                idleReads += 1;
+                continue;
+            }
+            return null;
+        }
+        if (bytesRead > 0) {
+            state.pending += buffer.toString('latin1', 0, bytesRead);
+            idleReads = 0;
+        }
+        else {
+            idleReads += 1;
+        }
+    }
+    return takeOscColorReply(state, expectedPrefix);
+}
+/**
+ * Queries the controlling terminal for its colors.
+ *
+ * Returns `null` — never a guess — when there is no terminal, when the
+ * terminal stays silent, or when anything about the exchange goes wrong.
+ */
+function probeTerminalPalette({ ttyPath = '/dev/tty', timeoutMs = TOTAL_TIMEOUT_MS, } = {}) {
+    if (process.platform === 'win32')
+        return null;
+    let fd = null;
+    let savedMode = null;
+    try {
+        fd = fs.openSync(ttyPath, 'r+');
+    }
+    catch {
+        return null;
+    }
+    try {
+        const saved = runStty(['-g'], ttyPath);
+        if (saved.status !== 0)
+            return null;
+        savedMode = saved.stdout.trim();
+        // The reply is written to the terminal, not echoed by a line discipline:
+        // raw mode is what lets this process read it instead of the user's shell.
+        if (runStty(['raw', '-echo', 'min', '0', 'time', READ_TIMEOUT_TENTHS], ttyPath).status !== 0)
+            return null;
+        const state = { pending: '', overallDeadline: Date.now() + timeoutMs };
+        const tty = fd;
+        return collectPalette((query, prefix) => askTerminal(tty, query, prefix, state));
+    }
+    catch {
+        return null;
+    }
+    finally {
+        if (savedMode)
+            runStty([savedMode], ttyPath);
+        if (fd !== null) {
+            try {
+                fs.closeSync(fd);
+            }
+            catch {
+                // The terminal state was already restored above; the descriptor is only closed.
+            }
+        }
+    }
+}
+/**
+ * Remembers a palette for the next start that has no terminal to ask.
+ *
+ * A service manager launches the services with no terminal at all, and the
+ * workstation has not changed color just because systemd, rather than a
+ * person, started it this time.
+ */
+function rememberTerminalPalette(palette) {
+    const clean = sanitizePalette(palette);
+    if (!clean)
+        return null;
+    try {
+        updateRuntime((state) => {
+            state.terminalPalette = clean;
+        });
+    }
+    catch {
+        // A palette is a nicety; failing to remember it must not break a start.
+    }
+    return clean;
+}
+/** The palette a previous start captured from a terminal, if any. */
+function rememberedTerminalPalette() {
+    try {
+        return sanitizePalette(readRuntime().terminalPalette);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * The palette a service start should hand to its children: whatever a parent
+ * already captured, otherwise a fresh probe of this process's terminal.
+ */
+function resolveHostPalette({ env = process.env, probe = probeTerminalPalette, } = {}) {
+    return paletteFromEnvironment(env) || probe() || null;
+}
+/**
+ * Capture the terminal's colors at the entry point, before anything else takes
+ * the screen.
+ *
+ * The configuration TUI owns the terminal once it starts, and a probe issued
+ * underneath it would race its input handling for the reply. Asking here, at
+ * the very start of the command, means every later caller in this process tree
+ * simply inherits the answer through the environment.
+ */
+function captureTerminalPalette({ env = process.env, probe = probeTerminalPalette, } = {}) {
+    if (env.HERDR_TERM_PALETTE_JSON)
+        return paletteFromEnvironment(env);
+    // Without both ends on a terminal there is nobody to answer the query.
+    if (!process.stdin.isTTY || !process.stdout.isTTY)
+        return null;
+    const palette = probe();
+    if (!palette)
+        return null;
+    env.HERDR_TERM_PALETTE_JSON = JSON.stringify(palette);
+    // The environment only reaches children of this process. A start handed to
+    // systemd or launchd runs outside that tree, so the answer is written down
+    // as well and picked up from there.
+    rememberTerminalPalette(palette);
+    return palette;
+}
+/**
+ * The colors of the terminal this workstation is looked at through.
+ *
+ * Asked once per process, from whichever start path has a real terminal, and
+ * remembered in the state file: a later start from a service manager has no
+ * terminal to ask, and the workstation's appearance has not changed just
+ * because systemd, and not a person, launched it this time.
+ */
+let cachedHostPalette;
+function hostTerminalPalette({ refresh = false } = {}) {
+    if (!refresh && cachedHostPalette !== undefined)
+        return cachedHostPalette;
+    const inherited = paletteFromEnvironment();
+    if (inherited) {
+        cachedHostPalette = inherited;
+        return cachedHostPalette;
+    }
+    const probed = probeTerminalPalette();
+    // Nothing to ask: fall back to what a start with a terminal wrote down,
+    // re-validated, because a state file is not a trusted wire either.
+    cachedHostPalette = probed ? rememberTerminalPalette(probed) : rememberedTerminalPalette();
+    return cachedHostPalette;
+}
+export { ANSI_KEYS, ANSI_SLOTS, parseXColor, parseOscColorReply, takeOscColorReply, collectPalette, sanitizePalette, paletteFromEnvironment, probeTerminalPalette, resolveHostPalette, hostTerminalPalette, captureTerminalPalette, rememberTerminalPalette, rememberedTerminalPalette, };

package/dist/tui/App.js

@@ -0,0 +1,195 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { Box, Text, useApp, useInput } from 'ink';
+import { useMouse, useMouseTarget } from './mouse/index.js';
+import { theme } from './theme.js';
+import { checkForUpdate, createDraft, createTranslator, detectLocale, ensureRuntime, fullStatus, loadConfig, requiresRestart, updateChecksEnabled, } from './api.js';
+import { Overview } from './screens/Overview.js';
+import { PairScreen } from './screens/Pair.js';
+import { Services } from './screens/Services.js';
+import { RelayScreen } from './screens/Relay.js';
+import { Keepalive } from './screens/Keepalive.js';
+import { HerdrScreen } from './screens/Herdr.js';
+import { About } from './screens/About.js';
+import { Wizard } from './screens/Wizard.js';
+const STATUS_POLL_MS = 3000;
+const TABS = [
+    { id: 'overview', labelKey: 'nav.overview' },
+    { id: 'pair', labelKey: 'nav.pair' },
+    { id: 'services', labelKey: 'nav.services' },
+    { id: 'relay', labelKey: 'nav.relay' },
+    { id: 'keepalive', labelKey: 'nav.keepalive' },
+    { id: 'herdr', labelKey: 'nav.herdr' },
+    { id: 'about', labelKey: 'nav.about' },
+];
+function Tab({ label, active, onSelect, }) {
+    const ref = useRef(null);
+    const hovered = useMouseTarget(ref, { onClick: onSelect });
+    return (_jsx(Box, { ref: ref, marginRight: 2, children: _jsx(Text, { color: active || hovered ? theme.accent : theme.muted, bold: active, underline: active || hovered, children: label }) }));
+}
+function Footer({ hints }) {
+    return (_jsx(Box, { marginTop: 1, paddingX: 1, children: _jsx(Text, { color: theme.muted, children: hints.join('  ·  ') }) }));
+}
+export function App({ initialLanguage, needsWizard, updateChecker = updateChecksEnabled() ? checkForUpdate : null, }) {
+    const { exit } = useApp();
+    const mouse = useMouse();
+    const [config, setConfig] = useState(() => loadConfig());
+    const [draft, setDraft] = useState(() => createDraft());
+    const [runtime, setRuntime] = useState(() => ensureRuntime());
+    const [status, setStatus] = useState(null);
+    const [tab, setTab] = useState('overview');
+    const [message, setMessage] = useState(null);
+    const [busy, setBusy] = useState(false);
+    const [editingId, setEditingId] = useState(null);
+    const [wizardDone, setWizardDone] = useState(!needsWizard);
+    const [updateCheck, setUpdateCheck] = useState(null);
+    // Every time the TUI opens: that is when someone is here to act on it.
+    // Failure says nothing; the About tab can still be asked by hand.
+    useEffect(() => {
+        if (!updateChecker)
+            return undefined;
+        let cancelled = false;
+        updateChecker()
+            .then((result) => {
+            if (!cancelled && result?.ok)
+                setUpdateCheck(result);
+        })
+            .catch(() => { });
+        return () => {
+            cancelled = true;
+        };
+    }, [updateChecker]);
+    const locale = useMemo(() => detectLocale({ preference: initialLanguage ?? draft.ui.language }), [initialLanguage, draft.ui.language]);
+    const t = useMemo(() => createTranslator(locale), [locale]);
+    const dirty = useMemo(() => JSON.stringify(config) !== JSON.stringify(draft), [config, draft]);
+    const restartPending = useMemo(() => dirty && requiresRestart(config, draft), [config, draft, dirty]);
+    const notify = useCallback((text, level = 'info') => {
+        setMessage({ text, level });
+    }, []);
+    const refresh = useCallback(() => {
+        fullStatus(loadConfig())
+            .then((next) => setStatus(next))
+            .catch((error) => notify(error.message, 'error'));
+    }, [notify]);
+    const reloadConfig = useCallback(() => {
+        const next = loadConfig();
+        setConfig(next);
+        setDraft(createDraft(next));
+        setRuntime(ensureRuntime());
+    }, []);
+    /**
+     * Run an action with a busy flag and a single place to surface failures, so
+     * no screen can leave the interface spinning or swallow an error.
+     */
+    const run = useCallback((task) => {
+        setBusy(true);
+        Promise.resolve()
+            .then(task)
+            .catch((error) => notify(error.message, 'error'))
+            .finally(() => {
+            setBusy(false);
+            refresh();
+        });
+    }, [notify, refresh]);
+    useEffect(() => {
+        if (!wizardDone)
+            return undefined;
+        refresh();
+        const timer = setInterval(() => {
+            if (!editingId)
+                refresh();
+        }, STATUS_POLL_MS);
+        return () => clearInterval(timer);
+    }, [wizardDone, refresh, editingId]);
+    // Mouse tracking starts on its own where the terminal supports it, and can be
+    // switched off with `m` — while it is on, the terminal's own text selection is
+    // disabled, which is exactly what you want back when copying a pairing URL
+    // out of the pane. Once the user presses `m`, their choice is recorded and the
+    // automatic enable stops interfering.
+    const mouseChoice = useRef(null);
+    useEffect(() => {
+        if (mouseChoice.current !== null)
+            return;
+        if (mouse.supported && !mouse.enabled)
+            mouse.enable();
+    }, [mouse.supported, mouse.enabled, mouse]);
+    const context = {
+        t,
+        locale,
+        config,
+        draft,
+        status,
+        runtime,
+        busy,
+        dirty,
+        editingId,
+        updateDraft: setDraft,
+        reloadConfig,
+        setEditing: setEditingId,
+        notify,
+        run,
+        refresh,
+        message,
+        updateCheck,
+        setUpdateCheck,
+    };
+    useInput((input, key) => {
+        if (key.ctrl && input === 'c') {
+            exit();
+            return;
+        }
+        if (input === 'q') {
+            exit();
+            return;
+        }
+        if (input === 'r') {
+            setMessage(null);
+            refresh();
+            return;
+        }
+        if (input === 'm') {
+            if (!mouse.supported) {
+                notify(t('hint.mouseUnsupported'), 'info');
+                return;
+            }
+            mouseChoice.current = !mouse.enabled;
+            if (mouse.enabled)
+                mouse.disable();
+            else
+                mouse.enable();
+            return;
+        }
+        const index = TABS.findIndex((entry) => entry.id === tab);
+        if (key.rightArrow || (key.tab && !key.shift)) {
+            setTab(TABS[(index + 1) % TABS.length].id);
+            return;
+        }
+        if (key.leftArrow || (key.tab && key.shift)) {
+            setTab(TABS[(index - 1 + TABS.length) % TABS.length].id);
+            return;
+        }
+        const digit = Number.parseInt(input, 10);
+        if (Number.isInteger(digit) && digit >= 1 && digit <= TABS.length)
+            setTab(TABS[digit - 1].id);
+    }, { isActive: wizardDone && editingId === null });
+    if (!wizardDone) {
+        return (_jsx(Wizard, { ctx: context, onDone: () => {
+                reloadConfig();
+                setWizardDone(true);
+                refresh();
+            } }));
+    }
+    const hints = [
+        t('hint.navigate'),
+        t('hint.select'),
+        t('hint.tabs'),
+        dirty ? t('hint.save') : null,
+        mouse.supported
+            ? mouse.enabled
+                ? t('hint.mouseOn')
+                : t('hint.mouseOff')
+            : t('hint.mouseUnsupported'),
+        t('hint.quit'),
+    ].filter(Boolean);
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, paddingY: 1, children: [_jsxs(Box, { marginBottom: 1, flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, children: t('app.name') }), _jsx(Text, { color: theme.muted, children: `  ${t('app.tagline')}` })] }), updateCheck?.updateAvailable ? (_jsx(Text, { color: theme.warn, children: t('update.banner', { latest: updateCheck.latest ?? '', current: updateCheck.current }) })) : null] }), _jsx(Box, { marginBottom: 1, children: TABS.map((entry, entryIndex) => (_jsx(Tab, { label: `${entryIndex + 1} ${t(entry.labelKey)}`, active: entry.id === tab, onSelect: () => setTab(entry.id) }, entry.id))) }), tab === 'overview' ? _jsx(Overview, { ctx: context }) : null, tab === 'pair' ? _jsx(PairScreen, { ctx: context }) : null, tab === 'services' ? _jsx(Services, { ctx: context }) : null, tab === 'relay' ? _jsx(RelayScreen, { ctx: context }) : null, tab === 'keepalive' ? _jsx(Keepalive, { ctx: context }) : null, tab === 'herdr' ? _jsx(HerdrScreen, { ctx: context }) : null, tab === 'about' ? _jsx(About, { ctx: context }) : null, restartPending ? (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.warn, children: t('hint.restartRequired') }) })) : null, _jsx(Footer, { hints: hints })] }));
+}

package/dist/tui/api.js

@@ -0,0 +1,79 @@
+// The only place the TUI reaches into the service layer.
+//
+// Everything below the interface — config, services, keep-alive, pairing — is
+// shared with the CLI. Funnelling it through one module gives the screens a
+// single surface to call.
+import { OFFICIAL_RELAY_URL, configExists, loadConfig } from '../config.js';
+import { configPath, stateDir } from '../paths.js';
+import { bindAddress, resolveAdminOrigin } from '../relay-urls.js';
+import { MIN_HERDR_VERSION, herdrVersion } from '../herdr-command.js';
+import { createTranslator, detectLocale } from '../i18n/index.js';
+import { listReachableAddresses } from '../net-interfaces.js';
+import { createDraft, fieldsForMode, getField, getFieldPlaceholder, isOfficialRelay, requiresRestart, saveDraft, selectedMode, setField, } from '../settings-model.js';
+import { extractPairingCode, requestJson } from '../relay-client.js';
+import { ensureRuntime, regenerateHostIdentity, setRelayPassword } from '../runtime.js';
+import { pair, readLogTail } from '../service.js';
+import { fullStatus, restartAll, startAll, stopAll } from '../lifecycle.js';
+import * as keepalive from '../keepalive/index.js';
+import { canSelfUpdate, checkForUpdate, currentVersion, updateChecksEnabled, installKind, performUpdate, } from '../updater.js';
+export { detectLocale, listReachableAddresses, MIN_HERDR_VERSION, OFFICIAL_RELAY_URL, isOfficialRelay, selectedMode, canSelfUpdate, checkForUpdate, currentVersion, updateChecksEnabled, installKind, performUpdate, bindAddress, configExists, configPath, createDraft, createTranslator, ensureRuntime, extractPairingCode, fieldsForMode, fullStatus, getField, getFieldPlaceholder, herdrVersion, keepalive, loadConfig, pair, readLogTail, regenerateHostIdentity, requiresRestart, restartAll, saveDraft, setField, setRelayPassword, startAll, stateDir, stopAll, };
+/** The command that starts a matching relay, ready to paste on the server. */
+export function relayStartCommand(config, password) {
+    const publicUrl = config.relay.remoteUrl
+        ? config.relay.remoteUrl.replace(/^ws/, 'http')
+        : 'https://relay.example.com';
+    const parts = ['herdr-remote-relay', `--public-url ${publicUrl}`, '--trust-proxy'];
+    if (password)
+        parts.push(`--password '${password.replace(/'/g, "'\\''")}'`);
+    return parts.join(' ');
+}
+/**
+ * Reachability probe used by the relay screen, for local and remote alike.
+ *
+ * Liveness and tenant status are deliberately separate: a relay must be able
+ * to report "I am reachable" before this workstation has enrolled, while the
+ * host count (when available) comes only from this workstation's scoped view.
+ */
+export async function probeRelay(config) {
+    const origin = resolveAdminOrigin(config);
+    let health;
+    try {
+        health = await requestJson(`${origin}/healthz`, { timeout: 4000 });
+    }
+    catch (error) {
+        return { ok: false, message: error.message };
+    }
+    try {
+        const runtime = ensureRuntime();
+        const status = await requestJson(`${origin}/api/status`, {
+            timeout: 4000,
+            headers: {
+                'X-Herdr-Host-Id': runtime.hostId,
+                'X-Herdr-Host-Token': runtime.hostToken,
+            },
+        });
+        return {
+            ok: true,
+            version: String(health.version || status.version || ''),
+            hosts: Array.isArray(status.hosts) ? status.hosts.length : 0,
+        };
+    }
+    catch {
+        // The relay is healthy even when this machine is not enrolled or its host
+        // connector is offline. Do not turn a tenant-auth failure into a network
+        // failure in the configuration TUI.
+        return { ok: true, version: String(health.version || ''), hosts: undefined };
+    }
+}
+export function formatUptime(seconds, t) {
+    if (!Number.isFinite(seconds))
+        return t('common.unknown');
+    const total = Math.max(0, Math.floor(seconds));
+    const hours = Math.floor(total / 3600);
+    const minutes = Math.floor((total % 3600) / 60);
+    if (hours > 0)
+        return `${hours}h ${minutes}m`;
+    if (minutes > 0)
+        return `${minutes}m ${total % 60}s`;
+    return `${total}s`;
+}

package/dist/tui/components/TextField.js

@@ -0,0 +1,50 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import { theme } from '../theme.js';
+// Anything below 0x20, plus DEL: escape sequences and control keys that must
+// never end up as literal text in a field.
+const CONTROL_CHARACTERS = /[\x00-\x1f\x7f]/;
+/**
+ * A single-line editor.
+ *
+ * Small enough to own rather than depend on: the TUI needs exactly one editing
+ * affordance, and keeping it here means the escape/confirm contract is the same
+ * everywhere and stays consistent with `useInput({ isActive })` gating, so a
+ * keystroke never lands in both the editor and the surrounding menu.
+ */
+export function TextField({ value, placeholder, active, mask = false, onSubmit, onCancel, }) {
+    const [buffer, setBuffer] = useState(value);
+    useEffect(() => {
+        if (active)
+            setBuffer(value);
+    }, [active, value]);
+    useInput((input, key) => {
+        if (key.return) {
+            onSubmit(buffer);
+            return;
+        }
+        if (key.escape) {
+            setBuffer(value);
+            onCancel();
+            return;
+        }
+        if (key.backspace || key.delete) {
+            setBuffer((current) => current.slice(0, -1));
+            return;
+        }
+        if (key.ctrl && input === 'u') {
+            setBuffer('');
+            return;
+        }
+        if (input && !key.ctrl && !key.meta && !CONTROL_CHARACTERS.test(input)) {
+            setBuffer((current) => current + input);
+        }
+    }, { isActive: active });
+    const display = active ? buffer : value;
+    const shown = mask && display ? '•'.repeat(Math.min(display.length, 32)) : display;
+    if (!active) {
+        return shown ? _jsx(Text, { children: shown }) : _jsx(Text, { color: theme.muted, children: placeholder ?? '' });
+    }
+    return (_jsxs(Box, { children: [_jsx(Text, { color: theme.accent, children: shown }), _jsx(Text, { color: theme.accent, inverse: true, children: ' ' })] }));
+}