docker-orb 1.0.0__py3-none-any.whl

docker_orb/viewer/panels/health.py

@@ -0,0 +1,239 @@
+"""
+HealthPanel — container health alerts.
+
+Hidden when all containers are healthy.
+Appears when any watched container is not Running or has new restarts.
+Rows persist until the user double-clicks to dismiss.
+R = delete container (with confirmation), Shift+R = rollout restart service.
+Stream mode only.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import timedelta
+
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import Vertical
+from textual.message import Message
+from textual.widgets import DataTable
+
+from ...models import HealthConfig, ContainerStatus
+from ..widgets import DragResizeHeader
+
+
+@dataclass
+class _HealthRow:
+    status: ContainerStatus
+    restart_delta: int
+    dismissed: bool = False
+
+
+class HealthPanel(Vertical):
+    """
+    Collapsible health panel.
+    Hidden when no unhealthy rows exist.
+    Double-click a row to add that service to the log stream.
+    D key dismisses the selected row.
+    """
+
+    class AddToStream(Message):
+        """Posted when the user double-clicks a container row to add it to the stream."""
+        def __init__(self, service_name: str) -> None:
+            super().__init__()
+            self.service_name = service_name
+
+    BINDINGS = [
+        Binding("r",       "restart_container",        "Restart container",     show=True),
+        Binding("shift+r", "rollout_restart",     "Rollout restart", show=True),
+        Binding("d",       "dismiss_row",         "Dismiss row",     show=True),
+    ]
+
+    def __init__(self, config: HealthConfig, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._config = config
+        self._rows: dict[str, _HealthRow] = {}   # container_name → row
+        self._collapsed = False
+        self._pre_collapse_height = None
+        self.display = False   # hidden until first unhealthy container
+
+    def compose(self) -> ComposeResult:
+        yield _HealthHeader(id="health-header")
+        yield DataTable(id="health-table", show_cursor=True, zebra_stripes=True)
+
+    def on_mount(self) -> None:
+        table = self.query_one(DataTable)
+        table.add_columns("Container", "Status", "Restarts (Δ+total)", "Age", "Hint")
+
+    def update_container(self, status: ContainerStatus, restart_delta: int) -> None:
+        """Called by the health poller with fresh status for an unhealthy container."""
+        table = self.query_one(DataTable)
+
+        row = self._rows.get(status.name)
+        if row is None:
+            # New unhealthy container — add a row
+            row = _HealthRow(status=status, restart_delta=restart_delta)
+            self._rows[status.name] = row
+            table.add_row(
+                *self._format_row(row),
+                key=status.name,
+            )
+        else:
+            # Update existing row
+            row.status = status
+            row.restart_delta = restart_delta
+            self._update_table_row(table, row)
+
+        self._show_panel()
+
+    def _format_row(self, row: _HealthRow) -> tuple[str, str, str, str, str]:
+        s = row.status
+        age = _fmt_age(s.age_seconds)
+        restarts = f"{row.restart_delta} (+{s.restart_count})"
+        status_style = s.phase if s.is_healthy else f"[red]{s.phase}[/red]"
+        hint = "dbl-click=stream  D=dismiss  R=restart"
+        return s.name, status_style, restarts, age, hint
+
+    def _update_table_row(self, table: DataTable, row: _HealthRow) -> None:
+        fmt = self._format_row(row)
+        # table.columns is a dict[ColumnKey, Column], not a positional list —
+        # indexing it by an int (e.g. table.columns[0]) raises KeyError.
+        # ordered_columns is the list form, in display order.
+        for column, value in zip(table.ordered_columns, fmt):
+            table.update_cell(row.status.name, column.key, value)
+
+    def on_data_table_row_selected(self, event: DataTable.RowSelected) -> None:
+        # Single click — just focus, no action
+        pass
+
+    def on_data_table_cell_selected(self, event) -> None:
+        pass
+
+    def _dismiss_row(self, container_name: str) -> None:
+        table = self.query_one(DataTable)
+        try:
+            table.remove_row(container_name)
+        except Exception:
+            pass
+        self._rows.pop(container_name, None)
+        if not self._rows:
+            self.display = False
+
+    # Double-click to dismiss — Textual fires on_data_table_row_highlighted
+    # on first click and on_data_table_row_selected on second.
+    # We track click timestamps per row to detect double-click.
+    _last_click: dict[str, float] = {}
+
+    def on_data_table_row_selected(self, event: DataTable.RowSelected) -> None:  # type: ignore[override]
+        import time
+        key = str(event.row_key.value)
+        now = time.monotonic()
+        last = self._last_click.get(key, 0.0)
+        if now - last < 0.5:
+            # Double-click → add this container's service to the stream
+            row = self._rows.get(key)
+            if row:
+                self.post_message(self.AddToStream(row.status.service))
+        self._last_click[key] = now
+
+    def action_dismiss_row(self) -> None:
+        table = self.query_one(DataTable)
+        if table.cursor_row < 0:
+            return
+        container_name = str(table.get_cell_at((table.cursor_row, 0)))
+        self._dismiss_row(container_name)
+
+    def action_restart_container(self) -> None:
+        table = self.query_one(DataTable)
+        if table.cursor_row < 0:
+            return
+        row_key = table.get_row_at(table.cursor_row)
+        container_name = str(table.get_row_index(table.cursor_row))
+        # Get container name from first cell
+        container_name = str(table.get_cell_at((table.cursor_row, 0)))
+        self._confirm_restart(container_name, rollout=False)
+
+    def action_rollout_restart(self) -> None:
+        table = self.query_one(DataTable)
+        if table.cursor_row < 0:
+            return
+        container_name = str(table.get_cell_at((table.cursor_row, 0)))
+        row = self._rows.get(container_name)
+        if row:
+            self._confirm_restart(container_name, rollout=True,
+                                  service=row.status.service)
+
+    def _confirm_restart(self, container_name: str, rollout: bool,
+                         service: str | None = None) -> None:
+        from ..widgets import ConfirmDialog
+        if rollout:
+            msg = f"Rollout restart service/{service}? [y/N]"
+        else:
+            msg = f"Delete container {container_name} (will be recreated)? [y/N]"
+
+        def _on_confirm(confirmed: bool) -> None:
+            if not confirmed:
+                return
+            from ... import compose as k
+            if rollout and service:
+                ok = k.restart_service(service, self.app._config.project)  # type: ignore
+                action = f"rollout restart service/{service}"
+            else:
+                ok = k.restart_container(container_name, self.app._config.project)  # type: ignore
+                action = f"delete container {container_name}"
+
+            if ok:
+                self.app.notify(f"✓ {action}", severity="information")
+            else:
+                self.app.notify(f"✗ {action} failed", severity="error")
+
+        self.app.push_screen(ConfirmDialog(message=msg), _on_confirm)
+
+    def _show_panel(self) -> None:
+        self.display = True
+        self.query_one(_HealthHeader).update_count(len(self._rows))
+
+    def toggle_collapsed(self) -> None:
+        self._collapsed = not self._collapsed
+        self.query_one("#health-table").display = not self._collapsed
+        self.set_class(self._collapsed, "-collapsed")
+        if self._collapsed:
+            self._pre_collapse_height = self.styles.height
+            self.styles.height = "auto"
+        else:
+            self.styles.height = self._pre_collapse_height
+        self.query_one(_HealthHeader).update_collapsed(self._collapsed)
+
+
+class _HealthHeader(DragResizeHeader):
+    def __init__(self, **kwargs) -> None:
+        super().__init__("", **kwargs)
+        self._count = 0
+        self._collapsed = False
+        self._refresh()
+
+    def update_count(self, count: int) -> None:
+        self._count = count
+        self._refresh()
+
+    def update_collapsed(self, collapsed: bool) -> None:
+        self._collapsed = collapsed
+        self._refresh()
+
+    def _refresh(self) -> None:
+        arrow = "▶" if self._collapsed else "▼"
+        suffix = f" ({self._count} unhealthy)" if self._count else ""
+        self.update(f"{arrow} [red]Container Health{suffix}[/red]")
+
+
+def _fmt_age(seconds: float) -> str:
+    td = timedelta(seconds=int(seconds))
+    if td.days:
+        return f"{td.days}d{td.seconds // 3600}h"
+    h, rem = divmod(td.seconds, 3600)
+    m, s = divmod(rem, 60)
+    if h:
+        return f"{h}h{m}m"
+    if m:
+        return f"{m}m{s}s"
+    return f"{s}s"

docker_orb/viewer/panels/main_stream.py

@@ -0,0 +1,389 @@
+"""
+MainStreamPanel — primary log display.
+
+Features:
+  - Colored container-name prefix per line
+  - Highlight support (bold + color emphasis)
+  - Auto-scroll to bottom unless paused
+  - Pause triggered by: scroll-up, clicking a line, or line-select in other panels
+  - PAUSED indicator in header showing buffered line count
+  - Jump-to-line from search/monitor panels
+  - Optional readable reformatting of detected JSON lines, with a detail
+    modal (Enter, after clicking a line) showing the full pretty-printed JSON
+  - Optional collapsing of consecutive identical lines from the same container
+    into a single "last line repeated N times" marker (journalctl-style)
+"""
+from __future__ import annotations
+
+import re
+
+from rich.style import Style
+from rich.text import Text
+from textual.binding import Binding
+from textual.widgets import RichLog, Static
+from textual.containers import Vertical
+
+from ...jsonlog import LEVEL_STYLES, ParsedJsonLine, parse_json_log_line
+from ...models import LogLine
+
+
+def _append_with_highlights(
+    text: Text,
+    content: str,
+    patterns: list[re.Pattern],
+    base_style: str,
+    hl_style: str,
+) -> None:
+    """Append content to text, highlighting only the matched spans."""
+    # Collect all match spans, merge overlaps, sort
+    spans: list[tuple[int, int]] = []
+    for pat in patterns:
+        for m in pat.finditer(content):
+            if m.start() < m.end():
+                spans.append((m.start(), m.end()))
+    spans.sort()
+
+    # Merge overlapping spans
+    merged: list[tuple[int, int]] = []
+    for start, end in spans:
+        if merged and start <= merged[-1][1]:
+            merged[-1] = (merged[-1][0], max(merged[-1][1], end))
+        else:
+            merged.append((start, end))
+
+    cursor = 0
+    for start, end in merged:
+        if cursor < start:
+            text.append(content[cursor:start], style=base_style)
+        text.append(content[start:end], style=hl_style)
+        cursor = end
+    if cursor < len(content):
+        text.append(content[cursor:], style=base_style)
+
+
+def _formatted_json_content(
+    parsed: ParsedJsonLine,
+    force_style: str | None,
+    highlight_style: str | None,
+) -> Text:
+    """
+    Build the readable one-line rendering of a parsed JSON line:
+    `HH:MM:SS LEVEL  message  key=val key=val`.
+
+    force_style: color-full-line mode passes the container color here so it wins
+    throughout instead of semantic level coloring.
+    highlight_style: set when the line matched a highlight pattern — spans
+    computed against the raw JSON text don't line up with this reformatted
+    text, so a highlight match emphasizes the whole message instead of a
+    precise span.
+    """
+    t = Text()
+    dim_style = force_style or "dim"
+    if parsed.timestamp:
+        t.append(parsed.timestamp + "  ", style=dim_style)
+    if parsed.level:
+        # A highlight match wins over the level's own semantic color —
+        # otherwise a pattern that matches the level word itself (very
+        # common: "ERROR", "WARN") would highlight everywhere in the raw/
+        # monitor view but silently do nothing to the level badge here.
+        level_style = highlight_style or force_style or LEVEL_STYLES.get(parsed.level.upper(), "bold")
+        t.append(f"{parsed.level.upper():<5} ", style=level_style)
+    t.append(parsed.message, style=highlight_style or force_style or "")
+    if parsed.extras:
+        t.append("  " + parsed.extras_text, style=dim_style)
+    return t
+
+
+class MainStreamPanel(Vertical):
+    """Collapsible container wrapping the log display."""
+
+    # When collapse-repeats is on and a run of identical lines never breaks
+    # (e.g. a crash loop logging the exact same line forever), flush a
+    # "still repeating" marker every this-many repeats rather than holding
+    # it indefinitely — otherwise the display would look frozen even though
+    # lines are still arriving.
+    REPEAT_CHECKPOINT = 500
+
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._collapsed = False
+        self._pre_collapse_height = None
+        self._paused = False
+        self._pending_count = 0
+        self._color_full_line = False
+        self._json_format = False
+        self._json_lines: dict[int, ParsedJsonLine] = {}
+        self._next_line_idx = 0
+        self._collapse_repeats = False
+        # (line, color) of the most recently WRITTEN line, while collapsing
+        # is on — used to recognize the next line as a repeat of it.
+        self._pending_repeat: tuple[LogLine, str] | None = None
+        self._repeat_count = 0
+
+    def set_color_mode(self, full_line: bool) -> None:
+        self._color_full_line = full_line
+
+    def set_wrap(self, wrap: bool) -> None:
+        self.query_one(_LogDisplay).wrap = wrap
+
+    def set_json_format(self, enabled: bool) -> None:
+        self._json_format = enabled
+
+    def set_collapse_repeats(self, enabled: bool) -> None:
+        self._collapse_repeats = enabled
+
+    def get_parsed_json(self, idx: int) -> ParsedJsonLine | None:
+        return self._json_lines.get(idx)
+
+    def compose(self):
+        yield _StreamHeader(id="stream-header")
+        yield _LogDisplay(id="stream-log", highlight=False, markup=False,
+                          wrap=True, auto_scroll=True)
+
+    def add_line(
+        self,
+        line: LogLine,
+        color: str,
+        highlight_patterns: list[re.Pattern] | None = None,
+        is_target: bool = False,
+    ) -> None:
+        # is_target lines (the jump-to-context / JSON-context views) are
+        # always their own one-off render — never folded into a repeat run.
+        if self._collapse_repeats and not is_target and self._is_repeat(line):
+            self._repeat_count += 1
+            if self._repeat_count % self.REPEAT_CHECKPOINT == 0:
+                orig_line, orig_color = self._pending_repeat
+                self._write_repeat_marker(orig_line, orig_color, self._repeat_count, ongoing=True)
+                self._repeat_count = 0
+            return
+
+        self._flush_pending_repeat()
+        self._write_line(line, color, highlight_patterns, is_target)
+        if self._collapse_repeats and not is_target:
+            self._pending_repeat = (line, color)
+            self._repeat_count = 0
+        else:
+            self._pending_repeat = None
+
+    def _is_repeat(self, line: LogLine) -> bool:
+        if self._pending_repeat is None:
+            return False
+        prev_line, _ = self._pending_repeat
+        return prev_line.container_name == line.container_name and prev_line.content == line.content
+
+    def _flush_pending_repeat(self) -> None:
+        """Emit the "repeated N times" marker for a just-ended run, if any."""
+        if self._repeat_count > 0 and self._pending_repeat is not None:
+            orig_line, orig_color = self._pending_repeat
+            self._write_repeat_marker(orig_line, orig_color, self._repeat_count, ongoing=False)
+        self._pending_repeat = None
+        self._repeat_count = 0
+
+    def _write_repeat_marker(self, orig_line: LogLine, color: str, n: int, ongoing: bool) -> None:
+        log = self.query_one(_LogDisplay)
+        text = Text()
+        text.append(f"[{orig_line.container_name}] ", style=color)
+        times = "time" if n == 1 else "times"
+        msg = f"↻ last line repeated {n} {times}"
+        if ongoing:
+            msg += " so far — still repeating…"
+        text.append(msg, style="dim italic")
+        log.write(text)
+
+    def _write_line(
+        self,
+        line: LogLine,
+        color: str,
+        highlight_patterns: list[re.Pattern] | None,
+        is_target: bool,
+    ) -> None:
+        log = self.query_one(_LogDisplay)
+        text = Text()
+        prefix = f"[{line.container_name}] "
+        content = line.content
+
+        # Detection always runs (cheap early-exit for non-JSON lines) so the
+        # Enter-for-detail feature works even when display formatting is off.
+        parsed = parse_json_log_line(content)
+        use_formatted = parsed is not None and self._json_format
+
+        if is_target:
+            text.append("▶ ", style="bold #ff8800")
+            text.append(prefix, style=f"bold {color}")
+            if use_formatted:
+                text.append_text(_formatted_json_content(
+                    parsed, force_style="bold white on #2a2a00", highlight_style=None))
+            else:
+                text.append(content, style="bold white on #2a2a00")
+        elif self._color_full_line:
+            text.append(prefix, style=f"bold {color}")
+            if use_formatted:
+                hl = f"bold {color} on #333300" if highlight_patterns else None
+                text.append_text(_formatted_json_content(parsed, force_style=color, highlight_style=hl))
+            elif highlight_patterns:
+                _append_with_highlights(text, content, highlight_patterns,
+                                        base_style=color, hl_style=f"bold {color} on #333300")
+            else:
+                text.append(content, style=color)
+        else:
+            text.append(prefix, style=color)
+            if use_formatted:
+                hl = "bold #ffff00 on #333300" if highlight_patterns else None
+                text.append_text(_formatted_json_content(parsed, force_style=None, highlight_style=hl))
+            elif highlight_patterns:
+                _append_with_highlights(text, content, highlight_patterns,
+                                        base_style="", hl_style="bold #ffff00 on #333300")
+            else:
+                text.append(content)
+
+        if parsed is not None:
+            idx = self._next_line_idx
+            self._next_line_idx += 1
+            self._json_lines[idx] = parsed
+            text.stylize(Style(meta={"line_idx": idx}), 0, len(text))
+
+        log.write(text)
+
+    def clear(self) -> None:
+        self.query_one(_LogDisplay).clear()
+        self._json_lines.clear()
+        self._next_line_idx = 0
+        self._pending_repeat = None
+        self._repeat_count = 0
+
+    def set_paused(self, paused: bool, pending: int = 0) -> None:
+        self._paused = paused
+        self._pending_count = pending
+        log = self.query_one(_LogDisplay)
+        log.auto_scroll = not paused
+        self.query_one(_StreamHeader).update_pause(paused, pending)
+
+    def scroll_to_end(self) -> None:
+        self.query_one(_LogDisplay).scroll_end(animate=False)
+
+    def toggle_collapsed(self) -> None:
+        log = self.query_one(_LogDisplay)
+        self._collapsed = not self._collapsed
+        log.display = not self._collapsed
+        self.set_class(self._collapsed, "-collapsed")
+        # The CSS class alone doesn't reliably win over an inline height set
+        # by a previous drag-resize/pane-size-modal action (inline styles
+        # take precedence over stylesheet rules), so also set/restore the
+        # panel's own height explicitly — otherwise a collapsed panel keeps
+        # its old reserved space instead of giving it back to MainStreamPanel.
+        if self._collapsed:
+            self._pre_collapse_height = self.styles.height
+            self.styles.height = "auto"
+        else:
+            self.styles.height = self._pre_collapse_height
+        self.query_one(_StreamHeader).update_collapsed(self._collapsed)
+
+
+class _StreamHeader(Static):
+    """Header bar showing title and pause status.
+
+    When paused, the header adds a `-paused` class (styled as a bright,
+    high-contrast bar in viewer.tcss) and flashes by toggling `-blink-off`
+    on a timer, so a paused stream is impossible to miss.
+    """
+
+    def __init__(self, **kwargs) -> None:
+        super().__init__("", **kwargs)
+        self._paused = False
+        self._pending = 0
+        self._collapsed = False
+        self._blink_timer = None
+        self._refresh()
+
+    def update_pause(self, paused: bool, pending: int) -> None:
+        self._paused = paused
+        self._pending = pending
+        self.set_class(paused, "-paused")
+        if paused and self._blink_timer is None:
+            self._blink_timer = self.set_interval(0.5, self._toggle_blink)
+        elif not paused and self._blink_timer is not None:
+            self._blink_timer.stop()
+            self._blink_timer = None
+            self.remove_class("-blink-off")
+        self._refresh()
+
+    def _toggle_blink(self) -> None:
+        self.toggle_class("-blink-off")
+
+    def update_collapsed(self, collapsed: bool) -> None:
+        self._collapsed = collapsed
+        self._refresh()
+
+    def _refresh(self) -> None:
+        arrow = "▶" if self._collapsed else "▼"
+        title = f"{arrow} Main Stream"
+        if self._paused:
+            if self._pending:
+                title += f"  ⏸ PAUSED  +{self._pending} lines — Space to resume"
+            else:
+                title += "  ⏸ PAUSED — Space to resume"
+        self.update(title)
+
+    def on_click(self) -> None:
+        self.parent.toggle_collapsed()  # type: ignore[union-attr]
+
+
+class _LogDisplay(RichLog):
+    """The actual scrollable log widget. Pauses on scroll-up, click, or drag.
+
+    Clicking a line also selects it (tagged via a "line_idx" style meta —
+    see MainStreamPanel.add_line) so Enter can open its JSON detail view,
+    if it was a detected JSON line.
+    """
+
+    BINDINGS = [
+        Binding("enter", "show_json_detail", "JSON detail", show=True),
+    ]
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self.selected_line_idx: int | None = None
+
+    def on_scroll_up(self) -> None:
+        # ScrollUp message = clicking the scrollbar track above the thumb.
+        app = self.app
+        if hasattr(app, "set_paused"):
+            app.set_paused(True)  # type: ignore[union-attr]
+
+    def on_click(self, event) -> None:
+        style = self.get_style_at(event.x, event.y)
+        self.selected_line_idx = style.meta.get("line_idx")
+        self.refresh_bindings()  # footer's "JSON detail" visibility depends on the selection
+        app = self.app
+        if hasattr(app, "set_paused"):
+            app.set_paused(True)  # type: ignore[union-attr]
+
+    def check_action(self, action: str, parameters: tuple[object, ...]) -> bool | None:
+        if action == "show_json_detail":
+            # Hide the hotkey from the footer entirely unless the currently
+            # selected line is actually a detected JSON line — otherwise
+            # it's advertised even when pressing it would do nothing.
+            return self.selected_line_idx is not None
+        return super().check_action(action, parameters)
+
+    def action_show_json_detail(self) -> None:
+        app = self.app
+        if hasattr(app, "show_json_detail"):
+            app.show_json_detail(self.selected_line_idx)  # type: ignore[union-attr]
+
+    def _on_scroll_to(self, message) -> None:
+        # Dragging the scrollbar thumb posts ScrollTo but does NOT trigger
+        # on_scroll_up (that fires for track-clicks / the wheel), so without
+        # this the app never pauses on a drag: auto_scroll stays on and the
+        # next incoming line snaps the view back to the bottom, making the
+        # thumb impossible to drag in a live stream. Pause while dragging;
+        # if the drag lands at the bottom, resume live-follow.
+        super()._on_scroll_to(message)
+        app = self.app
+        if hasattr(app, "set_paused") and message.y is not None:
+            want_paused = message.y < self.max_scroll_y - 1
+            # Only toggle when the state actually changes (auto_scroll is the
+            # inverse of paused), to avoid redundant header re-renders and
+            # repeated flush-worker spawns during a drag.
+            if self.auto_scroll == want_paused:
+                app.set_paused(want_paused)  # type: ignore[union-attr]