termainer 0.4.0__py3-none-any.whl

termainer/app.py

@@ -0,0 +1,242 @@
+from __future__ import annotations
+
+import asyncio
+import argparse
+import os
+from typing import List, Optional, Type
+
+from textual.app import App
+
+from .config import build_ssh_from_env, load_env_file
+from .config_manager import ServerConfig, load_config
+from .locale import _
+from .providers.base import Provider
+from .providers.docker import DockerProvider
+from .providers.kubernetes import KubernetesProvider
+from .providers.openshift import OpenShiftProvider
+from .providers.podman import PodmanProvider
+from .providers.swarm import SwarmProvider
+from .remote.ssh import SSHConnection
+from .server_manager import ServerConnection, ServerManager, provider_class_for
+from .ui.splash import BootScreen
+from .version import VERSION
+
+
+class TermainerApp(App):
+    TITLE = "Termainer"
+    CSS_PATH = "ui/styles.tcss"
+
+    def __init__(self, server_manager: ServerManager) -> None:
+        super().__init__()
+        self.server_manager = server_manager
+        self.sub_title = _("app.subtitle")
+
+    def on_mount(self) -> None:
+        self.push_screen(BootScreen(self.server_manager))
+
+
+async def detect_provider(ssh: Optional[SSHConnection] = None) -> Provider:
+    providers: List[Type] = [
+        DockerProvider,
+        SwarmProvider,
+        KubernetesProvider,
+        PodmanProvider,
+        OpenShiftProvider,
+    ]
+    for cls in providers:
+        instance = cls(ssh=ssh) if ssh else cls()
+        if await instance.is_available():
+            return instance
+    raise RuntimeError(_("app.error.no_runtime"))
+
+
+async def detect_available_providers(ssh: Optional[SSHConnection] = None) -> List[Provider]:
+    providers: List[Type] = [
+        DockerProvider,
+        SwarmProvider,
+        KubernetesProvider,
+        PodmanProvider,
+        OpenShiftProvider,
+    ]
+    available: List[Provider] = []
+    for cls in providers:
+        instance = cls(ssh=ssh) if ssh else cls()
+        if await instance.is_available():
+            available.append(instance)
+    return available
+
+
+async def create_provider(
+    provider_name: str | None = None,
+    ssh: Optional[SSHConnection] = None,
+) -> Provider:
+    providers: dict[str, Type] = {
+        "docker": DockerProvider,
+        "swarm": SwarmProvider,
+        "podman": PodmanProvider,
+        "kubernetes": KubernetesProvider,
+        "k8s": KubernetesProvider,
+        "openshift": OpenShiftProvider,
+    }
+    if not provider_name or provider_name == "auto":
+        return await detect_provider(ssh)
+
+    cls = providers.get(provider_name.lower())
+    if cls is None:
+        available = ", ".join(sorted(providers))
+        raise RuntimeError(_("app.error.unknown_provider", provider=provider_name, available=available))
+
+    instance = cls(ssh=ssh) if ssh else cls()
+    if not await instance.is_available():
+        raise RuntimeError(_("app.error.provider_not_available", provider=provider_name))
+    return instance
+
+
+async def build_server_manager(
+    config_servers: List[ServerConfig],
+    ssh: Optional[SSHConnection],
+    cli_provider: str,
+) -> ServerManager:
+    connections: List[ServerConnection] = []
+
+    if config_servers:
+        for sc in config_servers:
+            ssh_conn: Optional[SSHConnection] = None
+            if sc.host:
+                ssh_conn = SSHConnection(
+                    host=sc.host,
+                    user=sc.user,
+                    key_path=sc.key_path,
+                    password=sc.password,
+                    port=sc.port,
+                )
+            provider_cls = provider_class_for(sc.provider)
+            provider = provider_cls(ssh=ssh_conn) if ssh_conn else provider_cls()
+            connections.append(ServerConnection(label=sc.label, provider=provider, ssh=ssh_conn))
+        return ServerManager(connections)
+
+    provider_name = cli_provider
+    if provider_name == "auto" and ssh:
+        from .config import get_provider_from_env
+
+        env = load_env_file(".env")
+        provider_name = get_provider_from_env(env) or "auto"
+
+    if provider_name == "auto" and ssh is None:
+        # Local auto-detect mode: solo proveedores locales, sin conexiones SSH al startup
+        available = await detect_available_providers(ssh=None)
+        if not available:
+            raise RuntimeError(_("app.error.no_runtime"))
+        for provider in available:
+            label = _("app.server.local_label", provider=provider.name.capitalize())
+            connections.append(ServerConnection(label=label, provider=provider, ssh=None))
+
+        return ServerManager(connections)
+
+    provider = await create_provider(provider_name, ssh)
+    label = _("app.server.remote_label", provider=provider.name.capitalize(), host=ssh.host) if ssh else _("app.server.local_label", provider=provider.name.capitalize())
+    connections.append(ServerConnection(label=label, provider=provider, ssh=ssh))
+    return ServerManager(connections)
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Termainer — Container observability and operations from your terminal"
+    )
+    parser.add_argument(
+        "--provider",
+        choices=("auto", "docker", "swarm", "podman", "kubernetes", "k8s", "openshift"),
+        default="auto",
+        help="Container runtime provider to use",
+    )
+    parser.add_argument(
+        "--host",
+        help="Remote SSH host (IP or hostname). Overrides TERMAINER_REMOTE_HOST in .env",
+    )
+    parser.add_argument(
+        "--ssh-user",
+        default=None,
+        help="SSH user (default: root, or TERMAINER_REMOTE_USER from .env)",
+    )
+    parser.add_argument(
+        "--ssh-key",
+        default=None,
+        help="SSH private key path (.pem). Overrides TERMAINER_REMOTE_KEY_PATH in .env",
+    )
+    parser.add_argument(
+        "--ssh-password",
+        default=None,
+        help="SSH password. Overrides TERMAINER_REMOTE_PASSWORD in .env",
+    )
+    parser.add_argument(
+        "--ssh-port",
+        type=int,
+        default=None,
+        help="SSH port (default: 22, or TERMAINER_REMOTE_PORT from .env)",
+    )
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=f"%(prog)s {VERSION}",
+        help="Show version and exit",
+    )
+    parser.add_argument(
+        "--env",
+        default=".env",
+        dest="env_file",
+        help="Path to .env file for remote configuration (default: .env)",
+    )
+    parser.add_argument(
+        "--config",
+        default=None,
+        dest="config_file",
+        help="Path to config.yaml for multi-server setup (default: auto-detect XDG path)",
+    )
+    return parser.parse_args()
+
+
+def main() -> None:
+    from .locale import init as locale_init
+
+    # Initialize locale from env var first, then override with .env
+    locale_init()
+    args = parse_args()
+
+    env_file = args.env_file
+    env = load_env_file(env_file) if os.path.isfile(env_file) else {}
+    locale_init(env)
+
+    server_manager: Optional[ServerManager] = None
+
+    if args.config_file:
+        from .config_manager import _parse_yaml
+
+        path = os.path.expanduser(args.config_file)
+        app_cfg = _parse_yaml(path) if os.path.isfile(path) else load_config()
+    else:
+        app_cfg = load_config()
+
+    if app_cfg.servers:
+        server_manager = asyncio.run(
+            build_server_manager(app_cfg.servers, ssh=None, cli_provider="auto")
+        )
+    else:
+        ssh = build_ssh_from_env(
+            env,
+            cli_host=args.host,
+            cli_user=args.ssh_user,
+            cli_key=args.ssh_key,
+            cli_password=args.ssh_password,
+            cli_port=args.ssh_port,
+        )
+
+        server_manager = asyncio.run(
+            build_server_manager([], ssh=ssh, cli_provider=args.provider)
+        )
+
+    app = TermainerApp(server_manager)
+    app.run()
+
+
+if __name__ == "__main__":
+    main()

termainer/config.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+from typing import Dict, Optional
+
+from .remote.ssh import SSHConnection
+from .ssh_config import SSHServer, get_ssh_servers, filter_ssh_servers_for_container_mgmt
+
+
+def load_env_file(path: str = ".env") -> Dict[str, str]:
+    env: Dict[str, str] = {}
+    try:
+        with open(path) as f:
+            for line in f:
+                line = line.strip()
+                if not line or line.startswith("#"):
+                    continue
+                if "=" in line:
+                    key, _, val = line.partition("=")
+                    env[key.strip()] = val.strip().strip("'\"")
+    except FileNotFoundError:
+        pass
+    return env
+
+
+def build_ssh_from_env(
+    env: Dict[str, str],
+    cli_host: Optional[str] = None,
+    cli_user: Optional[str] = None,
+    cli_key: Optional[str] = None,
+    cli_password: Optional[str] = None,
+    cli_port: Optional[int] = None,
+) -> Optional[SSHConnection]:
+    host = cli_host or env.get("TERMAINER_REMOTE_HOST")
+    if not host:
+        return None
+
+    return SSHConnection(
+        host=host,
+        user=cli_user or env.get("TERMAINER_REMOTE_USER", "root"),
+        key_path=cli_key or env.get("TERMAINER_REMOTE_KEY_PATH"),
+        password=cli_password or env.get("TERMAINER_REMOTE_PASSWORD"),
+        port=cli_port or int(env.get("TERMAINER_REMOTE_PORT", "22")),
+    )
+
+
+def get_provider_from_env(env: Dict[str, str]) -> Optional[str]:
+    return env.get("TERMAINER_REMOTE_PROVIDER") or None
+
+
+def build_ssh_from_ssh_server(
+    ssh_server: SSHServer,
+    cli_password: Optional[str] = None,
+) -> SSHConnection:
+    """Build SSHConnection from an SSHServer object (parsed from ~/.ssh/config).
+
+    Uses the Host alias so SSH config matching works correctly (ProxyJump, etc).
+    User/key/port are passed explicitly only when specified in the config entry.
+    """
+    return SSHConnection(
+        host=ssh_server.host,
+        user=ssh_server.user,
+        key_path=ssh_server.identity_file,
+        password=cli_password,
+        port=ssh_server.port,
+    )
+
+
+def get_configured_ssh_servers() -> Dict[str, SSHServer]:
+    """
+    Get SSH servers from ~/.ssh/config that are suitable for container management.
+    Filters out localhost entries.
+
+    Returns:
+        Dict mapping connection aliases to SSHServer objects
+    """
+    all_servers = get_ssh_servers()
+    return filter_ssh_servers_for_container_mgmt(all_servers)
+
+
+def has_ssh_servers_configured() -> bool:
+    """Check if any SSH servers are configured in ~/.ssh/config."""
+    return bool(get_configured_ssh_servers())

termainer/config_manager.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+
+CONFIG_DIR_NAME = "termainer"
+CONFIG_FILE_NAME = "config.yaml"
+
+
+@dataclass
+class ServerConfig:
+    label: str
+    provider: str
+    host: Optional[str] = None
+    user: str = "root"
+    key_path: Optional[str] = None
+    password: Optional[str] = None
+    port: int = 22
+
+
+@dataclass
+class AppConfig:
+    lang: str = "en"
+    servers: List[ServerConfig] = field(default_factory=list)
+
+
+def _get_config_paths() -> List[Path]:
+    paths = []
+    xdg = os.environ.get("XDG_CONFIG_HOME")
+    if xdg:
+        paths.append(Path(xdg) / CONFIG_DIR_NAME / CONFIG_FILE_NAME)
+    paths.append(Path.home() / ".config" / CONFIG_DIR_NAME / CONFIG_FILE_NAME)
+    paths.append(Path.cwd() / CONFIG_FILE_NAME)
+    return paths
+
+
+def load_config() -> AppConfig:
+    config_paths = _get_config_paths()
+    for path in config_paths:
+        if path.exists():
+            return _parse_yaml(path)
+    return AppConfig()
+
+
+def _parse_yaml(path: Path) -> AppConfig:
+    try:
+        import yaml
+    except ImportError:
+        raise RuntimeError(
+            "PyYAML is required to load config.yaml. "
+            "Install it with: pip install pyyaml"
+        )
+
+    with open(path) as f:
+        data: Dict[str, Any] = yaml.safe_load(f) or {}
+
+    lang = data.get("lang", "en")
+    servers_raw: List[Dict[str, Any]] = data.get("servers", [])
+    servers = []
+    for s in servers_raw:
+        servers.append(
+            ServerConfig(
+                label=s["label"],
+                provider=s["provider"],
+                host=s.get("host"),
+                user=s.get("user", "root"),
+                key_path=s.get("key") or s.get("key_path"),
+                password=s.get("password"),
+                port=s.get("port", 22),
+            )
+        )
+    return AppConfig(lang=lang, servers=servers)