propr-cli 0.8.3 → 0.8.4

package/dist/tui/SetupApp.js

@@ -0,0 +1,586 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Interactive Ink view for `propr setup`.
+ *
+ * The setup engine (../commands/setup/engine.ts) is UI-agnostic: it emits state
+ * through a {@link SetupReporter} and collects user decisions through optional
+ * {@link SetupPrompts} hooks. This module bridges both seams to Ink.
+ *
+ *   - {@link SetupBridge} is the pub/sub bridge. The engine's reporter pushes
+ *     state/log events into it; its prompt primitives (confirm / input / single
+ *     choice / multi choice) let the engine's prompt hooks request a decision and
+ *     await the user's answer. Only one prompt is ever in flight because the
+ *     engine runs steps sequentially.
+ *   - {@link SetupApp} subscribes to the bridge, renders every step with its
+ *     status/title/detail, streams recent log lines, and renders the active
+ *     prompt with keyboard navigation (choices) or text entry (inputs).
+ *   - {@link buildSetupPrompts} maps the engine's typed prompt hooks onto the
+ *     bridge primitives.
+ *
+ * Ctrl-C cancels: it rejects any in-flight prompt (so the engine unwinds and
+ * `runSetup` resolves) and exits the Ink app so no session is left running.
+ */
+import { useEffect, useReducer, useState } from "react";
+import { Box, Text, useApp, useInput } from "ink";
+import { DEFAULT_PROPR_GH_RELAY_URL } from "../vendor/shared/index.js";
+import { INTAKE_DOCS_URL, WEBHOOK_DOCS_URL, intakeModeOptions, } from "../commands/setup/github.js";
+const SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const MAX_LOG_LINES = 8;
+/** Thrown into a pending prompt when the user cancels with Ctrl-C. */
+export class SetupCancelledError extends Error {
+    constructor() {
+        super("setup cancelled");
+        this.name = "SetupCancelledError";
+    }
+}
+/**
+ * Pub/sub bridge between the async setup engine and the React tree, plus the
+ * prompt primitives the engine's hooks call to collect a decision and wait for
+ * the user. The same history-replay pattern as CheckHub guarantees that events
+ * emitted before the component subscribes are still delivered exactly once.
+ */
+export class SetupBridge {
+    listeners = new Set();
+    history = [];
+    nextId = 1;
+    resolvers = new Map();
+    rejecters = new Map();
+    cancelled = false;
+    push(event) {
+        this.history.push(event);
+        for (const listener of [...this.listeners])
+            listener(event);
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        for (const event of this.history)
+            listener(event);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    // --- engine → UI -------------------------------------------------------
+    emitState(state) {
+        this.push({ type: "state", state });
+    }
+    emitLog(line) {
+        this.push({ type: "log", line });
+    }
+    /** Reflect the final state and tell the view the engine is finished. */
+    finish(state) {
+        this.push({ type: "state", state });
+        this.push({ type: "done" });
+    }
+    // --- engine prompt primitives (return a promise the UI resolves) -------
+    request(make) {
+        // After cancellation every further prompt rejects immediately so the engine
+        // unwinds instead of blocking on a view that is already gone.
+        if (this.cancelled)
+            return Promise.reject(new SetupCancelledError());
+        const id = this.nextId++;
+        return new Promise((resolve, reject) => {
+            this.resolvers.set(id, resolve);
+            this.rejecters.set(id, reject);
+            this.push({ type: "prompt", prompt: make(id) });
+        });
+    }
+    confirm(req) {
+        return this.request((id) => ({
+            id,
+            kind: "confirm",
+            title: req.title,
+            detail: req.detail,
+            defaultValue: req.defaultValue ?? false,
+        }));
+    }
+    input(req) {
+        return this.request((id) => ({
+            id,
+            kind: "input",
+            title: req.title,
+            detail: req.detail,
+            defaultValue: req.defaultValue ?? "",
+            placeholder: req.placeholder,
+            mask: req.mask,
+        }));
+    }
+    select(req) {
+        return this.request((id) => ({
+            id,
+            kind: "select",
+            title: req.title,
+            detail: req.detail,
+            options: req.options,
+            defaultIndex: req.defaultIndex ?? 0,
+        }));
+    }
+    multiSelect(req) {
+        return this.request((id) => ({
+            id,
+            kind: "multi",
+            title: req.title,
+            detail: req.detail,
+            options: req.options,
+            defaultSelected: req.defaultSelected ?? [],
+        }));
+    }
+    // --- UI → engine -------------------------------------------------------
+    /** Resolve the in-flight prompt with the user's answer. */
+    resolve(id, value) {
+        const resolve = this.resolvers.get(id);
+        if (!resolve)
+            return;
+        this.resolvers.delete(id);
+        this.rejecters.delete(id);
+        this.push({ type: "prompt-done", id });
+        resolve(value);
+    }
+    /** Reject any in-flight prompt; further prompts reject immediately. */
+    cancel() {
+        this.cancelled = true;
+        const pending = [...this.rejecters.entries()];
+        this.resolvers.clear();
+        this.rejecters.clear();
+        for (const [, reject] of pending)
+            reject(new SetupCancelledError());
+    }
+}
+/**
+ * Map the engine's typed prompt hooks onto the bridge primitives. Every hook
+ * keeps the engine's safe-default contract: a blank input or a "keep" choice
+ * leaves existing configuration untouched.
+ */
+export function buildSetupPrompts(bridge) {
+    return {
+        async resolveStackRoot({ currentRoot, init }) {
+            const entered = await bridge.input({
+                title: "Stack root directory",
+                detail: init.initialized
+                    ? `A stack already exists at ${currentRoot}.`
+                    : `The stack will be scaffolded at ${currentRoot}.`,
+                defaultValue: currentRoot,
+            });
+            const rootDir = entered.trim() || currentRoot;
+            // Only offer a re-scaffold when the resolved root already looks complete;
+            // an incomplete root is scaffolded by the engine regardless.
+            let reinitialize = false;
+            if (init.initialized && rootDir === currentRoot) {
+                reinitialize = await bridge.confirm({
+                    title: "Re-scaffold the stack?",
+                    detail: "Fill in any missing files. Your existing .env is preserved.",
+                    defaultValue: false,
+                });
+            }
+            return { rootDir, reinitialize };
+        },
+        async selectAgents({ available, detected }) {
+            const detectedSet = new Set(detected);
+            return bridge.multiSelect({
+                title: "Select agents to enable",
+                detail: "Their images are pulled and host credentials recorded in .env.",
+                options: available.map((type) => ({
+                    label: type,
+                    value: type,
+                    hint: detectedSet.has(type) ? "detected" : undefined,
+                })),
+                defaultSelected: detected,
+            });
+        },
+        async configureGithubAuth({ current }) {
+            // Token relay (the hosted ProPR GitHub App) leads as the recommended path.
+            // "Keep current configuration" is offered only when there is an existing
+            // config to keep — on a fresh install there is nothing to preserve, so the
+            // relay option is the first (and default) choice.
+            const options = [];
+            if (current.mode !== "none") {
+                options.push({ label: "Keep current configuration", value: "keep", hint: current.mode });
+            }
+            options.push({ label: "Token relay (use the ProPR GitHub App)", value: "relay" });
+            options.push({ label: "Custom GitHub App (set up your own GitHub App)", value: "app" });
+            const choice = await bridge.select({
+                title: "GitHub authentication",
+                detail: `Currently detected: ${current.mode}.`,
+                options,
+                defaultIndex: 0,
+            });
+            if (choice === "keep")
+                return { keep: true };
+            // Switching to a real auth mode must explicitly turn demo mode off:
+            // detectGithubAuthMode reads PROPR_DEMO_MODE, so a leftover
+            // PROPR_DEMO_MODE=true would keep resolving as demo and ignore the App/relay
+            // config the user just entered.
+            if (choice === "relay") {
+                // No manual URL/token entry: the engine enrolls with the hosted relay
+                // using the stored `propr login` token, discovers the installation, and
+                // mints the token. Only the relay base URL is asked, prefilled with the
+                // hosted default (Enter accepts it; override for a self-hosted relay).
+                const relayUrl = await bridge.input({
+                    title: "Relay URL",
+                    detail: "Press Enter for the hosted ProPR relay; override only for a self-hosted relay.",
+                    defaultValue: DEFAULT_PROPR_GH_RELAY_URL,
+                });
+                return { mode: "relay", enrollRelay: { relayUrl: relayUrl.trim() || DEFAULT_PROPR_GH_RELAY_URL } };
+            }
+            const appId = await bridge.input({ title: "GitHub App ID", defaultValue: "" });
+            // The CLI stack bind-mounts the key from the host via HOST_GH_PRIVATE_KEY
+            // (NOT the in-container GH_PRIVATE_KEY_PATH, which is the launcher path) —
+            // so `propr start` can find it. Ask for the host path and write that key.
+            const privateKeyPath = await bridge.input({ title: "Host path to the App private key (.pem)", defaultValue: "" });
+            const installationId = await bridge.input({ title: "Installation ID", defaultValue: "" });
+            return {
+                mode: "app",
+                vars: { PROPR_DEMO_MODE: "false", GH_AUTH_MODE: "app", GH_APP_ID: appId, HOST_GH_PRIVATE_KEY: privateKeyPath, GH_INSTALLATION_ID: installationId },
+            };
+        },
+        // Note: confirmGithubLogin is intentionally not implemented here. The
+        // interactive `gh auth login` would have to take over the terminal mid-render,
+        // which the full-screen Ink wizard can't do cleanly — so relay enrollment
+        // without a stored token surfaces "run `propr login`" guidance instead
+        // (see enrollRelayForSetup in engine.ts).
+        async selectInstallation({ installations }) {
+            return bridge.select({
+                title: "Choose a GitHub App installation",
+                detail: "Your account can access more than one; the relay token is minted for the one you pick.",
+                options: installations.map((i) => ({
+                    label: `${i.account_login} (${i.account_type})`,
+                    value: String(i.installation_id),
+                    hint: String(i.installation_id),
+                })),
+                defaultIndex: 0,
+            });
+        },
+        async configureIntake({ authMode, defaultMode, currentMode }) {
+            // Only some intake modes are valid for the chosen auth mode (e.g. direct
+            // webhooks need an own GitHub App, the routing WebSocket needs the ProPR
+            // relay). Show every mode, but mark the unsupported ones inactive with the
+            // reason so the user understands why a path is closed.
+            const baseLabel = {
+                routing_websocket: "Routing WebSocket — hosted ProPR relay (recommended)",
+                polling: "Polling (no inbound webhooks)",
+                direct_webhook: "Direct webhooks (own GitHub App + a signing secret)",
+            };
+            const options = intakeModeOptions(authMode).map((opt) => ({
+                label: baseLabel[opt.mode],
+                value: opt.mode,
+                hint: opt.note,
+                disabled: !opt.available,
+            }));
+            options.push({ label: "Keep current", value: "keep", hint: currentMode });
+            let defaultIndex = Math.max(0, options.findIndex((o) => o.value === defaultMode));
+            // If the recommended default isn't valid for this auth mode, fall back to
+            // the first selectable option rather than pre-selecting a disabled one.
+            if (options[defaultIndex]?.disabled)
+                defaultIndex = options.findIndex((o) => !o.disabled);
+            const choice = await bridge.select({
+                title: "GitHub event intake",
+                detail: `How the backend receives GitHub events. Docs: ${INTAKE_DOCS_URL}`,
+                options,
+                defaultIndex,
+            });
+            if (choice === "keep")
+                return { keep: true };
+            if (choice === "direct_webhook") {
+                // The API refuses to boot in direct_webhook mode with no secret — keep
+                // asking until a non-empty secret is entered.
+                let secret = "";
+                while (secret === "") {
+                    secret = (await bridge.input({
+                        title: "Webhook signing secret",
+                        detail: `Verifies GitHub webhook signatures; forged payloads are rejected. Docs: ${WEBHOOK_DOCS_URL}`,
+                        mask: true,
+                    })).trim();
+                }
+                return { mode: "direct_webhook", webhookSecret: secret };
+            }
+            return { mode: choice };
+        },
+        async confirmStartStack({ rootDir, alreadyRunning }) {
+            // A running stack is reused without prompting — nothing to start.
+            if (alreadyRunning)
+                return true;
+            return bridge.confirm({
+                title: "Start the stack now?",
+                detail: `Launch the local control-plane services in ${rootDir}.`,
+                defaultValue: true,
+            });
+        },
+        async confirmAgentLogin({ candidates }) {
+            return bridge.multiSelect({
+                title: "Authenticate agents through their images?",
+                detail: "Log in inside each agent's Docker image; credentials are written to the mounted host directory. Leave empty to skip.",
+                options: candidates.map((type) => ({ label: type, value: type })),
+                defaultSelected: [],
+            });
+        },
+        async configureWhitelist({ current, demoMode }) {
+            if (demoMode)
+                return null;
+            const entered = await bridge.input({
+                title: "Allowed GitHub usernames",
+                detail: 'Comma-separated; only these users can trigger ProPR. Blank keeps the current value, "none" clears it.',
+                defaultValue: current.join(", "),
+            });
+            const trimmed = entered.trim();
+            if (trimmed === "")
+                return null;
+            // An explicit "none" empties the whitelist, mirroring the sequential
+            // renderer — without this it would be parsed as a literal username "none".
+            if (trimmed.toLowerCase() === "none")
+                return [];
+            return trimmed
+                .split(",")
+                .map((entry) => entry.trim())
+                .filter(Boolean);
+        },
+        async addRepository() {
+            const add = await bridge.confirm({
+                title: "Connect a repository now?",
+                detail: "Optionally add a first repository for ProPR to monitor.",
+                defaultValue: false,
+            });
+            if (!add)
+                return null;
+            const fullName = (await bridge.input({ title: "Repository (owner/repo)", defaultValue: "" })).trim();
+            if (!fullName)
+                return null;
+            const baseBranch = (await bridge.input({ title: "Base branch (optional, blank for the default)", defaultValue: "" })).trim();
+            return { fullName, baseBranch: baseBranch || undefined };
+        },
+        async launchUi({ url }) {
+            if (!url)
+                return false;
+            return bridge.confirm({ title: "Open the ProPR web UI?", detail: url, defaultValue: false });
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// Rendering
+// ---------------------------------------------------------------------------
+const STATUS_GLYPH = {
+    pending: "○",
+    done: "✓",
+    skipped: "−",
+    warning: "!",
+    failed: "✗",
+};
+function statusColor(status) {
+    switch (status) {
+        case "done":
+            return "green";
+        case "warning":
+            return "yellow";
+        case "failed":
+            return "red";
+        case "active":
+            return "cyan";
+        default:
+            return "gray";
+    }
+}
+function StepGlyph({ status, frame }) {
+    if (status === "active") {
+        return _jsx(Text, { color: "cyan", children: SPINNER[frame % SPINNER.length] });
+    }
+    return _jsx(Text, { color: statusColor(status), children: STATUS_GLYPH[status] });
+}
+function StepRow({ step, frame }) {
+    const active = step.status === "active";
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Box, { flexShrink: 0, marginRight: 1, children: _jsx(StepGlyph, { status: step.status, frame: frame }) }), _jsx(Text, { bold: active, color: active ? "cyan" : undefined, children: step.title }), step.optional ? _jsx(Text, { dimColor: true, children: " (optional)" }) : null] }), step.detail ? (_jsx(Box, { paddingLeft: 2, children: _jsx(Text, { color: statusColor(step.status), dimColor: step.status !== "failed" && step.status !== "warning", children: step.detail }) })) : null, step.nextAction ? (_jsx(Box, { paddingLeft: 2, children: _jsxs(Text, { dimColor: true, children: ["\u21B3 ", step.nextAction] }) })) : null] }));
+}
+function PromptHeader({ prompt }) {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "cyan", bold: true, children: prompt.title }), prompt.detail ? _jsx(Text, { dimColor: true, children: prompt.detail }) : null] }));
+}
+function PromptView(props) {
+    const { prompt } = props;
+    if (prompt.kind === "confirm") {
+        const yes = props.highlighted === 0;
+        return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(PromptHeader, { prompt: prompt }), _jsxs(Box, { marginTop: 1, children: [_jsxs(Text, { color: yes ? "cyan" : undefined, bold: yes, children: [yes ? "❯ " : "  ", "Yes"] }), _jsx(Text, { children: " " }), _jsxs(Text, { color: !yes ? "cyan" : undefined, bold: !yes, children: [!yes ? "❯ " : "  ", "No"] })] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "\u2190/\u2192 or y/n select \u00B7 enter confirm \u00B7 Ctrl-C cancel" }) })] }));
+    }
+    if (prompt.kind === "input") {
+        const shown = prompt.mask ? "•".repeat(props.text.length) : props.text;
+        const before = shown.slice(0, props.cursor);
+        const at = shown.slice(props.cursor, props.cursor + 1) || " ";
+        const after = shown.slice(props.cursor + 1);
+        const empty = props.text.length === 0;
+        return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(PromptHeader, { prompt: prompt }), _jsxs(Box, { marginTop: 1, children: [_jsx(Text, { children: "\u276F " }), empty && prompt.placeholder ? (_jsx(Text, { dimColor: true, children: prompt.placeholder })) : (_jsxs(Text, { children: [before, _jsx(Text, { inverse: true, children: at }), after] }))] }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: ["enter submit", prompt.defaultValue ? ` (blank → ${prompt.mask ? "•".repeat(prompt.defaultValue.length) : prompt.defaultValue})` : "", " \u00B7 Ctrl-C cancel"] }) })] }));
+    }
+    if (prompt.kind === "select") {
+        return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(PromptHeader, { prompt: prompt }), _jsx(Box, { flexDirection: "column", marginTop: 1, children: prompt.options.map((option, index) => {
+                        const active = index === props.highlighted;
+                        const disabled = option.disabled ?? false;
+                        return (_jsxs(Box, { children: [_jsxs(Text, { color: active ? "cyan" : undefined, bold: active, dimColor: disabled && !active, children: [active ? "❯ " : "  ", option.label, disabled ? " — unavailable" : ""] }), option.hint ? _jsxs(Text, { dimColor: true, children: [" (", option.hint, ")"] }) : null] }, option.value));
+                    }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "\u2191/\u2193 select \u00B7 enter choose \u00B7 Ctrl-C cancel" }) })] }));
+    }
+    // multi
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(PromptHeader, { prompt: prompt }), _jsx(Box, { flexDirection: "column", marginTop: 1, children: prompt.options.map((option, index) => {
+                    const active = index === props.highlighted;
+                    const checked = props.selected.has(option.value);
+                    return (_jsxs(Box, { children: [_jsxs(Text, { color: active ? "cyan" : undefined, bold: active, children: [active ? "❯ " : "  ", checked ? "[x] " : "[ ] ", option.label] }), option.hint ? _jsxs(Text, { dimColor: true, children: [" (", option.hint, ")"] }) : null] }, option.value));
+                }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "\u2191/\u2193 move \u00B7 space toggle \u00B7 enter confirm \u00B7 Ctrl-C cancel" }) })] }));
+}
+function uiReducer(state, event) {
+    switch (event.type) {
+        case "state":
+            return { ...state, setup: event.state };
+        case "log":
+            return { ...state, logs: [...state.logs, event.line].slice(-MAX_LOG_LINES) };
+        case "prompt":
+            return { ...state, prompt: event.prompt };
+        case "prompt-done":
+            return state.prompt && state.prompt.id === event.id ? { ...state, prompt: null } : state;
+        case "done":
+            return { ...state, done: true, prompt: null };
+        default:
+            return state;
+    }
+}
+export function SetupApp({ bridge, onCancel }) {
+    const { exit } = useApp();
+    const [ui, dispatch] = useReducer(uiReducer, { setup: null, logs: [], prompt: null, done: false });
+    const [frame, setFrame] = useState(0);
+    // Per-prompt local input state, reset whenever a new prompt arrives.
+    const [text, setText] = useState("");
+    const [cursor, setCursor] = useState(0);
+    const [highlighted, setHighlighted] = useState(0);
+    const [selected, setSelected] = useState(() => new Set());
+    useEffect(() => bridge.subscribe(dispatch), [bridge]);
+    const prompt = ui.prompt;
+    const promptId = prompt?.id;
+    useEffect(() => {
+        if (!prompt)
+            return;
+        if (prompt.kind === "input") {
+            setText("");
+            setCursor(0);
+        }
+        else if (prompt.kind === "confirm") {
+            setHighlighted(prompt.defaultValue ? 0 : 1);
+        }
+        else if (prompt.kind === "select") {
+            let idx = Math.min(Math.max(prompt.defaultIndex, 0), prompt.options.length - 1);
+            // Never start the highlight on a disabled option.
+            if (prompt.options[idx]?.disabled) {
+                const firstEnabled = prompt.options.findIndex((o) => !o.disabled);
+                if (firstEnabled !== -1)
+                    idx = firstEnabled;
+            }
+            setHighlighted(idx);
+        }
+        else {
+            setHighlighted(0);
+            setSelected(new Set(prompt.defaultSelected));
+        }
+        // Keyed on the prompt id so each distinct request reinitializes cleanly.
+    }, [promptId]); // eslint-disable-line react-hooks/exhaustive-deps
+    // Animate the spinner while the engine is still working.
+    useEffect(() => {
+        if (ui.done)
+            return;
+        const timer = setInterval(() => setFrame((f) => f + 1), 80);
+        return () => clearInterval(timer);
+    }, [ui.done]);
+    // Let the final frame paint, then unmount so renderSetupWizard resolves.
+    useEffect(() => {
+        if (!ui.done)
+            return;
+        const timer = setTimeout(() => exit(), 40);
+        return () => clearTimeout(timer);
+    }, [ui.done, exit]);
+    useInput((input, key) => {
+        if (key.ctrl && input === "c") {
+            onCancel?.();
+            bridge.cancel();
+            exit();
+            return;
+        }
+        if (!prompt)
+            return;
+        if (prompt.kind === "confirm") {
+            if (key.leftArrow || key.rightArrow)
+                setHighlighted((h) => (h === 0 ? 1 : 0));
+            else if (input.toLowerCase() === "y")
+                bridge.resolve(prompt.id, true);
+            else if (input.toLowerCase() === "n")
+                bridge.resolve(prompt.id, false);
+            else if (key.return)
+                bridge.resolve(prompt.id, highlighted === 0);
+            return;
+        }
+        if (prompt.kind === "input") {
+            if (key.return) {
+                const value = text.length > 0 ? text : prompt.defaultValue;
+                bridge.resolve(prompt.id, value);
+            }
+            else if (key.leftArrow) {
+                setCursor((c) => Math.max(0, c - 1));
+            }
+            else if (key.rightArrow) {
+                setCursor((c) => Math.min(text.length, c + 1));
+            }
+            else if (key.backspace || key.delete) {
+                if (cursor > 0) {
+                    setText((t) => t.slice(0, cursor - 1) + t.slice(cursor));
+                    setCursor((c) => Math.max(0, c - 1));
+                }
+            }
+            else if (input && !key.ctrl && !key.meta && !key.upArrow && !key.downArrow) {
+                setText((t) => t.slice(0, cursor) + input + t.slice(cursor));
+                setCursor((c) => c + input.length);
+            }
+            return;
+        }
+        if (prompt.kind === "select") {
+            const count = prompt.options.length;
+            // Step over disabled options so the highlight only ever rests on a choice
+            // the user can actually pick.
+            const step = (from, dir) => {
+                for (let k = 1; k <= count; k++) {
+                    const i = (from + dir * k + count * k) % count;
+                    if (!prompt.options[i].disabled)
+                        return i;
+                }
+                return from;
+            };
+            if (key.upArrow)
+                setHighlighted((h) => step(h, -1));
+            else if (key.downArrow)
+                setHighlighted((h) => step(h, 1));
+            else if (key.return && !prompt.options[highlighted].disabled) {
+                bridge.resolve(prompt.id, prompt.options[highlighted].value);
+            }
+            return;
+        }
+        // multi
+        const count = prompt.options.length;
+        // With no options there is nothing to highlight or toggle — mirror the
+        // sequential wizard, which skips the prompt entirely and yields []. Only Enter
+        // is meaningful (it resolves to the empty set); arrow/space are ignored so we
+        // never index an empty array or compute a NaN highlight (`h % 0`).
+        if (count === 0) {
+            if (key.return)
+                bridge.resolve(prompt.id, []);
+            return;
+        }
+        if (key.upArrow)
+            setHighlighted((h) => (h - 1 + count) % count);
+        else if (key.downArrow)
+            setHighlighted((h) => (h + 1) % count);
+        else if (input === " ") {
+            const value = prompt.options[highlighted].value;
+            setSelected((prev) => {
+                const next = new Set(prev);
+                if (next.has(value))
+                    next.delete(value);
+                else
+                    next.add(value);
+                return next;
+            });
+        }
+        else if (key.return) {
+            const chosen = prompt.options.filter((option) => selected.has(option.value)).map((option) => option.value);
+            bridge.resolve(prompt.id, chosen);
+        }
+    });
+    const setup = ui.setup;
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, children: "ProPR setup" }), setup ? _jsxs(Text, { dimColor: true, children: ["  (stack root: ", setup.rootDir, ")"] }) : null] }), _jsx(Box, { flexDirection: "column", marginTop: 1, children: setup ? (setup.steps.map((step) => _jsx(StepRow, { step: step, frame: frame }, step.id))) : (_jsxs(Text, { dimColor: true, children: [SPINNER[frame % SPINNER.length], " preparing\u2026"] })) }), ui.logs.length > 0 && !ui.done ? (_jsx(Box, { flexDirection: "column", marginTop: 1, children: ui.logs.map((line, index) => (_jsx(Text, { dimColor: true, children: line }, index))) })) : null, prompt && !ui.done ? (_jsx(PromptView, { prompt: prompt, text: text, cursor: cursor, highlighted: highlighted, selected: selected })) : null, ui.done ? (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Setup finished." }) })) : null] }));
+}