docker-orb 1.0.0__py3-none-any.whl

docker_orb/viewer/panels/monitor.py

@@ -0,0 +1,233 @@
+"""
+MonitorPanel — passive accumulation of monitor-string hits.
+
+Lines matching monitor patterns are copied here without interrupting the main stream.
+A single click selects a hit (Enter then shows ± context lines from the buffer,
+like `grep -C`); double-clicking pauses the main stream and jumps to it.
+Stream mode only.
+"""
+from __future__ import annotations
+
+import re
+import time
+
+from rich.text import Text
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import ScrollableContainer, Vertical
+from textual.message import Message
+from textual.widgets import Label
+
+from ...config import matches
+from ...models import LogLine
+from ..widgets import DragResizeHeader
+
+# Cap the number of rendered rows to avoid layout slowdown with large hit counts.
+# _lines tracks the true total; only the most recent MAX_ROWS are shown.
+_MAX_ROWS = 500
+
+# Two clicks on the same row within this window count as a double-click.
+_DOUBLE_CLICK_SECONDS = 0.5
+
+
+class MonitorPanel(Vertical):
+    """Collapsible monitor accumulation panel."""
+
+    DEFAULT_HEIGHT = "20%"
+
+    class LineSelected(Message):
+        """Posted when the user double-clicks a monitor hit."""
+        def __init__(self, line: LogLine) -> None:
+            super().__init__()
+            self.line = line
+
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._collapsed = False
+        self._pre_collapse_height = None
+        self._lines: list[LogLine] = []
+        self._color_map: dict[str, str] = {}
+        self._color_full_line = False
+        self._patterns: list[re.Pattern] = []
+
+    def compose(self) -> ComposeResult:
+        yield _MonitorHeader(id="monitor-header")
+        with ScrollableContainer(id="monitor-scroll"):
+            yield Vertical(id="monitor-list")
+
+    def set_color_map(self, color_map: dict[str, str]) -> None:
+        self._color_map = color_map
+
+    def set_color_mode(self, full_line: bool) -> None:
+        self._color_full_line = full_line
+
+    def set_patterns(self, patterns: list[re.Pattern]) -> None:
+        self._patterns = patterns
+
+    def set_wrap(self, wrap: bool) -> None:
+        sc = self.query_one("#monitor-scroll", ScrollableContainer)
+        sc.set_class(wrap, "wrap-on")
+        sc.set_class(not wrap, "wrap-off")
+
+    def add_line(self, line: LogLine, color: str) -> None:
+        self._lines.append(line)
+        scroll = self.query_one("#monitor-scroll", ScrollableContainer)
+        inner = self.query_one("#monitor-list", Vertical)
+
+        at_top = scroll.scroll_y <= 1
+
+        text = _build_text(line, color, self._patterns, self._color_full_line)
+        # Prepend — newest hit at the top. mount(before=0) on Vertical is reliable.
+        inner.mount(_MonitorRow(text, line), before=0)
+
+        # Evict the oldest rendered row when we exceed the cap
+        if len(inner.children) > _MAX_ROWS:
+            inner.children[-1].remove()
+
+        if at_top:
+            scroll.scroll_home(animate=False)
+
+        self.query_one(_MonitorHeader).update_count(len(self._lines))
+
+    def rebuild(self, buffer: list[LogLine]) -> None:
+        """
+        Recompute the entire hit list from the full log buffer through the
+        current monitor patterns. Called when monitors are edited live so
+        unchecking a pattern drops its accumulated hits (and checking a new
+        one back-fills matches already in the buffer).
+        """
+        inner = self.query_one("#monitor-list", Vertical)
+        inner.remove_children()
+
+        matched = (
+            [line for line in buffer if matches(line.content, self._patterns)]
+            if self._patterns
+            else []
+        )
+        self._lines = matched
+
+        # Render only the most recent _MAX_ROWS, prepending in order so the
+        # newest hit ends up on top (matching add_line's ordering).
+        for line in matched[-_MAX_ROWS:]:
+            color = self._color_map.get(line.container_name, "#ffffff")
+            inner.mount(_MonitorRow(_build_text(line, color, self._patterns, self._color_full_line), line), before=0)
+
+        self.query_one(_MonitorHeader).update_count(len(self._lines))
+
+    def toggle_collapsed(self) -> None:
+        self._collapsed = not self._collapsed
+        self.query_one("#monitor-scroll").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(_MonitorHeader).update_collapsed(self._collapsed)
+
+
+class _MonitorRow(Label):
+    """
+    A single monitor hit. Click selects (and focuses) it — Enter then opens
+    a modal with ± context lines from the buffer around it. Double-click
+    instead posts MonitorPanel.LineSelected, pausing and jumping to it in
+    the main stream.
+    """
+
+    can_focus = True
+
+    BINDINGS = [
+        Binding("enter", "show_context", "Context", show=True),
+    ]
+
+    def __init__(self, text: Text, line: LogLine, **kwargs) -> None:
+        super().__init__(text, **kwargs)
+        self.line = line
+        self._last_click = 0.0
+
+    def on_click(self) -> None:
+        self.focus()
+        now = time.monotonic()
+        if now - self._last_click < _DOUBLE_CLICK_SECONDS:
+            self.post_message(MonitorPanel.LineSelected(self.line))
+            self._last_click = 0.0  # require two fresh clicks for the next jump
+        else:
+            self._last_click = now
+
+    def action_show_context(self) -> None:
+        app = self.app
+        if hasattr(app, "show_monitor_context"):
+            app.show_monitor_context(self.line)  # type: ignore[union-attr]
+
+
+def _build_text(
+    line: LogLine,
+    color: str,
+    patterns: list[re.Pattern],
+    full_line: bool = False,
+) -> Text:
+    text = Text()
+    if full_line:
+        text.append(f"[{line.container_name}] ", style=f"bold {color}")
+        if patterns:
+            _append_highlighted(text, line.content, patterns,
+                                base_style=color, hl_style=f"bold {color} on #333300")
+        else:
+            text.append(line.content, style=color)
+    else:
+        text.append(f"[{line.container_name}] ", style=color)
+        if patterns:
+            _append_highlighted(text, line.content, patterns)
+        else:
+            text.append(line.content)
+    return text
+
+
+def _append_highlighted(
+    text: Text,
+    content: str,
+    patterns: list[re.Pattern],
+    base_style: str = "",
+    hl_style: str = "bold #ffff00 on #333300",
+) -> None:
+    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()
+    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)
+
+
+class _MonitorHeader(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} hits)" if self._count else ""
+        self.update(f"{arrow} Monitor{suffix}")

docker_orb/viewer/panels/search.py

@@ -0,0 +1,182 @@
+"""
+SearchPanel — live search across the log buffer.
+
+Filters the main stream buffer in real time as the user types.
+Double-clicking a result pauses the main stream and jumps to that line.
+"""
+from __future__ import annotations
+
+import asyncio
+import re
+import time
+
+from rich.text import Text
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import Vertical
+from textual.message import Message
+from textual.widgets import Input, Label, ListItem, ListView
+
+from ...models import LogLine
+from ..widgets import DragResizeHeader
+
+
+class SearchPanel(Vertical):
+    """Collapsible search panel."""
+
+    DEFAULT_HEIGHT = "20%"
+
+    BINDINGS = [
+        Binding("escape", "close", "Close search", show=False),
+    ]
+
+    class LineSelected(Message):
+        """Posted when user double-clicks a search result."""
+        def __init__(self, line: LogLine) -> None:
+            super().__init__()
+            self.line = line
+
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._collapsed = False
+        self._pre_collapse_height = None
+        self._results: list[LogLine] = []
+        self._color_map: dict[str, str] = {}
+        self._color_full_line = False
+        self._pattern: re.Pattern | None = None
+        self._debounce_task: asyncio.Task | None = None
+        self._last_click: dict[int, float] = {}
+
+    def compose(self) -> ComposeResult:
+        yield _SearchHeader(id="search-header")
+        yield Input(placeholder="Search logs …", id="search-input")
+        yield ListView(id="search-results")
+
+    def set_color_map(self, color_map: dict[str, str]) -> None:
+        self._color_map = color_map
+
+    def set_color_mode(self, full_line: bool) -> None:
+        self._color_full_line = full_line
+
+    def set_wrap(self, wrap: bool) -> None:
+        lv = self.query_one("#search-results", ListView)
+        lv.set_class(wrap, "wrap-on")
+        lv.set_class(not wrap, "wrap-off")
+
+    def search(self, buffer: list[LogLine], query: str) -> None:
+        lv = self.query_one("#search-results", ListView)
+        lv.clear()
+        self._results = []
+        self._pattern = None
+        self._last_click.clear()
+
+        if not query:
+            self.query_one(_SearchHeader).update_count(0)
+            return
+
+        try:
+            pattern = re.compile(query, re.IGNORECASE)
+        except re.error:
+            pattern = re.compile(re.escape(query), re.IGNORECASE)
+
+        self._pattern = pattern
+        matched = [line for line in buffer if pattern.search(line.content)]
+        self._results = matched
+
+        for line in matched[-500:]:
+            color = self._color_map.get(line.container_name, "#ffffff")
+            text = Text()
+            if self._color_full_line:
+                text.append(f"[{line.container_name}] ", style=f"bold {color}")
+                _append_highlighted(text, line.content, pattern,
+                                    base_style=color, hl_style=f"bold {color} on #333300")
+            else:
+                text.append(f"[{line.container_name}] ", style=color)
+                _append_highlighted(text, line.content, pattern)
+            lv.append(ListItem(Label(text)))
+
+        self.query_one(_SearchHeader).update_count(len(matched))
+
+    def on_list_view_selected(self, event: ListView.Selected) -> None:
+        idx = event.list_view.index
+        if idx is None:
+            return
+        now = time.monotonic()
+        last = self._last_click.get(idx, 0.0)
+        self._last_click[idx] = now
+        if now - last < 0.5:
+            # Double-click
+            if idx < len(self._results):
+                self.post_message(self.LineSelected(self._results[idx]))
+
+    def on_input_changed(self, event: Input.Changed) -> None:
+        if event.input.id == "search-input":
+            if self._debounce_task is not None:
+                self._debounce_task.cancel()
+            self._debounce_task = asyncio.get_event_loop().create_task(
+                self._debounced_search(event.value)
+            )
+
+    async def _debounced_search(self, query: str) -> None:
+        await asyncio.sleep(0.3)
+        app = self.app
+        if hasattr(app, "_buffer"):
+            self.search(app._buffer, query)  # type: ignore[union-attr]
+
+    def toggle_collapsed(self) -> None:
+        self._collapsed = not self._collapsed
+        for widget in self.query("#search-input, #search-results"):
+            widget.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(_SearchHeader).update_collapsed(self._collapsed)
+
+    def action_close(self) -> None:
+        self.display = False
+        try:
+            self.app.query_one("#stream-log").focus()
+        except Exception:
+            pass
+
+
+def _append_highlighted(
+    text: Text,
+    content: str,
+    pattern: re.Pattern,
+    base_style: str = "",
+    hl_style: str = "bold #ffff00",
+) -> None:
+    cursor = 0
+    for m in pattern.finditer(content):
+        if m.start() > cursor:
+            text.append(content[cursor:m.start()], style=base_style)
+        text.append(content[m.start():m.end()], style=hl_style)
+        cursor = m.end()
+    if cursor < len(content):
+        text.append(content[cursor:], style=base_style)
+
+
+class _SearchHeader(DragResizeHeader):
+    def __init__(self, **kwargs) -> None:
+        super().__init__("", markup=True, **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} results)" if self._count else ""
+        hint = "" if self._collapsed else "  [dim]/ or Esc to close[/dim]"
+        self.update(f"{arrow} Search{suffix}{hint}")

docker_orb/viewer/viewer.tcss

@@ -0,0 +1,205 @@
+/* Viewer layout */
+
+Checkbox {
+    height: auto;
+    margin: 0;
+    padding: 0 1;
+    background: transparent;
+    border: none;
+}
+
+Checkbox > .toggle--button {
+    color: $panel;
+    background: $panel-darken-1;
+}
+
+Checkbox.-on > .toggle--button {
+    color: $text;
+    background: $success;
+    text-style: bold;
+}
+
+Screen {
+    layers: base overlay;
+    background: $background;
+}
+
+#panels {
+    height: 1fr;
+}
+
+/* ── Main stream ──────────────────────────────────────────────────────────── */
+
+MainStreamPanel {
+    height: 1fr;
+    min-height: 20;
+}
+
+_StreamHeader {
+    background: $panel;
+    color: $text;
+    padding: 0 1;
+    text-style: bold;
+    height: 1;
+}
+
+/* Paused: bright, high-contrast bar that flashes (see _StreamHeader). */
+_StreamHeader.-paused {
+    background: $warning;
+    color: black;
+    text-style: bold;
+}
+
+/* Every other tick the timer flips this on, dimming the bar to create a
+   visible flash without moving anything. */
+_StreamHeader.-paused.-blink-off {
+    background: $panel;
+    color: $warning;
+}
+
+_LogDisplay {
+    height: 1fr;
+    scrollbar-gutter: stable;
+}
+
+/* ── Search panel ─────────────────────────────────────────────────────────── */
+
+SearchPanel {
+    height: 10;
+    min-height: 4;
+    border-top: tall $accent;
+}
+
+_SearchHeader {
+    background: $panel;
+    color: $accent;
+    padding: 0 1;
+    height: 1;
+}
+
+_SearchHeader:hover {
+    background: $accent 30%;
+}
+
+#search-input {
+    height: 3;
+    dock: top;
+}
+
+#search-results {
+    height: 1fr;
+}
+
+/* ── Monitor panel ────────────────────────────────────────────────────────── */
+
+MonitorPanel {
+    height: 10;
+    min-height: 4;
+    border-top: tall $warning;
+}
+
+_MonitorHeader {
+    background: $panel;
+    color: $warning;
+    padding: 0 1;
+    height: 1;
+}
+
+_MonitorHeader:hover {
+    background: $warning 30%;
+}
+
+#monitor-scroll {
+    height: 1fr;
+}
+
+#monitor-list {
+    height: auto;
+}
+
+#monitor-scroll.wrap-on Label {
+    width: 1fr;
+}
+
+#monitor-scroll.wrap-off Label {
+    width: auto;
+}
+
+/* ── Health panel ─────────────────────────────────────────────────────────── */
+
+HealthPanel {
+    height: 8;
+    min-height: 4;
+    border-top: tall $error;
+}
+
+_HealthHeader {
+    background: $panel;
+    padding: 0 1;
+    height: 1;
+}
+
+_HealthHeader:hover {
+    background: $error 30%;
+}
+
+#health-table {
+    height: 1fr;
+}
+
+/* ── Modal dialogs ────────────────────────────────────────────────────────── */
+
+ConfirmDialog {
+    align: center middle;
+    background: $surface;
+    border: tall $error;
+    padding: 1 2;
+    width: 60;
+    height: auto;
+    layer: overlay;
+}
+
+SaveDialog {
+    align: center middle;
+    background: $surface;
+    border: tall $accent;
+    padding: 1 2;
+    width: 70;
+    height: auto;
+    layer: overlay;
+}
+
+ConfirmDialog Horizontal, SaveDialog Horizontal {
+    height: auto;
+    margin-top: 1;
+}
+
+ConfirmDialog Button, SaveDialog Button {
+    margin-right: 1;
+}
+
+/* ── ListView wrap control ───────────────────────────────────────────────── */
+
+ListView.wrap-on ListItem Label {
+    width: 1fr;
+}
+
+ListView.wrap-off ListItem Label {
+    width: auto;
+}
+
+/* ── Collapsed state ─────────────────────────────────────────────────────── */
+
+/* Panels shrink to header-only height when collapsed. auto (not a fixed 1)
+   because SearchPanel/MonitorPanel/HealthPanel also carry a border-top —
+   a hardcoded height: 1 leaves no room for that border row and clips the
+   header (with the collapse arrow) out of view entirely, along with any
+   way to click it back open. auto sizes to whatever the visible header
+   plus border chrome actually need. */
+MainStreamPanel.-collapsed,
+SearchPanel.-collapsed,
+MonitorPanel.-collapsed,
+HealthPanel.-collapsed {
+    height: auto;
+    min-height: 1;
+}