termainer 0.4.0__py3-none-any.whl

termainer/ui/environment.py

@@ -0,0 +1,300 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+import shutil
+from typing import List
+
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import Horizontal, Vertical
+from textual.events import Resize
+from textual.screen import Screen
+from textual.widgets import Button, Static
+
+from ..locale import _
+from ..config import has_ssh_servers_configured
+from ..server_manager import ServerManager
+from ..version import VERSION
+from .dashboard import Dashboard
+
+
+_SERVER_ICONS = {
+    "docker": "[bold #4ade80]◇[/]",
+    "podman": "[bold #22d3ee]◇[/]",
+    "kubernetes": "[bold #22d3ee]◈[/]",
+    "openshift": "[bold #f87171]◈[/]",
+    "swarm": "[bold #fbbf24]⬢[/]",
+}
+
+
+def _server_icon(provider_name: str) -> str:
+    return _SERVER_ICONS.get(provider_name.lower(), "[bold white]◇[/]")
+
+
+@dataclass(frozen=True)
+class TechnologyCard:
+    provider: str
+    title: str
+    subtitle: str
+
+
+TECHNOLOGY_CARDS: List[TechnologyCard] = [
+    TechnologyCard("docker", "Docker", _("environment.subtitle.docker")),
+    TechnologyCard("kubernetes", "Kubernetes", _("environment.subtitle.kubernetes")),
+    TechnologyCard("podman", "Podman", _("environment.subtitle.podman")),
+    TechnologyCard("openshift", "OpenShift", _("environment.subtitle.openshift")),
+    TechnologyCard("swarm", "Docker Swarm", _("environment.subtitle.swarm")),
+]
+
+
+PROVIDER_CLI_COMMAND = {
+    "docker": "docker",
+    "kubernetes": "kubectl",
+    "podman": "podman",
+    "openshift": "oc",
+    "swarm": "docker",
+}
+
+
+class EnvironmentScreen(Screen):
+    BINDINGS = [
+        Binding("up", "focus_up", _("environment.bind.up"), priority=True),
+        Binding("down", "focus_down", _("environment.bind.down"), priority=True),
+        Binding("left", "focus_left", _("environment.bind.left"), priority=True),
+        Binding("right", "focus_right", _("environment.bind.right"), priority=True),
+        Binding("enter", "select_focused", _("environment.bind.select"), priority=True),
+        Binding("?", "show_welcome_help", _("environment.bind.help"), priority=True),
+        Binding("h", "show_welcome_help", _("environment.bind.help"), priority=True),
+        Binding("q", "quit", _("environment.bind.quit"), priority=True),
+    ]
+
+    def __init__(self, server_manager: ServerManager) -> None:
+        super().__init__()
+        self._server_manager = server_manager
+        self._card_ids: List[str] = []
+        self._card_actions: List[str] = []
+
+    def compose(self) -> ComposeResult:
+        rows: List[Horizontal] = []
+        row_cards: List[Vertical] = []
+        cols_per_row = 2
+
+        for i, tech in enumerate(TECHNOLOGY_CARDS):
+            row_cards.append(self._technology_card(tech, i))
+            if len(row_cards) == cols_per_row:
+                rows.append(Horizontal(*row_cards, id=f"env-row-{len(rows)}"))
+                row_cards = []
+
+        if row_cards:
+            rows.append(Horizontal(*row_cards, id=f"env-row-{len(rows)}"))
+
+        yield Vertical(
+            Static(f"[bold #22d3ee]TERMAINER[/] [#808080]v{VERSION}[/]", id="env-brand"),
+            Static(_("environment.title"), id="env-title"),
+            Static(
+                f"[dim]{_('environment.copy')}[/]",
+                id="env-copy",
+            ),
+            *rows,
+            Horizontal(
+                Static(
+                    _("environment.footer.full"),
+                    id="env-footer-full",
+                    classes="env-footer-text",
+                ),
+                Static(
+                    _("environment.footer.compact"),
+                    id="env-footer-compact",
+                    classes="env-footer-text",
+                ),
+                id="env-footer",
+            ),
+            id="env-root",
+        )
+
+    @property
+    def _has_remote_servers(self) -> bool:
+        return any(s.ssh is not None for s in self._server_manager.servers)
+
+    def _servers_for_provider(self, provider_name: str):
+        return [s for s in self._server_manager.servers if s.provider.name.lower() == provider_name.lower()]
+
+    def _provider_cli_available(self, provider_name: str) -> bool:
+        cli = PROVIDER_CLI_COMMAND.get(provider_name)
+        if not cli:
+            return False
+        return shutil.which(cli) is not None
+
+    def _provider_status_text(self, provider_name: str) -> str:
+        count = len(self._servers_for_provider(provider_name))
+        if count > 0:
+            return _("environment.status.connections", count=str(count))
+        if self._provider_cli_available(provider_name):
+            if provider_name in {"kubernetes", "openshift"}:
+                if self._has_remote_servers:
+                    return _("environment.status.cli_no_context", provider=provider_name.capitalize())
+                return _("environment.status.cli_no_cluster", provider=provider_name.capitalize())
+            return _("environment.status.cli_no_servers", provider=provider_name.capitalize())
+        return _("environment.status.not_available", provider=provider_name.capitalize())
+
+    def _technology_card(self, tech: TechnologyCard, idx: int) -> Vertical:
+        icon = _server_icon(tech.provider)
+        card_id = f"env-card-{idx}"
+        self._card_ids.append(card_id)
+        self._card_actions.append(f"open_provider_{tech.provider}")
+
+        card = Vertical(
+            Static(f"{icon} [bold white]{tech.title}[/]", classes="env-card-title"),
+            Static(f"[dim]{tech.subtitle}[/]", classes="env-card-provider"),
+            Static(self._provider_status_text(tech.provider), classes="env-card-copy"),
+            Button(_("environment.button.open"), id=f"env-btn-{idx}", classes="env-card-button"),
+            classes="env-card",
+            id=card_id,
+        )
+        card.can_focus = True
+        return card
+
+    def on_mount(self) -> None:
+        self._apply_responsive_mode(self.size.width, self.size.height)
+        if self._card_ids:
+            self.query_one(f"#{self._card_ids[0]}").focus()
+        
+        if not has_ssh_servers_configured():
+            self.notify(
+                _("environment.notify.ssh_hint"),
+                severity="information",
+                timeout=5,
+            )
+
+    def on_resize(self, event: Resize) -> None:
+        self._apply_responsive_mode(event.size.width, event.size.height)
+
+    def _apply_responsive_mode(self, width: int, height: int) -> None:
+        compact = width < 120 or height < 34
+        ultra_compact = width < 95 or height < 28
+        try:
+            root = self.query_one("#env-root", Vertical)
+        except Exception:
+            return
+        if compact:
+            root.add_class("compact")
+        else:
+            root.remove_class("compact")
+        if ultra_compact:
+            root.add_class("ultra-compact")
+        else:
+            root.remove_class("ultra-compact")
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        btn_id = event.button.id or ""
+        try:
+            idx = int(btn_id.replace("env-btn-", ""))
+            action_name = self._card_actions[idx]
+            self._execute_action(action_name)
+        except (ValueError, IndexError):
+            pass
+
+    def _execute_action(self, action_name: str) -> None:
+        if not action_name.startswith("open_provider_"):
+            return
+        provider_name = action_name.replace("open_provider_", "")
+
+        matches = self._servers_for_provider(provider_name)
+        if not matches:
+            if self._provider_cli_available(provider_name):
+                if provider_name in {"kubernetes", "openshift"}:
+                    if self._has_remote_servers:
+                        self.notify(
+                            _("environment.notify.no_context", provider=provider_name.capitalize()),
+                            severity="warning",
+                        )
+                    else:
+                        self.notify(
+                            _("environment.notify.no_cluster", provider=provider_name.capitalize()),
+                            severity="warning",
+                        )
+                    return
+                self.notify(
+                    _("environment.notify.no_servers", provider=provider_name.capitalize()),
+                    severity="warning",
+                )
+                return
+            self.notify(
+                _("environment.notify.not_installed", provider=provider_name.capitalize()),
+                severity="warning",
+            )
+            return
+
+        provider_server_manager = ServerManager(matches)
+        self.app.switch_screen(
+            Dashboard(
+                provider_server_manager,
+                server_label=None,
+                root_server_manager=self._server_manager,
+            )
+        )
+
+    # Navigation
+    def action_focus_up(self) -> None:
+        self._move_focus(-self._cols())
+
+    def action_focus_down(self) -> None:
+        self._move_focus(self._cols())
+
+    def action_focus_left(self) -> None:
+        self._move_focus(-1)
+
+    def action_focus_right(self) -> None:
+        self._move_focus(1)
+
+    def _cols(self) -> int:
+        return min(2, max(1, len(self._card_ids)))
+
+    def _move_focus(self, delta: int) -> None:
+        if not self._card_ids:
+            return
+        focused = self.focused
+        if focused is None:
+            self.query_one(f"#{self._card_ids[0]}").focus()
+            return
+        focused_id = focused.id or ""
+        if focused_id not in self._card_ids:
+            parent = focused.parent
+            if parent and parent.id in self._card_ids:
+                focused_id = parent.id
+            else:
+                return
+        try:
+            idx = self._card_ids.index(focused_id)
+        except ValueError:
+            return
+        new_idx = (idx + delta) % len(self._card_ids)
+        self.query_one(f"#{self._card_ids[new_idx]}").focus()
+
+    def action_select_focused(self) -> None:
+        if not self._card_ids:
+            return
+        focused = self.focused
+        if focused is None:
+            return
+        focused_id = focused.id or ""
+        if focused_id not in self._card_ids:
+            parent = focused.parent
+            if parent and parent.id in self._card_ids:
+                focused_id = parent.id
+            else:
+                return
+        try:
+            idx = self._card_ids.index(focused_id)
+        except ValueError:
+            return
+        action_name = self._card_actions[idx]
+        self._execute_action(action_name)
+
+    def action_quit(self) -> None:
+        self.app.exit()
+
+    def action_show_welcome_help(self) -> None:
+        from .home import HomeScreen
+
+        self.app.switch_screen(HomeScreen(self._server_manager))

termainer/ui/home.py

@@ -0,0 +1,263 @@
+from __future__ import annotations
+
+from textual.app import ComposeResult
+from textual.containers import Horizontal, Vertical
+from textual.events import Resize
+from textual.reactive import reactive
+from textual.screen import Screen
+from textual.widgets import Static
+
+from ..locale import _
+from ..server_manager import ServerManager
+from ..version import VERSION
+
+
+# ── ASCII art ─────────────────────────────────────────────────────────────────
+
+LOGO_BLOCK = """\
+[bold #66FF33] _______ ______ _____  __  __          _____ _   _ ______ _____  [/]
+[bold #66FF33]|__   __|  ____|  __ \\|  \\/  |   /\\   |_   _| \\ | |  ____|  __ \\ [/]
+[bold #66FF33]   | |  | |__  | |__) | \\  / |  /  \\    | | |  \\| | |__  | |__) |[/]
+[bold #66FF33]   | |  |  __| |  _  /| |\\/| | / /\\ \\   | | | . ` |  __| |  _  / [/]
+[bold #66FF33]   | |  | |____| | \\ \\| |  | |/ ____ \\ _| |_| |\\  | |____| | \\ \\ [/]
+[bold #66FF33]   |_|  |______|_|  \\_\\_|  |_/_/    \\_\\_____|_| \\_|______|_|  \\_\\ [/]"""
+
+LOGO_COMPACT = "[bold #66FF33][ >_ ]  TERMAINER[/]"
+
+
+# ── Widgets ───────────────────────────────────────────────────────────────────
+
+class HeaderWidget(Horizontal):
+    """Fixed header: brand (left) · welcome (center) · live status (right)."""
+
+    _pulse: reactive[bool] = reactive(True)
+
+    def __init__(self, server_manager: ServerManager) -> None:
+        super().__init__(id="home-header")
+        self._server_manager = server_manager
+
+    def compose(self) -> ComposeResult:
+        yield Static(
+            f"[bold #66FF33][ >_ ][/]  [bold #66FF33]TERMAINER[/] [dim #66FF33]v{VERSION}[/]",
+            id="home-logo",
+        )
+        yield Static(f"─── {_('home.welcome')} ───", id="home-welcome")
+        yield Static("", id="home-status")
+
+    def on_mount(self) -> None:
+        self._render_status()
+        self.set_interval(0.9, self._toggle_pulse)
+
+    def _toggle_pulse(self) -> None:
+        self._pulse = not self._pulse
+
+    def watch__pulse(self, _: bool) -> None:
+        self._render_status()
+
+    def _render_status(self) -> None:
+        count = self._server_manager.server_count
+        dot = "[bold #66FF33]●[/]" if self._pulse else "[dim #2a2a2a]●[/]"
+        try:
+            self.query_one("#home-status", Static).update(
+                f"{dot} {_('home.header.status', connected=count, total=count)}"
+            )
+        except Exception:
+            pass
+
+
+class HeroWidget(Vertical):
+    """Full-width hero section: big logo + tagline."""
+
+    def compose(self) -> ComposeResult:
+        yield Static(LOGO_BLOCK, id="hero-logo")
+        yield Static(
+            f"[bold #00E5FF]{_('home.hero.tagline')}[/]",
+            id="hero-tagline",
+        )
+
+    def set_compact(self, compact: bool) -> None:
+        try:
+            self.query_one("#hero-logo", Static).update(
+                LOGO_COMPACT if compact else LOGO_BLOCK
+            )
+        except Exception:
+            pass
+
+
+class PlatformsStripWidget(Horizontal):
+    """Horizontal strip of 6 platform icons — no boxes, icon + name only."""
+
+    _PLATFORMS = [
+        ("🐳", "#3399FF", "home.platform.docker"),
+        ("⎈",  "#3399FF", "home.platform.k8s"),
+        ("⬡",  "#FFD400", "home.platform.swarm"),
+        ("◇",  "#B366FF", "home.platform.podman"),
+        ("◈",  "#FF3B30", "home.platform.openshift"),
+        ("▸_", "#66FF33", "home.platform.ssh"),
+    ]
+
+    def compose(self) -> ComposeResult:
+        for icon, color, key in self._PLATFORMS:
+            yield Static(
+                f"[bold {color}]{icon}[/]  [{color}]{_(key)}[/]",
+                classes="platform-item",
+            )
+
+
+class AboutWidget(Vertical):
+    """Compact description of what Termainer is."""
+
+    def compose(self) -> ComposeResult:
+        yield Static(f"[bold #00E5FF]{_('home.about.title')}[/]", classes="section-label")
+        yield Static(
+            _("home.about.description"),
+            id="about-description",
+        )
+
+
+class FeaturesWidget(Horizontal):
+    """Five-column feature breakdown with icons, titles and item lists."""
+
+    _COLS = [
+        ("#66FF33", "▥", "home.features.obs.title", "home.features.obs.items"),
+        ("#00E5FF", "⌕", "home.features.inspection.title", "home.features.inspection.items"),
+        ("#3399FF", "⚙", "home.features.ops.title", "home.features.ops.items"),
+        ("#B366FF", "⬡", "home.features.export.title", "home.features.export.items"),
+        ("#FFD400", "⇶", "home.features.unified.title", "home.features.unified.items"),
+    ]
+
+    def compose(self) -> ComposeResult:
+        for color, icon, title_key, items_key in self._COLS:
+            yield Vertical(
+                Static(f"[bold {color}]{icon}  {_(title_key)}[/]", classes="feat-title"),
+                Static(f"[dim]{_(items_key)}[/]", classes="feat-body"),
+                classes="feat-col",
+            )
+
+
+class SupportedPlatformsWidget(Horizontal):
+    """Six platform cards, each with its brand-color border."""
+
+    _CARDS = [
+        ("🐳", "#3399FF", "home.platform.docker",  "plat-docker"),
+        ("⎈",  "#3399FF", "home.platform.k8s",          "plat-k8s"),
+        ("⬡",  "#FFD400", "home.platform.swarm",        "plat-swarm"),
+        ("◇",  "#B366FF", "home.platform.podman",       "plat-podman"),
+        ("◈",  "#FF3B30", "home.platform.openshift",    "plat-openshift"),
+        ("▸_", "#66FF33", "home.platform.ssh",          "plat-ssh"),
+    ]
+
+    def compose(self) -> ComposeResult:
+        for icon, color, key, css_class in self._CARDS:
+            name = _(key)
+            parts = name.split(" ", 1)
+            display = f"{parts[0]}\n{parts[1]}" if len(parts) > 1 else name
+            yield Vertical(
+                Static(f"[bold {color}]{icon}[/]", classes="plat-icon"),
+                Static(display,                        classes="plat-name"),
+                Static(f"[bold #4ade80]{_('home.platforms.supported')}[/]", classes="plat-status"),
+                classes=f"plat-card {css_class}",
+            )
+
+
+class FooterWidget(Vertical):
+    """Centered footer: Enter hint + credits."""
+
+    def compose(self) -> ComposeResult:
+        hint = _("home.footer.enter_hint")
+        styled = hint.replace("ENTER", "[bold #66FF33]ENTER[/]")
+        yield Static(styled, id="footer-enter")
+        yield Static(
+            _("home.footer.credits"),
+            id="footer-credits",
+        )
+
+
+# ── Screen ────────────────────────────────────────────────────────────────────
+
+class HomeScreen(Screen):
+    """
+    Widget-based home/welcome screen.
+
+    Hierarchy:
+        HomeScreen
+        ├── HeaderWidget              brand · welcome · live pulsing status
+        ├── HeroWidget                big logo + tagline
+        ├── PlatformsStripWidget      6 platform icons, no boxes
+        ├── AboutWidget               description + ASCII connection diagram
+        ├── FeaturesWidget            5-column feature breakdown
+        ├── SupportedPlatformsWidget  6 colored-border platform cards
+        └── FooterWidget              Enter hint + credits (no shortcuts)
+    """
+
+    BINDINGS = [
+        ("enter",  "continue_to_env", _("home.bind.continue")),
+        ("escape", "continue_to_env", _("home.bind.continue")),
+        ("q",      "quit",            _("home.bind.quit")),
+    ]
+
+    def __init__(self, server_manager: ServerManager) -> None:
+        super().__init__()
+        self._server_manager = server_manager
+        self._dismissed = False
+        self._hero: HeroWidget | None = None
+
+    def compose(self) -> ComposeResult:
+        hero = HeroWidget(id="home-hero")
+        self._hero = hero
+        yield Vertical(
+            HeaderWidget(self._server_manager),
+            hero,
+            PlatformsStripWidget(id="home-platforms"),
+            AboutWidget(id="home-about"),
+            FeaturesWidget(id="home-features"),
+            Static(
+                f"[bold #00E5FF]{_('home.platforms.title')}[/]",
+                id="home-supported-label",
+            ),
+            SupportedPlatformsWidget(id="home-supported"),
+            id="home-root",
+        )
+        yield FooterWidget(id="home-footer")
+
+    def on_mount(self) -> None:
+        self._apply_responsive(self.size.width, self.size.height)
+
+    def on_resize(self, event: Resize) -> None:
+        self._apply_responsive(event.size.width, event.size.height)
+
+    def _apply_responsive(self, width: int, height: int) -> None:
+        compact = width < 100 or height < 34
+        try:
+            root = self.query_one("#home-root", Vertical)
+        except Exception:
+            return
+        if compact:
+            root.add_class("compact")
+            if self._hero:
+                self._hero.set_compact(True)
+        else:
+            root.remove_class("compact")
+            if self._hero:
+                self._hero.set_compact(False)
+
+    def on_key(self, event) -> None:
+        if event.key in ("enter", "escape"):
+            event.stop()
+            self._dismiss()
+
+    def on_click(self) -> None:
+        self._dismiss()
+
+    def action_continue_to_env(self) -> None:
+        self._dismiss()
+
+    def action_quit(self) -> None:
+        self.app.exit()
+
+    def _dismiss(self) -> None:
+        if self._dismissed:
+            return
+        self._dismissed = True
+        from .environment import EnvironmentScreen
+        self.app.switch_screen(EnvironmentScreen(self._server_manager))

termainer/ui/splash.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+
+import asyncio
+
+from textual.app import ComposeResult
+from textual.containers import Center, Vertical
+from textual.screen import Screen
+from textual.widgets import Static
+
+from ..locale import _
+from ..server_manager import ServerManager
+from ..version import VERSION
+
+
+_BRAND = f"[bold #66FF33]  [ >_ ]  T · E · R · M · A · I · N · E · R   v{VERSION}  [/]"
+
+_BOOT_STEP_KEYS: list[tuple[str, str]] = [
+    ("splash.boot.init",     "#66FF33"),
+    ("splash.boot.docker",   "#3399FF"),
+    ("splash.boot.k8s",      "#3399FF"),
+    ("splash.boot.openshift","#FF3B30"),
+    ("splash.boot.discover", "#00E5FF"),
+    ("splash.boot.sync",     "#66FF33"),
+]
+
+
+class BootScreen(Screen):
+    """Animated boot sequence. Auto-transitions to HomeScreen when done."""
+
+    BINDINGS = [
+        ("enter", "skip", _("home.bind.continue")),
+        ("space", "skip", _("home.bind.continue")),
+    ]
+
+    def __init__(self, server_manager: ServerManager) -> None:
+        super().__init__()
+        self._server_manager = server_manager
+        self._done = False
+
+    def compose(self) -> ComposeResult:
+        yield Center(
+            Vertical(
+                Static(_BRAND, id="boot-brand"),
+                Static(
+                    "[dim]─────────────────────────────────────────────[/]",
+                    id="boot-sep",
+                ),
+                Static("", id="boot-messages"),
+                id="boot-panel",
+            ),
+            id="boot-root",
+        )
+
+    async def on_mount(self) -> None:
+        asyncio.create_task(self._run_sequence())
+
+    async def _run_sequence(self) -> None:
+        widget = self.query_one("#boot-messages", Static)
+        lines: list[str] = []
+        for key, color in _BOOT_STEP_KEYS:
+            if self._done:
+                break
+            text = _(key)
+            lines.append(f"  [{color}]▶[/]  {text}[dim]...[/]")
+            widget.update("\n".join(lines))
+            await asyncio.sleep(0.11)
+            lines[-1] = f"  [{color}]✓[/]  {text}"
+            widget.update("\n".join(lines))
+            await asyncio.sleep(0.07)
+        if not self._done:
+            await asyncio.sleep(0.25)
+        self._go_home()
+
+    def _go_home(self) -> None:
+        if self._done:
+            return
+        self._done = True
+        from .home import HomeScreen
+        self.app.switch_screen(HomeScreen(self._server_manager))
+
+    def action_skip(self) -> None:
+        self._go_home()
+
+    def on_click(self) -> None:
+        self.action_skip()
+
+
+# Backward-compat alias
+SplashScreen = BootScreen