docker-orb 1.0.0__py3-none-any.whl

docker_orb/viewer/app.py

@@ -0,0 +1,824 @@
+"""
+Main viewer application.
+
+Launches with a SessionConfig and wires together:
+  - One log-streaming coroutine per container (or a dump loader)
+  - MainStreamPanel  — the primary log display
+  - SearchPanel      — live search
+  - MonitorPanel     — passive string accumulation  (stream mode only)
+  - HealthPanel      — container health alerts            (stream mode only)
+  - String-editing overlays for F / H / M keybinds
+  - Ctrl+S save-to-file dialog
+"""
+from __future__ import annotations
+
+import asyncio
+import re
+from datetime import datetime, timezone
+from pathlib import Path
+
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.containers import Vertical
+from textual.widgets import Footer, Header, Input, Rule
+
+from .. import _scrollbar
+from ..colors import assign_colors
+from ..config import compile_patterns, matches
+from ..models import LogLine, LogMode, SessionConfig
+from .panels.health import HealthPanel
+from .panels.main_stream import MainStreamPanel
+from .panels.monitor import MonitorPanel
+from .panels.search import SearchPanel
+from .widgets import (
+    JsonDetailModal,
+    MonitorContextModal,
+    PaneSizeModal,
+    ContainerSelectorModal,
+    SaveDialog,
+    StringEditModal,
+)
+
+_scrollbar.install()
+
+
+class ViewerApp(App):
+    """The log viewer."""
+
+    TITLE = "docker-orb"
+    CSS_PATH = "viewer.tcss"
+
+    # Dragging a side panel's header trades height with MainStreamPanel (the
+    # only auto-filling `1fr` panel) — never with a neighboring side panel.
+    MAIN_STREAM_MIN_HEIGHT = 20
+    SIDE_PANEL_MIN_HEIGHT = 4
+
+    # Force an early backfill flush past this many buffered lines, rather
+    # than waiting on every container to catch up (or the watchdog) — bounds the
+    # worst case (e.g. a deliberately long `since` on a very busy container) to a
+    # sort+dispatch of a few thousand lines instead of an unbounded one that
+    # could noticeably stall the UI. Below the main buffer's own 20,000 cap
+    # since this is meant to catch a burst, not hold a whole session.
+    BACKFILL_BUFFER_CAP = 3000
+
+    BINDINGS = [
+        Binding("f",       "edit_filters",    "Edit Filters",    show=True,  priority=True),
+        Binding("h",       "edit_highlights", "Edit highlights", show=True,  priority=True),
+        Binding("m",       "edit_monitors",   "Edit monitors",   show=True,  priority=True),
+        Binding("space",   "toggle_pause",    "Pause / Resume",  show=True,  priority=True),
+        Binding("ctrl+s",  "save_logs",       "Save logs",       show=True,  priority=True),
+        Binding("ctrl+q",  "quit",            "Quit",            show=True,  priority=True),
+        Binding("/",       "toggle_search",   "Search",          show=True,  priority=True),
+        Binding("t",       "toggle_color",    "Color mode",      show=True,  priority=True),
+        Binding("w",       "toggle_wrap",     "Wrap",            show=True,  priority=True),
+        Binding("p",       "manage_containers", "Containers",   show=True,  priority=True),
+        Binding("l",       "edit_layout",     "Pane sizes",      show=True,  priority=True),
+        Binding("j",       "toggle_json",     "JSON format",     show=True,  priority=True),
+        Binding("c",       "toggle_collapse", "Collapse repeats", show=True, priority=True),
+    ]
+
+    def __init__(self, config: SessionConfig) -> None:
+        super().__init__()
+        self._config = config
+        self._is_stream = config.mode == LogMode.STREAM
+
+        # Compiled match patterns — updated live when user edits strings
+        self._filter_patterns:    list[re.Pattern] = compile_patterns(config.filters,    config.filters_ignore_case)
+        self._highlight_patterns: list[re.Pattern] = compile_patterns(config.highlights, config.highlights_ignore_case)
+        self._monitor_patterns:   list[re.Pattern] = compile_patterns(config.monitors,   config.monitors_ignore_case)
+
+        # Full log buffer — capped to avoid unbounded memory / slow rerenders
+        self._buffer: list[LogLine] = []
+        self._buffer_cap = 20_000
+
+        # Container → color mapping
+        self._color_map: dict[str, str] = {}
+
+        self._paused = False
+        self._pending_lines: list[LogLine] = []   # buffered while paused
+        self._paused_since_last_ui = 0            # lines received since last indicator update
+
+        # Service → list of container names currently streaming
+        self._service_containers: dict[str, list[str]] = {}
+
+        # Backfill interleaving (only active when config.since requests a
+        # look-back window in stream mode) — see _handle_backfill_line().
+        # Concurrent per-container streams don't arrive in chronological order, so
+        # a backfill burst is held and sorted by real log_timestamp before
+        # display, rather than shown in arrival order and clumped per container.
+        # None = no backfill in progress (the common case — zero overhead).
+        self._backfill_pending: set[str] | None = None
+        self._backfill_buffer: list[LogLine] = []
+        self._backfill_cutoff: datetime | None = None
+        self._backfill_watchdog = None
+
+    # ── Layout ────────────────────────────────────────────────────────────────
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        with Vertical(id="panels"):
+            yield MainStreamPanel(id="main-stream")
+            yield SearchPanel(id="search-panel")
+            if self._is_stream:
+                yield MonitorPanel(id="monitor-panel")
+                yield HealthPanel(
+                    config=self._config.health,
+                    id="health-panel",
+                )
+        yield Rule()
+        yield Footer()
+
+    def _side_panels(self) -> list[Vertical]:
+        """Every panel other than MainStreamPanel that can be dragged/resized."""
+        panels = [self.query_one(SearchPanel)]
+        if self._is_stream:
+            panels.append(self.query_one(MonitorPanel))
+            panels.append(self.query_one(HealthPanel))
+        return panels
+
+    def _visible_side_panels(self) -> list[tuple[str, Vertical]]:
+        """(label, panel) for side panels currently shown and expanded —
+        the only ones a percentage-based size actually means anything for."""
+        labeled: list[tuple[str, Vertical]] = [("Search", self.query_one(SearchPanel))]
+        if self._is_stream:
+            labeled.append(("Monitor", self.query_one(MonitorPanel)))
+            labeled.append(("Health", self.query_one(HealthPanel)))
+        return [
+            (label, panel) for label, panel in labeled
+            if panel.display and not getattr(panel, "_collapsed", False)
+        ]
+
+    def resize_panel(self, panel: Vertical, delta: int) -> None:
+        """
+        Grow/shrink one side panel by `delta` rows, taking the difference
+        from (or giving it back to) MainStreamPanel — never from another
+        side panel — and never letting MainStreamPanel drop below
+        MAIN_STREAM_MIN_HEIGHT.
+        """
+        if delta == 0:
+            return
+        total = self.query_one("#panels").outer_size.height
+        if total <= 0:
+            return
+
+        # outer_size (not size) — size excludes a panel's own border row, but
+        # styles.height (what we're setting below) is border-inclusive. Mixing
+        # the two produces an off-by-one every time a bordered panel resizes.
+        others_height = sum(
+            p.outer_size.height for p in self._side_panels() if p is not panel
+        )
+        new_height = panel.outer_size.height + delta
+        new_height = max(new_height, self.SIDE_PANEL_MIN_HEIGHT)
+        max_allowed = total - others_height - self.MAIN_STREAM_MIN_HEIGHT
+        new_height = min(new_height, max(max_allowed, self.SIDE_PANEL_MIN_HEIGHT))
+        panel.styles.height = new_height
+
+    async def on_mount(self) -> None:
+        self.query_one(SearchPanel).display = False
+        panel = self.query_one(MainStreamPanel)
+        panel.set_color_mode(self._config.color_full_line)
+        panel.set_wrap(self._config.line_wrap)
+        panel.set_json_format(self._config.json_format)
+        panel.set_collapse_repeats(self._config.collapse_repeats)
+        search_panel = self.query_one(SearchPanel)
+        search_panel.set_wrap(self._config.line_wrap)
+        search_panel.set_color_mode(self._config.color_full_line)
+        if self._is_stream:
+            monitor_panel = self.query_one(MonitorPanel)
+            monitor_panel.set_wrap(self._config.line_wrap)
+            monitor_panel.set_color_mode(self._config.color_full_line)
+
+        # Give focus to the log display so all key bindings are reachable
+        self.query_one("#stream-log").focus()
+
+        # Run blocking compose calls off the event loop so the TUI stays responsive
+        self.run_worker(self._init_containers(), name="init-containers")
+
+    async def _init_containers(self) -> None:
+        from .. import compose as k
+
+        # Resolve containers from selected services (blocking subprocess, runs in worker)
+        services = await asyncio.get_event_loop().run_in_executor(
+            None, k.get_services, self._config.project
+        )
+        dep_map = {d.name: d for d in services}
+        selected_deps = [dep_map[n] for n in self._config.services if n in dep_map]
+        containers = await asyncio.get_event_loop().run_in_executor(
+            None, k.get_containers_for_services, self._config.project, selected_deps
+        )
+
+        if not containers:
+            self.notify("No containers found for selected services.", severity="error")
+            return
+
+        self._color_map = assign_colors([p.name for p in containers])
+        self.query_one(SearchPanel).set_color_map(self._color_map)
+        if self._is_stream:
+            self.query_one(MonitorPanel).set_color_map(self._color_map)
+            self.query_one(MonitorPanel).set_patterns(self._monitor_patterns)
+
+        if self._is_stream:
+            self._start_streaming(selected_deps, containers)
+            if self._config.health.enabled:
+                container_names = [p.name for p in containers]
+                self.run_worker(
+                    self._poll_health(container_names),
+                    name="health-poll",
+                )
+        else:
+            self.run_worker(self._load_dump(containers), name="dump-loader")
+
+    # ── Container stream management ─────────────────────────────────────────────────
+
+    def _start_streaming(self, deps, containers) -> None:
+        """Start streaming workers for a set of services and their containers."""
+        from .. import compose as k
+
+        for svc in deps:
+            self._service_containers[svc.name] = []
+
+        if k.wants_backfill(self._config.since):
+            # A look-back window means every container's stream opens with a
+            # backfill burst. Hold lines from all of them until every container
+            # has either caught up to live or the watchdog fires, then
+            # deliver the whole burst sorted by real timestamp — otherwise
+            # they show up in arrival order, clumped one container at a time.
+            # (wants_backfill, not a truthiness check: a user-entered "0"
+            # is non-empty but compose treats it as no window at all — see
+            # compose._normalize_since — so it shouldn't trigger a 5-second
+            # wait for a backfill that will never arrive.)
+            self._backfill_pending = {p.name for p in containers}
+            self._backfill_cutoff = datetime.now(timezone.utc)
+            self._backfill_watchdog = self.set_timer(5.0, self._backfill_watchdog_fire)
+
+        for container in containers:
+            self._service_containers.setdefault(container.service, []).append(container.name)
+            self.run_worker(
+                self._stream_container(container.name),
+                name=f"stream-{container.name}",
+                exclusive=False,
+            )
+
+    def add_service_to_stream(self, service_name: str) -> None:
+        """Dynamically add a service's containers to the live stream."""
+        if service_name in self._service_containers:
+            self.notify(f"Already streaming {service_name}", severity="warning")
+            return
+
+        from .. import compose as k
+        try:
+            all_deps = k.get_services(self._config.project)
+            dep = next((d for d in all_deps if d.name == service_name), None)
+            if dep is None:
+                self.notify(f"Service '{service_name}' not found", severity="error")
+                return
+            containers = k.get_containers_for_services(self._config.project, [dep])
+        except Exception as exc:
+            self.notify(f"Failed to get containers: {exc}", severity="error")
+            return
+
+        if not containers:
+            self.notify(f"No containers found for {service_name}", severity="warning")
+            return
+
+        # Assign colors for new containers
+        new_names = [p.name for p in containers if p.name not in self._color_map]
+        if new_names:
+            all_names = list(self._color_map) + new_names
+            self._color_map = assign_colors(all_names)
+
+        self._service_containers[service_name] = [p.name for p in containers]
+        self._config.services.append(service_name)
+
+        for container in containers:
+            self.run_worker(
+                self._stream_container(container.name),
+                name=f"stream-{container.name}",
+                exclusive=False,
+            )
+        self.notify(f"Now streaming {service_name} ({len(containers)} container{'s' if len(containers) != 1 else ''})")
+
+    def remove_service_from_stream(self, service_name: str) -> None:
+        """Stop streaming a service's containers."""
+        container_names = self._service_containers.pop(service_name, [])
+        if not container_names:
+            return
+        for worker in self.workers:
+            if worker.name in {f"stream-{p}" for p in container_names}:
+                worker.cancel()
+        if service_name in self._config.services:
+            self._config.services.remove(service_name)
+        self.notify(f"Stopped streaming {service_name}")
+
+    # ── Log ingestion ──────────────────────────────────────────────────────────
+
+    async def _stream_container(self, container_name: str) -> None:
+        from .. import compose as k
+        import time
+        backoff = 2.0
+        error_count = 0  # consecutive errors; reset on clean stream
+        while True:
+            try:
+                batch: list[LogLine] = []
+                last_flush = time.monotonic()
+                async for line in k.stream_logs(
+                    container_name,
+                    self._config.project,
+                    since=self._config.since,
+                    tail=self._config.tail,
+                ):
+                    batch.append(line)
+                    now = time.monotonic()
+                    if len(batch) >= 20 or (now - last_flush) >= 0.1:
+                        for l in batch:
+                            self._ingest(l)
+                        batch.clear()
+                        last_flush = now
+                        await asyncio.sleep(0)
+                for l in batch:
+                    self._ingest(l)
+                # Stream ended cleanly — reconnect silently
+                error_count = 0
+                backoff = 2.0
+                await asyncio.sleep(2)
+            except asyncio.CancelledError:
+                return
+            except Exception as exc:
+                error_count += 1
+                # Only notify on the first error per container; suppress repetitive reconnect spam
+                if error_count == 1:
+                    self.notify(f"{container_name}: stream error — {exc}",
+                                severity="warning", timeout=5)
+                await asyncio.sleep(backoff)
+                backoff = min(backoff * 2, 30.0)
+
+    async def _load_dump(self, containers) -> None:
+        from .. import compose as k
+        all_lines: list[LogLine] = []
+        for container in containers:
+            lines = await k.dump_logs(
+                container.name,
+                self._config.project,
+                since=self._config.since,
+                tail=self._config.tail,
+            )
+            all_lines.extend(lines)
+        # Sort by receive time (they each have received_at from when fetched)
+        all_lines.sort(key=lambda l: l.received_at)
+        for line in all_lines:
+            self._ingest(line)
+
+    def _ingest(self, line: LogLine) -> None:
+        """Process one incoming log line through filters and routing."""
+        if self._filter_patterns and matches(line.content, self._filter_patterns):
+            return
+
+        if self._backfill_pending is not None:
+            self._handle_backfill_line(line)
+            return
+
+        self._buffer.append(line)
+        if len(self._buffer) > self._buffer_cap:
+            del self._buffer[: self._buffer_cap // 10]  # trim 10% at a time
+
+        if self._paused:
+            self._pending_lines.append(line)
+            self._paused_since_last_ui += 1
+            if self._paused_since_last_ui >= 100:
+                self._paused_since_last_ui = 0
+                self._update_pause_indicator()
+            return
+
+        self._deliver_to_panels(line)
+
+    def _deliver_to_panels(self, line: LogLine) -> None:
+        color = self._color_map.get(line.container_name, "#ffffff")
+        hl = self._highlight_patterns if (self._highlight_patterns and
+             matches(line.content, self._highlight_patterns)) else None
+
+        self.query_one(MainStreamPanel).add_line(line, color, hl)
+
+        if self._is_stream and self._monitor_patterns:
+            if matches(line.content, self._monitor_patterns):
+                try:
+                    self.query_one(MonitorPanel).add_line(line, color)
+                except Exception:
+                    pass
+
+    # ── Backfill interleaving ────────────────────────────────────────────────
+
+    def _handle_backfill_line(self, line: LogLine) -> None:
+        """
+        Route one line while a backfill burst is in progress (see
+        _start_streaming). Lines from every container are held until all containers have
+        either caught up to live, the watchdog fires, or BACKFILL_BUFFER_CAP
+        is hit, then flushed sorted by real timestamp — otherwise each container's
+        backlog displays as one arrival-order clump instead of properly
+        interleaved history.
+        """
+        is_backfill = (
+            line.log_timestamp is not None
+            and self._backfill_cutoff is not None
+            and line.log_timestamp < self._backfill_cutoff
+        )
+        if not is_backfill:
+            # This container has caught up to live. Still hold the line (rather
+            # than display it immediately) if other containers are still behind,
+            # so a fast container's live lines don't jump ahead of a slow container's
+            # still-pending backfill.
+            self._backfill_pending.discard(line.container_name)
+
+        self._backfill_buffer.append(line)
+        if not self._backfill_pending or len(self._backfill_buffer) >= self.BACKFILL_BUFFER_CAP:
+            self._flush_backfill()
+
+    def _backfill_watchdog_fire(self) -> None:
+        self._backfill_watchdog = None
+        if self._backfill_pending:
+            self._flush_backfill()
+
+    def _flush_backfill(self) -> None:
+        lines, self._backfill_buffer = self._backfill_buffer, []
+        self._backfill_pending = None
+        self._backfill_cutoff = None
+        if self._backfill_watchdog is not None:
+            self._backfill_watchdog.stop()
+            self._backfill_watchdog = None
+        # Fallback for the rare line whose timestamp didn't parse — a single
+        # shared "now" (not received_at, which is naive local time and would
+        # misorder against real UTC timestamps by the local tz offset).
+        fallback = datetime.now(timezone.utc)
+        lines.sort(key=lambda l: l.log_timestamp or fallback)
+        for line in lines:
+            self._ingest(line)  # _backfill_pending is now None, so this goes through normally
+
+    # ── Pause / resume ─────────────────────────────────────────────────────────
+
+    def set_paused(self, paused: bool) -> None:
+        self._paused = paused
+        # Update indicator first — this sets auto_scroll=True on the RichLog before
+        # scroll_to_end() fires, so the widget is already in live-follow mode when
+        # new lines arrive from the pending flush.
+        self._update_pause_indicator()
+        if not paused:
+            self.query_one(MainStreamPanel).scroll_to_end()
+            if self._pending_lines:
+                self.run_worker(self._flush_pending(), group="flush-pending", exclusive=True)
+
+    async def _flush_pending(self) -> None:
+        lines, self._pending_lines = self._pending_lines, []
+        # Cap at 500 — discard oldest if the backlog is huge
+        if len(lines) > 500:
+            lines = lines[-500:]
+        for i, line in enumerate(lines):
+            self._deliver_to_panels(line)
+            if i % 50 == 49:
+                await asyncio.sleep(0)
+        self._update_pause_indicator()
+
+    def _update_pause_indicator(self) -> None:
+        n = len(self._pending_lines)
+        panel = self.query_one(MainStreamPanel)
+        panel.set_paused(self._paused, n)
+
+    # ── Pattern updates (from live string editing) ─────────────────────────────
+
+    def update_filters(self, new_strings: list[str]) -> None:
+        self._config.filters = new_strings
+        self._filter_patterns = compile_patterns(new_strings, self._config.filters_ignore_case)
+
+    def update_highlights(self, new_strings: list[str]) -> None:
+        self._config.highlights = new_strings
+        self._highlight_patterns = compile_patterns(new_strings, self._config.highlights_ignore_case)
+
+    def update_monitors(self, new_strings: list[str]) -> None:
+        self._config.monitors = new_strings
+        self._monitor_patterns = compile_patterns(new_strings, self._config.monitors_ignore_case)
+        self.query_one(MonitorPanel).set_patterns(self._monitor_patterns)
+
+    def _apply_edits_and_resume(self) -> None:
+        """
+        Rebuild both panels from the full buffer, then re-engage live-follow.
+        Called when an F/H/M edit modal closes. Rebuilding from `_buffer`
+        (which already holds every line received while paused) makes the
+        pending queue redundant, so we clear it rather than running the async
+        flush — avoiding double-delivery when a rebuild and a flush would
+        otherwise race. Also drops hits for monitors that were just unchecked
+        and re-shows everything buffered while the modal was open.
+        """
+        self._rerender_main_stream()
+        if self._is_stream:
+            self.query_one(MonitorPanel).rebuild(self._buffer)
+        if self._is_stream:
+            self._pending_lines.clear()
+            self._paused_since_last_ui = 0
+            self._paused = False
+            self._update_pause_indicator()
+            self.query_one(MainStreamPanel).scroll_to_end()
+
+    def _rerender_main_stream(self) -> None:
+        """Replay buffer through updated filters and highlights."""
+        panel = self.query_one(MainStreamPanel)
+        panel.clear()
+        for line in self._buffer:
+            if self._filter_patterns and matches(line.content, self._filter_patterns):
+                continue
+            color = self._color_map.get(line.container_name, "#ffffff")
+            hl = self._highlight_patterns if (self._highlight_patterns and
+                 matches(line.content, self._highlight_patterns)) else None
+            panel.add_line(line, color, hl)
+
+    # ── Health polling ─────────────────────────────────────────────────────────
+
+    async def _poll_health(self, container_names: list[str]) -> None:
+        from .. import compose as k
+        interval = max(1, self._config.health.interval_minutes) * 60
+        baseline: dict[str, int] = {}   # container_name → restart count at session start
+
+        while True:
+            statuses = k.get_container_statuses(self._config.project, container_names)
+            health_panel = self.query_one(HealthPanel)
+            threshold = self._config.health.restart_threshold
+
+            for status in statuses:
+                if status.name not in baseline:
+                    baseline[status.name] = status.restart_count
+
+                restart_delta = status.restart_count - baseline[status.name]
+                is_unhealthy = not status.is_healthy or restart_delta >= threshold
+
+                if is_unhealthy:
+                    health_panel.update_container(status, restart_delta)
+
+            await asyncio.sleep(interval)
+
+    # ── Keybind actions ────────────────────────────────────────────────────────
+
+    def action_toggle_pause(self) -> None:
+        if not self._is_stream:
+            return
+        self.set_paused(not self._paused)
+
+    def action_edit_filters(self) -> None:
+        from ..config import load_saved_strings
+        self.push_screen(
+            StringEditModal("filters", self._config.filters, load_saved_strings().filters),
+            self._on_filters_edited,
+        )
+
+    def action_edit_highlights(self) -> None:
+        from ..config import load_saved_strings
+        self.push_screen(
+            StringEditModal("highlights", self._config.highlights, load_saved_strings().highlights),
+            self._on_highlights_edited,
+        )
+
+    def action_edit_monitors(self) -> None:
+        if not self._is_stream:
+            return
+        from ..config import load_saved_strings
+        self.push_screen(
+            StringEditModal("monitors", self._config.monitors, load_saved_strings().monitors),
+            self._on_monitors_edited,
+        )
+
+    def _on_filters_edited(self, result: tuple[list[str], bool] | None) -> None:
+        if result is not None:
+            new_strings, save = result
+            if save:
+                from ..config import add_to_saved_strings, load_saved_strings
+                saved = load_saved_strings().filters
+                truly_new = [s for s in new_strings if s not in saved]
+                if truly_new:
+                    add_to_saved_strings("filters", truly_new)
+                    self.notify(f"Saved {len(truly_new)} filter(s) to saved settings")
+            self.update_filters(new_strings)
+        # Resume live-follow on close, whether applied or cancelled.
+        self._apply_edits_and_resume()
+
+    def _on_highlights_edited(self, result: tuple[list[str], bool] | None) -> None:
+        if result is not None:
+            new_strings, save = result
+            if save:
+                from ..config import add_to_saved_strings, load_saved_strings
+                saved = load_saved_strings().highlights
+                truly_new = [s for s in new_strings if s not in saved]
+                if truly_new:
+                    add_to_saved_strings("highlights", truly_new)
+                    self.notify(f"Saved {len(truly_new)} highlight(s) to saved settings")
+            self.update_highlights(new_strings)
+        self._apply_edits_and_resume()
+
+    def _on_monitors_edited(self, result: tuple[list[str], bool] | None) -> None:
+        if result is not None:
+            new_strings, save = result
+            if save:
+                from ..config import add_to_saved_strings, load_saved_strings
+                saved = load_saved_strings().monitors
+                truly_new = [s for s in new_strings if s not in saved]
+                if truly_new:
+                    add_to_saved_strings("monitors", truly_new)
+                    self.notify(f"Saved {len(truly_new)} monitor(s) to saved settings")
+            self.update_monitors(new_strings)
+        self._apply_edits_and_resume()
+
+    def action_save_logs(self) -> None:
+        proj = self._config.project
+        ts = datetime.now().strftime("%Y%m%d-%H%M%S")
+        default_name = f"docker-orb-{proj}-{ts}.log"
+        self.push_screen(
+            SaveDialog(default_name=default_name),
+            self._do_save,
+        )
+
+    def _do_save(self, path_str: str | None) -> None:
+        if not path_str:
+            return
+        path = Path(path_str)
+        lines = [line.display for line in self._buffer]
+        try:
+            path.write_text("\n".join(lines) + "\n")
+            self.notify(f"Saved {len(lines)} lines to {path}", severity="information")
+        except OSError as exc:
+            self.notify(f"Save failed: {exc}", severity="error")
+
+    def action_toggle_color(self) -> None:
+        self._config.color_full_line = not self._config.color_full_line
+        full_line = self._config.color_full_line
+
+        self.query_one(MainStreamPanel).set_color_mode(full_line)
+        self._rerender_main_stream()
+
+        search_panel = self.query_one(SearchPanel)
+        search_panel.set_color_mode(full_line)
+        query = search_panel.query_one("#search-input", Input).value
+        search_panel.search(self._buffer, query)
+
+        if self._is_stream:
+            monitor_panel = self.query_one(MonitorPanel)
+            monitor_panel.set_color_mode(full_line)
+            monitor_panel.rebuild(self._buffer)
+
+        mode = "full line" if full_line else "name only"
+        self.notify(f"Color mode: {mode}")
+
+    def action_toggle_wrap(self) -> None:
+        self._config.line_wrap = not self._config.line_wrap
+        wrap = self._config.line_wrap
+        self.query_one(MainStreamPanel).set_wrap(wrap)
+        self.query_one(SearchPanel).set_wrap(wrap)
+        if self._is_stream:
+            self.query_one(MonitorPanel).set_wrap(wrap)
+        # RichLog only applies wrap to new writes — re-render buffer so existing lines reflow
+        self._rerender_main_stream()
+        self.notify(f"Line wrap: {'on' if wrap else 'off'}")
+
+    def action_toggle_json(self) -> None:
+        self._config.json_format = not self._config.json_format
+        panel = self.query_one(MainStreamPanel)
+        panel.set_json_format(self._config.json_format)
+        self._rerender_main_stream()
+        self.notify(f"JSON format: {'on' if self._config.json_format else 'raw'}")
+
+    def action_toggle_collapse(self) -> None:
+        self._config.collapse_repeats = not self._config.collapse_repeats
+        panel = self.query_one(MainStreamPanel)
+        panel.set_collapse_repeats(self._config.collapse_repeats)
+        self._rerender_main_stream()
+        self.notify(f"Collapse repeats: {'on' if self._config.collapse_repeats else 'off'}")
+
+    def show_json_detail(self, idx: int | None) -> None:
+        if idx is None:
+            return
+        parsed = self.query_one(MainStreamPanel).get_parsed_json(idx)
+        if parsed is None:
+            return
+        self.push_screen(JsonDetailModal(parsed.pretty))
+
+    def show_monitor_context(self, target: LogLine) -> None:
+        """Open a modal with lines of context around a monitor hit, like
+        `grep -C` — the monitor panel itself only ever shows the matching
+        line, which is often not enough to tell what happened. The modal
+        starts with a small window and grows/shrinks it live via +/-.
+
+        Context is scoped to the SAME container as the hit, not sliced from the
+        raw session buffer — that buffer interleaves every concurrently
+        streamed container in arrival order, so its neighboring entries are
+        essentially unrelated lines from whichever other container happened to log
+        around the same moment, not anything that led up to the hit.
+        """
+        container_lines = [l for l in self._buffer if l.container_name == target.container_name]
+        # Try identity first, fall back to content match if buffer was trimmed
+        idx = next((i for i, l in enumerate(container_lines) if l is target), None)
+        if idx is None:
+            idx = next((i for i, l in enumerate(container_lines) if l.content == target.content), None)
+        if idx is None:
+            self.notify("Line no longer in buffer.", severity="warning")
+            return
+
+        self.push_screen(MonitorContextModal(container_lines, idx, target.container_name))
+
+    def action_toggle_search(self) -> None:
+        panel = self.query_one(SearchPanel)
+        panel.display = not panel.display
+        if panel.display:
+            panel.query_one("#search-input").focus()
+        else:
+            self.query_one("#stream-log").focus()
+
+    def action_manage_containers(self) -> None:
+        self.push_screen(
+            ContainerSelectorModal(
+                project=self._config.project,
+                active_services=list(self._config.services),
+            ),
+            self._on_containers_selected,
+        )
+
+    def _on_containers_selected(self, new_services: list[str] | None) -> None:
+        if new_services is None:
+            return
+        current = set(self._config.services)
+        new = set(new_services)
+        for dep in new - current:
+            self.add_service_to_stream(dep)
+        for dep in current - new:
+            self.remove_service_from_stream(dep)
+
+    def action_edit_layout(self) -> None:
+        panels = self._visible_side_panels()
+        if not panels:
+            self.notify("No resizable panes are currently visible.", severity="warning")
+            return
+        total = self.query_one("#panels").outer_size.height
+        if total <= 0:
+            return
+        entries = [
+            (label, round(panel.outer_size.height / total * 100))
+            for label, panel in panels
+        ]
+        self.push_screen(PaneSizeModal(entries), self._on_layout_edited)
+
+    def _on_layout_edited(self, result: dict[str, int] | None) -> None:
+        if result is None:
+            return
+        panels = dict(self._visible_side_panels())
+        total = self.query_one("#panels").outer_size.height
+        if total <= 0:
+            return
+
+        heights = {
+            label: max(self.SIDE_PANEL_MIN_HEIGHT, round(pct / 100 * total))
+            for label, pct in result.items()
+            if label in panels
+        }
+
+        remaining = total - sum(heights.values())
+        if remaining < self.MAIN_STREAM_MIN_HEIGHT:
+            self.notify(
+                f"Those sizes would leave only {remaining} rows for the main "
+                f"stream (minimum {self.MAIN_STREAM_MIN_HEIGHT}). Reduce one "
+                f"or more percentages and try again.",
+                severity="error",
+            )
+            return
+
+        for label, height in heights.items():
+            panels[label].styles.height = height
+
+    # ── Cross-panel: line-select jump ─────────────────────────────────────────
+
+    def on_health_panel_add_to_stream(self, event) -> None:
+        self.add_service_to_stream(event.service_name)
+
+    def on_search_panel_line_selected(self, event) -> None:
+        self.set_paused(True)
+        self._jump_to_line(event.line)
+
+    def on_monitor_panel_line_selected(self, event) -> None:
+        self.set_paused(True)
+        self._jump_to_line(event.line)
+
+    def _jump_to_line(self, target: LogLine) -> None:
+        """Rebuild the main stream showing context around target, with it highlighted."""
+        # Try identity first, fall back to content match if buffer was trimmed
+        idx = next((i for i, l in enumerate(self._buffer) if l is target), None)
+        if idx is None:
+            idx = next((i for i, l in enumerate(self._buffer)
+                        if l.container_name == target.container_name and l.content == target.content), None)
+        if idx is None:
+            self.notify("Line no longer in buffer.", severity="warning")
+            return
+        start = max(0, idx - 100)
+        context = self._buffer[start: idx + 11]
+        panel = self.query_one(MainStreamPanel)
+        panel.clear()
+        for line in context:
+            if self._filter_patterns and matches(line.content, self._filter_patterns):
+                continue
+            color = self._color_map.get(line.container_name, "#ffffff")
+            is_target = line is target
+            hl = self._highlight_patterns if (not is_target and self._highlight_patterns and
+                 matches(line.content, self._highlight_patterns)) else None
+            panel.add_line(line, color, hl, is_target=is_target)
+        panel.scroll_to_end()