@kaynooo/cli-kit 0.0.0-stage → 0.8.0

package/src/progress.ts

@@ -0,0 +1,314 @@
+import type { Colors } from './style'
+import process from 'node:process'
+import { formatDuration } from './format'
+import { holdSignals } from './process'
+import { marked, paint, takesControlCodes } from './style'
+
+export interface Progress {
+  step: string
+  done?: number | undefined
+  total?: number | undefined
+  unit?: string | undefined
+}
+
+interface ProgressStream {
+  isTTY?: boolean
+  columns?: number | undefined
+  rows?: number | undefined
+  write: (text: string) => unknown
+}
+
+export interface LiveRegion {
+  // Draws the lines again now, rather than at the next frame.
+  redraw: () => void
+  // Prints `text` above the region, where it stays once the region goes.
+  print: (text: string) => void
+  // Clears the region and leaves nothing behind.
+  stop: () => void
+}
+
+export interface TaskHandle {
+  update: (progress: Omit<Progress, 'step'>) => void
+  // Leaves `✓ <text> <time since the task began>` above the tasks still running, the label when no text is given.
+  done: (text?: string) => void
+  // Leaves `✗ <text>`, the label when no text is given.
+  failed: (text?: string) => void
+}
+
+export interface TaskList {
+  add: (label: string) => TaskHandle
+}
+
+export interface ProgressLine {
+  update: (progress: Progress) => void
+  // Clears the line and leaves nothing behind.
+  stop: () => void
+  // Clears the line and leaves `✓ <text> <time since the line began>` in its place.
+  done: (text: string) => void
+  // Clears the line and leaves `✗ <text>` in its place.
+  failed: (text: string) => void
+}
+
+type Env = Record<string, string | undefined>
+
+const FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
+const FRAME_MS = 80
+const BAR_WIDTH = 20
+// Back to the start of the line, then erases it.
+const CLEAR_LINE = '\r\x1B[2K'
+// Up a line, then erases it.
+const LINE_UP = '\x1B[1A\x1B[2K'
+const ESC = String.fromCharCode(27)
+// A colour or cursor code, or an OSC 8 link's opening or closing, read where `lastIndex` points.
+const ESCAPE_CODE = new RegExp(`${ESC}(?:\\[[\\x30-\\x3F]*[\\x20-\\x2F]*[\\x40-\\x7E]|\\][^\\u0007${ESC}]*(?:\\u0007|${ESC}\\\\))`, 'y')
+const RESET_STYLE = `${ESC}[0m`
+const CLOSE_LINK = `${ESC}]8;;${ESC}\\`
+// What the console prints with, to the terminal the line is drawn on or the other.
+const CONSOLE_METHODS = ['log', 'info', 'warn', 'error', 'debug', 'dir', 'dirxml', 'table', 'trace', 'group', 'groupCollapsed', 'count', 'timeEnd', 'timeLog', 'assert'] as const
+
+// A piece of the line and how it is tinted, so the line can be cut to the terminal's width on its visible text.
+interface Part { text: string, tint: (colors: Colors) => (text: string) => string }
+
+// Lines on `stream` redrawn in place every frame, `render` handed the spinner's next glyph, each line cut to the terminal's width and the block to its height.
+// Drawn only on a terminal that takes control codes, so elsewhere `render` never runs and the caller prints its own outcome; whatever else is printed meanwhile clears the block first, the next frame drawing it again under it, and an interrupt clears it before the process ends.
+export function liveRegion(render: (spinner: string) => string[], stream: ProgressStream = process.stderr, env: Env = process.env): LiveRegion {
+  if (!takesControlCodes(stream, env))
+    return { redraw: () => undefined, print: text => void stream.write(`${text}\n`), stop: () => undefined }
+
+  // Its own write, taken before the region clears itself ahead of every other.
+  const write = stream.write.bind(stream)
+  let frame = 0
+  let drawn = 0
+  const clear = () => {
+    if (drawn > 0)
+      write(`${CLEAR_LINE}${LINE_UP.repeat(drawn - 1)}`)
+
+    drawn = 0
+  }
+  const draw = () => {
+    // A terminal that does not say its size, as a pseudo-terminal may, answers 0.
+    const width = (stream.columns === undefined || stream.columns === 0 ? 80 : stream.columns) - 1
+    const height = stream.rows === undefined || stream.rows === 0 ? 24 : stream.rows
+    const lines = render(FRAMES[frame++ % FRAMES.length]!).slice(0, Math.max(1, height - 1)).map(line => cutToWidth(line, width))
+
+    if (lines.length === 0) {
+      clear()
+
+      return
+    }
+
+    write(`${drawn > 0 ? `${CLEAR_LINE}${LINE_UP.repeat(drawn - 1)}` : CLEAR_LINE}${lines.join('\n')}`)
+    drawn = lines.length
+  }
+  const timer = setInterval(draw, FRAME_MS)
+  const restore = interceptOutput(clear)
+  const onExit = () => clear()
+  // Interrupted, the block goes before the shell's prompt comes back.
+  const signals = holdSignals(stop)
+
+  function stop() {
+    clearInterval(timer)
+    clear()
+    restore()
+    process.off('exit', onExit)
+    signals.release()
+  }
+
+  timer.unref()
+  process.on('exit', onExit)
+
+  return {
+    redraw: draw,
+    print: (text) => {
+      clear()
+      write(`${text}\n`)
+      draw()
+    },
+    stop,
+  }
+}
+
+// One line on `stream`, redrawn in place while a task runs: a spinner, the step, a bar where its total is known, and the time since the step began.
+// Off a terminal taking control codes, a log, CI or `NO_COLOR` gets the `done` and `failed` lines alone.
+export function progressLine(stream: ProgressStream = process.stderr, env: Env = process.env): ProgressLine {
+  const colors = paint(stream, env)
+  // Its own write, taken before the region clears itself ahead of every other.
+  const write = stream.write.bind(stream)
+  const begun = performance.now()
+  let started = begun
+  let current: Progress | undefined
+  const region = liveRegion(spinner => current === undefined ? [] : [tinted(progressParts(current, spinner, performance.now() - started), colors)], stream, env)
+  const end = (line: string) => {
+    region.stop()
+    write(`${line}\n`)
+  }
+
+  return {
+    // A new step is drawn at once, its clock started again; a count moving on waits for the next frame, so a burst of updates writes one.
+    update: (progress) => {
+      const step = current?.step
+
+      current = progress
+
+      if (progress.step !== step) {
+        started = performance.now()
+        region.redraw()
+      }
+    },
+    stop: region.stop,
+    done: text => end(marked('ok', text, stream, formatDuration(performance.now() - begun), env)),
+    failed: text => end(marked('problem', text, stream, undefined, env)),
+  }
+}
+
+// Stacked lines for tasks running side by side, each drawn as a progress line is; a task ending leaves its ✓ or ✗ line above those still running, and the block goes once none is.
+export function taskList(stream: ProgressStream = process.stderr, env: Env = process.env): TaskList {
+  const colors = paint(stream, env)
+  const running = new Set<{ progress: Progress, started: number }>()
+  let region: LiveRegion | undefined
+  const render = (spinner: string) => [...running].map(({ progress, started }) => tinted(progressParts(progress, spinner, performance.now() - started), colors))
+
+  return {
+    add: (label) => {
+      const entry = { progress: { step: label } as Progress, started: performance.now() }
+      const end = (line: string) => {
+        if (!running.delete(entry))
+          return
+
+        region?.print(line)
+
+        if (running.size === 0) {
+          region?.stop()
+          region = undefined
+        }
+      }
+
+      running.add(entry)
+      region ??= liveRegion(render, stream, env)
+      region.redraw()
+
+      return {
+        update: (progress) => {
+          entry.progress = { ...progress, step: label }
+        },
+        done: text => end(marked('ok', text ?? label, stream, formatDuration(performance.now() - entry.started), env)),
+        failed: text => end(marked('problem', text ?? label, stream, undefined, env)),
+      }
+    },
+  }
+}
+
+// Runs one step under a spinner on a terminal, then leaves `✓ <label> <time>`, or `✗ <label>` and throws again; off a terminal those lines alone print, as `ok:` and `error:`.
+export async function task<T>(label: string, run: (update: (progress: Omit<Progress, 'step'>) => void) => Promise<T>, stream: ProgressStream = process.stderr, env: Env = process.env): Promise<T> {
+  const line = progressLine(stream, env)
+
+  line.update({ step: label })
+
+  try {
+    const result = await run(progress => line.update({ ...progress, step: label }))
+
+    line.done(label)
+
+    return result
+  }
+  catch (error) {
+    line.failed(label)
+
+    throw error
+  }
+}
+
+// `⠹ prerendering ████████░░░░░░░░░░░░ 8/20 routes 4.2s`; a step with no total has no bar.
+export function progressText(progress: Progress, spinner: string, ms: number): string {
+  return progressParts(progress, spinner, ms).map(part => part.text).join('')
+}
+
+function progressParts({ step, done, total, unit }: Progress, spinner: string, ms: number): Part[] {
+  const parts: Part[] = [{ text: spinner, tint: colors => colors.cyan }, { text: ` ${step}`, tint: () => plain }]
+
+  if (total !== undefined && total > 0) {
+    const counted = Math.min(done ?? 0, total)
+    const filled = Math.round(counted / total * BAR_WIDTH)
+
+    parts.push(
+      { text: ' ', tint: () => plain },
+      { text: '█'.repeat(filled), tint: colors => colors.cyan },
+      { text: '░'.repeat(BAR_WIDTH - filled), tint: colors => colors.dim },
+      { text: ` ${counted}/${total}${unit === undefined ? '' : ` ${unit}`}`, tint: colors => colors.dim },
+    )
+  }
+
+  parts.push({ text: ` ${(ms / 1000).toFixed(1)}s`, tint: colors => colors.dim })
+
+  return parts
+}
+
+function plain(text: string): string {
+  return text
+}
+
+function tinted(parts: Part[], colors: Colors): string {
+  return parts.map(({ text, tint }) => tint(colors)(text)).join('')
+}
+
+// The line cut to `width` columns of visible text, its escapes kept whole, and the styles and a link ended after a cut so none runs into the next line.
+function cutToWidth(line: string, width: number): string {
+  if (Bun.stringWidth(line) <= width)
+    return line
+
+  let room = width
+  let kept = ''
+  let index = 0
+  let linked = false
+
+  while (index < line.length) {
+    ESCAPE_CODE.lastIndex = index
+
+    const escape = ESCAPE_CODE.exec(line)
+
+    if (escape !== null) {
+      kept += escape[0]
+      linked ||= escape[0].startsWith(`${ESC}]`)
+      index = ESCAPE_CODE.lastIndex
+
+      continue
+    }
+
+    const char = String.fromCodePoint(line.codePointAt(index)!)
+    const columns = Bun.stringWidth(char)
+
+    if (columns > room)
+      break
+
+    kept += char
+    room -= columns
+    index += char.length
+  }
+
+  return `${kept}${RESET_STYLE}${linked ? CLOSE_LINK : ''}`
+}
+
+// Clears the region before anything the console or a stream writes, the caller's own code meanwhile included, and answers how to put them back.
+function interceptOutput(clear: () => void): () => void {
+  const targets = [...CONSOLE_METHODS.map(name => [console, name] as const), [process.stdout, 'write'] as const, [process.stderr, 'write'] as const]
+  const wrapped = targets.map(([target, name]) => {
+    const original = Reflect.get(target, name) as (...args: unknown[]) => unknown
+    const wrapper = (...args: unknown[]) => {
+      clear()
+
+      return original.apply(target, args)
+    }
+
+    Reflect.set(target, name, wrapper)
+
+    return { target, name, original, wrapper }
+  })
+
+  // What the caller replaced meanwhile is its own, and stays.
+  return () => {
+    for (const { target, name, original, wrapper } of wrapped) {
+      if (Reflect.get(target, name) === wrapper)
+        Reflect.set(target, name, original)
+    }
+  }
+}

package/src/prompt.ts

@@ -0,0 +1,331 @@
+import type { Colors } from './style'
+import process from 'node:process'
+import { fail } from './args'
+import { truncate } from './format'
+import { paint } from './style'
+
+// What the terminal sends for a key: a whole escape sequence, such as an arrow's or Home's, which no prompt but the arrows reads, or one character, a lone Escape included.
+// eslint-disable-next-line no-control-regex -- escape sequences are what it splits
+const KEY_SEQUENCES = /\x1B\[[0-9;]*[A-Z~]|\x1BO[A-Z]|[\s\S]/giu
+// eslint-disable-next-line no-control-regex -- control characters are what it leaves out
+const CONTROL = /^[\x00-\x1F\x7F]/
+const WORDS = /\s+/
+// Choices drawn at once at most, the rest scrolled to.
+const MAX_ROWS = 10
+
+type Key = 'up' | 'down' | 'enter' | 'cancel' | 'erase' | { text: string }
+type Outcome = 'enter' | 'cancel'
+type State = 'asking' | Outcome
+
+const KEYS: Record<string, Key> = { '\x1B[A': 'up', '\x1BOA': 'up', '\x1B[B': 'down', '\x1BOB': 'down', '\r': 'enter', '\n': 'enter', '\x03': 'cancel', '\x1B': 'cancel', '\x7F': 'erase', '\b': 'erase' }
+
+export interface Choice<T> {
+  value: T
+  label: string
+  hint: string
+}
+
+// The ends a prompt reads keys from and draws on, the process's own by default.
+export interface Terminal {
+  stdin: Pick<NodeJS.ReadStream, 'setRawMode' | 'resume' | 'pause' | 'on' | 'off'> & { isTTY?: boolean }
+  stderr: Pick<NodeJS.WriteStream, 'write' | 'columns' | 'rows'> & { isTTY?: boolean }
+}
+
+export interface PromptSettings {
+  // Shown under the error a prompt fails with off a terminal, such as `pass --yes`.
+  hint?: string
+  terminal?: Terminal
+}
+
+// The keys a chunk of terminal input holds, in order: the ones prompts read, and printable text.
+function readKeys(input: string): Key[] {
+  return (input.match(KEY_SEQUENCES) ?? []).flatMap(sequence => KEYS[sequence] ?? (CONTROL.test(sequence) ? [] : [{ text: sequence }]))
+}
+
+export interface SelectSettings extends PromptSettings {
+  // The index of the choice the cursor starts on.
+  initial?: number
+}
+
+// One choice among several, typing filtering them, the arrows moving and Enter picking; undefined once Escape or Ctrl+C cancels.
+export async function select<T>(question: string, choices: Choice<T>[], { initial = 0, ...settings }: SelectSettings = {}): Promise<T | undefined> {
+  const list = new List(choices, initial)
+  const picked = await ask(question, settings, (colors, state, rows) => state === 'asking'
+    ? [asking(colors, question, list.query, 'type to filter, enter picks'), ...list.rows(colors, rows, () => '')]
+    : [answer(colors, question, state, list.current()?.label ?? '')], (key) => {
+    if (key === 'enter')
+      return list.current() === undefined ? undefined : 'enter'
+
+    if (key === 'cancel')
+      return 'cancel'
+
+    list.press(key)
+
+    return undefined
+  })
+
+  return picked ? list.current()?.value : undefined
+}
+
+export interface ChecklistSettings<T> extends PromptSettings {
+  initial?: ReadonlySet<T>
+  // What checking or unchecking `value` leaves checked, which may change other choices along; flips `value` alone by default.
+  toggle?: (checked: ReadonlySet<T>, value: T) => ReadonlySet<T>
+}
+
+function flip<T>(checked: ReadonlySet<T>, value: T): ReadonlySet<T> {
+  const next = new Set(checked)
+
+  if (!next.delete(value))
+    next.add(value)
+
+  return next
+}
+
+// Several choices, typing filtering them, Space checking or unchecking the one under the cursor and Enter accepting what is checked; undefined once cancelled.
+export async function checklist<T>(question: string, choices: Choice<T>[], { initial = new Set(), toggle = flip, ...settings }: ChecklistSettings<T> = {}): Promise<ReadonlySet<T> | undefined> {
+  const list = new List(choices, 0)
+  let checked = initial
+  const accepted = await ask(question, settings, (colors, state, rows) => state === 'asking'
+    ? [asking(colors, question, list.query, 'type to filter, space toggles, enter accepts'), ...list.rows(colors, rows, choice => checked.has(choice.value) ? `${colors.cyan('◉')} ` : `${colors.dim('◯')} `)]
+    : [answer(colors, question, state, choices.filter(choice => checked.has(choice.value)).map(choice => choice.label).join(', ') || 'none')], (key) => {
+    if (key === 'enter' || key === 'cancel')
+      return key
+
+    const current = list.current()
+
+    if (typeof key === 'object' && key.text === ' ') {
+      if (current !== undefined)
+        checked = toggle(checked, current.value)
+
+      return undefined
+    }
+
+    list.press(key)
+
+    return undefined
+  })
+
+  return accepted ? checked : undefined
+}
+
+export interface ConfirmSettings extends PromptSettings {
+  // What Enter answers; without one, Enter waits for y or n.
+  default?: boolean
+}
+
+// A yes or no, y or n answering it and Enter taking the default; undefined once cancelled.
+export async function confirm(question: string, { default: fallback, ...settings }: ConfirmSettings = {}): Promise<boolean | undefined> {
+  let answered = fallback
+  const choices = { true: 'Y/n', false: 'y/N', undefined: 'y/n' }[String(fallback) as 'true' | 'false' | 'undefined']
+  const accepted = await ask(question, settings, (colors, state) => [state === 'asking' ? asking(colors, question, '', choices) : answer(colors, question, state, answered ? 'yes' : 'no')], (key) => {
+    if (key === 'cancel')
+      return 'cancel'
+
+    if (key === 'enter')
+      return answered === undefined ? undefined : 'enter'
+
+    const letter = typeof key === 'object' ? key.text.toLowerCase() : ''
+
+    if (letter !== 'y' && letter !== 'n')
+      return undefined
+
+    answered = letter === 'y'
+
+    return 'enter'
+  })
+
+  return accepted ? answered : undefined
+}
+
+export interface InputPromptSettings extends PromptSettings {
+  // What an empty answer stands for, shown dimmed until something is typed.
+  default?: string
+  // Draws each character typed as `*`, for a password or a token.
+  mask?: boolean
+  // What is wrong with the answer, shown under it until Enter is pressed on one it takes; undefined takes it.
+  validate?: (value: string) => string | undefined
+}
+
+// A line of text, Enter taking it once `validate` does; undefined once cancelled.
+export async function input(question: string, { default: fallback, mask = false, validate, ...settings }: InputPromptSettings = {}): Promise<string | undefined> {
+  let value = ''
+  let invalid: string | undefined
+  const taken = () => value === '' ? fallback ?? '' : value
+  const shown = () => mask ? '*'.repeat([...taken()].length) : taken()
+  const accepted = await ask(question, settings, (colors, state, { columns }) => {
+    if (state !== 'asking')
+      return [answer(colors, question, state, shown())]
+
+    // Its end alone where it would wrap: `? `, the question, a space, the caret, and the last column kept free.
+    const characters = [...shown()]
+    const room = Math.max(columns - question.length - 5, 1)
+    const tail = characters.length > room ? `…${characters.slice(1 - room).join('')}` : shown()
+    const typed = value === '' ? colors.dim(tail) : tail
+
+    return [`${colors.cyan('?')} ${question} ${typed}${colors.dim('█')}`, ...invalid === undefined ? [] : [`  ${colors.red(invalid)}`]]
+  }, (key) => {
+    if (key === 'cancel')
+      return 'cancel'
+
+    invalid = undefined
+
+    if (key === 'enter') {
+      invalid = validate?.(taken())
+
+      return invalid === undefined ? 'enter' : undefined
+    }
+
+    if (key === 'erase')
+      value = [...value].slice(0, -1).join('')
+    else if (typeof key === 'object')
+      value += key.text
+
+    return undefined
+  })
+
+  return accepted ? taken() : undefined
+}
+
+// The choices a filter leaves, the cursor on one of them and the window of rows drawn around it.
+class List<T> {
+  query = ''
+  private matches: Choice<T>[]
+  private cursor: number
+  private top = 0
+  private readonly width: number
+
+  constructor(private readonly choices: Choice<T>[], initial: number) {
+    this.matches = choices
+    this.cursor = Math.min(Math.max(initial, 0), choices.length - 1)
+    this.width = Math.max(0, ...choices.map(choice => choice.label.length))
+  }
+
+  current(): Choice<T> | undefined {
+    return this.matches[this.cursor]
+  }
+
+  press(key: Key): void {
+    if (key === 'up' || key === 'down') {
+      if (this.matches.length > 0)
+        this.cursor = (this.cursor + (key === 'up' ? this.matches.length - 1 : 1)) % this.matches.length
+
+      return
+    }
+
+    if (key === 'erase')
+      this.filter([...this.query].slice(0, -1).join(''))
+    else if (typeof key === 'object')
+      this.filter(this.query + key.text)
+  }
+
+  // Every word typed is in the label or the hint, case ignored; the cursor stays on its choice while it still matches, else goes to the first.
+  private filter(query: string): void {
+    const words = query.toLowerCase().split(WORDS).filter(word => word !== '')
+    const current = this.current()
+
+    this.query = query
+    this.matches = this.choices.filter(({ label, hint }) => words.every(word => `${label} ${hint}`.toLowerCase().includes(word)))
+    this.cursor = current === undefined ? 0 : Math.max(this.matches.indexOf(current), 0)
+    this.top = 0
+  }
+
+  // A line per choice in the window, each cut to the terminal's width so none wraps, which would throw off the redraw, and a dimmed count of those scrolled past.
+  rows(colors: Colors, { columns, rows }: { columns: number, rows: number }, marker: (choice: Choice<T>) => string): string[] {
+    if (this.matches.length === 0)
+      return [colors.dim('  no match')]
+
+    const height = Math.max(1, Math.min(MAX_ROWS, rows - 3, this.matches.length))
+
+    this.top = Math.min(Math.max(this.top, this.cursor - height + 1), this.cursor)
+
+    const shown = this.matches.slice(this.top, this.top + height).map((choice, index) => {
+      const here = this.top + index === this.cursor
+      const mark = marker(choice)
+      const head = `${here ? '❯' : ' '} ${mark}`
+      const label = choice.label.padEnd(this.width)
+      // What is left of the line for the hint: the pointer and a space, a mark of two visible characters (`◉ `) when there is one, the label, two spaces, and the last column kept free.
+      const room = columns - 5 - (mark === '' ? 0 : 2) - this.width
+
+      return `${here ? colors.cyan(head) : head}${here ? colors.cyan(label) : label}  ${colors.dim(truncate(choice.hint, Math.max(room, 0)))}`
+    })
+    const below = this.matches.length - this.top - height
+
+    return [...this.top > 0 ? [colors.dim(`  … ${this.top} more`)] : [], ...shown, ...below > 0 ? [colors.dim(`  … ${below} more`)] : []]
+  }
+}
+
+// The question line while asking: what was typed after it, else a dimmed note of the keys.
+function asking(colors: Colors, question: string, typed: string, keys: string): string {
+  return `${colors.cyan('?')} ${question} ${typed === '' ? colors.dim(`(${keys})`) : typed}`
+}
+
+// The line a prompt leaves once answered: what was picked, or that it was cancelled.
+function answer(colors: Colors, question: string, state: Outcome, picked: string): string {
+  return state === 'enter' ? `${colors.green('✓')} ${question} ${colors.cyan(picked)}` : `${colors.red('✗')} ${question} ${colors.dim('cancelled')}`
+}
+
+type Render = (colors: Colors, state: State, size: { columns: number, rows: number }) => string[]
+
+// Draws a prompt on stderr and redraws it after each key stdin sends raw, until `press` answers `enter` or `cancel`; true once entered. Off a terminal, nobody could answer, so it fails at once.
+async function ask(question: string, { hint, terminal = process }: PromptSettings, render: Render, press: (key: Key) => Outcome | undefined): Promise<boolean> {
+  const { stdin, stderr } = terminal
+
+  if (stdin.isTTY !== true || stderr.isTTY !== true)
+    fail(`cannot ask "${question}" off a terminal`, 2, hint)
+
+  const colors = paint(stderr)
+  let drawn = 0
+  let outcome: Outcome | undefined
+  const draw = (state: State) => {
+    // A terminal that does not say its size, as a pseudo-terminal may, answers 0.
+    const frame = render(colors, state, { columns: stderr.columns || 80, rows: stderr.rows || 24 })
+
+    stderr.write(`${drawn > 1 ? `\x1B[${drawn - 1}A` : ''}\r\x1B[0J${frame.join('\n')}`)
+    drawn = frame.length
+  }
+
+  try {
+    stdin.setRawMode(true)
+    stdin.resume()
+    stderr.write('\x1B[?25l')
+    draw('asking')
+
+    return await new Promise<boolean>((resolve) => {
+      function onData(data: Buffer) {
+        for (const key of readKeys(data.toString())) {
+          const pressed = press(key)
+
+          if (pressed !== undefined) {
+            settle(pressed)
+
+            return
+          }
+        }
+
+        draw('asking')
+      }
+
+      // A stdin closing before an answer, as a terminal hung up does, cancels instead of leaving the prompt waiting forever.
+      function onEnd() {
+        settle('cancel')
+      }
+
+      function settle(settled: Outcome) {
+        outcome = settled
+        stdin.off('data', onData)
+        stdin.off('end', onEnd)
+        resolve(settled === 'enter')
+      }
+
+      stdin.on('data', onData)
+      stdin.on('end', onEnd)
+    })
+  }
+  finally {
+    draw(outcome ?? 'cancel')
+    stderr.write('\n\x1B[?25h')
+    stdin.setRawMode(false)
+    stdin.pause()
+  }
+}