@flowscripter/dynamic-cli-framework 1.7.2 → 1.7.4

package/dist/src/service/printer/terminal/Progress.js

@@ -0,0 +1,271 @@
+const RATE_SMOOTHING_FACTOR = 0.005;
+export { ProgressStyle } from "../../../api/service/core/PrinterService.js";
+import { ProgressStyle } from "../../../api/service/core/PrinterService.js";
+const STYLE_CHARS = {
+    [ProgressStyle.STROKE]: { complete: "=", remaining: "-" },
+    [ProgressStyle.FILL]: { complete: "▰", remaining: "▱" },
+};
+export default class Progress {
+    #terminal;
+    #styler;
+    #bars = new Map();
+    #timer;
+    #isDirty = false;
+    #currentRenderedBarCount = 0;
+    #lastRenderTime = 0;
+    #comColor = 0x5f8700;
+    #remColor = 0x585858;
+    #labColor = 0x585858;
+    #valColor = 0x808080;
+    #style = ProgressStyle.STROKE;
+    constructor(terminal, styler) {
+        this.#terminal = terminal;
+        this.#styler = styler;
+    }
+    add(units, message, total, current) {
+        if (total < 0) {
+            total = 100;
+        }
+        if (current < 0) {
+            current = 0;
+        }
+        if (current > total) {
+            current = total;
+        }
+        this.#bars.set(this.#bars.size + 1, {
+            name: message,
+            current,
+            total,
+            units,
+            startMillis: Date.now(),
+        });
+        // force render on next timeout
+        this.#isDirty = true;
+        // start rendering timer
+        if (this.#timer === undefined) {
+            this.#timer = setInterval(async () => {
+                await this.#renderBars();
+            }, 100);
+        }
+        return this.#bars.size;
+    }
+    #updateRate(bar, current) {
+        const now = Date.now();
+        if (bar.lastMillis === undefined) {
+            bar.rate = ((current - bar.current) * 1000) / (now - bar.startMillis);
+        }
+        else {
+            let currentRate = ((current - bar.current) * 1000) / (now - bar.lastMillis);
+            if (!isFinite(currentRate)) {
+                currentRate = 0;
+            }
+            bar.rate = currentRate * RATE_SMOOTHING_FACTOR + bar.rate * (1 - RATE_SMOOTHING_FACTOR);
+        }
+        bar.lastMillis = now;
+    }
+    update(handle, current, message) {
+        if (!this.#bars.has(handle)) {
+            return;
+        }
+        const bar = this.#bars.get(handle);
+        if (current < 0) {
+            current = 0;
+        }
+        if (current > bar.total) {
+            current = bar.total;
+        }
+        if (current === bar.total && bar.endMillis === undefined) {
+            bar.endMillis = Date.now();
+        }
+        this.#updateRate(bar, current);
+        bar.current = current;
+        if (message !== undefined) {
+            bar.name = message;
+        }
+        // force render on next timeout
+        this.#isDirty = true;
+    }
+    async hide(handle) {
+        // clear specified bar
+        if (this.#bars.has(handle)) {
+            this.#bars.delete(handle);
+        }
+        // if no more bars, effectively this is a pause
+        if (this.#bars.size === 0) {
+            await this.pause();
+            return;
+        }
+        // otherwise, force render on next timeout
+        this.#isDirty = true;
+    }
+    async hideAll() {
+        // clear all bars
+        this.#bars.clear();
+        await this.pause();
+    }
+    async pause() {
+        if (this.#timer === undefined) {
+            return;
+        }
+        this.#isDirty = false;
+        // stop rendering timer
+        clearInterval(this.#timer);
+        this.#timer = undefined;
+        // clear the previously rendered bars
+        await this.#terminal.clearUpLines(this.#currentRenderedBarCount * 2);
+        this.#currentRenderedBarCount = 0;
+        // restore the cursor
+        await this.#terminal.showCursor();
+    }
+    resume() {
+        // don't resume if nothing to render
+        if (this.#bars.size === 0) {
+            return;
+        }
+        // force render on next timeout
+        this.#isDirty = true;
+        // start rendering timer
+        if (this.#timer === undefined) {
+            this.#timer = setInterval(async () => {
+                await this.#renderBars();
+            }, 100);
+        }
+    }
+    async #renderBars() {
+        const now = Date.now();
+        // force render after one second to update newly calculated eta
+        if (now - this.#lastRenderTime >= 1000 && !this.#isDirty) {
+            this.#bars.forEach((bar) => this.#updateRate(bar, bar.current));
+            this.#isDirty = true;
+        }
+        // don't render if we don't need to
+        if (!this.#isDirty) {
+            return;
+        }
+        this.#lastRenderTime = now;
+        const consoleWidth = this.#terminal.columns();
+        const lines = [];
+        const barInfo = [];
+        this.#bars.forEach((bar) => {
+            const name = `${this.#styler.colorText(bar.name, this.#valColor)}${this.#styler.colorText(":", this.#labColor)}`;
+            const prefix = `${this.#styler.colorText("[", this.#labColor)}`;
+            let visibleWidth = 1;
+            const percentString = ((bar.current / bar.total) * 100).toFixed(2);
+            const percent = this.#styler.colorText(percentString, this.#valColor) +
+                this.#styler.colorText("%,", this.#labColor);
+            visibleWidth += percentString.length + 1;
+            const rateText = bar.rate === undefined ? "-" : bar.rate.toFixed(2) + "";
+            const rate = `${this.#styler.colorText(rateText, this.#valColor)}`;
+            let suffix = `${this.#styler.colorText("]", this.#labColor)} ${percent} `;
+            visibleWidth += 3;
+            if (bar.current === bar.total) {
+                const taken = this.#formatTime(bar.endMillis - bar.startMillis);
+                const totalString = bar.total + "";
+                suffix += `${this.#styler.colorText(totalString, this.#valColor)}${this.#styler.colorText(bar.units + ", rate:", this.#labColor)} ${rate}${this.#styler.colorText(bar.units + "/s, time taken:", this.#labColor)} ${taken}`;
+                visibleWidth +=
+                    totalString.length +
+                        bar.units.length +
+                        7 +
+                        1 +
+                        rateText.length +
+                        bar.units.length +
+                        15 +
+                        1 +
+                        taken.length;
+            }
+            else {
+                const remaining = bar.rate === undefined || bar.rate === 0
+                    ? "-"
+                    : this.#formatTime(((bar.total - bar.current) / bar.rate) * 1000);
+                const currentString = bar.current + "";
+                const totalString = bar.total + "";
+                suffix += `${this.#styler.colorText(currentString, this.#valColor)}${this.#styler.colorText("/", this.#labColor)}${this.#styler.colorText(totalString, this.#valColor)}${this.#styler.colorText(bar.units + ", rate:", this.#labColor)} ${rate}${this.#styler.colorText(bar.units + "/s, time remaining:", this.#labColor)} ${remaining}`;
+                visibleWidth +=
+                    currentString.length +
+                        1 +
+                        totalString.length +
+                        bar.units.length +
+                        7 +
+                        1 +
+                        rateText.length +
+                        bar.units.length +
+                        19 +
+                        1 +
+                        remaining.length;
+            }
+            let available = consoleWidth - visibleWidth;
+            if (available < 0) {
+                available = 0;
+            }
+            barInfo.push({
+                name,
+                prefix,
+                available,
+                suffix,
+                bar,
+            });
+        });
+        let totalLength = consoleWidth;
+        barInfo.forEach((barInfo) => {
+            if (barInfo.available < totalLength) {
+                totalLength = barInfo.available;
+            }
+        });
+        totalLength = Math.min(50, totalLength);
+        barInfo.forEach((barInfo) => {
+            const completeLength = Math.floor((totalLength * barInfo.bar.current) / barInfo.bar.total);
+            const chars = STYLE_CHARS[this.#style];
+            const complete = this.#styler.colorText(chars.complete.repeat(completeLength), this.#comColor);
+            const remaining = this.#styler.colorText(chars.remaining.repeat(totalLength - completeLength), this.#remColor);
+            lines.push(barInfo.name);
+            lines.push(barInfo.prefix + complete + remaining + barInfo.suffix);
+        });
+        // hide the cursor before rendering
+        await this.#terminal.hideCursor();
+        // clear the previously rendered bars
+        await this.#terminal.clearUpLines(this.#currentRenderedBarCount * 2);
+        // rendere the new bars
+        await this.#terminal.write(lines.join("\n") + "\n");
+        // save count rendered bars so we can clear on the next render cycle
+        this.#currentRenderedBarCount = barInfo.length;
+        // show the cursor if there are no bars or the timer is not running
+        if (this.#bars.size === 0 || this.#timer === undefined) {
+            await this.#terminal.showCursor();
+        }
+        this.#isDirty = false;
+    }
+    set completeColor(color) {
+        this.#comColor = color;
+    }
+    set remainingColor(color) {
+        this.#remColor = color;
+    }
+    set labelColor(color) {
+        this.#labColor = color;
+    }
+    set valueColor(color) {
+        this.#valColor = color;
+    }
+    set progressStyle(style) {
+        this.#style = style;
+    }
+    #formatTime(millis) {
+        let sec = millis / 1000;
+        if (sec < 60) {
+            return `${this.#styler.colorText(sec.toFixed(0), this.#valColor)}${this.#styler.colorText("s", this.#labColor)}`;
+        }
+        let min = Math.floor(sec / 60);
+        sec %= 60;
+        if (min < 60) {
+            return `${this.#styler.colorText(min.toFixed(0), this.#valColor)}${this.#styler.colorText("m", this.#labColor)} ${this.#styler.colorText(sec.toFixed(0), this.#valColor)}${this.#styler.colorText("s", this.#labColor)}`;
+        }
+        let hour = Math.floor(min / 60);
+        min %= 60;
+        if (hour < 24) {
+            return `${this.#styler.colorText(hour.toFixed(0), this.#valColor)}${this.#styler.colorText("h", this.#labColor)} ${this.#styler.colorText(min.toFixed(0), this.#valColor)}${this.#styler.colorText("m", this.#labColor)} ${this.#styler.colorText(sec.toFixed(0), this.#valColor)}${this.#styler.colorText("s", this.#labColor)}`;
+        }
+        const day = Math.floor(hour / 24);
+        hour %= 24;
+        return `${this.#styler.colorText(day.toFixed(0), this.#valColor)}${this.#styler.colorText("d", this.#labColor)} ${this.#styler.colorText(hour.toFixed(0), this.#valColor)}${this.#styler.colorText("h", this.#labColor)} ${this.#styler.colorText(min.toFixed(0), this.#valColor)}${this.#styler.colorText("m", this.#labColor)} ${this.#styler.colorText(sec.toFixed(0), this.#valColor)}${this.#styler.colorText("s", this.#labColor)}`;
+    }
+}

package/dist/src/service/printer/terminal/Spinner.js

@@ -0,0 +1,83 @@
+const BOX_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const STAR_FRAMES = ["★", "✶", "✷", "✹", "✷", "✶", "★", "✦"];
+export { SpinnerStyle } from "../../../api/service/core/PrinterService.js";
+import { SpinnerStyle } from "../../../api/service/core/PrinterService.js";
+export default class Spinner {
+    #isShown = false;
+    #message;
+    #frameIndex = 0;
+    #timer;
+    #spinColor = 0x8a8a8a;
+    #msgColor = 0x808080;
+    #style = SpinnerStyle.BOX;
+    #terminal;
+    #styler;
+    constructor(terminal, styler) {
+        this.#terminal = terminal;
+        this.#styler = styler;
+    }
+    get #frames() {
+        return this.#style === SpinnerStyle.STAR ? STAR_FRAMES : BOX_FRAMES;
+    }
+    async #nextFrame() {
+        if (!this.#isShown) {
+            return;
+        }
+        const frames = this.#frames;
+        await this.#terminal.clearLine();
+        if (this.#message) {
+            await this.#terminal.write(`${this.#styler.colorText(frames[this.#frameIndex], this.#spinColor)} ${this.#styler.colorText(this.#message, this.#msgColor)}`);
+        }
+        else {
+            await this.#terminal.write(this.#styler.colorText(frames[this.#frameIndex], this.#spinColor));
+        }
+        this.#frameIndex = (this.#frameIndex + 1) % frames.length;
+    }
+    async show(message) {
+        this.#message = message;
+        if (this.#isShown) {
+            return Promise.resolve();
+        }
+        this.#isShown = true;
+        this.#frameIndex = 0;
+        this.#timer = setInterval(async () => {
+            await this.#nextFrame();
+        }, 100);
+        await this.#terminal.hideCursor();
+    }
+    async hide() {
+        if (!this.#isShown) {
+            return Promise.resolve();
+        }
+        this.#isShown = false;
+        clearInterval(this.#timer);
+        await this.#terminal.clearLine();
+        await this.#terminal.showCursor();
+        this.#message = undefined;
+    }
+    async pause() {
+        if (!this.#isShown) {
+            return Promise.resolve();
+        }
+        clearInterval(this.#timer);
+        this.#timer = undefined;
+        await this.#terminal.clearLine();
+    }
+    resume() {
+        if (!this.#isShown || this.#timer !== undefined) {
+            return;
+        }
+        this.#timer = setInterval(async () => {
+            await this.#nextFrame();
+        }, 100);
+    }
+    set spinnerColor(color) {
+        this.#spinColor = color;
+    }
+    set messageColor(color) {
+        this.#msgColor = color;
+    }
+    set spinnerStyle(style) {
+        this.#style = style;
+    }
+}

package/dist/src/service/printer/terminal/Theme.js

@@ -0,0 +1,26 @@
+import { Color } from "./Color.js";
+const commonTheme = [];
+commonTheme[Color.YELLOW] = 0xb58900;
+commonTheme[Color.ORANGE] = 0xcb4b16;
+commonTheme[Color.RED] = 0xdc322f;
+commonTheme[Color.MAGENTA] = 0xd33682;
+commonTheme[Color.VIOLET] = 0x6c71c4;
+commonTheme[Color.BLUE] = 0x268bd2;
+commonTheme[Color.CYAN] = 0x2aa198;
+commonTheme[Color.GREEN] = 0x859900;
+export function getLightModeTheme() {
+    const lightModeTheme = [...commonTheme];
+    lightModeTheme[Color.PRIMARY] = 0x657b83;
+    lightModeTheme[Color.SECONDARY] = 0x93a1a1;
+    lightModeTheme[Color.EMPHASISED] = 0x586e75;
+    lightModeTheme[Color.SELECTED] = 0xeee8d5;
+    return lightModeTheme;
+}
+export function getDarkModeTheme() {
+    const darkModeTheme = [...commonTheme];
+    darkModeTheme[Color.PRIMARY] = 0x839496;
+    darkModeTheme[Color.SECONDARY] = 0x586e75;
+    darkModeTheme[Color.EMPHASISED] = 0x93a1a1;
+    darkModeTheme[Color.SELECTED] = 0x073642;
+    return darkModeTheme;
+}

package/dist/src/service/prompter/DefaultPrompterService.js

@@ -0,0 +1,52 @@
+import { PromptType, } from "../../api/service/core/PrompterService.js";
+import promptSingleSelect from "./prompt/promptSingleSelect.js";
+import promptMultiSelect from "./prompt/promptMultiSelect.js";
+import promptAcknowledge from "./prompt/promptAcknowledge.js";
+import promptToggle from "./prompt/promptToggle.js";
+import promptText from "./prompt/promptText.js";
+import promptOpenUrl from "./prompt/promptOpenUrl.js";
+export const DEFAULT_PROMPTER_CONFIG = {
+    inputPromptCharacters: "> ",
+    checkboxCheckedChars: "[x]",
+    checkboxUncheckedChars: "[ ]",
+    scrollVisibleOptions: 8,
+};
+export default class DefaultPrompterService {
+    promptEnabled = true;
+    #ctx;
+    constructor(config, terminal, keyReader, printerService) {
+        this.#ctx = { config, terminal, keyReader, printerService };
+    }
+    prompt(promptDef) {
+        if (!this.promptEnabled) {
+            if (promptDef.defaultOption) {
+                return Promise.resolve({
+                    name: promptDef.name,
+                    value: promptDef.defaultOption.returnedValue,
+                });
+            }
+            return Promise.reject(new Error(`Prompting is disabled and no default for prompt: ${promptDef.name}`));
+        }
+        switch (promptDef.type) {
+            case PromptType.SINGLE_SELECT:
+                return promptSingleSelect(this.#ctx, promptDef);
+            case PromptType.MULTI_SELECT:
+                return promptMultiSelect(this.#ctx, promptDef);
+            case PromptType.ACKNOWLEDGE:
+                return promptAcknowledge(this.#ctx, promptDef);
+            case PromptType.TOGGLE:
+                return promptToggle(this.#ctx, promptDef);
+            case PromptType.TEXT:
+                return promptText(this.#ctx, promptDef);
+            case PromptType.OPEN_URL:
+                return promptOpenUrl(this.#ctx, promptDef);
+        }
+    }
+    async promptAll(prompts) {
+        const results = [];
+        for (const p of prompts) {
+            results.push(await this.prompt(p));
+        }
+        return results;
+    }
+}

package/dist/src/service/prompter/PrompterServiceProvider.js

@@ -0,0 +1,20 @@
+import { PROMPTER_SERVICE_ID } from "../../api/service/core/PrompterService.js";
+import NoPromptCommand from "./command/NoPromptCommand.js";
+export default class PrompterServiceProvider {
+    serviceId = PROMPTER_SERVICE_ID;
+    servicePriority;
+    prompterService;
+    constructor(servicePriority, prompterService) {
+        this.servicePriority = servicePriority;
+        this.prompterService = prompterService;
+    }
+    getServiceInfo(_cliConfig) {
+        return Promise.resolve({
+            service: this.prompterService,
+            commands: [new NoPromptCommand(this, this.servicePriority)],
+        });
+    }
+    initService(_context) {
+        return Promise.resolve();
+    }
+}

package/dist/src/service/prompter/command/NoPromptCommand.js

@@ -0,0 +1,21 @@
+import { ArgumentValueTypeName, } from "../../../api/argument/ArgumentValueTypes.js";
+export default class NoPromptCommand {
+    name = "no-prompt";
+    description = "Disable interactive prompting";
+    enableConfiguration = true;
+    argument = {
+        type: ArgumentValueTypeName.BOOLEAN,
+        defaultValue: false,
+        configurationKey: "NO_PROMPT",
+    };
+    executePriority;
+    #prompterServiceProvider;
+    constructor(prompterServiceProvider, executePriority) {
+        this.#prompterServiceProvider = prompterServiceProvider;
+        this.executePriority = executePriority;
+    }
+    execute(_context, argumentValue) {
+        this.#prompterServiceProvider.prompterService.promptEnabled = !argumentValue;
+        return Promise.resolve();
+    }
+}

package/dist/src/service/prompter/prompt/PromptContext.js

@@ -0,0 +1,22 @@
+export function physicalLineCount(terminal, text) {
+    const cols = terminal.columns();
+    if (cols <= 0)
+        return 1;
+    return text.split("\n").reduce((sum, segment) => {
+        const width = Bun.stringWidth(segment);
+        return sum + Math.max(1, Math.ceil(width / cols));
+    }, 0);
+}
+export function headerLineCount(terminal, promptDef) {
+    let count = physicalLineCount(terminal, promptDef.promptText);
+    if (promptDef.description) {
+        count += physicalLineCount(terminal, promptDef.description);
+    }
+    return count;
+}
+export async function renderPromptHeader(ctx, promptDef) {
+    await ctx.terminal.write(`${ctx.printerService.emphasised(promptDef.promptText)}\n`);
+    if (promptDef.description) {
+        await ctx.terminal.write(`${ctx.printerService.secondary(promptDef.description)}\n`);
+    }
+}

package/dist/src/service/prompter/prompt/promptAcknowledge.js

@@ -0,0 +1,19 @@
+import { PromptType, } from "../../../api/service/core/PrompterService.js";
+import promptSingleSelect from "./promptSingleSelect.js";
+export default function promptAcknowledge(ctx, promptDef) {
+    const yesNo = {
+        name: promptDef.name,
+        promptText: promptDef.promptText,
+        description: promptDef.description,
+        type: PromptType.SINGLE_SELECT,
+        defaultOption: promptDef.defaultOption ?? {
+            displayValue: "No",
+            returnedValue: false,
+        },
+        options: [
+            { displayValue: "Yes", returnedValue: true },
+            { displayValue: "No", returnedValue: false },
+        ],
+    };
+    return promptSingleSelect(ctx, yesNo);
+}

package/dist/src/service/prompter/prompt/promptMultiSelect.js

@@ -0,0 +1,74 @@
+import { SpecialKey } from "../../../terminal/KeyReader.js";
+import ShutdownServiceProvider from "../../shutdown/ShutdownServiceProvider.js";
+import { headerLineCount, renderPromptHeader } from "./PromptContext.js";
+export default async function promptMultiSelect(ctx, promptDef) {
+    const options = promptDef.options;
+    if (options.length === 0) {
+        throw new Error(`No options for prompt: ${promptDef.name}`);
+    }
+    let focusIndex = 0;
+    const checked = new Set();
+    let scrollOffset = 0;
+    const visibleCount = Math.min(ctx.config.scrollVisibleOptions, options.length);
+    ctx.keyReader.enableRawMode();
+    try {
+        await ctx.terminal.hideCursor();
+        let firstRender = true;
+        while (true) {
+            if (scrollOffset > focusIndex) {
+                scrollOffset = focusIndex;
+            }
+            else if (focusIndex >= scrollOffset + visibleCount) {
+                scrollOffset = focusIndex - visibleCount + 1;
+            }
+            const headerLines = headerLineCount(ctx.terminal, promptDef);
+            if (!firstRender) {
+                await ctx.terminal.clearUpLines(visibleCount + headerLines);
+            }
+            firstRender = false;
+            await renderPromptHeader(ctx, promptDef);
+            for (let i = scrollOffset; i < scrollOffset + visibleCount; i++) {
+                const option = options[i];
+                const isFocused = i === focusIndex;
+                const isChecked = checked.has(i);
+                const checkbox = isChecked
+                    ? ctx.printerService.green(ctx.config.checkboxCheckedChars)
+                    : ctx.printerService.secondary(ctx.config.checkboxUncheckedChars);
+                const text = option.displayValue;
+                await ctx.terminal.write(`${checkbox} ${isFocused ? ctx.printerService.cyan(text) : ctx.printerService.secondary(text)}\n`);
+            }
+            const keyEvent = await ctx.keyReader.readKey();
+            if (keyEvent.specialKey === SpecialKey.UP && focusIndex > 0) {
+                focusIndex--;
+            }
+            else if (keyEvent.specialKey === SpecialKey.DOWN && focusIndex < options.length - 1) {
+                focusIndex++;
+            }
+            else if (keyEvent.specialKey === SpecialKey.SPACE) {
+                if (checked.has(focusIndex)) {
+                    checked.delete(focusIndex);
+                }
+                else {
+                    checked.add(focusIndex);
+                }
+            }
+            else if (keyEvent.specialKey === SpecialKey.ENTER) {
+                await ctx.terminal.showCursor();
+                const values = [...checked].sort().map((i) => options[i].returnedValue);
+                return { name: promptDef.name, value: values };
+            }
+            else if (keyEvent.specialKey === SpecialKey.ESCAPE) {
+                await ctx.terminal.showCursor();
+                throw new Error("Prompt cancelled");
+            }
+            else if (keyEvent.specialKey === SpecialKey.INTERRUPT) {
+                await ctx.terminal.showCursor();
+                ShutdownServiceProvider.onInterrupt();
+                throw new Error("Interrupted");
+            }
+        }
+    }
+    finally {
+        ctx.keyReader.disableRawMode();
+    }
+}

package/dist/src/service/prompter/prompt/promptOpenUrl.js

@@ -0,0 +1,70 @@
+import { SpecialKey } from "../../../terminal/KeyReader.js";
+import ShutdownServiceProvider from "../../shutdown/ShutdownServiceProvider.js";
+import { renderPromptHeader } from "./PromptContext.js";
+function isRemoteSession() {
+    return !!(process.env.SSH_CONNECTION || process.env.SSH_CLIENT || process.env.SSH_TTY);
+}
+async function defaultOpenUrl(url) {
+    const parsed = new URL(url);
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+        throw new Error(`Unsupported URL protocol: ${parsed.protocol}`);
+    }
+    const platform = process.platform;
+    let cmd;
+    if (platform === "darwin") {
+        cmd = ["open", url];
+    }
+    else if (platform === "win32") {
+        cmd = ["cmd", "/c", "start", "", url];
+    }
+    else {
+        cmd = ["xdg-open", url];
+    }
+    const proc = Bun.spawn(cmd, { stdout: "ignore", stderr: "ignore" });
+    const exitCode = await proc.exited;
+    if (exitCode !== 0) {
+        throw new Error(`Failed to open URL (exit code ${exitCode})`);
+    }
+}
+export default async function promptOpenUrl(ctx, promptDef) {
+    if (promptDef.options.length === 0) {
+        throw new Error(`No URL option for prompt: ${promptDef.name}`);
+    }
+    const url = String(promptDef.options[0].returnedValue);
+    const displayLabel = promptDef.options[0].displayValue;
+    const openUrlFn = ctx.config.openUrl ?? defaultOpenUrl;
+    const canOpenBrowser = !isRemoteSession();
+    ctx.keyReader.enableRawMode();
+    try {
+        await renderPromptHeader(ctx, promptDef);
+        await ctx.terminal.write(`${displayLabel}: ${ctx.printerService.cyan(url)}\n`);
+        const instruction = canOpenBrowser
+            ? "Press ENTER to open in the browser..."
+            : "Copy the URL above and open it in your local browser, then press ENTER to continue...";
+        await ctx.terminal.write(`${ctx.printerService.secondary(instruction)}\n`);
+        while (true) {
+            const keyEvent = await ctx.keyReader.readKey();
+            if (keyEvent.specialKey === SpecialKey.ENTER) {
+                if (canOpenBrowser) {
+                    try {
+                        await openUrlFn(url);
+                    }
+                    catch (e) {
+                        await ctx.terminal.write(`${ctx.printerService.red(`Failed to open URL: ${e instanceof Error ? e.message : String(e)}`)}\n`);
+                    }
+                }
+                return { name: promptDef.name, value: url };
+            }
+            else if (keyEvent.specialKey === SpecialKey.ESCAPE) {
+                throw new Error("Prompt cancelled");
+            }
+            else if (keyEvent.specialKey === SpecialKey.INTERRUPT) {
+                ShutdownServiceProvider.onInterrupt();
+                throw new Error("Interrupted");
+            }
+        }
+    }
+    finally {
+        ctx.keyReader.disableRawMode();
+    }
+}