homeconsole-cli 0.0.4__tar.gz → 0.0.6__tar.gz

{homeconsole_cli-0.0.4 → homeconsole_cli-0.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: homeconsole-cli
-Version: 0.0.4
+Version: 0.0.6
 Summary: HomeConsole CLI (hc) — управление платформой через HTTP API
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown

{homeconsole_cli-0.0.4 → homeconsole_cli-0.0.6}/hc/commands/core.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-import subprocess
-import sys
 from pathlib import Path
 
 import typer
@@ -72,9 +70,9 @@ def register(app: typer.Typer) -> None:
         src = init_core_source(console, repo_url=repo, ref=ref)
         console.print(f"[green]✓[/green] Core исходники готовы: {src.path}")
 
-    @core_app.command("pull-sources")
-    def pull_sources() -> None:
-        """Обновить локальную копию исходников Core (git pull). Раньше: `hc core update` только для git."""
+    @core_app.command("update")
+    def core_update() -> None:
+        """Обновить локальную копию исходников Core (git pull --ff-only)."""
         console = Console()
         src = update_core_source(console)
         console.print(f"[green]✓[/green] Обновлено: {src.path}")
@@ -259,19 +257,5 @@ def register(app: typer.Typer) -> None:
             raise typer.Exit(code=1)
         _docker_logs(console, follow=follow, tail=tail)
 
-    @core_app.command("update")
-    def core_runtime_update(
-        tag: str = typer.Option("latest", "--tag", help="Тег образа"),
-        wait: bool = typer.Option(True, "--wait/--no-wait"),
-        quiet: bool = typer.Option(False, "--quiet"),
-    ) -> None:
-        """Обновить core-runtime до образа (алиас для `hc update core`)."""
-        cmd = [sys.executable, "-m", "hc.main", "update", "core", "--tag", tag]
-        if not wait:
-            cmd.append("--no-wait")
-        if quiet:
-            cmd.append("--quiet")
-        raise SystemExit(subprocess.run(cmd, check=False).returncode)
-
     app.add_typer(core_app, name="core")
 

homeconsole_cli-0.0.6/hc/commands/doctor.py

@@ -0,0 +1,128 @@
+from __future__ import annotations
+
+import shutil
+import socket
+import subprocess
+from pathlib import Path
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from hc.config import Config
+from hc.constants import CONFIG_PATH, CORE_SRC_DIR
+from hc.core_source import COMPOSE_MODES
+
+
+def register(app: typer.Typer) -> None:
+    @app.command("doctor")
+    def doctor() -> None:
+        """Диагностика системы: Docker, конфиг, исходники, порты, диск."""
+        console = Console()
+        table = Table(show_header=False, box=None, padding=(0, 1))
+        table.add_column(min_width=28)
+        table.add_column()
+        table.add_column(style="dim")
+
+        ok = "[green]✓[/green]"
+        warn = "[yellow]![/yellow]"
+        fail = "[red]✗[/red]"
+        issues: list[str] = []
+
+        def row(label: str, icon: str, detail: str = "") -> None:
+            table.add_row(label, icon, detail)
+
+        # ── Docker ────────────────────────────────────────────────────
+        docker_bin = shutil.which("docker")
+        if docker_bin:
+            ver = subprocess.run(  # noqa: S603
+                ["docker", "version", "--format", "{{.Server.Version}}"],
+                capture_output=True, text=True, check=False, timeout=5,
+            )
+            docker_ver = ver.stdout.strip() or "?"
+            row("Docker", ok, f"v{docker_ver}  ({docker_bin})")
+        else:
+            row("Docker", fail, "не найден — установи Docker или OrbStack")
+            issues.append("Docker не найден")
+
+        compose_ver = subprocess.run(  # noqa: S603
+            ["docker", "compose", "version", "--short"],
+            capture_output=True, text=True, check=False, timeout=5,
+        )
+        if compose_ver.returncode == 0:
+            row("Docker Compose", ok, compose_ver.stdout.strip())
+        else:
+            row("Docker Compose", warn, "не определена версия")
+
+        git_bin = shutil.which("git")
+        if git_bin:
+            git_ver = subprocess.run(  # noqa: S603
+                ["git", "--version"], capture_output=True, text=True, check=False
+            )
+            row("git", ok, git_ver.stdout.strip())
+        else:
+            row("git", warn, "не найден — нужен для hc core init/update")
+
+        # ── Config ────────────────────────────────────────────────────
+        table.add_row("")
+        if CONFIG_PATH.exists():
+            cfg = Config.load()
+            host_ok = bool(cfg.core.host.strip())
+            token_ok = bool(cfg.core.token.strip())
+            row("Конфиг (~/.config/hc)", ok, str(CONFIG_PATH))
+            row("  Core host",  ok if host_ok else warn,
+                f"{cfg.core.host}:{cfg.core.port}" if host_ok else "не задан")
+            row("  Token",      ok if token_ok else warn,
+                "задан" if token_ok else "не задан — запусти hc connect")
+        else:
+            row("Конфиг (~/.config/hc)", warn, "не найден — запусти hc connect или hc setup")
+            issues.append("Конфиг не найден")
+
+        # ── Core sources ──────────────────────────────────────────────
+        table.add_row("")
+        if CORE_SRC_DIR.exists():
+            row("Core исходники", ok, str(CORE_SRC_DIR))
+            for mode, rel in COMPOSE_MODES.items():
+                cf = CORE_SRC_DIR / rel
+                row(f"  compose [{mode}]", ok if cf.exists() else warn,
+                    rel if cf.exists() else f"{rel}  ← не найден")
+            env_file = CORE_SRC_DIR / ".env"
+            row("  .env", ok if env_file.exists() else warn,
+                ".env готов" if env_file.exists() else "нет — будет создан при hc env up")
+        else:
+            row("Core исходники", warn, f"не найдены — запусти hc core init")
+            issues.append("Core исходники не найдены")
+
+        # ── Ports ─────────────────────────────────────────────────────
+        table.add_row("")
+        CHECK_PORTS = {18080: "UI (caddy)", 18000: "Core API", 5432: "PostgreSQL", 6379: "Redis"}
+        for port, label in CHECK_PORTS.items():
+            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+                s.settimeout(0.3)
+                in_use = s.connect_ex(("127.0.0.1", port)) == 0
+            icon = ok if in_use else "[dim]—[/dim]"
+            row(f"  :{port} {label}", icon, "listening" if in_use else "free")
+
+        # ── Disk ─────────────────────────────────────────────────────
+        table.add_row("")
+        try:
+            stat = shutil.disk_usage(Path.home())
+            free_gb = stat.free / 1024 ** 3
+            total_gb = stat.total / 1024 ** 3
+            used_pct = (stat.used / stat.total) * 100
+            disk_color = "red" if used_pct > 90 else "yellow" if used_pct > 75 else "green"
+            row("Диск (home)", f"[{disk_color}]{'!' if used_pct > 75 else '✓'}[/{disk_color}]",
+                f"{free_gb:.1f} GB свободно из {total_gb:.1f} GB ({used_pct:.0f}% занято)")
+            if used_pct > 90:
+                issues.append(f"Диск почти полон ({used_pct:.0f}%)")
+        except Exception:
+            pass
+
+        console.print(table)
+
+        if issues:
+            console.print()
+            for issue in issues:
+                console.print(f"[yellow]![/yellow] {issue}")
+        else:
+            console.print("\n[green]✓ Всё в порядке[/green]")

{homeconsole_cli-0.0.4 → homeconsole_cli-0.0.6}/hc/commands/env.py

@@ -168,6 +168,32 @@ def _run(cmd: list[str], *, cwd: Path | None = None, extra_env: dict[str, str] |
         raise typer.Exit(code=p.returncode)
 
 
+def _try_pull_source(src: CoreSource, console: Console) -> None:
+    """git pull --ff-only if the working tree is clean. Silently skips on dirty tree or any error."""
+    try:
+        status = subprocess.run(  # noqa: S603
+            ["git", "status", "--porcelain"],
+            cwd=str(src.path),
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        if status.returncode != 0 or status.stdout.strip():
+            return  # dirty or not a git repo — skip
+
+        pull = subprocess.run(  # noqa: S603
+            ["git", "pull", "--ff-only", "--quiet"],
+            cwd=str(src.path),
+            capture_output=True,
+            text=True,
+            timeout=15,
+        )
+        if pull.returncode == 0 and pull.stdout.strip():
+            console.print(f"[dim]↑ core-runtime-service обновлён[/dim]")
+    except Exception:  # noqa: BLE001
+        pass  # network unavailable, timeout, etc. — not critical
+
+
 def _get_running_services(compose_file: Path, cwd: Path) -> set[str]:
     try:
         r = subprocess.run(  # noqa: S603
@@ -424,6 +450,7 @@ def register(app: typer.Typer) -> None:
                 raise typer.Exit(code=2)
 
             src = _resolve_source(console)
+            _try_pull_source(src, console)
             project = compose_project_from_source(console, src, mode=mode)
             running = _get_running_services(project.compose_file, project.cwd)
 
@@ -592,6 +619,59 @@ def register(app: typer.Typer) -> None:
                 console.print(f"[dim]Подсказка:[/dim] {e.hint}")
             raise typer.Exit(code=int(e.exit_code or 1))
 
+    @env_app.command("rebuild")
+    def env_rebuild(
+        mode: str = typer.Option(_MODE_DEFAULT, "--mode", "-m", help=_MODE_HELP),
+        profile: str | None = typer.Option(None, "--profile", "-p", help=_PROFILE_HELP),
+        no_cache: bool = typer.Option(False, "--no-cache", help="Сборка без кэша Docker"),
+    ) -> None:
+        """
+        Пересобрать образы и перезапустить сервисы (интерактивный выбор).
+
+        Примеры:
+          hc env rebuild                          # интерактив
+          hc env rebuild --profile base           # core + caddy без вопросов
+          hc env rebuild --no-cache               # интерактив, без кэша
+        """
+        console = Console()
+        try:
+            require_docker(console)
+            mode = mode.strip().lower()
+            if mode not in _SERVICES:
+                console.print(f"[red]Ошибка:[/red] неизвестный режим {mode!r}. Допустимые: {' | '.join(_SERVICES)}")
+                raise typer.Exit(code=2)
+
+            src = _resolve_source(console)
+            project = compose_project_from_source(console, src, mode=mode)
+            running = _get_running_services(project.compose_file, project.cwd)
+
+            selected = _resolve_services(mode=mode, profile=profile, console=console, running=running)
+            service_names = [s.name for s in selected]
+
+            console.print(
+                f"\n[cyan]→[/cyan] env rebuild  "
+                f"mode=[bold]{mode}[/bold]  "
+                f"services=[bold]{', '.join(service_names)}[/bold]"
+                + ("  [dim]--no-cache[/dim]" if no_cache else "")
+            )
+
+            base_cmd = ["docker", "compose", "-f", str(project.compose_file)]
+
+            build_cmd = [*base_cmd, "build"]
+            if no_cache:
+                build_cmd.append("--no-cache")
+            build_cmd += service_names
+            _run(build_cmd, cwd=project.cwd)
+
+            _run([*base_cmd, "up", "-d", *service_names], cwd=project.cwd)
+            console.print(f"[green]✓[/green] rebuild ok")
+
+        except HcCliError as e:
+            console.print(f"[red]Ошибка:[/red] {e.message}")
+            if e.hint:
+                console.print(f"[dim]Подсказка:[/dim] {e.hint}")
+            raise typer.Exit(code=int(e.exit_code or 1))
+
     @env_app.command("status")
     def env_status(
         mode: str = typer.Option(_MODE_DEFAULT, "--mode", "-m", help=_MODE_HELP),
@@ -617,4 +697,159 @@ def register(app: typer.Typer) -> None:
                 console.print(f"[dim]Подсказка:[/dim] {e.hint}")
             raise typer.Exit(code=int(e.exit_code or 1))
 
+    @env_app.command("stats")
+    def env_stats(
+        mode: str = typer.Option(_MODE_DEFAULT, "--mode", "-m", help=_MODE_HELP),
+        watch: bool = typer.Option(False, "--watch", "-w", help="Обновлять каждые N секунд"),
+        interval: float = typer.Option(3.0, "--interval", "-n", help="Интервал обновления (сек)"),
+    ) -> None:
+        """CPU%, RAM, NET I/O контейнеров dev-окружения."""
+        import json
+        import time
+        from rich.live import Live
+        from rich.table import Table
+
+        console = Console()
+        try:
+            require_docker(console)
+            mode = mode.strip().lower()
+            src = _resolve_source(console)
+            project = compose_project_from_source(console, src, mode=mode)
+
+            def _stats_table() -> Table:
+                r = subprocess.run(  # noqa: S603
+                    ["docker", "compose", "-f", str(project.compose_file),
+                     "stats", "--no-stream", "--format", "{{json .}}"],
+                    cwd=str(project.cwd),
+                    capture_output=True, text=True, check=False,
+                )
+                table = Table(show_header=True, header_style="bold cyan", box=None, padding=(0, 1))
+                table.add_column("Сервис")
+                table.add_column("CPU%",     justify="right")
+                table.add_column("RAM",      justify="right")
+                table.add_column("RAM%",     justify="right")
+                table.add_column("NET I/O",  justify="right")
+                table.add_column("BLOCK I/O",justify="right")
+                table.add_column("PIDs",     justify="right")
+
+                for line in r.stdout.strip().splitlines():
+                    try:
+                        d = json.loads(line)
+                        cpu_s = d.get("CPUPerc", "0%")
+                        try:
+                            cpu_f = float(cpu_s.rstrip("%"))
+                            cpu_color = "red" if cpu_f > 80 else "yellow" if cpu_f > 40 else "green"
+                        except ValueError:
+                            cpu_color = "white"
+                        table.add_row(
+                            d.get("Name", "?"),
+                            f"[{cpu_color}]{cpu_s}[/{cpu_color}]",
+                            d.get("MemUsage", "?"),
+                            d.get("MemPerc", "?"),
+                            d.get("NetIO", "?"),
+                            d.get("BlockIO", "?"),
+                            d.get("PIDs", "?"),
+                        )
+                    except (json.JSONDecodeError, KeyError):
+                        pass
+                return table
+
+            if watch:
+                with Live(refresh_per_second=1, screen=False) as live:
+                    while True:
+                        live.update(_stats_table())
+                        time.sleep(interval)
+            else:
+                console.print(_stats_table())
+
+        except (KeyboardInterrupt, typer.Abort):
+            pass
+        except HcCliError as e:
+            console.print(f"[red]Ошибка:[/red] {e.message}")
+            if e.hint:
+                console.print(f"[dim]Подсказка:[/dim] {e.hint}")
+            raise typer.Exit(code=int(e.exit_code or 1))
+
+    @env_app.command("health")
+    def env_health(
+        mode: str = typer.Option(_MODE_DEFAULT, "--mode", "-m", help=_MODE_HELP),
+    ) -> None:
+        """Healthcheck статус каждого сервиса окружения."""
+        import json
+        from rich.table import Table
+
+        console = Console()
+        try:
+            require_docker(console)
+            mode = mode.strip().lower()
+            src = _resolve_source(console)
+            project = compose_project_from_source(console, src, mode=mode)
+
+            r = subprocess.run(  # noqa: S603
+                ["docker", "compose", "-f", str(project.compose_file),
+                 "ps", "--format", "json"],
+                cwd=str(project.cwd),
+                capture_output=True, text=True, check=False,
+            )
+
+            table = Table(show_header=True, header_style="bold cyan", box=None, padding=(0, 1))
+            table.add_column("Сервис")
+            table.add_column("Статус")
+            table.add_column("Health")
+            table.add_column("Порты")
+
+            _STATUS_COLOR = {"running": "green", "exited": "red", "paused": "yellow"}
+            _HEALTH_COLOR = {"healthy": "green", "unhealthy": "red",
+                             "starting": "yellow", "none": "dim"}
+
+            rows: list[dict] = []
+            raw = r.stdout.strip()
+            if raw:
+                try:
+                    parsed = json.loads(raw)
+                    rows = parsed if isinstance(parsed, list) else [parsed]
+                except json.JSONDecodeError:
+                    for line in raw.splitlines():
+                        try:
+                            rows.append(json.loads(line))
+                        except json.JSONDecodeError:
+                            pass
+
+            if not rows:
+                console.print("[yellow]Нет запущенных контейнеров.[/yellow]")
+                console.print(f"[dim]compose:[/dim] {project.compose_file}")
+                return
+
+            for row in rows:
+                name = row.get("Service") or row.get("Name") or "?"
+                state = str(row.get("State") or row.get("Status") or "?").lower()
+                health = str(row.get("Health") or "none").lower()
+                ports = row.get("Publishers") or row.get("Ports") or ""
+                if isinstance(ports, list):
+                    ports = ", ".join(
+                        f"{p.get('PublishedPort', '')}→{p.get('TargetPort', '')}"
+                        for p in ports if p.get("PublishedPort")
+                    )
+
+                sc = _STATUS_COLOR.get(state, "white")
+                hc_color = _HEALTH_COLOR.get(health, "white")
+                health_icon = {"healthy": "✓", "unhealthy": "✗",
+                               "starting": "…", "none": "—"}.get(health, health)
+
+                table.add_row(
+                    f"[bold]{name}[/bold]",
+                    f"[{sc}]{state}[/{sc}]",
+                    f"[{hc_color}]{health_icon} {health}[/{hc_color}]",
+                    str(ports),
+                )
+
+            console.print(table)
+            console.print(f"\n[dim]compose:[/dim] {project.compose_file}")
+
+        except HcCliError as e:
+            console.print(f"[red]Ошибка:[/red] {e.message}")
+            if e.hint:
+                console.print(f"[dim]Подсказка:[/dim] {e.hint}")
+            raise typer.Exit(code=int(e.exit_code or 1))
+
     app.add_typer(env_app, name="env")

homeconsole_cli-0.0.6/hc/commands/status.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+import time
+
+import anyio
+import typer
+from rich.console import Console
+from rich.live import Live
+from rich.panel import Panel
+from rich.text import Text
+
+from hc.commands._client_helpers import require_client
+
+
+def register(app: typer.Typer) -> None:
+    @app.command("status")
+    def status(
+        watch: bool = typer.Option(False, "--watch", "-w", help="Live-мониторинг (Ctrl+C для выхода)"),
+        interval: float = typer.Option(5.0, "--interval", "-n", help="Интервал обновления в секундах"),
+    ) -> None:
+        """Статус Core: версия, uptime, плагины, модули. С --watch — live-мониторинг."""
+        console = Console()
+        client = require_client(console)
+
+        latencies: list[float] = []
+
+        async def _fetch() -> tuple[dict | None, int | None, tuple[int, int] | None, float]:
+            t0 = time.monotonic()
+            health = await client.admin_status()
+            if not health:
+                health = await client.health()
+            latency_ms = (time.monotonic() - t0) * 1000
+
+            plugins = await client.get_plugins()
+            modules = await client.get_modules()
+
+            active_plugins = None
+            if isinstance(plugins, list):
+                active_plugins = sum(1 for p in plugins if str(p.get("status", "")).lower() == "running")
+
+            modules_stat = None
+            if isinstance(modules, list):
+                total = len(modules)
+                ok = sum(1 for m in modules if str(m.get("status", "")).lower() in {"running", "ok"})
+                modules_stat = (ok, total)
+
+            return health, active_plugins, modules_stat, latency_ms
+
+        def _build_panel(
+            health: dict | None,
+            active_plugins: int | None,
+            modules_stat: tuple[int, int] | None,
+            latency_ms: float,
+        ) -> Panel:
+            if not health:
+                return Panel(Text("Core недоступен", style="red"), title="HomeConsole", border_style="red")
+
+            latencies.append(latency_ms)
+            if len(latencies) > 10:
+                latencies.pop(0)
+
+            version = str(health.get("version", "unknown"))
+            status_value = str(health.get("status", "running"))
+            uptime = str(health.get("uptime", "unknown"))
+
+            status_text = Text(status_value)
+            if status_value.lower() in {"running", "ok"}:
+                status_text.stylize("green")
+                status_text = Text("✓ ") + status_text
+            else:
+                status_text.stylize("red")
+
+            lat_color = "green" if latency_ms < 100 else "yellow" if latency_ms < 500 else "red"
+            lat_avg = sum(latencies) / len(latencies)
+            lat_line = f"{latency_ms:.0f}ms  [dim](avg {lat_avg:.0f}ms)[/dim]"
+
+            lines: list[Text] = [
+                Text.assemble(("Версия:   ", "bold"), (version, "")),
+                Text.assemble(("Статус:   ", "bold"), status_text),
+                Text.assemble(("Latency:  ", "bold"), Text(lat_line, style=lat_color)),
+            ]
+            if active_plugins is not None:
+                lines.append(Text.assemble(("Плагинов: ", "bold"), (f"{active_plugins} активных", "")))
+            if modules_stat is not None:
+                ok, total = modules_stat
+                col = "green" if ok == total else "yellow"
+                lines.append(Text.assemble(("Модулей:  ", "bold"), Text(f"{ok} / {total}", style=col)))
+            lines.append(Text.assemble(("Uptime:   ", "bold"), (uptime, "")))
+
+            title = "HomeConsole"
+            if watch:
+                ts = time.strftime("%H:%M:%S")
+                title += f"  [dim]{ts}[/dim]"
+
+            return Panel(Text("\n").join(lines), title=title, border_style="cyan")
+
+        if not watch:
+            health, active_plugins, modules_stat, latency_ms = anyio.run(_fetch)
+            console.print(_build_panel(health, active_plugins, modules_stat, latency_ms))
+            if not health:
+                raise typer.Exit(code=1)
+            return
+
+        try:
+            with Live(refresh_per_second=1, screen=False) as live:
+                while True:
+                    health, active_plugins, modules_stat, latency_ms = anyio.run(_fetch)
+                    live.update(_build_panel(health, active_plugins, modules_stat, latency_ms))
+                    time.sleep(interval)
+        except (KeyboardInterrupt, typer.Abort):
+            pass

{homeconsole_cli-0.0.4 → homeconsole_cli-0.0.6}/hc/main.py

@@ -23,6 +23,7 @@ from hc.commands.status import register as register_status
 from hc.commands.deploy import register as register_deploy
 from hc.commands.update import register as register_update
 from hc.commands.ping import register as register_ping
+from hc.commands.doctor import register as register_doctor
 from hc.commands.marketplace import register as register_marketplace
 from hc.commands.secrets import register as register_secrets
 from hc.shell import run_shell
@@ -70,7 +71,8 @@ _NAV_TREE: dict[str, dict[str, object]] = {
     "secrets": {"desc": "Управление секретами", "children": {}},
     "recovery": {"desc": "Recovery сценарии", "children": {}},
     "reset": {"desc": "Сброс состояний", "children": {}},
-    "ping": {"desc": "Проверка доступности", "children": {}},
+    "ping":   {"desc": "Проверка доступности", "children": {}},
+    "doctor": {"desc": "Диагностика системы (Docker, конфиг, порты, диск)", "children": {}},
     "marketplace": {"desc": "Маркетплейс", "children": {}},
     "repl": {"desc": "Интерактивный режим", "children": {}},
     "shell": {"desc": "Алиас для repl", "children": {}},
@@ -189,6 +191,7 @@ def _register_all() -> None:
     register_update(app)
     register_ping(app)
     register_marketplace(app)
+    register_doctor(app)
     register_secrets(app)
 
 

{homeconsole_cli-0.0.4 → homeconsole_cli-0.0.6}/hc/repl.py

@@ -18,6 +18,7 @@ from hc import __version__
 from hc.config import Config
 from hc.constants import APP_NAME, HISTORY_PATH
 from hc.commands._client_helpers import require_client
+from hc.update_check import get_update_notification
 
 
 _GROUPS = {"core", "auth", "setup", "plugin", "module", "reset", "recovery", "deploy", "update"}
@@ -298,6 +299,14 @@ def run_repl(app: typer.Typer) -> None:
     console.print(f"{APP_NAME} {__version__} | {status}")
     console.print("Type 'help' or '?' for commands, 'exit' to quit")
 
+    latest = get_update_notification(__version__)
+    if latest:
+        console.print(
+            f"[yellow]→ Доступна новая версия [bold]{latest}[/bold] "
+            f"(текущая {__version__})[/yellow]"
+        )
+        console.print("[dim]  pipx upgrade homeconsole-cli  |  pip install --upgrade homeconsole-cli[/dim]")
+
     HISTORY_PATH.parent.mkdir(parents=True, exist_ok=True)
     session = PromptSession(_prompt(None), history=FileHistory(str(HISTORY_PATH)), completer=completer)
 

homeconsole_cli-0.0.6/hc/update_check.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+import json
+import threading
+import time
+
+from hc.constants import STATE_DIR
+
+_CACHE_FILE = STATE_DIR / "version_check.json"
+_TTL = 86400  # 24 hours
+_PYPI_URL = "https://pypi.org/pypi/homeconsole-cli/json"
+
+
+def _parse_ver(v: str) -> tuple[int, ...]:
+    try:
+        return tuple(int(x) for x in v.split(".") if x.isdigit())
+    except Exception:
+        return (0,)
+
+
+def _is_newer(latest: str, current: str) -> bool:
+    return _parse_ver(latest) > _parse_ver(current)
+
+
+def _read_cache() -> dict:
+    try:
+        return json.loads(_CACHE_FILE.read_text())
+    except Exception:
+        return {}
+
+
+def _write_cache(latest: str) -> None:
+    try:
+        STATE_DIR.mkdir(parents=True, exist_ok=True)
+        _CACHE_FILE.write_text(json.dumps({"ts": time.time(), "latest": latest}))
+    except Exception:
+        pass
+
+
+def _fetch_and_cache() -> None:
+    """Background thread: fetch latest version from PyPI and cache it."""
+    try:
+        import httpx
+        with httpx.Client(timeout=5.0) as client:
+            resp = client.get(_PYPI_URL)
+        if resp.status_code == 200:
+            latest = resp.json()["info"]["version"]
+            _write_cache(latest)
+    except Exception:
+        pass
+
+
+def get_update_notification(current: str) -> str | None:
+    """
+    Returns a notification string if a newer version is available, else None.
+    Uses a 24-hour cache — never blocks startup.
+    If cache is missing or expired, starts a background refresh for next session.
+    """
+    try:
+        data = _read_cache()
+        ts = data.get("ts", 0)
+        latest = data.get("latest", "")
+
+        if not latest or time.time() - ts > _TTL:
+            # Refresh in background — result visible next session
+            threading.Thread(target=_fetch_and_cache, daemon=True).start()
+
+        if latest and _is_newer(latest, current):
+            return latest
+    except Exception:
+        pass
+    return None

{homeconsole_cli-0.0.4 → homeconsole_cli-0.0.6}/homeconsole_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: homeconsole-cli
-Version: 0.0.4
+Version: 0.0.6
 Summary: HomeConsole CLI (hc) — управление платформой через HTTP API
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown

{homeconsole_cli-0.0.4 → homeconsole_cli-0.0.6}/homeconsole_cli.egg-info/SOURCES.txt

@@ -16,6 +16,7 @@ hc/native_core.py
 hc/repl.py
 hc/setup_runner.py
 hc/shell.py
+hc/update_check.py
 hc/commands/__init__.py
 hc/commands/_client_helpers.py
 hc/commands/_compose_helpers.py
@@ -23,6 +24,7 @@ hc/commands/auth.py
 hc/commands/connect.py
 hc/commands/core.py
 hc/commands/deploy.py
+hc/commands/doctor.py
 hc/commands/env.py
 hc/commands/install.py
 hc/commands/logs.py

{homeconsole_cli-0.0.4 → homeconsole_cli-0.0.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "homeconsole-cli"
-version = "0.0.4"
+version = "0.0.6"
 description = "HomeConsole CLI (hc) — управление платформой через HTTP API"
 readme = "README.md"
 requires-python = ">=3.11"

homeconsole_cli-0.0.4/hc/commands/status.py

@@ -1,64 +0,0 @@
-from __future__ import annotations
-
-import os
-
-import anyio
-import typer
-from rich.console import Console
-from rich.panel import Panel
-from rich.text import Text
-
-from hc.commands._client_helpers import require_client
-
-
-def register(app: typer.Typer) -> None:
-    @app.command("status")
-    def status() -> None:
-        console = Console()
-        client = require_client(console)
-
-        async def _run() -> tuple[dict | None, int | None, tuple[int, int] | None]:
-            health = await client.admin_status()
-            if not health:
-                health = await client.health()
-            plugins = await client.get_plugins()
-            modules = await client.get_modules()
-            active_plugins = None
-            if isinstance(plugins, list):
-                active_plugins = sum(1 for p in plugins if str(p.get("status", "")).lower() == "running")
-            modules_stat = None
-            if isinstance(modules, list):
-                total = len(modules)
-                ok = sum(1 for m in modules if str(m.get("status", "")).lower() in {"running", "ok"})
-                modules_stat = (ok, total)
-            return health, active_plugins, modules_stat
-
-        health, active_plugins, modules_stat = anyio.run(_run)
-        if not health:
-            raise typer.Exit(code=1)
-
-        version = str(health.get("version", "unknown"))
-        status_value = str(health.get("status", "running"))
-        uptime = str(health.get("uptime", "unknown"))
-
-        status_text = Text(status_value)
-        if status_value.lower() in {"running", "ok"}:
-            status_text.stylize("green")
-            status_text = Text("✓ ") + status_text
-        else:
-            status_text.stylize("red")
-
-        lines: list[Text] = [
-            Text.assemble(("Версия:   ", "bold"), (version, "")),
-            Text.assemble(("Статус:   ", "bold"), status_text),
-        ]
-        if active_plugins is not None:
-            lines.append(Text.assemble(("Плагинов: ", "bold"), (f"{active_plugins} активных", "")))
-        if modules_stat is not None:
-            ok, total = modules_stat
-            lines.append(Text.assemble(("Модулей:  ", "bold"), (f"{ok} / {total}", "")))
-        lines.append(Text.assemble(("Uptime:   ", "bold"), (uptime, "")))
-
-        body = Text("\n").join(lines)
-        console.print(Panel(body, title="HomeConsole", border_style="cyan"))
-