wehub-resource-sync
574 lines
23 KiB
Python
574 lines
23 KiB
Python
"""Theme-picker-styled interactive selectors for the onboarding CLI.
|
||
|
||
This module is the shared home for the generic, REPL-theme-picker-styled
|
||
selection primitives used by ``omnigent setup --no-internal-beta`` (and any
|
||
future configure noun). The look reproduces
|
||
:mod:`omnigent.repl._theme_picker`:
|
||
|
||
- a bold accent header line,
|
||
- one row per option (selected → ``❯ <label>`` in bold accent, others
|
||
normal weight; non-selectable sub-lines dim italic and indented beneath),
|
||
- a muted footer hint line (``↑/↓ move · Enter select · Esc back``),
|
||
- a raw-termios keypress loop with in-place redraw (move up, clear,
|
||
reprint), and
|
||
- a non-TTY numbered fallback so pipes / CI / tests work.
|
||
|
||
The raw-termios reading and redraw mechanics are deliberately ported
|
||
from :mod:`omnigent.repl._theme_picker` rather than imported: that
|
||
module exposes only private helpers, and this module is the generic,
|
||
reusable version. The duplication is intentional for now — a future
|
||
cleanup can converge ``_theme_picker._render_theme_picker`` onto
|
||
:func:`select`. That convergence is out of scope here;
|
||
``_theme_picker.py`` is left unchanged.
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import io
|
||
import os
|
||
import sys
|
||
from collections.abc import Callable
|
||
from typing import Protocol, cast
|
||
|
||
import click
|
||
from rich.cells import cell_len
|
||
from rich.console import Console
|
||
from rich.text import Text
|
||
|
||
# Reuse the REPL theme picker's palette verbatim so the selector is
|
||
# visually identical to ``_theme_picker.py`` (``_ACCENT`` / ``_MUTED``).
|
||
ACCENT = "#F43BA6"
|
||
MUTED = "#6a6a6a"
|
||
|
||
# Shared Rich console for all onboarding interactive output. A module
|
||
# singleton so all callers render through one surface.
|
||
console = Console()
|
||
|
||
|
||
class _TermUIWithHiddenPrompt(Protocol):
|
||
hidden_prompt_func: Callable[[str], str]
|
||
|
||
|
||
def clear_screen() -> None:
|
||
"""Clear the terminal (screen + scrollback) and home the cursor.
|
||
|
||
The :func:`select` picker only erases the lines *it* rendered
|
||
(``\\033[<n>A\\033[J``); it cannot erase output printed above its frame.
|
||
A flow that shells out to a noisy subprocess (e.g. the Databricks
|
||
``+ Add`` path running ``databricks auth login`` + ``ucode configure``)
|
||
therefore leaves that output on screen, and the next in-place menu
|
||
redraw collides with it. Callers bracket such a takeover with this full
|
||
clear so the picker re-renders on a clean buffer.
|
||
|
||
No-op when stdout is not a TTY (pipes / CI / the numbered-fallback
|
||
tests), so captured output stays free of escape sequences.
|
||
|
||
:returns: None. Side effect: writes the clear sequence to stdout.
|
||
"""
|
||
if not sys.stdout.isatty():
|
||
return
|
||
# 2J clears the visible screen, 3J clears the scrollback buffer, H homes
|
||
# the cursor — together they wipe the leaked subprocess output.
|
||
sys.stdout.write("\033[2J\033[3J\033[H")
|
||
sys.stdout.flush()
|
||
|
||
|
||
def _truncate_cells(text: str, max_cells: int) -> str:
|
||
"""Truncate *text* to a terminal-cell budget, adding an ellipsis if needed."""
|
||
if cell_len(text) <= max_cells:
|
||
return text
|
||
ellipsis = "…"
|
||
budget = max(0, max_cells - cell_len(ellipsis))
|
||
out: list[str] = []
|
||
used = 0
|
||
for ch in text:
|
||
width = cell_len(ch)
|
||
if used + width > budget:
|
||
break
|
||
out.append(ch)
|
||
used += width
|
||
return "".join(out) + ellipsis
|
||
|
||
|
||
def _render_menu(
|
||
title: str,
|
||
options: list[str],
|
||
selected: int,
|
||
*,
|
||
descriptions: list[str] | None,
|
||
width: int,
|
||
selectable: list[bool],
|
||
status: str | None = None,
|
||
max_visible: int | None = None,
|
||
window_start: int = 0,
|
||
compact: bool = False,
|
||
) -> str:
|
||
"""Render the menu frame to an ANSI string for the termios redraw.
|
||
|
||
A bold accent header, one row per option (selected → bold accent with the
|
||
``❯`` pointer, others normal weight aligned under it), an optional dim
|
||
description line for the selected option (the generic analogue of the theme
|
||
preview), and a muted footer of key hints.
|
||
|
||
Non-selectable rows (``selectable[i]`` is ``False``) render as dim italic
|
||
sub-lines indented beneath the preceding choice (e.g. a harness's
|
||
``default: …`` summary) with a blank line after — no ``❯`` pointer, and
|
||
↑/↓ skip them so the cursor only lands on real choices.
|
||
|
||
:param title: The header shown above the options, e.g.
|
||
``"What kind of provider?"``.
|
||
:param options: The row labels, e.g. ``["Claude", " key", "Quit"]``.
|
||
:param selected: Zero-based index of the highlighted (selectable) row.
|
||
:param descriptions: Optional per-option description strings (same
|
||
length as *options*); the selected option's description renders
|
||
as a dim line under the menu. ``None`` to omit.
|
||
:param width: Terminal width for rendering, e.g. ``80``.
|
||
:param selectable: Parallel to *options*; ``False`` marks a row as a
|
||
non-selectable section header/separator.
|
||
:param status: Optional transient status line (e.g. ``"✓ added X"``)
|
||
rendered green above the title. Being part of the frame, it is
|
||
erased with the frame on ``clear_on_exit`` — so a re-rendering loop
|
||
shows only the latest action's result, never an accumulating stack.
|
||
:returns: An ANSI-styled string ready for ``stdout.write()``.
|
||
"""
|
||
buf = io.StringIO()
|
||
render_console = Console(file=buf, force_terminal=True, width=width, highlight=False)
|
||
|
||
render_console.print()
|
||
if status:
|
||
render_console.print(Text(f" {status}", style="bold green"))
|
||
render_console.print()
|
||
render_console.print(Text(f" {title}", style=f"bold {ACCENT}"))
|
||
if not compact:
|
||
# The compact overview hugs the title to the list (Hermes-style); other
|
||
# menus keep a blank line below the title for breathing room.
|
||
render_console.print()
|
||
|
||
# Optional scrolling viewport: when *max_visible* is set and the list is
|
||
# longer, render only ``options[window_start : window_start + max_visible]``
|
||
# (the caller keeps the selected row inside this window) plus dim "N more"
|
||
# markers, so a long flat list fits one screen instead of overflowing and
|
||
# flickering. ``None`` (the default) renders every row, unchanged.
|
||
n_options = len(options)
|
||
if max_visible is not None and n_options > max_visible:
|
||
win_start = max(0, min(window_start, n_options - max_visible))
|
||
win_end = win_start + max_visible
|
||
else:
|
||
win_start, win_end = 0, n_options
|
||
if win_start > 0:
|
||
render_console.print(Text.from_markup(f" [{MUTED}]↑ {win_start} more[/]"))
|
||
|
||
last_choice = -1 # index of the most recent selectable (group-owning) row
|
||
for i in range(win_start, win_end):
|
||
label = options[i]
|
||
if not selectable[i]:
|
||
# Sub-line(s) under the preceding choice (a harness's default +
|
||
# "+N more" summary): indented, no pointer. ↑/↓ skip them. Their
|
||
# styling follows the cursor — the label's own emphasis (e.g. a
|
||
# bold-green default) shows only under the SELECTED choice; under an
|
||
# unselected choice the same sub-line is muted to dim so the
|
||
# highlight tracks where you are.
|
||
if last_choice == selected:
|
||
render_console.print(Text.from_markup(f" {label}"))
|
||
else:
|
||
plain = Text.from_markup(label).plain # drop the label's own color
|
||
render_console.print(Text(f" {plain}", style="dim"))
|
||
# One blank line after the LAST sub-line of a group (next row is a
|
||
# real choice, or the menu ends) — so consecutive sub-lines stay
|
||
# together and the gap separates one choice's block from the next.
|
||
if i + 1 >= len(options) or selectable[i + 1]:
|
||
render_console.print()
|
||
elif i == selected:
|
||
# Highlighted choice: bold accent with the ❯ pointer.
|
||
last_choice = i
|
||
render_console.print(Text.from_markup(f" [bold {ACCENT}]❯ {label}[/]"))
|
||
else:
|
||
# Unselected choice: normal weight (readable), aligned under the
|
||
# pointer so the column doesn't shift as the cursor moves.
|
||
last_choice = i
|
||
render_console.print(Text.from_markup(f" {label}"))
|
||
|
||
if win_end < n_options:
|
||
render_console.print(Text.from_markup(f" [{MUTED}]↓ {n_options - win_end} more[/]"))
|
||
|
||
if descriptions is not None and descriptions[selected]:
|
||
render_console.print()
|
||
description = descriptions[selected]
|
||
if compact:
|
||
description = _truncate_cells(description, max(8, width - 4))
|
||
render_console.print(Text(f" {description}", style="dim italic"))
|
||
|
||
render_console.print()
|
||
# The compact overview is a top-level menu (Esc exits setup), so it shows a
|
||
# navigate/select/exit hint in the spirit of other modern CLIs; nested menus
|
||
# keep the "Esc back" wording, where Esc returns rather than exits.
|
||
hint = (
|
||
"↑/↓ nav · Enter select · Esc exit"
|
||
if compact
|
||
else "↑/↓ move · Enter select · Esc back"
|
||
)
|
||
render_console.print(Text.from_markup(f" [{MUTED}]{hint}[/]"))
|
||
|
||
return buf.getvalue()
|
||
|
||
|
||
def _normalize_selectable(options: list[str], selectable: list[bool] | None) -> list[bool]:
|
||
"""Validate/expand the *selectable* mask for a menu.
|
||
|
||
:param options: The row labels.
|
||
:param selectable: Parallel ``bool`` mask, or ``None`` to mean every
|
||
row is selectable (today's behavior).
|
||
:returns: A concrete mask, one ``bool`` per option.
|
||
:raises ValueError: If *selectable* length differs from *options*, or
|
||
no row is selectable.
|
||
"""
|
||
if selectable is None:
|
||
return [True] * len(options)
|
||
if len(selectable) != len(options):
|
||
raise ValueError("selectable must match options length")
|
||
if not any(selectable):
|
||
raise ValueError("select() requires at least one selectable row")
|
||
return list(selectable)
|
||
|
||
|
||
def _step_selectable(selectable: list[bool], start: int, step: int) -> int:
|
||
"""Return the next selectable index from *start* moving by *step*, wrapping.
|
||
|
||
Skips non-selectable (header/separator) rows so ↑/↓ glide over them.
|
||
|
||
:param selectable: The per-row selectable mask (at least one ``True``).
|
||
:param start: The current index.
|
||
:param step: ``-1`` for up, ``+1`` for down.
|
||
:returns: The next selectable index (``start`` if it is the only one).
|
||
"""
|
||
count = len(selectable)
|
||
i = start
|
||
for _ in range(count):
|
||
i = (i + step) % count
|
||
if selectable[i]:
|
||
return i
|
||
return start
|
||
|
||
|
||
def _first_selectable(selectable: list[bool], preferred: int) -> int:
|
||
"""Return *preferred* if selectable, else the first selectable index.
|
||
|
||
:param selectable: The per-row selectable mask (at least one ``True``).
|
||
:param preferred: The caller's requested default index.
|
||
:returns: A selectable index to start the cursor on.
|
||
"""
|
||
if 0 <= preferred < len(selectable) and selectable[preferred]:
|
||
return preferred
|
||
return next(i for i, ok in enumerate(selectable) if ok)
|
||
|
||
|
||
def _select_fallback(
|
||
title: str,
|
||
options: list[str],
|
||
*,
|
||
default: int,
|
||
selectable: list[bool],
|
||
) -> int:
|
||
"""Non-TTY numbered fallback for :func:`select`.
|
||
|
||
Gives pipes / CI / tests a numbered prompt instead of a raw-termios
|
||
loop they cannot drive. Non-selectable rows are printed as plain
|
||
section labels (no number); only selectable rows are numbered, and the
|
||
returned value is the original index into *options*.
|
||
|
||
:param title: The header shown above the numbered list, e.g.
|
||
``"Which provider?"``.
|
||
:param options: The row labels (may include header/separator rows).
|
||
:param default: Zero-based index (into *options*) pre-selected; the
|
||
prompt default is its position among the numbered rows.
|
||
:param selectable: Parallel mask; ``False`` rows are unnumbered labels.
|
||
:returns: The chosen zero-based index into *options*.
|
||
"""
|
||
console.print(f" [{ACCENT}]{title}[/]")
|
||
# Map each printed number → original options index; print headers as
|
||
# plain labels so the grouping is still visible in the fallback.
|
||
number_to_index: list[int] = []
|
||
for i, label in enumerate(options):
|
||
if selectable[i]:
|
||
number_to_index.append(i)
|
||
console.print(f" {len(number_to_index)}. {label}")
|
||
else:
|
||
console.print(f" {label}")
|
||
console.print(f" [{MUTED}](q to go back)[/{MUTED}]")
|
||
console.print()
|
||
default_number = number_to_index.index(default) + 1 if default in number_to_index else 1
|
||
while True:
|
||
raw = str(click.prompt("Choice", default=str(default_number)))
|
||
# "q" is the fallback's abort, mirroring Esc on the TTY path — it
|
||
# returns -1 so callers go back / cancel without a dedicated menu row.
|
||
if raw.strip().lower() == "q":
|
||
return -1
|
||
try:
|
||
number = int(raw)
|
||
if 1 <= number <= len(number_to_index):
|
||
return number_to_index[number - 1]
|
||
except ValueError:
|
||
pass
|
||
console.print(" [red]Invalid selection.[/red]")
|
||
|
||
|
||
def _term_width() -> int:
|
||
"""Return the terminal width clamped to a sane minimum.
|
||
|
||
:returns: Terminal columns, at least ``40``; ``80`` when the size
|
||
cannot be determined.
|
||
"""
|
||
try:
|
||
return max(40, os.get_terminal_size().columns)
|
||
except (OSError, ValueError):
|
||
return 80
|
||
|
||
|
||
def select(
|
||
title: str,
|
||
options: list[str],
|
||
*,
|
||
descriptions: list[str] | None = None,
|
||
default: int = 0,
|
||
selectable: list[bool] | None = None,
|
||
clear_on_exit: bool = False,
|
||
status: str | None = None,
|
||
max_visible: int | None = None,
|
||
compact: bool = False,
|
||
) -> int:
|
||
"""Show a theme-picker-styled arrow-key menu and return the choice.
|
||
|
||
On a TTY this draws the menu via raw termios (accent ``❯`` pointer,
|
||
dimmed others, footer hints) and redraws in place on ↑/↓. Enter
|
||
confirms the highlighted option. Esc (or Ctrl-C / Ctrl-D) **aborts**
|
||
and returns ``-1`` so the caller can cancel / go back; callers must
|
||
check for ``< 0`` before indexing ``options``.
|
||
|
||
On a non-TTY (pipe / CI / test), falls back to a numbered prompt
|
||
(:func:`_select_fallback`).
|
||
|
||
Pass *selectable* to render a grouped tree in one view: rows whose
|
||
mask is ``False`` are non-selectable section headers/separators that
|
||
↑/↓ skip over (e.g. ``"Claude"`` / ``"Codex"`` labels above their
|
||
provider rows). With no mask, every row is selectable (today's flat
|
||
menu).
|
||
|
||
:param title: The header shown above the options, e.g.
|
||
``"What do you want to do?"``.
|
||
:param options: The row labels, e.g. ``["Add a provider",
|
||
"Quit"]``. Must be non-empty.
|
||
:param descriptions: Optional per-option descriptions (same length
|
||
as *options*); the selected option's description renders as a
|
||
dim line under the menu. ``None`` to omit.
|
||
:param default: Zero-based index of the initially highlighted
|
||
option, e.g. ``0``. If it points at a non-selectable row, the
|
||
cursor starts on the first selectable row instead.
|
||
:param selectable: Optional parallel ``bool`` mask; ``False`` marks a
|
||
row as a non-selectable header/separator. ``None`` → all rows
|
||
selectable.
|
||
:param clear_on_exit: When ``True`` (TTY only), erase the rendered menu
|
||
frame on return instead of leaving it in the scrollback — so a
|
||
multi-step interactive loop (re-rendering the menu after each
|
||
action) doesn't pile up stale frames. No-op on the numbered
|
||
fallback (nothing to erase).
|
||
:param status: Optional transient status line shown green above the
|
||
title (part of the frame, so it clears with ``clear_on_exit``).
|
||
Pass the prior action's result so a re-rendering loop shows only
|
||
the latest, never an accumulating stack. No-op on the fallback.
|
||
:param max_visible: Optional cap on visible rows. When set and the list
|
||
is longer, the menu shows a scrolling viewport that follows the
|
||
cursor (with "N more" markers) so a long flat list fits one screen
|
||
instead of overflowing and flickering. ``None`` renders every row.
|
||
No-op on the numbered fallback.
|
||
:param compact: When ``True`` (TTY only), render the dense top-level
|
||
overview layout: the title hugs the list (no blank line below it) and
|
||
the footer reads ``nav · select · Esc exit`` (Esc exits rather
|
||
than goes back). Intended for the setup harness overview. No-op on the
|
||
numbered fallback.
|
||
:returns: The chosen zero-based index into *options* (always a
|
||
selectable row), or ``-1`` when the user aborts — Esc / Ctrl-C /
|
||
Ctrl-D on the TTY, or ``q`` on the numbered fallback.
|
||
:raises ValueError: If *options* is empty, *descriptions* or
|
||
*selectable* length differs from *options*, or no row is
|
||
selectable.
|
||
"""
|
||
if not options:
|
||
raise ValueError("select() requires at least one option")
|
||
if descriptions is not None and len(descriptions) != len(options):
|
||
raise ValueError("descriptions must match options length")
|
||
mask = _normalize_selectable(options, selectable)
|
||
|
||
if not sys.stdin.isatty():
|
||
return _select_fallback(title, options, default=default, selectable=mask)
|
||
|
||
import termios
|
||
import tty
|
||
|
||
fd = sys.stdin.fileno()
|
||
selected = _first_selectable(mask, default)
|
||
cancelled = False
|
||
width = _term_width()
|
||
# Single-element list tracks how many lines the previous frame
|
||
# occupied so the next redraw can move up and overwrite it
|
||
# (the ``_theme_picker`` redraw idiom).
|
||
prev_lines = [0]
|
||
# Scrolling-viewport start index (mutable for the redraw closure); only
|
||
# used when ``max_visible`` bounds a long list.
|
||
window_start = [0]
|
||
|
||
def _redraw() -> None:
|
||
"""Clear the prior frame region and reprint the menu in place."""
|
||
if max_visible is not None and len(options) > max_visible:
|
||
# Keep the selected row inside the [start, start+max_visible) window,
|
||
# scrolling the window just enough to follow the cursor.
|
||
if selected < window_start[0]:
|
||
window_start[0] = selected
|
||
elif selected >= window_start[0] + max_visible:
|
||
window_start[0] = selected - max_visible + 1
|
||
window_start[0] = max(0, min(window_start[0], len(options) - max_visible))
|
||
rendered = _render_menu(
|
||
title,
|
||
options,
|
||
selected,
|
||
descriptions=descriptions,
|
||
width=width,
|
||
selectable=mask,
|
||
status=status,
|
||
max_visible=max_visible,
|
||
window_start=window_start[0],
|
||
compact=compact,
|
||
)
|
||
if prev_lines[0] > 0:
|
||
sys.stdout.write(f"\033[{prev_lines[0]}A")
|
||
sys.stdout.write("\033[J") # Clear from cursor to end of screen.
|
||
sys.stdout.write(rendered)
|
||
sys.stdout.flush()
|
||
prev_lines[0] = rendered.count("\n")
|
||
|
||
try:
|
||
old_attrs = termios.tcgetattr(fd)
|
||
except termios.error:
|
||
# Cannot enter raw mode — degrade to the numbered fallback.
|
||
return _select_fallback(title, options, default=default, selectable=mask)
|
||
|
||
try:
|
||
_redraw()
|
||
tty.setcbreak(fd)
|
||
while True:
|
||
ch = os.read(fd, 1)
|
||
if not ch:
|
||
break
|
||
if ch in (b"\x03", b"\x04"):
|
||
# Ctrl-C / Ctrl-D — abort the menu.
|
||
cancelled = True
|
||
break
|
||
if ch == b"\x1b":
|
||
# Escape alone, or the start of an arrow sequence.
|
||
import select as _select
|
||
|
||
if _select.select([fd], [], [], 0.05)[0]:
|
||
nxt = os.read(fd, 1)
|
||
if nxt == b"[":
|
||
arrow = os.read(fd, 1)
|
||
if arrow == b"A": # Up
|
||
selected = _step_selectable(mask, selected, -1)
|
||
_redraw()
|
||
elif arrow == b"B": # Down
|
||
selected = _step_selectable(mask, selected, +1)
|
||
_redraw()
|
||
# Ignore other escape sequences.
|
||
continue
|
||
# Bare Escape — abort the menu.
|
||
cancelled = True
|
||
break
|
||
if ch in (b"\r", b"\n"):
|
||
break
|
||
if ch in (b"k", b"K"): # vi-style up
|
||
selected = _step_selectable(mask, selected, -1)
|
||
_redraw()
|
||
elif ch in (b"j", b"J"): # vi-style down
|
||
selected = _step_selectable(mask, selected, +1)
|
||
_redraw()
|
||
finally:
|
||
termios.tcsetattr(fd, termios.TCSADRAIN, old_attrs)
|
||
|
||
if clear_on_exit and prev_lines[0] > 0:
|
||
# Erase the rendered frame so a re-rendering loop doesn't leave a
|
||
# trail of stale menus in the scrollback: move up over the frame and
|
||
# clear from there to the end of screen.
|
||
sys.stdout.write(f"\033[{prev_lines[0]}A\033[J")
|
||
sys.stdout.flush()
|
||
|
||
return -1 if cancelled else selected
|
||
|
||
|
||
def prompt_text(
|
||
label: str,
|
||
*,
|
||
default: str | None = None,
|
||
hide_input: bool = False,
|
||
) -> str:
|
||
"""Prompt for a free-text value in the onboarding selector style.
|
||
|
||
On a TTY this prints an accent label line, then reads the value via
|
||
``click.prompt`` (which handles ``hide_input`` masking and the
|
||
``default`` echo). Hidden prompts also print muted metadata-only
|
||
feedback so users can tell a pasted secret registered without seeing
|
||
the secret. On a non-TTY the same ``click.prompt`` path runs, so pipes
|
||
/ tests behave identically.
|
||
|
||
:param label: The prompt label, e.g. ``"anthropic API key"``.
|
||
:param default: Pre-filled default returned on an empty enter, or
|
||
``None`` to require a value.
|
||
:param hide_input: When ``True``, mask the typed value (for secrets
|
||
like API keys).
|
||
:returns: The entered (or default) string.
|
||
"""
|
||
if sys.stdin.isatty():
|
||
console.print(f" [{ACCENT}]{label}[/]")
|
||
prompt_label = " ❯"
|
||
else:
|
||
prompt_label = label
|
||
|
||
if not hide_input:
|
||
return str(
|
||
click.prompt(
|
||
prompt_label,
|
||
default=default,
|
||
hide_input=False,
|
||
show_default=default is not None,
|
||
)
|
||
)
|
||
|
||
console.print(f" [{MUTED}](input hidden; paste your key, then press Enter)[/{MUTED}]")
|
||
received_hidden_input = False
|
||
termui = cast(_TermUIWithHiddenPrompt, click.termui)
|
||
hidden_prompt_func = termui.hidden_prompt_func
|
||
|
||
def _record_hidden_input(text: str) -> str:
|
||
nonlocal received_hidden_input
|
||
value = hidden_prompt_func(text)
|
||
if value:
|
||
received_hidden_input = True
|
||
return value
|
||
|
||
termui.hidden_prompt_func = _record_hidden_input
|
||
try:
|
||
value = str(
|
||
click.prompt(
|
||
prompt_label,
|
||
default=default,
|
||
hide_input=True,
|
||
show_default=False,
|
||
)
|
||
)
|
||
finally:
|
||
termui.hidden_prompt_func = hidden_prompt_func
|
||
|
||
if received_hidden_input and value:
|
||
count = len(value)
|
||
unit = "character" if count == 1 else "characters"
|
||
console.print(f" [{MUTED}]✓ received ({count} {unit})[/{MUTED}]")
|
||
|
||
return value
|