cc-session-control 0.4.0__py3-none-any.whl

cc_session_control/__init__.py

@@ -0,0 +1,3 @@
+"""cc-session-control — TUI manager for Claude Code sessions and Remote Control."""
+
+__version__ = "0.4.0"

cc_session_control/__main__.py

@@ -0,0 +1,5 @@
+"""Allow running as `python -m cc_session_control`."""
+
+from .cli import main
+
+main()

cc_session_control/actions/agent_ops.py

@@ -0,0 +1,201 @@
+"""Background-agent lifecycle actions (R4 / Phase 6).
+
+The persistent truth for a background agent lives in `jobs/<short>/state.json`
+(registry.read_agent_jobs → AgentJob); it carries NO pid. So a live worker's host
+pid is resolved by JOINing the job's sid back to `sessions/<pid>.json`
+(`job_host`) — a live worker with no sessions file is therefore unstoppable, a
+documented orphan risk surfaced in `HELP`.
+
+Capability red lines honoured here:
+  - respawn/takeover never replace the csctl process (respawn spawns a tmux
+    window; takeover hands a Session to the existing `do_resume` path run AFTER
+    the UI loop exits).
+  - stop only signals a confirmed-live joined host pid; killing a
+    `--remote-control`/bg worker does not always fully reap it (orphan risk).
+  - destructive ops (remove/stop) refuse when "current" can't be determined
+    (no `/proc`, R10) so they never blind-hit csctl's own session.
+
+This is an action module: internals are English, but the user-facing label/help
+constants the (Phase 7) background view reads are Simplified Chinese.
+"""
+
+from __future__ import annotations
+
+import os
+import shlex
+import signal
+import time
+from dataclasses import replace
+
+from ..config import cfg
+from ..data import cleanup, liveness, proc, rc, registry
+from ..models import AgentJob, Session
+
+# --- User-facing labels/help (Simplified Chinese, read by the Phase 7 view) ---
+
+TAKEOVER_LABEL = "接回"
+
+# Unified verb table (matches Sessions/RC): Enter/o=接回(primary), s=停止(kill a
+# live thing), d=删除, R=重启(respawn). `r`=刷新 lives in the App-level footer
+# prefix now, so it is NOT repeated here; separators are ` · ` like the other tabs.
+KEYHINTS = "Enter/o 接回 · s 停止 · d 删除 · w 查看 · R 重启"
+
+# Orphan-process risk (R4.5 red line): stop only kills the host pid joined from
+# the sessions registry, killing a --remote-control/bg worker does not always
+# fully reap it, and a live worker with no sessions file can't be located at all.
+HELP = (
+    "后台 agent 生命周期：\n"
+    "  Enter/o 接回(拉回前台，复用 resume；接运行中的 agent 会先确认接管)  w 查看 timeline(只读)\n"
+    "  R 重启(respawn)  d 删除(仅已结束)  s 停止(仅运行中，需确认)  r 刷新\n"
+    "停止/孤儿风险：停止只能杀经 sessions 文件 join 到的 host pid；"
+    "杀 --remote-control/后台 agent 不一定彻底回收，可能残留孤儿进程，需手动确认；"
+    "找不到运行中的后台 agent 的 host pid 时无法停止。"
+)
+
+
+# --- host-pid join (shared by stop_job, remove_job, and the view) -------------
+
+def job_host(job: AgentJob) -> tuple[int | None, bool]:
+    """Resolve a background job's host pid + liveness — `(pid, alive)`.
+
+    `state.json` has no pid, so the worker's pid is JOINed from
+    `sessions/<pid>.json` on `job.sid` (a bg session proc; `kind` is typically
+    "bg"). Prefers a `/proc`-confirmed live match (so `alive=True` is trustworthy
+    and defeats pid reuse via `procStart`); falls back to the first sid match
+    with `alive=False`. Returns `(None, False)` when no sessions file exists for
+    the sid — that live worker is unstoppable (documented orphan risk).
+
+    Injects `/proc` liveness onto the registry rows, then defers to the single
+    pure join `registry.host_pid_for_sid` (shared with `snapshot._enrich_jobs`).
+    """
+    procs = [
+        replace(sp, proc_alive=proc.pid_alive(sp.pid, sp.proc_start))
+        for sp in registry.read_session_procs()
+    ]
+    return registry.host_pid_for_sid(job.sid, procs)
+
+
+# --- respawn ------------------------------------------------------------------
+
+def respawn_cmd(job: AgentJob) -> str:
+    """The exact relaunch command: `claude --resume <resume_sid> <flags> --bg`.
+
+    Pure string build via `shlex.join` (split from `respawn` so it can be copied
+    to the clipboard / asserted in tests). `respawn_flags` are reused verbatim
+    from the recorded job state.
+    """
+    args = ["claude", "--resume", job.resume_sid, *job.respawn_flags, "--bg"]
+    return shlex.join(args)
+
+
+def _job_window(job: AgentJob) -> str:
+    """tmux window name for a respawned agent (name or short, suffixed)."""
+    base = (job.name or "bg").strip() or "bg"
+    return f"{base}-{job.short[:8]}"
+
+
+def respawn(job: AgentJob) -> str:
+    """Relaunch a background agent in tmux; returns the exact command string.
+
+    Runs `respawn_cmd(job)` in the shared tmux session (`cfg.tmux_session`) so it
+    outlives the terminal — it does NOT os.exec/replace the csctl process. The
+    returned string also feeds the clipboard `y`-style key.
+    """
+    cmd = respawn_cmd(job)
+    rc.run_in_tmux(cfg.tmux_session, _job_window(job), cmd)
+    return cmd
+
+
+# --- remove (settled agents only) ---------------------------------------------
+
+def remove_job(job: AgentJob) -> bool:
+    """Remove a SETTLED background agent: `jobs/<short>/` + its sid artifacts.
+
+    Returns True iff the job dir was removed. Refuses (False) for a LIVE worker
+    (`job_host` reports alive) and when "current" can't be determined (no
+    `/proc`, R10) — destructive, must not run blind.
+    """
+    if not proc.current_determinable():
+        return False
+    _, alive = job_host(job)
+    if alive:
+        return False
+    job_dir = os.path.join(str(cfg.jobs_dir), job.short)
+    removed = cleanup._remove_path(job_dir)
+    # Reuse cleanup's artifact-path helper / remover: it returns the sid-keyed
+    # dirs (session-env/file-history/tasks/uploads) plus jobs/<sid[:8]> (which
+    # usually equals job_dir — a second remove is a harmless no-op), so the job's
+    # session leaves no orphan artifacts behind.
+    for path in cleanup._session_artifact_paths(job.sid):
+        cleanup._remove_path(path)
+    return removed
+
+
+# --- watch (read-only) --------------------------------------------------------
+
+def watch(job: AgentJob) -> str | None:
+    """Path to the job's read-only `jobs/<short>/timeline.jsonl`, or None.
+
+    Pure lookup, no mutation — returns the path only when the file exists so the
+    view can fall back gracefully (R4.4 read-only watch).
+    """
+    path = os.path.join(str(cfg.jobs_dir), job.short, "timeline.jsonl")
+    return path if os.path.isfile(path) else None
+
+
+# --- resume takeover (reuses the existing foreground resume path) -------------
+
+def resume_takeover(job: AgentJob) -> Session:
+    """Adapt a background job into a `Session` for the EXISTING resume path.
+
+    Bringing a bg session to the foreground is just a resume of its
+    `resume_sid`, so this returns a Session the view feeds to the SAME
+    `app.exit_with_resume` → `do_resume` pipeline used for foreground sessions —
+    all kill/exec/`_resume_plan` logic is reused, none duplicated (R4.4 takeover).
+    `pid`/`alive` come from the host join so a live worker is killed first
+    (resume = takeover); `current` is computed so the launching session stays
+    protected. Does NOT itself replace the csctl process.
+    """
+    pid, alive = job_host(job)
+    current = bool(pid) and pid in proc.ancestor_pids()
+    return Session(
+        sid=job.resume_sid,
+        cwd=job.cwd,
+        label=job.name or job.short,
+        mtime=0.0,
+        prompts=0,
+        pid=pid,
+        alive=alive,
+        current=current,
+        source="bg",
+        agent_short=job.short,
+    )
+
+
+# --- stop (live workers only) -------------------------------------------------
+
+def stop_job(job: AgentJob) -> bool:
+    """Stop a LIVE background worker via its joined host pid. True iff signalled.
+
+    The host pid is JOINed from `sessions/<pid>.json` (`job_host`); only a
+    confirmed-live pid is killed — a worker with no sessions file is unstoppable
+    (no-op False, orphan risk). Refuses when "current" can't be determined (no
+    `/proc`, R10). Owns the liveness-cache invalidation (like terminate). Killing
+    does not always fully reap a `--remote-control`/bg worker (orphan risk, see
+    `HELP`).
+    """
+    if not proc.current_determinable():
+        return False
+    pid, alive = job_host(job)
+    if not alive or not pid:
+        return False
+    try:
+        os.kill(pid, signal.SIGTERM)
+    except ProcessLookupError:
+        liveness.invalidate_cache()  # already gone — liveness changed
+        return True
+    except Exception:
+        return False
+    time.sleep(1)
+    liveness.invalidate_cache()
+    return True

cc_session_control/actions/session_ops.py

@@ -0,0 +1,150 @@
+"""Session operations: resume, terminate, delete, clipboard."""
+
+from __future__ import annotations
+
+import os
+import shlex
+import signal
+import time
+
+from .. import clipboard
+from ..config import cfg
+from ..data import proc, rc
+from ..data.liveness import invalidate_cache
+from ..models import Session
+
+
+def terminate_session(s: Session) -> bool:
+    """Send SIGTERM and own the liveness-cache invalidation.
+
+    Terminating is the one session op that changes `claude agents` liveness,
+    so it invalidates the alive_map cache itself — callers no longer have to
+    remember to. (delete/cleanup only touch already-dead sessions, so they
+    don't.)
+
+    R10: refuses (returns False) when "current" can't be determined (no
+    `/proc`) — we can't prove `s` is not the launching session, so a SIGTERM
+    here could hit csctl's own session.
+    """
+    if not proc.current_determinable():
+        return False
+    if not s.pid:
+        return False
+    try:
+        os.kill(s.pid, signal.SIGTERM)
+    except ProcessLookupError:
+        invalidate_cache()  # already gone — liveness changed
+        return True
+    except Exception:
+        return False
+    time.sleep(1)
+    invalidate_cache()
+    return True
+
+
+def _resume_plan(s: Session, fork: bool = False) -> tuple[str, list[str], bool]:
+    """Shared resume recipe: the cwd to enter, the claude argv, and whether
+    to kill the old session first.
+
+    Returns (cwd, args, should_kill). Unified kill semantics: a fork is a copy
+    and leaves the original running, while a plain resume takes the session
+    over — so we kill only when it is alive, not the current session, and we
+    are NOT forking. `resume_cmd` and `do_resume` both obey this single
+    decision; they must not re-derive it.
+    """
+    args = ["claude", "--resume", s.sid]
+    if fork:
+        args.append("--fork-session")
+    should_kill = s.alive and not s.current and not fork
+    return s.cwd, args, should_kill
+
+
+def would_take_over(s: Session, fork: bool = False) -> bool:
+    """Whether resuming/relaunching `s` would first kill a live process (takeover).
+
+    The single source of the "needs confirmation" decision for the UI: it reads
+    `_resume_plan`'s `should_kill` so views never re-derive `s.alive and not
+    s.current` themselves (CLAUDE.md: should_kill is single-point — re-derivation
+    was the old divergence). `do_resume`/`relaunch_in_tmux` and the confirm gate
+    thus agree by construction.
+    """
+    return _resume_plan(s, fork)[2]
+
+
+def resume_cmd(s: Session, fork: bool = False) -> str:
+    cwd, args, should_kill = _resume_plan(s, fork)
+    parts: list[str] = []
+    if should_kill and s.pid:  # never emit a bare `kill None` (L7)
+        parts.append(f"kill {s.pid} && sleep 1")
+    if cwd:
+        parts.append(f"cd {shlex.quote(cwd)}")
+    parts.append(shlex.join(args))
+    return " && ".join(parts)
+
+
+def do_resume(s: Session, fork: bool = False) -> None:
+    """chdir + (kill if needed) + exec claude. Does not return on success.
+
+    R10: when a takeover kill is required but "current" can't be determined (no
+    `/proc`), refuse — print a message and return WITHOUT killing or exec'ing, so
+    we never SIGTERM the launching session (every pid looks dead off `/proc`).
+    """
+    cwd, args, should_kill = _resume_plan(s, fork)
+    if should_kill:
+        if not proc.current_determinable():
+            print(
+                "Refused: '/proc' unavailable — cannot determine the current "
+                "session, so the old process can't be safely killed (R10)."
+            )
+            return
+        try:
+            os.kill(s.pid, signal.SIGTERM)
+        except Exception:
+            pass
+        time.sleep(1)
+    if cwd and os.path.isdir(cwd):
+        os.chdir(cwd)
+    os.execvp("claude", args)
+
+
+def _rc_name(s: Session) -> str:
+    """Remote-control label (shown in claude.ai/code) for a relaunched session."""
+    base = s.cwd.rstrip("/").rsplit("/", 1)[-1] if s.cwd else ""
+    return f"{base or 'session'}-{s.sid[:8]}"
+
+
+def tmux_resume_cmd(s: Session, fork: bool = False) -> str:
+    """Shell command that resumes the session under remote control."""
+    cwd, args, _ = _resume_plan(s, fork)
+    args = args + ["--remote-control", _rc_name(s)]
+    line = shlex.join(args)
+    return f"cd {shlex.quote(cwd)} && {line}" if cwd else line
+
+
+def relaunch_in_tmux(s: Session, fork: bool = False) -> bool:
+    """Relaunch a session as `claude --resume … --remote-control …` inside a
+    tmux window, so it outlives the terminal and is remotely controllable.
+
+    A live, non-current session is taken over (its old pid is killed first and
+    the liveness cache invalidated, like terminate); a fork leaves the original
+    running. csctl is NOT replaced — it just spawns the tmux window.
+
+    R10: when a takeover kill is required but "current" can't be determined (no
+    `/proc`), refuse (return False, do not kill or relaunch) — we can't prove `s`
+    is not the launching session.
+    """
+    _, _, should_kill = _resume_plan(s, fork)
+    if should_kill and s.pid:
+        if not proc.current_determinable():
+            return False
+        try:
+            os.kill(s.pid, signal.SIGTERM)
+        except Exception:
+            pass
+        time.sleep(1)
+        invalidate_cache()
+    return rc.run_in_tmux(cfg.tmux_session, _rc_name(s), tmux_resume_cmd(s, fork))
+
+
+def to_clipboard(text: str) -> bool:
+    return clipboard.copy(text)

cc_session_control/app.py

@@ -0,0 +1,264 @@
+"""CCM — Claude Code Manager urwid App."""
+
+from __future__ import annotations
+
+import curses
+import os
+import threading
+from collections.abc import Callable
+from typing import Protocol, runtime_checkable
+
+import urwid
+
+from .data import proc
+from .data.snapshot import WorldSnapshot, build_world_snapshot
+from .views.agents import AgentsView
+from .views.rc import RCView
+from .views.sessions import SessionsView
+
+# D7/R10: shown across all tabs when `/proc` is unavailable (e.g. macOS), where
+# the "current" session can't be determined and destructive ops are refused.
+_DEGRADED_BANNER = "⚠ liveness 降级（无 /proc）：terminate/delete/cleanup 已受限"
+
+
+@runtime_checkable
+class TabView(Protocol):
+    """The contract App uses to drive each tab generically.
+
+    A tab satisfies this structurally — App never special-cases a concrete
+    view. `fetch_pending(snapshot)` runs on the worker thread and must not touch
+    widgets; `apply_data()` runs on the main loop and swaps `_pending` into the
+    walker. The `snapshot` is the shared per-cycle world (R11/D8); it is OPTIONAL
+    — a view called with `None` self-fetches (back-compat / tests). Adding a tab
+    means honoring every member below.
+    """
+
+    widget: urwid.Widget
+    _loaded: bool
+
+    def load(self) -> None: ...
+    def fetch_pending(self, snapshot: WorldSnapshot | None = None) -> None: ...
+    def apply_data(self) -> None: ...
+    def keyhints(self) -> str: ...
+    def handle_key(self, key: str) -> None: ...
+
+# 6-tuple: (name, fg_16, bg_16, mono, fg_256, bg_256)
+PALETTE = [
+    ("header",     "white,bold",  "black", "bold",     "#fff,bold",  "#111"),
+    ("footer",     "light gray",  "black", None,       "#999",       "#111"),
+    ("tab_on",     "white,bold",  "dark cyan", "bold,standout", "#fff,bold", "#068"),
+    ("tab_off",    "dark cyan",   "black", None,       "#688",       "#111"),
+    ("alive",      "light green", "black", None,       "#6d6",       "#111"),
+    ("dead",       "light gray",  "black", None,       "#ccc",       "#111"),
+    ("selected",   "white,bold",  "dark cyan", "standout", "#fff,bold", "#068"),
+    ("notify",     "yellow,bold", "black", "bold",     "#ff0,bold",  "#111"),
+    ("status",     "light gray",  "black", None,       "#aaa",       "#111"),
+    ("rc_running", "light green", "black", None,       "#6d6",       "#111"),
+    ("rc_stopped", "light gray",  "black", None,       "#ccc",       "#111"),
+    ("body",       "light gray",  "black", None,       "#ccc",       "#111"),
+    ("col_header", "dark cyan",   "black", None,       "#8aa",       "#181818"),
+]
+
+TAB_NAMES = ["会话", "后台", "远程控制"]
+
+# D1: all three tabs share ONE footer prefix — the universal verbs (Tab/q/r) live
+# here exactly once so `r 刷新` shows identically on every tab. View-specific keys
+# come from each view's `keyhints()` and are appended via `App.set_hints`.
+FOOTER_PREFIX = " Tab 切换 · q 退出 · r 刷新 · "
+
+
+def _make_screen() -> urwid.raw_display.Screen:
+    screen = urwid.raw_display.Screen()
+    try:
+        curses.setupterm()
+        term_colors = curses.tigetnum("colors")
+        if term_colors >= 256:
+            screen.set_terminal_properties(colors=256)
+    except Exception:
+        pass
+    screen.register_palette(PALETTE)
+    return screen
+
+
+class App:
+    def __init__(self) -> None:
+        self.result: tuple | None = None
+        self._exiting = False
+        self._alarm_handle: object | None = None
+        self._pipe_fd: int | None = None
+        self._refreshing = False
+        # When set, a y/n confirm modal is up: `_input` routes y/n/esc here and
+        # swallows every other key (App-level so all tabs share it — D8 view files
+        # stay small). `_confirm_base` is the widget restored on close.
+        self._confirm_yes: Callable[[], None] | None = None
+        self._confirm_base: urwid.Widget | None = None
+
+        self.views: list[TabView] = [SessionsView(self), AgentsView(self), RCView(self)]
+        self._active = 0
+
+        self.body = urwid.WidgetPlaceholder(self.views[0].widget)
+        self._tab_texts: list[urwid.Text] = []
+        tab_bar = self._build_tab_bar()
+        title = urwid.AttrMap(urwid.Text("Claude Code 会话管理器", align="center"), "header")
+        # Title at 0 and tab_bar at 1 are positional (see `_update_tab_bar`); the
+        # degraded banner, if any, is appended LAST so those indices are stable.
+        header_rows: list[urwid.Widget] = [title, tab_bar]
+        if not proc.has_proc():
+            header_rows.append(urwid.AttrMap(urwid.Text(f" {_DEGRADED_BANNER}"), "notify"))
+        self.header = urwid.Pile(header_rows)
+
+        self.footer_text = urwid.Text(FOOTER_PREFIX)
+        self.footer = urwid.AttrMap(self.footer_text, "footer")
+
+        self.frame = urwid.Frame(self.body, header=self.header, footer=self.footer)
+
+        self._screen = _make_screen()
+        self.loop = urwid.MainLoop(
+            self.frame,
+            screen=self._screen,
+            unhandled_input=self._input,
+        )
+
+    def _build_tab_bar(self) -> urwid.Columns:
+        self._tab_texts = []
+        cols = []
+        for i, name in enumerate(TAB_NAMES):
+            txt = urwid.Text(f" {name} ", align="center")
+            self._tab_texts.append(txt)
+            attr = "tab_on" if i == self._active else "tab_off"
+            cols.append(urwid.AttrMap(txt, attr))
+        return urwid.Columns(cols)
+
+    def _update_tab_bar(self) -> None:
+        tab_bar = self._build_tab_bar()
+        self.header.contents[1] = (tab_bar, self.header.options())
+
+    def _switch_tab(self) -> None:
+        self._active = (self._active + 1) % len(self.views)
+        self.body.original_widget = self.views[self._active].widget
+        self._update_tab_bar()
+        self.set_hints(self.views[self._active].keyhints())
+        if not self.views[self._active]._loaded:
+            self.trigger_async_refresh()
+
+    def _input(self, key: str) -> None:
+        if self._confirm_yes is not None:
+            # Modal: only y/n/esc are live; tab/q/everything else is swallowed so
+            # a destructive confirm can't be skipped past by an accidental key.
+            if key == "y":
+                cb = self._confirm_yes
+                self._close_confirm()
+                cb()
+            elif key in ("n", "esc"):
+                self._close_confirm()
+            return
+        if key == "tab":
+            self._switch_tab()
+        elif key == "q":
+            self._exit()
+        else:
+            self.views[self._active].handle_key(key)
+
+    def confirm(self, message: str, on_yes: Callable[[], None]) -> None:
+        """Show a y/n modal over the active tab; run `on_yes` only on `y`.
+
+        App-level (not a per-view mode) so every tab gets confirmation for free
+        and the view files stay under budget. While up, `_input` routes y/n/esc
+        and swallows the rest. The overlay sits ABOVE the view widget in
+        `self.body`, so a worker-thread refresh (which only rebuilds a view's own
+        walker) never disturbs it.
+        """
+        self._confirm_yes = on_yes
+        self._confirm_base = self.body.original_widget
+        text = urwid.Text(f"  {message}\n\n  y 确认    n / Esc 取消")
+        box = urwid.AttrMap(urwid.LineBox(urwid.Filler(text)), "notify")
+        self.body.original_widget = urwid.Overlay(
+            box, self._confirm_base,
+            align="center", width=("relative", 50),
+            valign="middle", height=7,
+        )
+        self.footer_text.set_text(" y 确认 · n/Esc 取消")
+
+    def _close_confirm(self) -> None:
+        if self._confirm_base is not None:
+            self.body.original_widget = self._confirm_base
+        self._confirm_base = None
+        self._confirm_yes = None
+        self.set_hints(self.views[self._active].keyhints())
+
+    def _exit(self, result: tuple | None = None) -> None:
+        self._exiting = True
+        if self._alarm_handle:
+            self.loop.remove_alarm(self._alarm_handle)
+        self.result = result
+        raise urwid.ExitMainLoop()
+
+    def exit_with_resume(self, session: object, fork: bool = False) -> None:
+        self._exit(("resume", session, fork))
+
+    def set_hints(self, hints: str) -> None:
+        """Footer = shared prefix + the active tab's keyhints (D1 single source)."""
+        self.footer_text.set_text(FOOTER_PREFIX + hints)
+
+    def notify(self, msg: str, seconds: float = 3) -> None:
+        self.frame.footer = urwid.AttrMap(urwid.Text(f" {msg}"), "notify")
+        self.loop.set_alarm_in(seconds, lambda *_: self._restore_footer())
+
+    def _restore_footer(self) -> None:
+        self.frame.footer = self.footer
+
+    def _run_fetch_cycle(self) -> None:
+        """Worker-phase of a refresh — the synchronous, testable seam (R11/D8).
+
+        Computes ONE shared world snapshot per cycle so the three tabs don't each
+        re-scan /proc + transcripts, then projects it into every view's `_pending`
+        via `fetch_pending(snapshot)`. A failed build degrades to per-view
+        self-fetch (`snapshot=None`). Pure data side: it only sets `_pending`
+        fields and NEVER touches widgets, so it is safe on the worker thread and
+        can be driven directly in tests without a MainLoop.
+        """
+        try:
+            snapshot: WorldSnapshot | None = build_world_snapshot()
+        except Exception:
+            snapshot = None
+        for v in self.views:
+            v.fetch_pending(snapshot)
+
+    def trigger_async_refresh(self) -> None:
+        if self._refreshing or self._exiting:
+            return
+        self._refreshing = True
+
+        def worker() -> None:
+            try:
+                self._run_fetch_cycle()
+            finally:
+                self._refreshing = False
+            if self._pipe_fd is not None:
+                try:
+                    os.write(self._pipe_fd, b"1")
+                except OSError:
+                    pass
+
+        threading.Thread(target=worker, daemon=True).start()
+
+    def _schedule_refresh(self, loop: object = None, data: object = None) -> None:
+        if self._exiting:
+            return
+        self.trigger_async_refresh()
+        self._alarm_handle = self.loop.set_alarm_in(10, self._schedule_refresh)
+
+    def _on_pipe(self, data: bytes) -> bool:
+        if not self._exiting:
+            for view in self.views:
+                view.apply_data()
+        return True
+
+    def run(self) -> tuple | None:
+        self._pipe_fd = self.loop.watch_pipe(self._on_pipe)
+        self.views[self._active].load()
+        self.set_hints(self.views[self._active].keyhints())
+        self.trigger_async_refresh()
+        self._alarm_handle = self.loop.set_alarm_in(10, self._schedule_refresh)
+        self.loop.run()
+        return self.result