whiletrue 0.1.0__py3-none-any.whl

whiletrue/cli/gates.py

@@ -0,0 +1,156 @@
+"""Commands for the humans in the loop: approve, reject, comment, history."""
+
+from __future__ import annotations
+
+import getpass
+import time
+import uuid
+from datetime import UTC, datetime
+from pathlib import Path
+
+from whiletrue.cli.common import EXIT, Io
+from whiletrue.core import Decision
+from whiletrue.store_sqlite import SqliteStore
+
+
+def _now() -> int:
+    return int(time.time() * 1000)
+
+
+def _who() -> str:
+    try:
+        return getpass.getuser()
+    except Exception:  # pragma: no cover (no passwd entry)
+        return "cli"
+
+
+def open_store(io: Io) -> SqliteStore | None:
+    db_path = Path(io.cwd) / ".whiletrue" / "state.db"
+    if not db_path.exists():
+        io.err("No runs yet (.whiletrue/state.db not found)\n")
+        return None
+    return SqliteStore(db_path)
+
+
+def decide(io: Io, decision: Decision, item: str | None, note: str | None, step: str | None) -> int:
+    verb = "approve" if decision == "approved" else "reject"
+    if item is None:
+        io.err(
+            f"Usage: whiletrue {verb} <item>{' --note "..."' if decision == 'rejected' else ''}\n"
+        )
+        return EXIT.usage
+    if decision == "rejected" and not (note and note.strip()):
+        io.err('A rejection needs a reason: whiletrue reject <item> --note "what to change"\n')
+        return EXIT.usage
+    store = open_store(io)
+    if store is None:
+        return EXIT.failed
+    try:
+        waiting = store.list_parks(item, undecided_only=True)
+        if step is not None:
+            waiting = [p for p in waiting if p.node_path == step]
+        if not waiting:
+            io.err(f'Nothing is waiting on a decision for "{item}"\n')
+            return EXIT.failed
+        steps = sorted({p.node_path for p in waiting})
+        if len(steps) > 1:
+            io.err(f'"{item}" is waiting at several gates ({", ".join(steps)}); pass --step <id>\n')
+            return EXIT.usage
+        park = waiting[-1]
+        store.decide_park(park.id, decision, decided_by=_who(), decided_at=_now(), notes=note)
+        io.out(f"{item}: {decision} ({park.what} at {park.node_path})\n")
+        io.out("Run `whiletrue resume` to continue (a watching run picks it up by itself).\n")
+        return EXIT.ok
+    finally:
+        store.close()
+
+
+def comment(io: Io, item: str | None, text: str | None) -> int:
+    if item is None or not text or not text.strip():
+        io.err('Usage: whiletrue comment <item> "your comment"\n')
+        return EXIT.usage
+    store = open_store(io)
+    if store is None:
+        return EXIT.failed
+    try:
+        added = store.add_comment(
+            item_id=item,
+            source="local",
+            external_id=uuid.uuid4().hex,
+            author=_who(),
+            body=text.strip(),
+            created_at=_now(),
+        )
+        assert added is not None
+        io.out(f"comment #{added.id} added to {item}; the pipeline answers it at the next wake\n")
+        return EXIT.ok
+    finally:
+        store.close()
+
+
+def _stamp(ms: int) -> str:
+    return datetime.fromtimestamp(ms / 1000, UTC).strftime("%Y-%m-%d %H:%M:%S")
+
+
+def history(io: Io, item: str | None) -> int:
+    if item is None:
+        io.err("Usage: whiletrue history <item>\n")
+        return EXIT.usage
+    store = open_store(io)
+    if store is None:
+        return EXIT.failed
+    try:
+        lines: list[tuple[int, str]] = []
+        for park in store.list_parks(item):
+            lines.append((park.created_at, f"parked at {park.node_path}: waiting for {park.what}"))
+            if park.decision is not None and park.decided_at is not None:
+                note = f" — {park.notes}" if park.notes else ""
+                lines.append(
+                    (park.decided_at, f"{park.decision} by {park.decided_by}{note}"),
+                )
+        for c in store.list_comments(item):
+            lines.append((c.created_at, f"comment from {c.author} ({c.source}): {c.body}"))
+            if c.reply:
+                lines.append((c.created_at, f"  reply: {c.reply}"))
+        for s in store.list_steers(item):
+            lines.append((s.created_at, f"steered {s.step}: {s.prompt}"))
+        if not lines:
+            io.err(f'No history for "{item}"\n')
+            return EXIT.failed
+        for when, text in sorted(lines, key=lambda x: x[0]):
+            io.out(f"{_stamp(when)}  {text}\n")
+        return EXIT.ok
+    finally:
+        store.close()
+
+
+def learnings(io: Io, action: str | None, learning_id: str | None) -> int:
+    """List proposed lessons, or approve/reject one. Only approved lessons reach agents."""
+    store = open_store(io)
+    if store is None:
+        return EXIT.failed
+    try:
+        if action in (None, "list"):
+            rows = store.list_learnings()
+            if not rows:
+                io.out("No learnings yet\n")
+                return EXIT.ok
+            for row in rows:
+                source = row.provenance.get("source", "?")
+                item = row.provenance.get("item", "?")
+                io.out(f"#{row.id}  {row.status:<8}  {row.note}  (from {source} on {item})\n")
+            return EXIT.ok
+        if action not in ("approve", "reject") or not (learning_id or "").isdigit():
+            io.err("Usage: whiletrue learnings [list | approve <id> | reject <id>]\n")
+            return EXIT.usage
+        try:
+            store.set_learning_status(
+                int(learning_id or 0), "approved" if action == "approve" else "rejected"
+            )
+        except KeyError:
+            io.err(f"No learning #{learning_id}\n")
+            return EXIT.failed
+        io.out(f"learning #{learning_id}: {action}d\n")
+        return EXIT.ok
+    finally:
+        store.close()

whiletrue/cli/ops.py

@@ -0,0 +1,339 @@
+"""Operating a project's runs: the run lock, crash recovery, rerun, cancel, logs and cost."""
+
+from __future__ import annotations
+
+import asyncio
+import fcntl
+import os
+import time
+from collections import defaultdict
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, cast
+
+from whiletrue.cli.common import EXIT, Io
+from whiletrue.core import (
+    ReplayError,
+    RunItem,
+    SourceError,
+    fetch_items,
+    find_dependency_cycles,
+    load_recording,
+    run_pipeline,
+)
+from whiletrue.store_sqlite import SqliteStore
+
+if TYPE_CHECKING:
+    from whiletrue.cli.app import _Loaded  # pyright: ignore[reportPrivateUsage]
+
+
+class RunLock:
+    """An exclusive lock on `.whiletrue/run.lock`, held for as long as a run's process lives.
+
+    It tells a crashed run (status `running`, nobody holds the lock) from a live one.
+    """
+
+    def __init__(self, cwd: str) -> None:
+        self._path = Path(cwd) / ".whiletrue" / "run.lock"
+        self._handle: Any = None
+
+    def acquire(self) -> bool:
+        self._path.parent.mkdir(parents=True, exist_ok=True)
+        handle = self._path.open("a+")
+        try:
+            fcntl.flock(handle, fcntl.LOCK_EX | fcntl.LOCK_NB)
+        except OSError:
+            handle.close()
+            return False
+        handle.seek(0)
+        handle.truncate()
+        handle.write(str(os.getpid()))
+        handle.flush()
+        self._handle = handle
+        return True
+
+    def release(self) -> None:
+        if self._handle is not None:
+            fcntl.flock(self._handle, fcntl.LOCK_UN)
+            self._handle.close()
+            self._handle = None
+
+    def holder(self) -> str:
+        try:
+            return self._path.read_text().strip() or "?"
+        except OSError:
+            return "?"
+
+
+def item_line(item: Any) -> str:
+    """One result line; a failure or park says why, so nobody has to dig in the database."""
+    line = f"  {item.item_id}: {item.state} ({item.port})"
+    value: Any = item.value
+    if item.port in ("fail", "needs_human", "rejected") and isinstance(value, dict):
+        fields = cast(dict[str, Any], value)
+        why = fields.get("error") or fields.get("reason") or fields.get("detail")
+        if why:
+            line += f" — {str(why).strip().splitlines()[0][:200]}"
+    return line + "\n"
+
+
+def _status_code(status: str) -> int:
+    return {"done": EXIT.ok, "parked": EXIT.parked, "cancelled": EXIT.cancelled}.get(
+        status, EXIT.failed
+    )
+
+
+def _log(io: Io):
+    def log(level: str, message: str, data: object = None) -> None:
+        if level != "debug":
+            io.out(f"[{level}] {message}\n")
+
+    return log
+
+
+async def source_items(loaded: _Loaded) -> list[RunItem] | None:
+    return await fetch_items(loaded.registry, loaded.config.extra, loaded.cwd)
+
+
+def cycle_error(items: list[RunItem] | None) -> str | None:
+    cycles = find_dependency_cycles(items or [])
+    if not cycles:
+        return None
+    return "Items depend on each other in a cycle: " + "; ".join(" -> ".join(c) for c in cycles)
+
+
+async def resume(io: Io, loaded: _Loaded, run_id: str | None, lock_hash: str | None) -> int:
+    """Continue a parked run, or one whose process died: recorded steps are replayed."""
+    db_path = Path(loaded.cwd) / ".whiletrue" / "state.db"
+    if not db_path.exists():
+        io.err("No runs yet (.whiletrue/state.db not found)\n")
+        return EXIT.failed
+    store = SqliteStore(db_path)
+    try:
+        if run_id is None:
+            latest = store.latest_run()
+            run_id = latest.id if latest else ""
+        run = store.get_run(run_id)
+        if run is not None and run.status == "running":
+            # We hold the run lock, so nothing is running it: the process died.
+            store.interrupt_run(run_id, int(time.time() * 1000))
+            io.out(f"run {run_id} was interrupted (its process is gone); recovering it\n")
+        try:
+            recording = load_recording(store, run_id)
+        except ReplayError as error:
+            io.err(f"{error}\n")
+            return EXIT.failed
+        if recording.status != "parked":
+            io.err(f"Run {run_id} is {recording.status}, not parked: nothing to resume\n")
+            return EXIT.failed
+        items = [i for i in recording.items if recording.item_states.get(i.id) != "cancelled"]
+        try:
+            fresh = await source_items(loaded)
+        except SourceError as error:
+            io.err(f"Cannot fetch items: {error}\n")
+            return EXIT.failed
+        if fresh is not None:
+            # The source wins: items it no longer lists are dropped, and its newest data is used.
+            wanted = {i.id for i in items}
+            gone = sorted(wanted - {f.id for f in fresh})
+            if gone:
+                io.out(f"no longer in the source, dropped: {', '.join(gone)}\n")
+            items = [f for f in fresh if f.id in wanted or f.id not in recording.item_states]
+        result = await run_pipeline(
+            registry=loaded.registry,
+            config=loaded.config,
+            store=store,
+            cwd=loaded.cwd,
+            signal=io.signal,
+            log=_log(io),
+            lockfile=lock_hash,
+            items=items,
+            replay=recording.steps,
+            resume=True,
+            lineage=recording.lineage,
+        )
+        io.out(f"resumed {recording.run_id} as run {result.run_id}: {result.status}\n")
+        for item in result.items:
+            io.out(item_line(item))
+        return _status_code(result.status)
+    finally:
+        store.close()
+
+
+async def rerun(
+    io: Io, loaded: _Loaded, item_id: str, from_step: str | None, lock_hash: str | None
+) -> int:
+    """Run one item again as a new run; with `--from`, steps before that step are replayed."""
+    db_path = Path(loaded.cwd) / ".whiletrue" / "state.db"
+    if not db_path.exists():
+        io.err("No runs yet (.whiletrue/state.db not found)\n")
+        return EXIT.failed
+    store = SqliteStore(db_path)
+    try:
+        latest = store.latest_run()
+        if latest is None:
+            io.err("No runs yet\n")
+            return EXIT.failed
+        if latest.status == "running":
+            io.err("The latest run is still running; cancel it or wait\n")
+            return EXIT.failed
+        recording = load_recording(store, latest.id)
+        item = next((i for i in recording.items if i.id == item_id), None)
+        if item is None:
+            io.err(f'Run {latest.id} has no item "{item_id}"\n')
+            return EXIT.failed
+        replay: dict[tuple[str, str, int], tuple[str, Any]] = {}
+        if from_step is not None:
+            steps = store.list_steps(latest.id, item_id)
+            cut = next((s.id for s in steps if s.node_path == from_step), None)
+            if cut is None:
+                io.err(f'Item "{item_id}" has no step "{from_step}" in run {latest.id}\n')
+                return EXIT.failed
+            replay = {
+                (s.item_id, s.node_path, s.attempt): (s.port, s.output)
+                for s in steps
+                if s.id < cut and s.port is not None and s.port != "needs_human"
+            }
+        # Its blockers already ran; only this item is run again.
+        again = RunItem(item.id, item.payload, [])
+        result = await run_pipeline(
+            registry=loaded.registry,
+            config=loaded.config,
+            store=store,
+            cwd=loaded.cwd,
+            signal=io.signal,
+            log=_log(io),
+            lockfile=lock_hash,
+            items=[again],
+            replay=replay if from_step is not None else None,
+            resume=True,
+        )
+        io.out(f"rerun of {item_id} as run {result.run_id}: {result.status}\n")
+        return _status_code(result.status)
+    finally:
+        store.close()
+
+
+def cancel(io: Io, item_id: str | None) -> int:
+    """Cancel an item in the latest run. A running one stops before its next step."""
+    if item_id is None:
+        io.err("Usage: whiletrue cancel <item>\n")
+        return EXIT.usage
+    db_path = Path(io.cwd) / ".whiletrue" / "state.db"
+    if not db_path.exists():
+        io.err("No runs yet (.whiletrue/state.db not found)\n")
+        return EXIT.failed
+    store = SqliteStore(db_path)
+    try:
+        run = store.latest_run()
+        record = store.get_item(run.id, item_id) if run else None
+        if run is None or record is None:
+            io.err(f'No item "{item_id}" in the latest run\n')
+            return EXIT.failed
+        if record.state in ("done", "cancelled"):
+            io.err(f'"{item_id}" is already {record.state}\n')
+            return EXIT.failed
+        for park in store.list_parks(item_id, undecided_only=True):
+            store.decide_park(
+                park.id, "rejected", decided_by="cancel", decided_at=_now(), notes="cancelled"
+            )
+        store.set_item_state(run.id, item_id, "cancelled")
+        io.out(f"{item_id}: cancelled\n")
+        return EXIT.ok
+    finally:
+        store.close()
+
+
+def _now() -> int:
+    return int(time.time() * 1000)
+
+
+def _event_line(event: Any) -> str:
+    stamp = time.strftime("%H:%M:%S", time.gmtime(event.ts / 1000))
+    detail = " ".join(f"{k}={v}" for k, v in event.data.items() if k not in ("files",))
+    return f"{stamp}  {event.type:<16} {detail}".rstrip()
+
+
+async def logs(io: Io, item_id: str | None, follow: bool) -> int:
+    if item_id is None:
+        io.err("Usage: whiletrue logs <item> [--follow]\n")
+        return EXIT.usage
+    db_path = Path(io.cwd) / ".whiletrue" / "state.db"
+    if not db_path.exists():
+        io.err("No runs yet (.whiletrue/state.db not found)\n")
+        return EXIT.failed
+    store = SqliteStore(db_path)
+    try:
+        run = store.latest_run()
+        if run is None:
+            io.err("No runs yet\n")
+            return EXIT.failed
+        shown = 0
+        while True:
+            events = store.list_events(run.id, item_id=item_id)
+            for event in events[shown:]:
+                io.out(_event_line(event) + "\n")
+            shown = len(events)
+            current = store.get_run(run.id)
+            if not follow or current is None or current.status != "running":
+                break
+            if io.signal is not None and io.signal.aborted:
+                return EXIT.cancelled
+            await asyncio.sleep(0.5)
+        if shown == 0:
+            io.err(f'No events for "{item_id}" in run {run.id}\n')
+            return EXIT.failed
+        return EXIT.ok
+    finally:
+        store.close()
+
+
+def _lineage_runs(store: SqliteStore, run_id: str) -> list[str]:
+    """The run and every other run of the same lineage (the resumes of one piece of work)."""
+
+    def lineage_of(rid: str) -> str:
+        started = store.list_events(rid, type="run.started")
+        return str(started[0].data.get("lineage", rid)) if started else rid
+
+    wanted = lineage_of(run_id)
+    return [r.id for r in store.list_runs() if lineage_of(r.id) == wanted]
+
+
+def cost(io: Io, run_id: str | None) -> int:
+    """Spend by item, step and runner, over a run and all its resumes."""
+    db_path = Path(io.cwd) / ".whiletrue" / "state.db"
+    if not db_path.exists():
+        io.err("No runs yet (.whiletrue/state.db not found)\n")
+        return EXIT.failed
+    store = SqliteStore(db_path)
+    try:
+        run = store.get_run(run_id) if run_id else store.latest_run()
+        if run is None:
+            io.err("No runs yet\n")
+            return EXIT.failed
+        runs = _lineage_runs(store, run.id)
+        runner_of: dict[tuple[str, str], str] = {}
+        by_item: dict[str, float] = defaultdict(float)
+        by_step: dict[str, float] = defaultdict(float)
+        by_runner: dict[str, float] = defaultdict(float)
+        for rid in runs:
+            for event in store.list_events(rid, type="agent.event"):
+                if event.data.get("kind") == "runner" and event.item_id:
+                    key = (event.item_id, str(event.data.get("node")))
+                    runner_of[key] = str(event.data["runner"])
+            for step in store.list_steps(rid):
+                if step.cost_usd <= 0:
+                    continue
+                by_item[step.item_id] += step.cost_usd
+                by_step[step.node_path] += step.cost_usd
+                runner = runner_of.get((step.item_id, step.node_path), "other")
+                by_runner[runner] += step.cost_usd
+        total = sum(by_item.values())
+        span = f" (over {len(runs)} runs)" if len(runs) > 1 else ""
+        io.out(f"run {run.id}  total ${total:.4f}{span}\n")
+        for title, table in (("by item", by_item), ("by step", by_step), ("by runner", by_runner)):
+            io.out(f"{title}:\n")
+            for name, usd in sorted(table.items(), key=lambda kv: -kv[1]):
+                io.out(f"  {name:<24} ${usd:.4f}\n")
+        return EXIT.ok
+    finally:
+        store.close()

whiletrue/cli/panel.py

@@ -0,0 +1,198 @@
+"""The tmux control panel (window 0): every item, where it is, and who it is waiting for."""
+
+from __future__ import annotations
+
+import asyncio
+import sys
+import time
+from collections.abc import Awaitable, Callable
+from dataclasses import dataclass
+
+from whiletrue.cli.common import Io
+from whiletrue.core import StateStore
+from whiletrue.tmux import TmuxController
+
+KEYS = "j/k move  a approve  r reject  c cancel  f focus pane  R rerun (hint)  q quit"
+
+
+@dataclass
+class Row:
+    item: str
+    state: str
+    step: str
+    waiting: str
+    cost: float
+    age_s: int
+
+
+def rows(store: StateStore, now_ms: int) -> list[Row]:
+    run = store.latest_run()
+    if run is None:
+        return []
+    parks = store.list_parks(undecided_only=True)
+    out: list[Row] = []
+    for item in store.list_items(run.id):
+        steps = store.list_steps(run.id, item.id)
+        working = [s for s in steps if s.status == "running" and s.node_path != "root"]
+        last = working[-1] if working else (steps[-1] if steps else None)
+        mine = [p for p in parks if p.item_id == item.id]
+        waiting = f"{mine[-1].what} at {mine[-1].node_path}" if mine else ""
+        started = min((s.started_at for s in steps), default=run.started_at)
+        out.append(
+            Row(
+                item=item.id,
+                state=item.state,
+                step=last.node_path if last else "",
+                waiting=waiting,
+                cost=sum(s.cost_usd for s in steps),
+                age_s=max(0, (now_ms - started) // 1000),
+            )
+        )
+    return out
+
+
+def _age(seconds: int) -> str:
+    if seconds >= 3600:
+        return f"{seconds // 3600}h{(seconds % 3600) // 60:02d}m"
+    return f"{seconds // 60}m{seconds % 60:02d}s"
+
+
+def render(table: list[Row], selected: int, message: str = "") -> str:
+    lines = [f"  {'ITEM':<10}{'STATE':<10}{'STEP':<18}{'WAITING FOR':<24}{'COST':>8}  AGE"]
+    for index, row in enumerate(table):
+        mark = ">" if index == selected else " "
+        lines.append(
+            f"{mark} {row.item:<10}{row.state:<10}{row.step:<18}{row.waiting:<24}"
+            f"{'$' + format(row.cost, '.2f'):>8}  {_age(row.age_s)}"
+        )
+    if not table:
+        lines.append("  (no items yet)")
+    lines += ["", KEYS]
+    if message:
+        lines.append(message)
+    return "\n".join(lines)
+
+
+class Panel:
+    """Keys act on the selected item. Reads and writes go through the store, like the CLI."""
+
+    def __init__(
+        self,
+        store: StateStore,
+        tmux: TmuxController | None = None,
+        *,
+        now: Callable[[], int] = lambda: int(time.time() * 1000),
+        ask: Callable[[str], Awaitable[str]] | None = None,
+        who: str = "panel",
+    ) -> None:
+        self._store = store
+        self._tmux = tmux
+        self._now = now
+        self._ask = ask
+        self._who = who
+        self.selected = 0
+        self.message = ""
+
+    def view(self) -> str:
+        table = rows(self._store, self._now())
+        self.selected = min(self.selected, max(0, len(table) - 1))
+        return render(table, self.selected, self.message)
+
+    def _current(self) -> Row | None:
+        table = rows(self._store, self._now())
+        return table[self.selected] if table else None
+
+    async def key(self, key: str) -> bool:
+        """Handles one key; False means quit."""
+        self.message = ""
+        if key == "q":
+            return False
+        if key in ("j", "k"):
+            size = len(rows(self._store, self._now()))
+            self.selected = max(0, min(size - 1, self.selected + (1 if key == "j" else -1)))
+            return True
+        row = self._current()
+        if row is None:
+            return True
+        if key in ("a", "r"):
+            await self._decide(row, approve=key == "a")
+        elif key == "f":
+            await self._focus(row)
+        elif key == "c":
+            self._cancel(row)
+        elif key == "R":
+            self.message = f"run: whiletrue rerun {row.item} [--from <step>]"
+        return True
+
+    def _cancel(self, row: Row) -> None:
+        run = self._store.latest_run()
+        if run is None or row.state in ("done", "cancelled"):
+            self.message = f"{row.item} is already {row.state}"
+            return
+        for park in self._store.list_parks(row.item, undecided_only=True):
+            self._store.decide_park(
+                park.id, "rejected", decided_by=self._who, decided_at=self._now(), notes="cancelled"
+            )
+        self._store.set_item_state(run.id, row.item, "cancelled")
+        self.message = f"{row.item}: cancelled"
+
+    async def _decide(self, row: Row, *, approve: bool) -> None:
+        waiting = self._store.list_parks(row.item, undecided_only=True)
+        if not waiting:
+            self.message = f"{row.item} is not waiting for a decision"
+            return
+        note: str | None = None
+        if not approve:
+            note = (await self._ask("rejection note: ")).strip() if self._ask else ""
+            if not note:
+                self.message = "a rejection needs a note"
+                return
+        self._store.decide_park(
+            waiting[-1].id,
+            "approved" if approve else "rejected",
+            decided_by=self._who,
+            decided_at=self._now(),
+            notes=note,
+        )
+        self.message = f"{row.item}: {'approved' if approve else 'rejected'}"
+
+    async def _focus(self, row: Row) -> None:
+        if self._tmux is None:
+            self.message = "no tmux session to focus"
+            return
+        pane = await self._tmux.find_pane(row.item)
+        if pane is None:
+            self.message = f"no live pane for {row.item}"
+            return
+        await self._tmux.focus(pane)
+
+
+async def run_panel(
+    io: Io, store: StateStore, tmux: TmuxController | None
+) -> int:  # pragma: no cover
+    """The interactive loop: redraw every second, act on single key presses."""
+    import getpass  # noqa: PLC0415
+    import select  # noqa: PLC0415
+    import termios  # noqa: PLC0415
+    import tty  # noqa: PLC0415
+
+    fd = sys.stdin.fileno()
+    saved = termios.tcgetattr(fd)
+
+    async def ask(prompt: str) -> str:
+        termios.tcsetattr(fd, termios.TCSADRAIN, saved)
+        try:
+            return await asyncio.to_thread(input, prompt)
+        finally:
+            tty.setcbreak(fd)
+
+    panel = Panel(store, tmux, ask=ask, who=getpass.getuser())
+    tty.setcbreak(fd)
+    try:
+        while True:
+            io.out("\x1b[2J\x1b[H" + panel.view() + "\n")
+            ready, _, _ = await asyncio.to_thread(select.select, [sys.stdin], [], [], 1.0)
+            if ready and not await panel.key(sys.stdin.read(1)):
+                return 0
+    finally:
+        termios.tcsetattr(fd, termios.TCSADRAIN, saved)